def test_deserializeRemovesWrongContainerClass(global_stack):
global_stack._containers[cura.Settings.CuraContainerStack.
_ContainerIndexes.Quality] = DefinitionContainer(
container_id="wrong class")
global_stack._containers[cura.Settings.CuraContainerStack._ContainerIndexes
.Definition] = DefinitionContainer(
container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
global_stack.deserialize("")
assert global_stack.quality == global_stack._empty_instance_container #Replaced with empty.
def test_deserializeRemovesWrongContainerClass(extruder_stack):
extruder_stack._containers[
steslicer.Settings.SteSlicerContainerStack._ContainerIndexes.
Quality] = DefinitionContainer(container_id="wrong class")
extruder_stack._containers[
steslicer.Settings.SteSlicerContainerStack._ContainerIndexes.
Definition] = DefinitionContainer(container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.quality == extruder_stack._empty_instance_container #Replaced with empty.
def test_addContainer(container_registry):
definition_container_0 = DefinitionContainer("a")
assert definition_container_0.getMetaData(
) not in container_registry.findDefinitionContainersMetadata(
) # Sanity check.
assert definition_container_0 not in container_registry.findDefinitionContainers(
)
container_registry.addContainer(definition_container_0)
assert definition_container_0.getMetaData(
) in container_registry.findDefinitionContainersMetadata()
assert definition_container_0 in container_registry.findDefinitionContainers(
)
# Add a second one of the same type.
definition_container_1 = DefinitionContainer("b")
assert definition_container_1.getMetaData(
) not in container_registry.findDefinitionContainersMetadata(
) # Sanity check.
assert definition_container_1 not in container_registry.findDefinitionContainers(
) # Sanity check.
container_registry.addContainer(definition_container_1)
assert definition_container_1.getMetaData(
) in container_registry.findDefinitionContainersMetadata()
assert definition_container_1 in container_registry.findDefinitionContainers(
)
assert definition_container_0.getMetaData(
) in container_registry.findDefinitionContainersMetadata()
assert definition_container_0 in container_registry.findDefinitionContainers(
)
# Add a container with the same type and same ID.
definition_container_1_clone = DefinitionContainer("b")
container_registry.addContainer(definition_container_1_clone)
#Since comparing metadata is a deep comparison, you'll find that the metadata of the clone got in there. But it's not, it's just exactly the same as the original metadata so it appears as if it's in there.
assert definition_container_1_clone not in container_registry.findDefinitionContainers(
)
# For good measure, add a container with a different type too.
instance_container_1 = InstanceContainer("a")
assert instance_container_1.getMetaData(
) not in container_registry.findDefinitionContainersMetadata(
) # Sanity check.
assert instance_container_1 not in container_registry.findDefinitionContainers(
)
container_registry.addContainer(instance_container_1)
assert instance_container_1.getMetaData(
) not in container_registry.findDefinitionContainersMetadata()
assert instance_container_1 not in container_registry.findDefinitionContainers(
)
def test_serialize(container_stack):
registry = ContainerRegistry.getInstance() # All containers need to be registered in order to be recovered again after deserialising.
# First test the empty container stack.
_test_serialize_cycle(container_stack)
# Case with one subcontainer.
container = InstanceContainer(str(uuid.uuid4()))
registry.addContainer(container)
container_stack.addContainer(container)
_test_serialize_cycle(container_stack)
# Case with two subcontainers.
container = InstanceContainer(str(uuid.uuid4()))
registry.addContainer(container)
container_stack.addContainer(container) # Already had one, if all previous assertions were correct.
_test_serialize_cycle(container_stack)
# Case with all types of subcontainers.
container = DefinitionContainer(str(uuid.uuid4()))
registry.addContainer(container)
container_stack.addContainer(container)
container = ContainerStack(str(uuid.uuid4()))
registry.addContainer(container)
container_stack.addContainer(container)
_test_serialize_cycle(container_stack)
# With some metadata.
container_stack.getMetaData()["foo"] = "bar"
_test_serialize_cycle(container_stack)
# With a changed name.
container_stack.setName("Fred")
_test_serialize_cycle(container_stack)
# A name with special characters, to test the encoding.
container_stack.setName("ルベン")
_test_serialize_cycle(container_stack)
# Just to bully the one who implements this, a name with special characters in JSON and CFG.
container_stack.setName("=,\"")
_test_serialize_cycle(container_stack)
# A container that is not in the registry.
container_stack.addContainer(DefinitionContainer(str(uuid.uuid4())))
serialised = container_stack.serialize()
container_stack = ContainerStack(str(uuid.uuid4())) # Completely fresh container stack.
with pytest.raises(Exception):
container_stack.deserialize(serialised)
def __init__(self):
super().__init__()
self._settings = None
self._stack = None
setting_data = self.getSettingData()
self._stack = ContainerStack(stack_id = str(id(self)))
self._stack.setDirty(False) # This stack does not need to be saved.
## Check if the definition of this script already exists. If not, add it to the registry.
if "key" in setting_data:
definitions = ContainerRegistry.getInstance().findDefinitionContainers(id = setting_data["key"])
if definitions:
# Definition was found
self._definition = definitions[0]
else:
self._definition = DefinitionContainer(setting_data["key"])
self._definition.deserialize(json.dumps(setting_data))
ContainerRegistry.getInstance().addContainer(self._definition)
self._stack.addContainer(self._definition)
self._instance = InstanceContainer(container_id="ScriptInstanceContainer")
self._instance.setDefinition(self._definition.getId())
self._instance.addMetaDataEntry("setting_version", self._definition.getMetaDataEntry("setting_version", default = 0))
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onPropertyChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
def findContainers(container_type=0, id=None):
if id == "some_instance":
return [UM.Settings.ContainerRegistry._EmptyInstanceContainer(id)]
elif id == "some_definition":
return [DefinitionContainer(container_id=id)]
else:
return []
def test_deserializeRemovesWrongContainerClass(extruder_stack):
"""Tests whether a container with the wrong class gets removed when deserialising."""
extruder_stack._containers[
cura.Settings.CuraContainerStack._ContainerIndexes.
Quality] = DefinitionContainer(container_id="wrong class")
extruder_stack._containers[
cura.Settings.CuraContainerStack._ContainerIndexes.
Definition] = DefinitionContainer(container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.quality == extruder_stack._empty_instance_container #Replaced with empty.
def test_approximateMaterialDiameter(diameter, approximate_diameter,
global_stack):
global_stack.definition = DefinitionContainer(
container_id="TestDefinition")
global_stack.definition._metadata["material_diameter"] = str(diameter)
assert float(
global_stack.approximateMaterialDiameter) == approximate_diameter
def test_containers_provider(
container_provider: ContainerProvider,
upgrade_manager: VersionUpgradeManager) -> ContainerProvider:
my_folder = os.path.dirname(os.path.abspath(__file__))
definition_ids = {
"basic_definition", "children", "functions", "inherits",
"metadata_definition", "multiple_settings", "single_setting"
}
for definition_id in definition_ids:
container = DefinitionContainer(definition_id)
container.deserialize(
open(
os.path.join(my_folder, "definitions",
definition_id + ".def.json")).read())
container_provider._containers[definition_id] = container
container_provider.addMetadata(container.getMetaData())
instance_ids = {"basic_instance", "metadata_instance", "setting_values"}
for instance_id in instance_ids:
container = UM.Settings.InstanceContainer.InstanceContainer(
instance_id)
container.deserialize(
open(
os.path.join(my_folder, "instances",
instance_id + ".inst.cfg")).read())
container_provider._containers[instance_id] = container
container_provider.addMetadata(container.getMetaData())
return container_provider
def test_removeContainer(container_registry):
# Removing a container that isn't added shouldn't break
container_registry.removeContainer("NotAContainerThatIsLoaded")
test_container = DefinitionContainer("omgzomg")
container_registry.addContainer(test_container)
container_registry.removeContainer("omgzomg")
assert not container_registry.isLoaded("omgzomg")
def collectAllSettingIds():
VersionUpgradeManager._VersionUpgradeManager__instance = VersionUpgradeManager(MagicMock())
CuraApplication._initializeSettingDefinitions()
definition_container = DefinitionContainer("whatever")
with open(os.path.join(os.path.dirname(__file__), "..", "..", "resources", "definitions", "fdmprinter.def.json"), encoding = "utf-8") as data:
definition_container.deserialize(data.read())
return definition_container.getAllKeys()
def test_readOnly(container_registry):
assert not container_registry.isReadOnly("NotAContainerThatIsLoaded")
test_container = DefinitionContainer("omgzomg")
container_registry.addContainer(test_container)
mock_provider = MagicMock()
mock_provider.isReadOnly = MagicMock(return_value=True)
container_registry.source_provider = {"omgzomg": mock_provider}
assert container_registry.isReadOnly("omgzomg")
def test_findDefinitionContainers(container_registry, data):
for container in data["containers"]: # Fill the registry with mock containers.
definition_container = DefinitionContainer(container["id"])
for key, value in container.items(): # Copy data into metadata.
definition_container.getMetaData()[key] = value
container_registry.addContainer(definition_container)
results = container_registry.findDefinitionContainers(**data["filter"]) # The actual function call we're testing.
_verifyMetaDataMatches(results, data["result"])
def test_getContainerFilePathByID(container_registry):
# There is no provider and the container isn't even there.
assert container_registry.getContainerFilePathById("NotAContainerThatIsLoaded") is None
test_container = DefinitionContainer("omgzomg")
container_registry.addContainer(test_container)
mock_provider = MagicMock()
mock_provider.getContainerFilePathById = MagicMock(return_value="")
container_registry.source_provider = {"omgzomg": mock_provider}
assert container_registry.getContainerFilePathById("omgzomg") == ""
def test_deserializeCompletesEmptyContainers(extruder_stack: cura.Settings.ExtruderStack):
extruder_stack._containers = [DefinitionContainer(container_id = "definition")] #Set the internal state of this stack manually.
with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert len(extruder_stack.getContainers()) == len(cura.Settings.CuraContainerStack._ContainerIndexes.IndexTypeMap) #Needs a slot for every type.
for container_type_index in cura.Settings.CuraContainerStack._ContainerIndexes.IndexTypeMap:
if container_type_index == cura.Settings.CuraContainerStack._ContainerIndexes.Definition: #We're not checking the definition.
continue
assert extruder_stack.getContainer(container_type_index).getId() == "empty" #All others need to be empty.
def test_deserializeCompletesEmptyContainers(global_stack):
global_stack._containers = [DefinitionContainer(container_id = "definition"), global_stack.definitionChanges] #Set the internal state of this stack manually.
with unittest.mock.patch("UM.Settings.ContainerStack.ContainerStack.deserialize", unittest.mock.MagicMock()): #Prevent calling super().deserialize.
global_stack.deserialize("")
assert len(global_stack.getContainers()) == len(cura.Settings.CuraContainerStack._ContainerIndexes.IndexTypeMap) #Needs a slot for every type.
for container_type_index in cura.Settings.CuraContainerStack._ContainerIndexes.IndexTypeMap:
if container_type_index in \
(cura.Settings.CuraContainerStack._ContainerIndexes.Definition, cura.Settings.CuraContainerStack._ContainerIndexes.DefinitionChanges): #We're not checking the definition or definition_changes
continue
assert global_stack.getContainer(container_type_index) == empty_container #All others need to be empty.
def test_deserializeMoveDefinitionContainer(extruder_stack):
extruder_stack._containers[
steslicer.Settings.SteSlicerContainerStack.
_ContainerIndexes.Material] = DefinitionContainer(
container_id="some definition") #Not in the correct spot.
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.material == empty_container
assert extruder_stack.definition != empty_container
def test_deserializeMoveDefinitionContainer(global_stack):
global_stack._containers[
cura.Settings.CuraContainerStack.
_ContainerIndexes.Material] = DefinitionContainer(
container_id="some definition") #Not in the correct spot.
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
global_stack.deserialize("")
assert global_stack.material == empty_container
assert global_stack.definition != empty_container
def test_approximateMaterialDiameter(diameter, approximate_diameter,
global_stack):
global_stack.definition = DefinitionContainer(
container_id="TestDefinition")
material_diameter = UM.Settings.SettingDefinition.SettingDefinition(
key="material_diameter", container=global_stack.definition)
material_diameter.addSupportedProperty(
"value",
UM.Settings.SettingDefinition.DefinitionPropertyType.Any,
default=diameter)
global_stack.definition.definitions.append(material_diameter)
assert float(
global_stack.approximateMaterialDiameter) == approximate_diameter
def test_addContainer(container_registry):
definition_container_0 = DefinitionContainer("a", {})
assert definition_container_0 not in container_registry.findDefinitionContainers() # Sanity check.
container_registry.addContainer(definition_container_0)
assert definition_container_0 in container_registry.findDefinitionContainers()
# Add a second one of the same type.
definition_container_1 = DefinitionContainer("b", {})
assert definition_container_1 not in container_registry.findDefinitionContainers() # Sanity check.
container_registry.addContainer(definition_container_1)
assert definition_container_1 in container_registry.findDefinitionContainers()
assert definition_container_0 in container_registry.findDefinitionContainers()
# Add a container with the same type and same ID.
definition_container_1_clone = DefinitionContainer("b", {})
container_registry.addContainer(definition_container_1_clone)
assert definition_container_1_clone not in container_registry.findDefinitionContainers() # Didn't get added!
# For good measure, add a container with a different type too.
instance_container_1 = InstanceContainer("a")
assert instance_container_1 not in container_registry.findDefinitionContainers() # Sanity check.
container_registry.addContainer(instance_container_1)
assert instance_container_1 not in container_registry.findDefinitionContainers()
def test_deserializeRemovesWrongInstanceContainer(extruder_stack):
extruder_stack._containers[
cura.Settings.CuraContainerStack._ContainerIndexes.
Quality] = getInstanceContainer(container_type="wrong type")
extruder_stack._containers[
cura.Settings.CuraContainerStack._ContainerIndexes.
Definition] = DefinitionContainer(container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.quality == extruder_stack._empty_instance_container #Replaced with empty.
def test_deserializeMoveDefinitionContainer(extruder_stack):
"""Tests whether a definition container in the wrong spot is moved into the correct spot by deserialising."""
extruder_stack._containers[
cura.Settings.CuraContainerStack.
_ContainerIndexes.Material] = DefinitionContainer(
container_id="some definition") #Not in the correct spot.
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.material == empty_container
assert extruder_stack.definition != empty_container
def test_deserializeMoveDefinitionContainer(extruder_stack):
extruder_stack._containers[
cura.Settings.CuraContainerStack.
_ContainerIndexes.Material] = DefinitionContainer(
container_id="some definition") #Not in the correct spot.
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.material.getId() == "empty"
assert extruder_stack.definition.getId() != "empty"
UM.Settings.ContainerStack._containerRegistry = None
def test_deserializeMoveInstanceContainer(extruder_stack):
extruder_stack._containers[
cura.Settings.CuraContainerStack.
_ContainerIndexes.Quality] = getInstanceContainer(
container_type="material") #Not in the correct spot.
extruder_stack._containers[
cura.Settings.CuraContainerStack._ContainerIndexes.
Definition] = DefinitionContainer(container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.quality.getId() == "empty"
assert extruder_stack.material.getId() != "empty"
def test_deserializeMoveInstanceContainer(global_stack):
global_stack._containers[
steslicer.Settings.SteSlicerContainerStack.
_ContainerIndexes.Quality] = getInstanceContainer(
container_type="material") #Not in the correct spot.
global_stack._containers[
steslicer.Settings.SteSlicerContainerStack._ContainerIndexes.
Definition] = DefinitionContainer(container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
global_stack.deserialize("")
assert global_stack.quality == empty_container
assert global_stack.material != empty_container
def test_getHasErrors(container_stack):
definition_container = DefinitionContainer(str(uuid.uuid4()))
container_stack.addContainer(definition_container)
definition_container.getAllKeys = MagicMock(return_value={"test_key"})
container = MagicMock()
container_stack.addContainer(container)
# We won't get any wrong validation states, so it shouldn't have errors.
assert not container_stack.hasErrors()
# Fake the property so it does return validation state
container.getProperty = MagicMock(return_value=ValidatorState.MaximumError)
assert container_stack.hasErrors() # Now the container stack has errors!
assert container_stack.getErrorKeys() == ["test_key"]
def load_definitions(self):
"""
Load all the setting definitions into a custom definition container.
This definition container also contains extra entries for the articles
that are not settings.
The result is stored in `self.definition_container`.
"""
if self.definition_container:
return # Already done earlier. Don't re-load.
with open(os.path.join(os.path.dirname(__file__), "resources", "settings_guide_definitions.def.json")) as f:
definitions_serialised = f.read()
self.definition_container = DefinitionContainer("settings_guide_definitions")
self.definition_container.deserialize(definitions_serialised)
ContainerRegistry.getInstance().addContainer(self.definition_container)
def test_roundtrip_definition(tmpdir, process_count, loaded_container_registry):
definition = loaded_container_registry.findDefinitionContainers(id = "multiple_settings")[0]
temp_file = tmpdir.join("container_stack_test")
mp_run(process_count, write_data, temp_file, definition)
assert len(list(tmpdir.listdir())) == 1
results = mp_run(process_count, read_data, temp_file)
for result in results:
deserialized_definition = DefinitionContainer("multiple_settings")
deserialized_definition.deserialize(result)
assert deserialized_definition.getName() == definition.getName()
assert deserialized_definition.getMetaData() == definition.getMetaData()
def test_deserializeMoveInstanceContainer(extruder_stack):
"""Tests whether an instance container with the wrong type is moved into the correct slot by deserialising."""
extruder_stack._containers[
cura.Settings.CuraContainerStack.
_ContainerIndexes.Quality] = getInstanceContainer(
container_type="material") #Not in the correct spot.
extruder_stack._containers[
cura.Settings.CuraContainerStack._ContainerIndexes.
Definition] = DefinitionContainer(container_id="some definition")
with unittest.mock.patch(
"UM.Settings.ContainerStack.ContainerStack.deserialize",
unittest.mock.MagicMock()): #Prevent calling super().deserialize.
extruder_stack.deserialize("")
assert extruder_stack.quality == empty_container
assert extruder_stack.material != empty_container
def createModel(definition="multiple_settings.def.json"):
model = SettingDefinitionsModel()
# Get a basic definition container
uid = str(uuid.uuid4())
definition_container = DefinitionContainer(uid)
with open(os.path.join(os.path.dirname(os.path.abspath(__file__)),
"definitions", definition),
encoding="utf-8") as data:
json = data.read()
definition_container.deserialize(json)
model._container = definition_container
model.setShowAll(True)
model.forceUpdate()
model._updateVisibleRows()
return model
