TestGlobalStack.py 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559
  1. # Copyright (c) 2017 Ultimaker B.V.
  2. # Cura is released under the terms of the AGPLv3 or higher.
  3. import pytest #This module contains unit tests.
  4. import unittest.mock #To monkeypatch some mocks in place of dependencies.
  5. import cura.Settings.GlobalStack #The module we're testing.
  6. import cura.Settings.CuraContainerStack #To get the list of container types.
  7. from cura.Settings.Exceptions import TooManyExtrudersError, InvalidContainerError, InvalidOperationError #To test raising these errors.
  8. from UM.Settings.DefinitionContainer import DefinitionContainer #To test against the class DefinitionContainer.
  9. from UM.Settings.InstanceContainer import InstanceContainer #To test against the class InstanceContainer.
  10. from UM.Settings.SettingInstance import InstanceState
  11. import UM.Settings.ContainerRegistry
  12. import UM.Settings.ContainerStack
  13. ## Fake container registry that always provides all containers you ask of.
  14. @pytest.yield_fixture()
  15. def container_registry():
  16. registry = unittest.mock.MagicMock()
  17. registry.return_value = unittest.mock.NonCallableMagicMock()
  18. registry.findInstanceContainers = lambda *args, registry = registry, **kwargs: [registry.return_value]
  19. registry.findDefinitionContainers = lambda *args, registry = registry, **kwargs: [registry.return_value]
  20. UM.Settings.ContainerRegistry.ContainerRegistry._ContainerRegistry__instance = registry
  21. UM.Settings.ContainerStack._containerRegistry = registry
  22. yield registry
  23. UM.Settings.ContainerRegistry.ContainerRegistry._ContainerRegistry__instance = None
  24. UM.Settings.ContainerStack._containerRegistry = None
  25. #An empty global stack to test with.
  26. @pytest.fixture()
  27. def global_stack() -> cura.Settings.GlobalStack.GlobalStack:
  28. return cura.Settings.GlobalStack.GlobalStack("TestStack")
  29. ## Gets an instance container with a specified container type.
  30. #
  31. # \param container_type The type metadata for the instance container.
  32. # \return An instance container instance.
  33. def getInstanceContainer(container_type) -> InstanceContainer:
  34. container = InstanceContainer(container_id = "InstanceContainer")
  35. container.addMetaDataEntry("type", container_type)
  36. return container
  37. class DefinitionContainerSubClass(DefinitionContainer):
  38. def __init__(self):
  39. super().__init__(container_id = "SubDefinitionContainer")
  40. class InstanceContainerSubClass(InstanceContainer):
  41. def __init__(self, container_type):
  42. super().__init__(container_id = "SubInstanceContainer")
  43. self.addMetaDataEntry("type", container_type)
  44. #############################START OF TEST CASES################################
  45. ## Tests whether adding a container is properly forbidden.
  46. def test_addContainer(global_stack):
  47. with pytest.raises(InvalidOperationError):
  48. global_stack.addContainer(unittest.mock.MagicMock())
  49. ## Tests adding extruders to the global stack.
  50. def test_addExtruder(global_stack):
  51. mock_definition = unittest.mock.MagicMock()
  52. mock_definition.getProperty = lambda key, property: 2 if key == "machine_extruder_count" and property == "value" else None
  53. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
  54. global_stack.definition = mock_definition
  55. assert len(global_stack.extruders) == 0
  56. first_extruder = unittest.mock.MagicMock()
  57. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
  58. global_stack.addExtruder(first_extruder)
  59. assert len(global_stack.extruders) == 1
  60. assert global_stack.extruders[0] == first_extruder
  61. second_extruder = unittest.mock.MagicMock()
  62. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
  63. global_stack.addExtruder(second_extruder)
  64. assert len(global_stack.extruders) == 2
  65. assert global_stack.extruders[1] == second_extruder
  66. # Disabled for now for Custom FDM Printer
  67. # with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
  68. # with pytest.raises(TooManyExtrudersError): #Should be limited to 2 extruders because of machine_extruder_count.
  69. # global_stack.addExtruder(unittest.mock.MagicMock())
  70. assert len(global_stack.extruders) == 2 #Didn't add the faulty extruder.
  71. #Tests setting user changes profiles to invalid containers.
  72. @pytest.mark.parametrize("container", [
  73. getInstanceContainer(container_type = "wrong container type"),
  74. getInstanceContainer(container_type = "material"), #Existing, but still wrong type.
  75. DefinitionContainer(container_id = "wrong class")
  76. ])
  77. def test_constrainUserChangesInvalid(container, global_stack):
  78. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  79. global_stack.userChanges = container
  80. #Tests setting user changes profiles.
  81. @pytest.mark.parametrize("container", [
  82. getInstanceContainer(container_type = "user"),
  83. InstanceContainerSubClass(container_type = "user")
  84. ])
  85. def test_constrainUserChangesValid(container, global_stack):
  86. global_stack.userChanges = container #Should not give an error.
  87. #Tests setting quality changes profiles to invalid containers.
  88. @pytest.mark.parametrize("container", [
  89. getInstanceContainer(container_type = "wrong container type"),
  90. getInstanceContainer(container_type = "material"), #Existing, but still wrong type.
  91. DefinitionContainer(container_id = "wrong class")
  92. ])
  93. def test_constrainQualityChangesInvalid(container, global_stack):
  94. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  95. global_stack.qualityChanges = container
  96. #Test setting quality changes profiles.
  97. @pytest.mark.parametrize("container", [
  98. getInstanceContainer(container_type = "quality_changes"),
  99. InstanceContainerSubClass(container_type = "quality_changes")
  100. ])
  101. def test_constrainQualityChangesValid(container, global_stack):
  102. global_stack.qualityChanges = container #Should not give an error.
  103. #Tests setting quality profiles to invalid containers.
  104. @pytest.mark.parametrize("container", [
  105. getInstanceContainer(container_type = "wrong container type"),
  106. getInstanceContainer(container_type = "material"), #Existing, but still wrong type.
  107. DefinitionContainer(container_id = "wrong class")
  108. ])
  109. def test_constrainQualityInvalid(container, global_stack):
  110. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  111. global_stack.quality = container
  112. #Test setting quality profiles.
  113. @pytest.mark.parametrize("container", [
  114. getInstanceContainer(container_type = "quality"),
  115. InstanceContainerSubClass(container_type = "quality")
  116. ])
  117. def test_constrainQualityValid(container, global_stack):
  118. global_stack.quality = container #Should not give an error.
  119. #Tests setting materials to invalid containers.
  120. @pytest.mark.parametrize("container", [
  121. getInstanceContainer(container_type = "wrong container type"),
  122. getInstanceContainer(container_type = "quality"), #Existing, but still wrong type.
  123. DefinitionContainer(container_id = "wrong class")
  124. ])
  125. def test_constrainMaterialInvalid(container, global_stack):
  126. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  127. global_stack.material = container
  128. #Test setting materials.
  129. @pytest.mark.parametrize("container", [
  130. getInstanceContainer(container_type = "material"),
  131. InstanceContainerSubClass(container_type = "material")
  132. ])
  133. def test_constrainMaterialValid(container, global_stack):
  134. global_stack.material = container #Should not give an error.
  135. #Tests setting variants to invalid containers.
  136. @pytest.mark.parametrize("container", [
  137. getInstanceContainer(container_type = "wrong container type"),
  138. getInstanceContainer(container_type = "material"), #Existing, but still wrong type.
  139. DefinitionContainer(container_id = "wrong class")
  140. ])
  141. def test_constrainVariantInvalid(container, global_stack):
  142. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  143. global_stack.variant = container
  144. #Test setting variants.
  145. @pytest.mark.parametrize("container", [
  146. getInstanceContainer(container_type = "variant"),
  147. InstanceContainerSubClass(container_type = "variant")
  148. ])
  149. def test_constrainVariantValid(container, global_stack):
  150. global_stack.variant = container #Should not give an error.
  151. #Tests setting definition changes profiles to invalid containers.
  152. @pytest.mark.parametrize("container", [
  153. getInstanceContainer(container_type = "wrong container type"),
  154. getInstanceContainer(container_type = "material"), #Existing, but still wrong type.
  155. DefinitionContainer(container_id = "wrong class")
  156. ])
  157. def test_constrainDefinitionChangesInvalid(container, global_stack):
  158. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  159. global_stack.definitionChanges = container
  160. #Test setting definition changes profiles.
  161. @pytest.mark.parametrize("container", [
  162. getInstanceContainer(container_type = "definition_changes"),
  163. InstanceContainerSubClass(container_type = "definition_changes")
  164. ])
  165. def test_constrainDefinitionChangesValid(container, global_stack):
  166. global_stack.definitionChanges = container #Should not give an error.
  167. #Tests setting definitions to invalid containers.
  168. @pytest.mark.parametrize("container", [
  169. getInstanceContainer(container_type = "wrong class"),
  170. getInstanceContainer(container_type = "material"), #Existing, but still wrong class.
  171. ])
  172. def test_constrainVariantInvalid(container, global_stack):
  173. with pytest.raises(InvalidContainerError): #Invalid container, should raise an error.
  174. global_stack.definition = container
  175. #Test setting definitions.
  176. @pytest.mark.parametrize("container", [
  177. DefinitionContainer(container_id = "DefinitionContainer"),
  178. DefinitionContainerSubClass()
  179. ])
  180. def test_constrainDefinitionValid(container, global_stack):
  181. global_stack.definition = container #Should not give an error.
  182. ## Tests whether deserialising completes the missing containers with empty
  183. # ones.
  184. @pytest.mark.skip #The test currently fails because the definition container doesn't have a category, which is wrong but we don't have time to refactor that right now.
  185. def test_deserializeCompletesEmptyContainers(global_stack: cura.Settings.GlobalStack):
  186. global_stack._containers = [DefinitionContainer(container_id = "definition")] #Set the internal state of this stack manually.
  187. with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
  188. global_stack.deserialize("")
  189. assert len(global_stack.getContainers()) == len(cura.Settings.CuraContainerStack._ContainerIndexes.IndexTypeMap) #Needs a slot for every type.
  190. for container_type_index in cura.Settings.CuraContainerStack._ContainerIndexes.IndexTypeMap:
  191. if container_type_index == cura.Settings.CuraContainerStack._ContainerIndexes.Definition: #We're not checking the definition.
  192. continue
  193. assert global_stack.getContainer(container_type_index).getId() == "empty" #All others need to be empty.
  194. ## Tests whether an instance container with the wrong type gets removed when
  195. # deserialising.
  196. def test_deserializeRemovesWrongInstanceContainer(global_stack):
  197. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Quality] = getInstanceContainer(container_type = "wrong type")
  198. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Definition] = DefinitionContainer(container_id = "some definition")
  199. with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
  200. global_stack.deserialize("")
  201. assert global_stack.quality == global_stack._empty_instance_container #Replaced with empty.
  202. ## Tests whether a container with the wrong class gets removed when
  203. # deserialising.
  204. def test_deserializeRemovesWrongContainerClass(global_stack):
  205. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Quality] = DefinitionContainer(container_id = "wrong class")
  206. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Definition] = DefinitionContainer(container_id = "some definition")
  207. with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
  208. global_stack.deserialize("")
  209. assert global_stack.quality == global_stack._empty_instance_container #Replaced with empty.
  210. ## Tests whether an instance container in the definition spot results in an
  211. # error.
  212. def test_deserializeWrongDefinitionClass(global_stack):
  213. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Definition] = getInstanceContainer(container_type = "definition") #Correct type but wrong class.
  214. with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
  215. with pytest.raises(UM.Settings.ContainerStack.InvalidContainerStackError): #Must raise an error that there is no definition container.
  216. global_stack.deserialize("")
  217. ## Tests whether an instance container with the wrong type is moved into the
  218. # correct slot by deserialising.
  219. def test_deserializeMoveInstanceContainer(global_stack):
  220. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Quality] = getInstanceContainer(container_type = "material") #Not in the correct spot.
  221. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Definition] = DefinitionContainer(container_id = "some definition")
  222. with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
  223. global_stack.deserialize("")
  224. assert global_stack.quality.getId() == "empty"
  225. assert global_stack.material.getId() != "empty"
  226. ## Tests whether a definition container in the wrong spot is moved into the
  227. # correct spot by deserialising.
  228. @pytest.mark.skip #The test currently fails because the definition container doesn't have a category, which is wrong but we don't have time to refactor that right now.
  229. def test_deserializeMoveDefinitionContainer(global_stack):
  230. global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes.Material] = DefinitionContainer(container_id = "some definition") #Not in the correct spot.
  231. with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
  232. global_stack.deserialize("")
  233. assert global_stack.material.getId() == "empty"
  234. assert global_stack.definition.getId() != "empty"
  235. UM.Settings.ContainerStack._containerRegistry = None
  236. ## Tests whether getProperty properly applies the stack-like behaviour on its
  237. # containers.
  238. def test_getPropertyFallThrough(global_stack):
  239. #A few instance container mocks to put in the stack.
  240. mock_layer_heights = {} #For each container type, a mock container that defines layer height to something unique.
  241. mock_no_settings = {} #For each container type, a mock container that has no settings at all.
  242. container_indexes = cura.Settings.CuraContainerStack._ContainerIndexes #Cache.
  243. for type_id, type_name in container_indexes.IndexTypeMap.items():
  244. container = unittest.mock.MagicMock()
  245. container.getProperty = lambda key, property, type_id = type_id: type_id if (key == "layer_height" and property == "value") else None #Returns the container type ID as layer height, in order to identify it.
  246. container.hasProperty = lambda key, property: key == "layer_height"
  247. container.getMetaDataEntry = unittest.mock.MagicMock(return_value = type_name)
  248. mock_layer_heights[type_id] = container
  249. container = unittest.mock.MagicMock()
  250. container.getProperty = unittest.mock.MagicMock(return_value = None) #Has no settings at all.
  251. container.hasProperty = unittest.mock.MagicMock(return_value = False)
  252. container.getMetaDataEntry = unittest.mock.MagicMock(return_value = type_name)
  253. mock_no_settings[type_id] = container
  254. global_stack.userChanges = mock_no_settings[container_indexes.UserChanges]
  255. global_stack.qualityChanges = mock_no_settings[container_indexes.QualityChanges]
  256. global_stack.quality = mock_no_settings[container_indexes.Quality]
  257. global_stack.material = mock_no_settings[container_indexes.Material]
  258. global_stack.variant = mock_no_settings[container_indexes.Variant]
  259. global_stack.definitionChanges = mock_no_settings[container_indexes.DefinitionChanges]
  260. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock): #To guard against the type checking.
  261. global_stack.definition = mock_layer_heights[container_indexes.Definition] #There's a layer height in here!
  262. assert global_stack.getProperty("layer_height", "value") == container_indexes.Definition
  263. global_stack.definitionChanges = mock_layer_heights[container_indexes.DefinitionChanges]
  264. assert global_stack.getProperty("layer_height", "value") == container_indexes.DefinitionChanges
  265. global_stack.variant = mock_layer_heights[container_indexes.Variant]
  266. assert global_stack.getProperty("layer_height", "value") == container_indexes.Variant
  267. global_stack.material = mock_layer_heights[container_indexes.Material]
  268. assert global_stack.getProperty("layer_height", "value") == container_indexes.Material
  269. global_stack.quality = mock_layer_heights[container_indexes.Quality]
  270. assert global_stack.getProperty("layer_height", "value") == container_indexes.Quality
  271. global_stack.qualityChanges = mock_layer_heights[container_indexes.QualityChanges]
  272. assert global_stack.getProperty("layer_height", "value") == container_indexes.QualityChanges
  273. global_stack.userChanges = mock_layer_heights[container_indexes.UserChanges]
  274. assert global_stack.getProperty("layer_height", "value") == container_indexes.UserChanges
  275. ## In definitions, test whether having no resolve allows us to find the value.
  276. def test_getPropertyNoResolveInDefinition(global_stack):
  277. value = unittest.mock.MagicMock() #Just sets the value for bed temperature.
  278. value.getProperty = lambda key, property: 10 if (key == "material_bed_temperature" and property == "value") else None
  279. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock): #To guard against the type checking.
  280. global_stack.definition = value
  281. assert global_stack.getProperty("material_bed_temperature", "value") == 10 #No resolve, so fall through to value.
  282. ## In definitions, when the value is asked and there is a resolve function, it
  283. # must get the resolve first.
  284. def test_getPropertyResolveInDefinition(global_stack):
  285. resolve_and_value = unittest.mock.MagicMock() #Sets the resolve and value for bed temperature.
  286. resolve_and_value.getProperty = lambda key, property: (7.5 if property == "resolve" else 5) if (key == "material_bed_temperature" and property in ("resolve", "value")) else None #7.5 resolve, 5 value.
  287. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock): #To guard against the type checking.
  288. global_stack.definition = resolve_and_value
  289. assert global_stack.getProperty("material_bed_temperature", "value") == 7.5 #Resolve wins in the definition.
  290. ## In instance containers, when the value is asked and there is a resolve
  291. # function, it must get the value first.
  292. def test_getPropertyResolveInInstance(global_stack):
  293. container_indices = cura.Settings.CuraContainerStack._ContainerIndexes
  294. instance_containers = {}
  295. for container_type in container_indices.IndexTypeMap:
  296. instance_containers[container_type] = unittest.mock.MagicMock() #Sets the resolve and value for bed temperature.
  297. instance_containers[container_type].getProperty = lambda key, property: (7.5 if property == "resolve" else (InstanceState.User if property == "state" else (5 if property != "limit_to_extruder" else "-1"))) if (key == "material_bed_temperature") else None #7.5 resolve, 5 value.
  298. instance_containers[container_type].getMetaDataEntry = unittest.mock.MagicMock(return_value = container_indices.IndexTypeMap[container_type]) #Make queries for the type return the desired type.
  299. instance_containers[container_indices.Definition].getProperty = lambda key, property: 10 if (key == "material_bed_temperature" and property == "value") else None #Definition only has value.
  300. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock): #To guard against the type checking.
  301. global_stack.definition = instance_containers[container_indices.Definition] #Stack must have a definition.
  302. #For all instance container slots, the value reigns over resolve.
  303. global_stack.definitionChanges = instance_containers[container_indices.DefinitionChanges]
  304. assert global_stack.getProperty("material_bed_temperature", "value") == 5
  305. global_stack.variant = instance_containers[container_indices.Variant]
  306. assert global_stack.getProperty("material_bed_temperature", "value") == 5
  307. global_stack.material = instance_containers[container_indices.Material]
  308. assert global_stack.getProperty("material_bed_temperature", "value") == 5
  309. global_stack.quality = instance_containers[container_indices.Quality]
  310. assert global_stack.getProperty("material_bed_temperature", "value") == 5
  311. global_stack.qualityChanges = instance_containers[container_indices.QualityChanges]
  312. assert global_stack.getProperty("material_bed_temperature", "value") == 5
  313. global_stack.userChanges = instance_containers[container_indices.UserChanges]
  314. assert global_stack.getProperty("material_bed_temperature", "value") == 5
  315. ## Tests whether the value in instances gets evaluated before the resolve in
  316. # definitions.
  317. def test_getPropertyInstancesBeforeResolve(global_stack):
  318. value = unittest.mock.MagicMock() #Sets just the value.
  319. value.getProperty = lambda key, property: (10 if property == "value" else (InstanceState.User if property != "limit_to_extruder" else "-1")) if key == "material_bed_temperature" else None
  320. value.getMetaDataEntry = unittest.mock.MagicMock(return_value = "quality")
  321. resolve = unittest.mock.MagicMock() #Sets just the resolve.
  322. resolve.getProperty = lambda key, property: 7.5 if (key == "material_bed_temperature" and property == "resolve") else None
  323. with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock): #To guard against the type checking.
  324. global_stack.definition = resolve
  325. global_stack.quality = value
  326. assert global_stack.getProperty("material_bed_temperature", "value") == 10
  327. ## Tests whether the hasUserValue returns true for settings that are changed in
  328. # the user-changes container.
  329. def test_hasUserValueUserChanges(global_stack):
  330. container = unittest.mock.MagicMock()
  331. container.getMetaDataEntry = unittest.mock.MagicMock(return_value = "user")
  332. container.hasProperty = lambda key, property: key == "layer_height" #Only have the layer_height property set.
  333. global_stack.userChanges = container
  334. assert global_stack.hasUserValue("layer_height")
  335. assert not global_stack.hasUserValue("infill_sparse_density")
  336. assert not global_stack.hasUserValue("")
  337. ## Tests whether the hasUserValue returns true for settings that are changed in
  338. # the quality-changes container.
  339. def test_hasUserValueQualityChanges(global_stack):
  340. container = unittest.mock.MagicMock()
  341. container.getMetaDataEntry = unittest.mock.MagicMock(return_value = "quality_changes")
  342. container.hasProperty = lambda key, property: key == "layer_height" #Only have the layer_height property set.
  343. global_stack.qualityChanges = container
  344. assert global_stack.hasUserValue("layer_height")
  345. assert not global_stack.hasUserValue("infill_sparse_density")
  346. assert not global_stack.hasUserValue("")
  347. ## Tests whether a container in some other place on the stack is correctly not
  348. # recognised as user value.
  349. def test_hasNoUserValue(global_stack):
  350. container = unittest.mock.MagicMock()
  351. container.getMetaDataEntry = unittest.mock.MagicMock(return_value = "quality")
  352. container.hasProperty = lambda key, property: key == "layer_height" #Only have the layer_height property set.
  353. global_stack.quality = container
  354. assert not global_stack.hasUserValue("layer_height") #However this container is quality, so it's not a user value.
  355. ## Tests whether inserting a container is properly forbidden.
  356. def test_insertContainer(global_stack):
  357. with pytest.raises(InvalidOperationError):
  358. global_stack.insertContainer(0, unittest.mock.MagicMock())
  359. ## Tests whether removing a container is properly forbidden.
  360. def test_removeContainer(global_stack):
  361. with pytest.raises(InvalidOperationError):
  362. global_stack.removeContainer(unittest.mock.MagicMock())
  363. ## Tests setting definitions by specifying an ID of a definition that exists.
  364. def test_setDefinitionByIdExists(global_stack, container_registry):
  365. container_registry.return_value = DefinitionContainer(container_id = "some_definition")
  366. global_stack.setDefinitionById("some_definition")
  367. assert global_stack.definition.getId() == "some_definition"
  368. ## Tests setting definitions by specifying an ID of a definition that doesn't
  369. # exist.
  370. def test_setDefinitionByIdDoesntExist(global_stack):
  371. with pytest.raises(InvalidContainerError):
  372. global_stack.setDefinitionById("some_definition") #Container registry is empty now.
  373. ## Tests setting definition changes by specifying an ID of a container that
  374. # exists.
  375. def test_setDefinitionChangesByIdExists(global_stack, container_registry):
  376. container_registry.return_value = getInstanceContainer(container_type = "definition_changes")
  377. global_stack.setDefinitionChangesById("InstanceContainer")
  378. assert global_stack.definitionChanges.getId() == "InstanceContainer"
  379. ## Tests setting definition changes by specifying an ID of a container that
  380. # doesn't exist.
  381. def test_setDefinitionChangesByIdDoesntExist(global_stack):
  382. with pytest.raises(InvalidContainerError):
  383. global_stack.setDefinitionChangesById("some_definition_changes") #Container registry is empty now.
  384. ## Tests setting materials by specifying an ID of a material that exists.
  385. def test_setMaterialByIdExists(global_stack, container_registry):
  386. container_registry.return_value = getInstanceContainer(container_type = "material")
  387. global_stack.setMaterialById("InstanceContainer")
  388. assert global_stack.material.getId() == "InstanceContainer"
  389. ## Tests setting materials by specifying an ID of a material that doesn't
  390. # exist.
  391. def test_setMaterialByIdDoesntExist(global_stack):
  392. with pytest.raises(InvalidContainerError):
  393. global_stack.setMaterialById("some_material") #Container registry is empty now.
  394. ## Tests whether changing the next stack is properly forbidden.
  395. def test_setNextStack(global_stack):
  396. with pytest.raises(InvalidOperationError):
  397. global_stack.setNextStack(unittest.mock.MagicMock())
  398. ## Tests setting properties directly on the global stack.
  399. @pytest.mark.parametrize("key, property, value", [
  400. ("layer_height", "value", 0.1337),
  401. ("foo", "value", 100),
  402. ("support_enabled", "value", True),
  403. ("layer_height", "default_value", 0.1337),
  404. ("layer_height", "is_bright_pink", "of course")
  405. ])
  406. def test_setPropertyUser(key, property, value, global_stack):
  407. user_changes = unittest.mock.MagicMock()
  408. user_changes.getMetaDataEntry = unittest.mock.MagicMock(return_value = "user")
  409. global_stack.userChanges = user_changes
  410. global_stack.setProperty(key, property, value) #The actual test.
  411. global_stack.userChanges.setProperty.assert_called_once_with(key, property, value) #Make sure that the user container gets a setProperty call.
  412. ## Tests setting properties on specific containers on the global stack.
  413. @pytest.mark.parametrize("target_container, stack_variable", [
  414. ("user", "userChanges"),
  415. ("quality_changes", "qualityChanges"),
  416. ("quality", "quality"),
  417. ("material", "material"),
  418. ("variant", "variant"),
  419. ("definition_changes", "definitionChanges")
  420. ])
  421. def test_setPropertyOtherContainers(target_container, stack_variable, global_stack):
  422. #Other parameters that don't need to be varied.
  423. key = "layer_height"
  424. property = "value"
  425. value = 0.1337
  426. #A mock container in the right spot.
  427. container = unittest.mock.MagicMock()
  428. container.getMetaDataEntry = unittest.mock.MagicMock(return_value = target_container)
  429. setattr(global_stack, stack_variable, container) #For instance, set global_stack.qualityChanges = container.
  430. global_stack.setProperty(key, property, value, target_container = target_container) #The actual test.
  431. getattr(global_stack, stack_variable).setProperty.assert_called_once_with(key, property, value) #Make sure that the proper container gets a setProperty call.
  432. ## Tests setting qualities by specifying an ID of a quality that exists.
  433. def test_setQualityByIdExists(global_stack, container_registry):
  434. container_registry.return_value = getInstanceContainer(container_type = "quality")
  435. global_stack.setQualityById("InstanceContainer")
  436. assert global_stack.quality.getId() == "InstanceContainer"
  437. ## Tests setting qualities by specifying an ID of a quality that doesn't exist.
  438. def test_setQualityByIdDoesntExist(global_stack):
  439. with pytest.raises(InvalidContainerError):
  440. global_stack.setQualityById("some_quality") #Container registry is empty now.
  441. ## Tests setting quality changes by specifying an ID of a quality change that
  442. # exists.
  443. def test_setQualityChangesByIdExists(global_stack, container_registry):
  444. container_registry.return_value = getInstanceContainer(container_type = "quality_changes")
  445. global_stack.setQualityChangesById("InstanceContainer")
  446. assert global_stack.qualityChanges.getId() == "InstanceContainer"
  447. ## Tests setting quality changes by specifying an ID of a quality change that
  448. # doesn't exist.
  449. def test_setQualityChangesByIdDoesntExist(global_stack):
  450. with pytest.raises(InvalidContainerError):
  451. global_stack.setQualityChangesById("some_quality_changes") #Container registry is empty now.
  452. ## Tests setting variants by specifying an ID of a variant that exists.
  453. def test_setVariantByIdExists(global_stack, container_registry):
  454. container_registry.return_value = getInstanceContainer(container_type = "variant")
  455. global_stack.setVariantById("InstanceContainer")
  456. assert global_stack.variant.getId() == "InstanceContainer"
  457. ## Tests setting variants by specifying an ID of a variant that doesn't exist.
  458. def test_setVariantByIdDoesntExist(global_stack):
  459. with pytest.raises(InvalidContainerError):
  460. global_stack.setVariantById("some_variant") #Container registry is empty now.
  461. ## Smoke test for findDefaultVariant
  462. def test_smoke_findDefaultVariant(global_stack):
  463. global_stack.findDefaultVariant()
  464. ## Smoke test for findDefaultMaterial
  465. def test_smoke_findDefaultMaterial(global_stack):
  466. global_stack.findDefaultMaterial()
  467. ## Smoke test for findDefaultQuality
  468. def test_smoke_findDefaultQuality(global_stack):
  469. global_stack.findDefaultQuality()