# Copyright (c) 2017 Ultimaker B.V.
# Cura is released under the terms of the AGPLv3 or higher.
import os.path #To find the test files.
import pytest #This module contains unit tests.
import unittest.mock #To monkeypatch some mocks in place of dependencies.
import functools
import cura.Settings.GlobalStack #The module we're testing.
from cura.Settings.Exceptions import TooManyExtrudersError, InvalidContainerError, InvalidOperationError #To test raising these errors.
from UM.Settings.DefinitionContainer import DefinitionContainer #To test against the class DefinitionContainer.
from UM.Settings.InstanceContainer import InstanceContainer #To test against the class InstanceContainer.
import UM.Settings.ContainerRegistry
import UM.Settings.ContainerStack
class MockContainer:
def __init__(self, container_id, type = "mock"):
self._id = container_id
self._type = type
self._property_map = {}
def getId(self):
return self._id
def getMetaDataEntry(self, entry, default = None):
if entry == "type":
return self._type
return default
def getProperty(self, key, property_name):
if key not in self._property_map:
return None
if property_name not in self._property_map[key]:
return None
return self._property_map[key][property_name]
def setProperty(self, key, property_name, value):
if key not in self._property_map:
self._property_map[key] = {}
self._property_map[key][property_name] = value
propertyChanged = unittest.mock.MagicMock()
## Fake container registry that always provides all containers you ask of.
@pytest.yield_fixture()
def container_registry():
registry = unittest.mock.MagicMock()
registry.typeMetaData = "registry_mock"
def findInstanceContainers(registry, **kwargs):
container_id = kwargs.get("id", default = "test_container")
return [MockContainer(container_id, registry.typeMetaData)]
registry.findInstanceContainers = functools.partial(findInstanceContainers, registry)
def findContainers(registry, container_type = None, id = None):
if not id:
id = "test_container"
return [MockContainer(id, registry.typeMetaData)]
registry.findContainers = functools.partial(findContainers, registry)
def getEmptyInstanceContainer():
return MockContainer(container_id = "empty")
registry.getEmptyInstanceContainer = getEmptyInstanceContainer
UM.Settings.ContainerRegistry.ContainerRegistry._ContainerRegistry__instance = registry
UM.Settings.ContainerStack._containerRegistry = registry
yield registry
UM.Settings.ContainerRegistry.ContainerRegistry._ContainerRegistry__instance = None
UM.Settings.ContainerStack._containerRegistry = None
#An empty global stack to test with.
@pytest.fixture()
def global_stack() -> cura.Settings.GlobalStack.GlobalStack:
return cura.Settings.GlobalStack.GlobalStack("TestStack")
@pytest.fixture()
def writable_global_stack(global_stack):
global_stack.userChanges = MockContainer("test_user_changes", "user")
global_stack.qualityChanges = MockContainer("test_quality_changes", "quality_changes")
global_stack.quality = MockContainer("test_quality", "quality")
global_stack.material = MockContainer("test_material", "material")
global_stack.variant = MockContainer("test_variant", "variant")
global_stack.definitionChanges = MockContainer("test_definition_changes", "definition_changes")
global_stack.definition = DefinitionContainerSubClass()
return global_stack
## Place-in function for findContainer that finds only containers that start
# with "some_".
def findSomeContainers(container_id = "*", container_type = None, type = None, category = "*"):
if container_id.startswith("some_"):
return UM.Settings.ContainerRegistry._EmptyInstanceContainer(container_id)
if container_type == DefinitionContainer:
definition_mock = unittest.mock.MagicMock()
definition_mock.getId = unittest.mock.MagicMock(return_value = "some_definition") #getId returns some_definition.
return definition_mock
## Helper function to read the contents of a container stack in the test
# stack folder.
#
# \param filename The name of the file in the "stacks" folder to read from.
# \return The contents of that file.
def readStack(filename):
with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "stacks", filename)) as file_handle:
serialized = file_handle.read()
return serialized
class DefinitionContainerSubClass(DefinitionContainer):
def __init__(self):
super().__init__(container_id = "SubDefinitionContainer")
class InstanceContainerSubClass(InstanceContainer):
def __init__(self):
super().__init__(container_id = "SubInstanceContainer")
#############################START OF TEST CASES################################
## Tests whether adding a container is properly forbidden.
def test_addContainer(global_stack):
with pytest.raises(InvalidOperationError):
global_stack.addContainer(unittest.mock.MagicMock())
## Tests adding extruders to the global stack.
def test_addExtruder(global_stack):
mock_definition = unittest.mock.MagicMock()
mock_definition.getProperty = lambda key, property: 2 if key == "machine_extruder_count" and property == "value" else None
with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
global_stack.definition = mock_definition
assert len(global_stack.extruders) == 0
first_extruder = unittest.mock.MagicMock()
with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
global_stack.addExtruder(first_extruder)
assert len(global_stack.extruders) == 1
assert global_stack.extruders[0] == first_extruder
second_extruder = unittest.mock.MagicMock()
with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
global_stack.addExtruder(second_extruder)
assert len(global_stack.extruders) == 2
assert global_stack.extruders[1] == second_extruder
with unittest.mock.patch("cura.Settings.CuraContainerStack.DefinitionContainer", unittest.mock.MagicMock):
with pytest.raises(TooManyExtrudersError): #Should be limited to 2 extruders because of machine_extruder_count.
global_stack.addExtruder(unittest.mock.MagicMock())
assert len(global_stack.extruders) == 2 #Didn't add the faulty extruder.
## Tests whether the container types are properly enforced on the stack.
#
# When setting a field to have a different type of stack than intended, we
# should get an exception.
@pytest.mark.parametrize("definition_container, instance_container", [
(DefinitionContainer(container_id = "TestDefinitionContainer"), InstanceContainer(container_id = "TestInstanceContainer")),
(DefinitionContainerSubClass(), InstanceContainerSubClass())
])
def test_constrainContainerTypes(definition_container, instance_container, global_stack):
instance_container.addMetaDataEntry("type", "")
with pytest.raises(InvalidContainerError): # Putting a definition container in the user changes is not allowed.
global_stack.userChanges = definition_container
with pytest.raises(InvalidContainerError):
global_stack.userChanges = instance_container # Putting a random instance container in the user changes is not allowed.
instance_container.setMetaDataEntry("type", "user") # After setting the metadata type entry correctly, we are allowed to set the container
global_stack.userChanges = instance_container
with pytest.raises(InvalidContainerError):
global_stack.qualityChanges = definition_container
with pytest.raises(InvalidContainerError):
global_stack.qualityChanges = instance_container
instance_container.setMetaDataEntry("type", "quality_changes")
global_stack.qualityChanges = instance_container
with pytest.raises(InvalidContainerError):
global_stack.quality = definition_container
with pytest.raises(InvalidContainerError):
global_stack.quality = instance_container
instance_container.setMetaDataEntry("type", "quality")
global_stack.quality = instance_container
with pytest.raises(InvalidContainerError):
global_stack.material = definition_container
with pytest.raises(InvalidContainerError):
global_stack.material = instance_container
instance_container.setMetaDataEntry("type", "material")
global_stack.material = instance_container
with pytest.raises(InvalidContainerError):
global_stack.variant = definition_container
with pytest.raises(InvalidContainerError):
global_stack.variant = instance_container
instance_container.setMetaDataEntry("type", "variant")
global_stack.variant = instance_container
with pytest.raises(InvalidContainerError):
global_stack.definitionChanges = definition_container
with pytest.raises(InvalidContainerError):
global_stack.definitionChanges = instance_container
instance_container.setMetaDataEntry("type", "definition_changes")
global_stack.definitionChanges = instance_container
with pytest.raises(InvalidContainerError): #Putting an instance container in the definition is not allowed.
global_stack.definition = instance_container
global_stack.definition = definition_container #Putting a definition container in the definition is allowed.
## Tests whether the user changes are being read properly from a global stack.
@pytest.mark.parametrize("filename, user_changes_id", [
("Global.global.cfg", "empty"),
("Global.stack.cfg", "empty"),
("MachineLegacy.stack.cfg", "empty"),
("OnlyUser.global.cfg", "some_instance"), #This one does have a user profile.
("Complete.global.cfg", "some_user_changes")
])
def test_deserializeUserChanges(filename, user_changes_id, container_registry, global_stack):
serialized = readStack(filename)
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.userChanges.getId() == user_changes_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests whether the quality changes are being read properly from a global
# stack.
@pytest.mark.parametrize("filename, quality_changes_id", [
("Global.global.cfg", "empty"),
("Global.stack.cfg", "empty"),
("MachineLegacy.stack.cfg", "empty"),
("OnlyQualityChanges.global.cfg", "some_instance"),
("Complete.global.cfg", "some_quality_changes")
])
def test_deserializeQualityChanges(filename, quality_changes_id, container_registry, global_stack):
serialized = readStack(filename)
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all the profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.qualityChanges.getId() == quality_changes_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests whether the quality profile is being read properly from a global
# stack.
@pytest.mark.parametrize("filename, quality_id", [
("Global.global.cfg", "empty"),
("Global.stack.cfg", "empty"),
("MachineLegacy.stack.cfg", "empty"),
("OnlyQuality.global.cfg", "some_instance"),
("Complete.global.cfg", "some_quality")
])
def test_deserializeQuality(filename, quality_id, container_registry, global_stack):
serialized = readStack(filename)
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all the profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.quality.getId() == quality_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests whether the material profile is being read properly from a global
# stack.
@pytest.mark.parametrize("filename, material_id", [
("Global.global.cfg", "some_instance"),
("Global.stack.cfg", "some_instance"),
("MachineLegacy.stack.cfg", "some_instance"),
("OnlyDefinition.global.cfg", "empty"),
("OnlyMaterial.global.cfg", "some_instance"),
("Complete.global.cfg", "some_material")
])
def test_deserializeMaterial(filename, material_id, container_registry, global_stack):
serialized = readStack(filename)
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all the profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.material.getId() == material_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests whether the variant profile is being read properly from a global
# stack.
@pytest.mark.parametrize("filename, variant_id", [
("Global.global.cfg", "empty"),
("Global.stack.cfg", "empty"),
("MachineLegacy.stack.cfg", "empty"),
("OnlyVariant.global.cfg", "some_instance"),
("Complete.global.cfg", "some_variant")
])
def test_deserializeVariant(filename, variant_id, container_registry, global_stack):
serialized = readStack(filename)
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all the profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.variant.getId() == variant_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests whether the definition changes profile is being read properly from a
# global stack.
@pytest.mark.parametrize("filename, definition_changes_id", [
("Global.global.cfg", "empty"),
("Global.stack.cfg", "empty"),
("MachineLegacy.stack.cfg", "empty"),
("OnlyDefinitionChanges.global.cfg", "some_instance"),
("Complete.global.cfg", "some_material")
])
def test_deserializeDefinitionChanges(filename, definition_changes_id, container_registry, global_stack):
serialized = readStack(filename)
global_stack = cura.Settings.GlobalStack.GlobalStack("TestStack")
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all the profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.definitionChanges.getId() == definition_changes_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests whether the definition is being read properly from a global stack.
@pytest.mark.parametrize("filename, definition_id", [
("Global.global.cfg", "some_definition"),
("Global.stack.cfg", "some_definition"),
("MachineLegacy.stack.cfg", "some_definition"),
("OnlyDefinition.global.cfg", "some_definition"),
("Complete.global.cfg", "some_definition")
])
def test_deserializeDefinition(filename, definition_id, container_registry, global_stack):
serialized = readStack(filename)
#Mock the loading of the instance containers.
global_stack.findContainer = findSomeContainers
original_container_registry = UM.Settings.ContainerStack._containerRegistry
UM.Settings.ContainerStack._containerRegistry = container_registry #Always has all the profiles you ask of.
global_stack.deserialize(serialized)
assert global_stack.definition.getId() == definition_id
#Restore.
UM.Settings.ContainerStack._containerRegistry = original_container_registry
## Tests that when a global stack is loaded with an unknown instance, it raises
# an exception.
def test_deserializeMissingContainer(global_stack):
serialized = readStack("Global.global.cfg")
with pytest.raises(Exception):
global_stack.deserialize(serialized)
try:
global_stack.deserialize(serialized)
except Exception as e:
#Must be exactly Exception, not one of its subclasses, since that is what gets raised when a stack has an unknown container.
#That's why we can't use pytest.raises.
assert type(e) == Exception
## Tests whether getProperty properly applies the stack-like behaviour on its
# containers.
def test_getPropertyFallThrough(global_stack):
#A few instance container mocks to put in the stack.
layer_height_5 = unittest.mock.MagicMock() #Sets layer height to 5.
layer_height_5.getProperty = lambda key, property: 5 if (key == "layer_height" and property == "value") else None
layer_height_5.hasProperty = lambda key: key == "layer_height"
layer_height_10 = unittest.mock.MagicMock() #Sets layer height to 10.
layer_height_10.getProperty = lambda key, property: 10 if (key == "layer_height" and property == "value") else None
layer_height_10.hasProperty = lambda key: key == "layer_height"
no_layer_height = unittest.mock.MagicMock() #No settings at all.
no_layer_height.getProperty = lambda key, property: None
no_layer_height.hasProperty = lambda key: False
global_stack.userChanges = no_layer_height
global_stack.qualityChanges = no_layer_height
global_stack.quality = no_layer_height
global_stack.material = no_layer_height
global_stack.variant = no_layer_height
global_stack.definitionChanges = no_layer_height
global_stack.definition = layer_height_5 #Here it is!
assert global_stack.getProperty("layer_height", "value") == 5
global_stack.definitionChanges = layer_height_10
assert global_stack.getProperty("layer_height", "value") == 10
global_stack.variant = layer_height_5
assert global_stack.getProperty("layer_height", "value") == 5
global_stack.material = layer_height_10
assert global_stack.getProperty("layer_height", "value") == 10
global_stack.quality = layer_height_5
assert global_stack.getProperty("layer_height", "value") == 5
global_stack.qualityChanges = layer_height_10
assert global_stack.getProperty("layer_height", "value") == 10
global_stack.userChanges = layer_height_5
assert global_stack.getProperty("layer_height", "value") == 5
def test_getPropertyWithResolve(global_stack):
#Define some containers for the stack.
resolve = unittest.mock.MagicMock() #Sets just the resolve for bed temperature.
resolve.getProperty = lambda key, property: 15 if (key == "material_bed_temperature" and property == "resolve") else None
resolve_and_value = unittest.mock.MagicMock() #Sets the resolve and value for bed temperature.
resolve_and_value.getProperty = lambda key, property: (7.5 if property == "resolve" else 5) if (key == "material_bed_temperature") else None #7.5 resolve, 5 value.
value = unittest.mock.MagicMock() #Sets just the value for bed temperature.
value.getProperty = lambda key, property: 10 if (key == "material_bed_temperature" and property == "value") else None
empty = unittest.mock.MagicMock() #Sets no value or resolve.
empty.getProperty = unittest.mock.MagicMock(return_value = None)
global_stack.definition = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 7.5 #Resolve wins in the definition.
global_stack.userChanges = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 5 #Value wins in other places.
global_stack.userChanges = value
assert global_stack.getProperty("material_bed_temperature", "value") == 10 #Resolve in the definition doesn't influence the value in the user changes.
global_stack.userChanges = resolve
assert global_stack.getProperty("material_bed_temperature", "value") == 15 #Falls through to definition for lack of values, but then asks the start of the stack for the resolve.
global_stack.userChanges = empty
global_stack.qualityChanges = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 5 #Value still wins in lower places, except definition.
global_stack.qualityChanges = empty
global_stack.quality = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 5
global_stack.quality = empty
global_stack.material = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 5
global_stack.material = empty
global_stack.variant = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 5
global_stack.variant = empty
global_stack.definitionChanges = resolve_and_value
assert global_stack.getProperty("material_bed_temperature", "value") == 5
## Tests whether the hasUserValue returns true for settings that are changed in
# the user-changes container.
def test_hasUserValueUserChanges(global_stack):
user_changes = MockContainer("test_user_changes", "user")
def hasProperty(key, property):
return key == "layer_height" and property == "value" # Only have the layer_height property set.
user_changes.hasProperty = hasProperty
global_stack.userChanges = user_changes
assert not global_stack.hasUserValue("infill_sparse_density")
assert global_stack.hasUserValue("layer_height")
assert not global_stack.hasUserValue("")
## Tests whether the hasUserValue returns true for settings that are changed in
# the quality-changes container.
def test_hasUserValueQualityChanges(global_stack):
quality_changes = MockContainer("test_quality_changes", "quality_changes")
def hasProperty(key, property):
return key == "layer_height" and property == "value" # Only have the layer_height property set.
quality_changes.hasProperty = hasProperty
global_stack.qualityChanges = quality_changes
assert not global_stack.hasUserValue("infill_sparse_density")
assert global_stack.hasUserValue("layer_height")
assert not global_stack.hasUserValue("")
## Tests whether inserting a container is properly forbidden.
def test_insertContainer(global_stack):
with pytest.raises(InvalidOperationError):
global_stack.insertContainer(0, unittest.mock.MagicMock())
## Tests whether removing a container is properly forbidden.
def test_removeContainer(global_stack):
with pytest.raises(InvalidOperationError):
global_stack.removeContainer(unittest.mock.MagicMock())
## Tests setting definitions by specifying an ID of a definition that exists.
def test_setDefinitionByIdExists(global_stack, container_registry):
global_stack.setDefinitionById("some_definition") #The container registry always has a container with the ID.
## Tests setting definitions by specifying an ID of a definition that doesn't
# exist.
def test_setDefinitionByIdDoesntExist(global_stack):
with pytest.raises(InvalidContainerError):
global_stack.setDefinitionById("some_definition") #Container registry is empty now.
## Tests setting definition changes by specifying an ID of a container that
# exists.
def test_setDefinitionChangesByIdExists(global_stack, container_registry):
container_registry.typeMetaData = "definition_changes"
global_stack.setDefinitionChangesById("some_definition_changes") #The container registry always has a container with the ID.
## Tests setting definition changes by specifying an ID of a container that
# doesn't exist.
def test_setDefinitionChangesByIdDoesntExist(global_stack):
with pytest.raises(InvalidContainerError):
global_stack.setDefinitionChangesById("some_definition_changes") #Container registry is empty now.
## Tests setting materials by specifying an ID of a material that exists.
def test_setMaterialByIdExists(global_stack, container_registry):
container_registry.typeMetaData = "material"
global_stack.setMaterialById("some_material") #The container registry always has a container with the ID.
## Tests setting materials by specifying an ID of a material that doesn't
# exist.
def test_setMaterialByIdDoesntExist(global_stack):
with pytest.raises(InvalidContainerError):
global_stack.setMaterialById("some_material") #Container registry is empty now.
## Tests whether changing the next stack is properly forbidden.
def test_setNextStack(global_stack):
with pytest.raises(InvalidOperationError):
global_stack.setNextStack(unittest.mock.MagicMock())
## Tests setting properties directly on the global stack.
@pytest.mark.parametrize("key, property, value, output_value", [
("layer_height", "value", 0.1337, 0.1337),
("foo", "value", 100, 100),
("support_enabled", "value", True, True),
("layer_height", "default_value", 0.1337, 0.1337),
("layer_height", "is_bright_pink", "of course", "of course")
])
def test_setPropertyUser(key, property, value, output_value, writable_global_stack):
writable_global_stack.setProperty(key, property, value)
assert writable_global_stack.userChanges.getProperty(key, property) == output_value
## Tests setting properties on specific containers on the global stack.
@pytest.mark.parametrize("target_container", [
"user",
"quality_changes",
"quality",
"material",
"variant",
"definition_changes",
])
def test_setPropertyOtherContainers(target_container, writable_global_stack):
#Other parameters that don't need to be varied.
key = "layer_height"
property = "value"
value = 0.1337
output_value = 0.1337
writable_global_stack.setProperty(key, property, value, target_container = target_container)
containers = {
"user": writable_global_stack.userChanges,
"quality_changes": writable_global_stack.qualityChanges,
"quality": writable_global_stack.quality,
"material": writable_global_stack.material,
"variant": writable_global_stack.variant,
"definition_changes": writable_global_stack.definitionChanges,
"definition": writable_global_stack.definition
}
assert containers[target_container].getProperty(key, property) == output_value
## Tests setting qualities by specifying an ID of a quality that exists.
def test_setQualityByIdExists(global_stack, container_registry):
container_registry.typeMetaData = "quality"
global_stack.setQualityById("some_quality") #The container registry always has a container with the ID.
## Tests setting qualities by specifying an ID of a quality that doesn't exist.
def test_setQualityByIdDoesntExist(global_stack):
with pytest.raises(InvalidContainerError):
global_stack.setQualityById("some_quality") #Container registry is empty now.
## Tests setting quality changes by specifying an ID of a quality change that
# exists.
def test_setQualityChangesByIdExists(global_stack, container_registry):
container_registry.typeMetaData = "quality_changes"
global_stack.setQualityChangesById("some_quality_changes") #The container registry always has a container with the ID.
## Tests setting quality changes by specifying an ID of a quality change that
# doesn't exist.
def test_setQualityChangesByIdDoesntExist(global_stack):
with pytest.raises(InvalidContainerError):
global_stack.setQualityChangesById("some_quality_changes") #Container registry is empty now.
## Tests setting variants by specifying an ID of a variant that exists.
def test_setVariantByIdExists(global_stack, container_registry):
container_registry.typeMetaData = "variant"
global_stack.setVariantById("some_variant") #The container registry always has a container with the ID.
## Tests setting variants by specifying an ID of a variant that doesn't exist.
def test_setVariantByIdDoesntExist(global_stack):
with pytest.raises(InvalidContainerError):
global_stack.setVariantById("some_variant") #Container registry is empty now.