Merge branch 'master' into feature_intent

Conflicts:
	resources/bundled_packages/cura.json -> 4.1 to 4.2 upgrade package added simultaneously
	tests/TestMachineManager.py -> Due to changes in conftest.py
	tests/conftest.py -> Simultaneously expanding the magic mocks to have some correct properties

tests/Settings/TestCuraContainerRegistry.py

@@ -12,7 +12,7 @@ from cura.Settings.GlobalStack import GlobalStack #Testing for returning the cor
 import UM.Settings.InstanceContainer #Creating instance containers to register.
 import UM.Settings.ContainerRegistry #Making empty container stacks.
 import UM.Settings.ContainerStack #Setting the container registry here properly.
-
+import cura.CuraApplication
 
 def teardown():
     #If the temporary file for the legacy file rename test still exists, remove it.
@@ -299,4 +299,20 @@ class TestImportProfile:
         with unittest.mock.patch.object(container_registry, "createUniqueName", return_value="derp"):
             with unittest.mock.patch.object(container_registry, "_configureProfile", return_value=None):
                 result = container_registry.importProfile("test.zomg")
-        assert result["status"] == "ok"
+        assert result["status"] == "ok"
+
+
+@pytest.mark.parametrize("metadata,result", [(None, False),
+                                             ({}, False),
+                                             ({"setting_version": cura.CuraApplication.CuraApplication.SettingVersion}, True),
+                                             ({"setting_version": 0}, False)])
+def test_isMetaDataValid(container_registry, metadata, result):
+    assert container_registry._isMetadataValid(metadata) == result
+
+
+def test_getIOPlugins(container_registry):
+    plugin_registry = unittest.mock.MagicMock()
+    plugin_registry.getActivePlugins = unittest.mock.MagicMock(return_value = ["lizard"])
+    plugin_registry.getMetaData = unittest.mock.MagicMock(return_value = {"zomg": {"test": "test"}})
+    with unittest.mock.patch("UM.PluginRegistry.PluginRegistry.getInstance", unittest.mock.MagicMock(return_value = plugin_registry)):
+        assert container_registry._getIOPlugins("zomg") == [("lizard", {"zomg": {"test": "test"}})]

tests/TestCuraSceneNode.py

@@ -0,0 +1,54 @@
+from UM.Math.Polygon import Polygon
+from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
+from cura.Scene.CuraSceneNode import CuraSceneNode
+import pytest
+
+from unittest.mock import patch
+
+
+class MockedConvexHullDecorator(SceneNodeDecorator):
+    def __init__(self):
+        super().__init__()
+
+    def getConvexHull(self):
+        return Polygon([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+
+
+class InvalidConvexHullDecorator(SceneNodeDecorator):
+    def __init__(self):
+        super().__init__()
+
+    def getConvexHull(self):
+        return Polygon()
+
+
+@pytest.fixture()
+def cura_scene_node():
+    # Replace the SettingOverrideDecorator with an empty decorator
+    with patch("cura.Scene.CuraSceneNode.SettingOverrideDecorator", SceneNodeDecorator):
+        return CuraSceneNode()
+
+
+class TestCollidesWithAreas:
+    def test_noConvexHull(self, cura_scene_node):
+        assert not cura_scene_node.collidesWithAreas([Polygon([[10, 10], [-10, 10], [-10, -10], [10, -10]])])
+
+    def test_convexHullIntersects(self, cura_scene_node):
+        cura_scene_node.addDecorator(MockedConvexHullDecorator())
+        assert cura_scene_node.collidesWithAreas([Polygon([[10, 10], [-10, 10], [-10, -10], [10, -10]])])
+
+    def test_convexHullNoIntersection(self, cura_scene_node):
+        cura_scene_node.addDecorator(MockedConvexHullDecorator())
+
+        assert not cura_scene_node.collidesWithAreas([Polygon([[60, 60], [40, 60], [40, 40], [60, 40]])])
+
+    def test_invalidConvexHull(self, cura_scene_node):
+        cura_scene_node.addDecorator(InvalidConvexHullDecorator())
+        assert not cura_scene_node.collidesWithAreas([Polygon([[10, 10], [-10, 10], [-10, -10], [10, -10]])])
+
+
+def test_outsideBuildArea(cura_scene_node):
+    cura_scene_node.setOutsideBuildArea(True)
+    assert cura_scene_node.isOutsideBuildArea
+
+

tests/TestExtruderManager.py

@@ -0,0 +1,31 @@
+
+from unittest.mock import MagicMock, patch
+
+
+def createMockedExtruder(extruder_id):
+    extruder = MagicMock()
+    extruder.getId = MagicMock(return_value = extruder_id)
+    return extruder
+
+
+def test_getAllExtruderSettings(extruder_manager):
+    extruder_1 = createMockedExtruder("extruder_1")
+    extruder_1.getProperty = MagicMock(return_value ="beep")
+    extruder_2 = createMockedExtruder("extruder_2")
+    extruder_2.getProperty = MagicMock(return_value="zomg")
+    extruder_manager.getActiveExtruderStacks = MagicMock(return_value = [extruder_1, extruder_2])
+    assert extruder_manager.getAllExtruderSettings("whatever", "value") == ["beep", "zomg"]
+
+
+def test_registerExtruder(extruder_manager):
+    extruder = createMockedExtruder("beep")
+    extruder.getMetaDataEntry = MagicMock(return_value = "0")  # because the extruder position gets called
+
+    extruder_manager.extrudersChanged = MagicMock()
+    extruder_manager.registerExtruder(extruder, "zomg")
+
+    assert extruder_manager.extrudersChanged.emit.call_count == 1
+
+    # Doing it again should not trigger anything
+    extruder_manager.registerExtruder(extruder, "zomg")
+    assert extruder_manager.extrudersChanged.emit.call_count == 1

tests/TestLayer.py

@@ -0,0 +1,39 @@
+from cura.Layer import Layer
+from unittest.mock import MagicMock
+
+
+def test_lineMeshVertexCount():
+    layer = Layer(1)
+    layer_polygon = MagicMock()
+    layer_polygon.lineMeshVertexCount = MagicMock(return_value = 9001)
+    layer.polygons.append(layer_polygon)
+    assert layer.lineMeshVertexCount() == 9001
+
+
+def test_lineMeshElementCount():
+    layer = Layer(1)
+    layer_polygon = MagicMock()
+    layer_polygon.lineMeshElementCount = MagicMock(return_value = 9001)
+    layer.polygons.append(layer_polygon)
+    assert layer.lineMeshElementCount() == 9001
+
+
+def test_getAndSet():
+    layer = Layer(0)
+
+    layer.setThickness(12)
+    assert layer.thickness == 12
+
+    layer.setHeight(0.1)
+    assert layer.height == 0.1
+
+
+def test_elementCount():
+    layer = Layer(1)
+    layer_polygon = MagicMock()
+    layer_polygon.lineMeshElementCount = MagicMock(return_value=9002)
+    layer_polygon.lineMeshVertexCount = MagicMock(return_value=9001)
+    layer_polygon.elementCount = 12
+    layer.polygons.append(layer_polygon)
+    assert layer.build(0, 0, [], [], [], [], [] ,[] , []) == (9001, 9002)
+    assert layer.elementCount == 12

tests/TestMachineManager.py

@@ -2,6 +2,26 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
+from cura.Settings.MachineManager import MachineManager
+
+
+@pytest.fixture()
+def global_stack():
+    stack = MagicMock(name = "Global Stack")
+    stack.getId = MagicMock(return_value = "GlobalStack")
+    return stack
+
+
+@pytest.fixture()
+def machine_manager(application, extruder_manager, container_registry, global_stack) -> MachineManager:
+    application.getExtruderManager = MagicMock(return_value = extruder_manager)
+    application.getGlobalContainerStack = MagicMock(return_value = global_stack)
+    with patch("cura.Settings.CuraContainerRegistry.CuraContainerRegistry.getInstance", MagicMock(return_value=container_registry)):
+        manager = MachineManager(application)
+
+    return manager
+
+
 def test_setActiveMachine(machine_manager):
     registry = MagicMock()
 
@@ -17,6 +37,29 @@ def test_setActiveMachine(machine_manager):
             machine_manager._application.setGlobalContainerStack.assert_called_with(mocked_global_stack)
 
 
+def test_getMachine():
+    registry = MagicMock()
+    mocked_global_stack = MagicMock()
+    mocked_global_stack.getId = MagicMock(return_value="test_machine")
+    mocked_global_stack.definition.getId = MagicMock(return_value = "test")
+    registry.findContainerStacks = MagicMock(return_value=[mocked_global_stack])
+    with patch("cura.Settings.CuraContainerRegistry.CuraContainerRegistry.getInstance", MagicMock(return_value=registry)):
+        assert MachineManager.getMachine("test") == mocked_global_stack
+
+
+def test_addMachine(machine_manager):
+    registry = MagicMock()
+
+    mocked_stack = MagicMock()
+    mocked_stack.getId = MagicMock(return_value="newlyCreatedStack")
+    mocked_create_machine = MagicMock(name="createMachine", return_value = mocked_stack)
+    machine_manager.setActiveMachine = MagicMock()
+    with patch("cura.Settings.CuraStackBuilder.CuraStackBuilder.createMachine", mocked_create_machine):
+        with patch("cura.Settings.CuraContainerRegistry.CuraContainerRegistry.getInstance", MagicMock(return_value=registry)):
+            machine_manager.addMachine("derp")
+    machine_manager.setActiveMachine.assert_called_with("newlyCreatedStack")
+
+
 def test_hasUserSettings(machine_manager, application):
     mocked_stack = application.getGlobalContainerStack()
 
@@ -35,3 +78,73 @@ def test_totalNumberOfSettings(machine_manager):
     registry.findDefinitionContainers = MagicMock(return_value = [mocked_definition])
     with patch("cura.Settings.CuraContainerRegistry.CuraContainerRegistry.getInstance", MagicMock(return_value=registry)):
         assert machine_manager.totalNumberOfSettings == 3
+
+
+def createMockedExtruder(extruder_id):
+    extruder = MagicMock()
+    extruder.getId = MagicMock(return_value = extruder_id)
+    return extruder
+
+
+def createMockedInstanceContainer(instance_id, name = ""):
+    instance = MagicMock()
+    instance.getName = MagicMock(return_value = name)
+    instance.getId = MagicMock(return_value=instance_id)
+    return instance
+
+
+def test_allActiveMaterialIds(machine_manager, extruder_manager):
+    extruder_1 = createMockedExtruder("extruder_1")
+    extruder_2 = createMockedExtruder("extruder_2")
+    extruder_1.material = createMockedInstanceContainer("material_1")
+    extruder_2.material = createMockedInstanceContainer("material_2")
+    extruder_manager.getActiveExtruderStacks = MagicMock(return_value = [extruder_1, extruder_2])
+    assert machine_manager.allActiveMaterialIds == {"extruder_1": "material_1", "extruder_2": "material_2"}
+
+
+def test_activeVariantNames(machine_manager, extruder_manager):
+    extruder_1 = createMockedExtruder("extruder_1")
+    extruder_2 = createMockedExtruder("extruder_2")
+    extruder_1.getMetaDataEntry = MagicMock(return_value = "0")
+    extruder_2.getMetaDataEntry = MagicMock(return_value= "2")
+    extruder_1.variant = createMockedInstanceContainer("variant_1", "variant_name_1")
+    extruder_2.variant = createMockedInstanceContainer("variant_2", "variant_name_2")
+    extruder_manager.getActiveExtruderStacks = MagicMock(return_value=[extruder_1, extruder_2])
+
+    assert machine_manager.activeVariantNames == {"0": "variant_name_1", "2": "variant_name_2"}
+
+
+def test_globalVariantName(machine_manager, application):
+    global_stack = application.getGlobalContainerStack()
+    global_stack.variant = createMockedInstanceContainer("beep", "zomg")
+    assert machine_manager.globalVariantName == "zomg"
+
+
+def test_activeMachineDefinitionName(machine_manager):
+    global_stack = machine_manager.activeMachine
+    global_stack.definition = createMockedInstanceContainer("beep", "zomg")
+    assert machine_manager.activeMachineDefinitionName == "zomg"
+
+
+def test_activeMachineId(machine_manager):
+    assert machine_manager.activeMachineId == "GlobalStack"
+
+
+def test_activeVariantBuildplateName(machine_manager):
+    global_stack = machine_manager.activeMachine
+    global_stack.variant = createMockedInstanceContainer("beep", "zomg")
+    assert machine_manager.activeVariantBuildplateName == "zomg"
+
+
+def test_resetSettingForAllExtruders(machine_manager):
+    global_stack = machine_manager.activeMachine
+    extruder_1 = createMockedExtruder("extruder_1")
+    extruder_2 = createMockedExtruder("extruder_2")
+    extruder_1.userChanges = createMockedInstanceContainer("settings_1")
+    extruder_2.userChanges = createMockedInstanceContainer("settings_2")
+    global_stack.extruders = {"1": extruder_1, "2": extruder_2}
+
+    machine_manager.resetSettingForAllExtruders("whatever")
+
+    extruder_1.userChanges.removeInstance.assert_called_once_with("whatever")
+    extruder_2.userChanges.removeInstance.assert_called_once_with("whatever")

tests/TestMaterialManager.py

@@ -4,8 +4,8 @@ from cura.Machines.MaterialManager import MaterialManager
 
 
 mocked_registry = MagicMock()
-material_1 = {"id": "test", "GUID":"TEST!", "base_file": "base_material", "definition": "fdmmachine", "approximate_diameter": 3, "brand": "generic"}
-material_2 = {"id": "base_material", "GUID": "TEST2!", "base_file": "test", "definition": "fdmmachine", "approximate_diameter": 3}
+material_1 = {"id": "test", "GUID":"TEST!", "base_file": "base_material", "definition": "fdmmachine", "approximate_diameter": "3", "brand": "generic", "material": "pla"}
+material_2 = {"id": "base_material", "GUID": "TEST2!", "base_file": "test", "definition": "fdmmachine", "approximate_diameter": "3", "material": "pla"}
 mocked_registry.findContainersMetadata = MagicMock(return_value = [material_1, material_2])
 
 
@@ -24,21 +24,116 @@ def test_initialize(application):
     assert manager.getMaterialGroup("test").name == "test"
 
 
-def test_getAvailableMaterials(application):
+def test_getMaterialGroupListByGUID(application):
     with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
         manager = MaterialManager(mocked_registry)
     manager.initialize()
 
-    available_materials = manager.getAvailableMaterials(mocked_definition, None, None, 3)
+    assert manager.getMaterialGroupListByGUID("TEST!")[0].name == "test"
+    assert manager.getMaterialGroupListByGUID("TEST2!")[0].name == "base_material"
 
-    assert "base_material" in available_materials
-    assert "test" in available_materials
+
+def test_getRootMaterialIDforDiameter(application):
+    with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+        manager = MaterialManager(mocked_registry)
+    manager.initialize()
+
+    assert manager.getRootMaterialIDForDiameter("base_material", "3") == "base_material"
+
+
+def test_getMaterialNodeByTypeMachineHasNoMaterials(application):
+    with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+        manager = MaterialManager(mocked_registry)
+    manager.initialize()
+
+    mocked_stack = MagicMock()
+    assert manager.getMaterialNodeByType(mocked_stack, "0", "nozzle", "", "") is None
+
+
+def test_getMaterialNodeByTypeMachineHasMaterialsButNoMaterialFound(application):
+    with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+        manager = MaterialManager(mocked_registry)
+    manager.initialize()
+
+    mocked_stack = MagicMock()
+    mocked_stack.definition.getMetaDataEntry = MagicMock(return_value = True)  # For the "has_materials" metadata
+
+    assert manager.getMaterialNodeByType(mocked_stack, "0", "nozzle", "", "") is None
+
+
+def test_getMaterialNodeByTypeMachineHasMaterialsAndMaterialExists(application):
+    with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+        manager = MaterialManager(mocked_registry)
+    manager.initialize()
+    mocked_result = MagicMock()
+    manager.getMaterialNode = MagicMock(return_value = mocked_result)
+    mocked_stack = MagicMock()
+    mocked_stack.definition.getMetaDataEntry = MagicMock(return_value = True)  # For the "has_materials" metadata
+
+    assert manager.getMaterialNodeByType(mocked_stack, "0", "nozzle", "", "TEST!") is mocked_result
+
+
+def test_getAllMaterialGroups(application):
+    with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+        manager = MaterialManager(mocked_registry)
+    manager.initialize()
+
+    material_groups = manager.getAllMaterialGroups()
+
+    assert "base_material" in material_groups
+    assert "test" in material_groups
+    assert material_groups["base_material"].name == "base_material"
+    assert material_groups["test"].name == "test"
+
+
+class TestAvailableMaterials:
+    def test_happy(self, application):
+        with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+            manager = MaterialManager(mocked_registry)
+        manager.initialize()
+
+        available_materials = manager.getAvailableMaterials(mocked_definition, None, None, 3)
+
+        assert "base_material" in available_materials
+        assert "test" in available_materials
+
+    def test_wrongDiameter(self, application):
+        with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+            manager = MaterialManager(mocked_registry)
+        manager.initialize()
+
+        available_materials = manager.getAvailableMaterials(mocked_definition, None, None, 200)
+        assert available_materials == {} # Nothing found.
+
+    def test_excludedMaterials(self, application):
+        with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+            manager = MaterialManager(mocked_registry)
+        manager.initialize()
+        with patch.object(mocked_definition, "getMetaDataEntry", MagicMock(return_value = ["test"])):
+            available_materials = manager.getAvailableMaterials(mocked_definition, None, None, 3)
+        assert "base_material" in available_materials
+        assert "test" not in available_materials
+
+
+class Test_getFallbackMaterialIdByMaterialType:
+    def test_happyFlow(self, application):
+        with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+            manager = MaterialManager(mocked_registry)
+        manager.initialize()
+
+        assert manager.getFallbackMaterialIdByMaterialType("pla") == "test"
+
+    def test_unknownMaterial(self, application):
+        with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
+            manager = MaterialManager(mocked_registry)
+        manager.initialize()
+        assert manager.getFallbackMaterialIdByMaterialType("OMGZOMG") is None
 
 
 def test_getMaterialNode(application):
     with patch("UM.Application.Application.getInstance", MagicMock(return_value=application)):
         manager = MaterialManager(mocked_registry)
-    manager.initialize()
+    manager._updateMaps()
 
     assert manager.getMaterialNode("fdmmachine", None, None, 3, "base_material").getMetaDataEntry("id") == "test"
 

tests/TestQualityManager.py

@@ -1,11 +1,10 @@
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 import pytest
 
+from cura.Machines.QualityChangesGroup import QualityChangesGroup
 from cura.Machines.QualityManager import QualityManager
 
-
-
 mocked_stack = MagicMock()
 mocked_extruder = MagicMock()
 
@@ -28,6 +27,8 @@ def container_registry():
                        {"id": "test_material", "definition": "fdmprinter", "quality_type": "normal", "name": "test_name_material", "material": "base_material", "type": "quality"},
                        {"id": "quality_changes_id", "definition": "fdmprinter", "type": "quality_changes", "quality_type": "amazing!", "name": "herp"}]
     result.findContainersMetadata = MagicMock(return_value = mocked_metadata)
+
+    result.uniqueName = MagicMock(return_value = "uniqueName")
     return result
 
 
@@ -58,3 +59,73 @@ def test_getQualityChangesGroup(quality_mocked_application):
     manager.initialize()
 
     assert "herp" in manager.getQualityChangesGroups(mocked_stack)
+
+
+@pytest.mark.skip("Doesn't work on remote")
+def test_getDefaultQualityType(quality_mocked_application):
+    manager = QualityManager(quality_mocked_application)
+    manager.initialize()
+    mocked_stack = MagicMock()
+    mocked_stack.definition.getMetaDataEntry = MagicMock(return_value = "normal")
+    assert manager.getDefaultQualityType(mocked_stack).quality_type == "normal"
+
+
+def test_createQualityChanges(quality_mocked_application):
+    manager = QualityManager(quality_mocked_application)
+    mocked_quality_changes = MagicMock()
+    manager._createQualityChanges = MagicMock(return_value = mocked_quality_changes)
+    manager.initialize()
+    container_manager = MagicMock()
+
+    manager._container_registry.addContainer = MagicMock()  # Side effect we want to check.
+    with patch("cura.Settings.ContainerManager.ContainerManager.getInstance", container_manager):
+        manager.createQualityChanges("derp")
+        assert manager._container_registry.addContainer.called_once_with(mocked_quality_changes)
+
+
+def test_renameQualityChangesGroup(quality_mocked_application):
+    manager = QualityManager(quality_mocked_application)
+    manager.initialize()
+
+    mocked_container = MagicMock()
+
+    quality_changes_group = QualityChangesGroup("zomg", "beep")
+    quality_changes_group.getAllNodes = MagicMock(return_value = [mocked_container])
+
+    # We need to check for "uniqueName" instead of "NEWRANDOMNAMEYAY" because the mocked registry always returns
+    # "uniqueName" when attempting to generate an unique name.
+    assert manager.renameQualityChangesGroup(quality_changes_group, "NEWRANDOMNAMEYAY") == "uniqueName"
+    assert mocked_container.setName.called_once_with("uniqueName")
+
+
+def test_duplicateQualityChangesQualityOnly(quality_mocked_application):
+    manager = QualityManager(quality_mocked_application)
+    manager.initialize()
+    mocked_quality = MagicMock()
+    quality_group = MagicMock()
+    quality_group.getAllNodes = MagicMock(return_value = mocked_quality)
+    mocked_quality_changes = MagicMock()
+
+    # Isolate what we want to test (in this case, we're not interested if createQualityChanges does it's job!)
+    manager._createQualityChanges = MagicMock(return_value = mocked_quality_changes)
+    manager._container_registry.addContainer = MagicMock()  # Side effect we want to check.
+
+    manager.duplicateQualityChanges("zomg", {"quality_group": quality_group, "quality_changes_group": None})
+    assert manager._container_registry.addContainer.called_once_with(mocked_quality_changes)
+
+
+def test_duplicateQualityChanges(quality_mocked_application):
+    manager = QualityManager(quality_mocked_application)
+    manager.initialize()
+    mocked_quality = MagicMock()
+    quality_group = MagicMock()
+    quality_group.getAllNodes = MagicMock(return_value = mocked_quality)
+    quality_changes_group = MagicMock()
+    mocked_quality_changes = MagicMock()
+    quality_changes_group.getAllNodes = MagicMock(return_value=[mocked_quality_changes])
+    mocked_quality_changes.duplicate = MagicMock(return_value = mocked_quality_changes)
+
+    manager._container_registry.addContainer = MagicMock()  # Side effect we want to check.
+
+    manager.duplicateQualityChanges("zomg", {"quality_group": quality_group, "quality_changes_group": quality_changes_group})
+    assert manager._container_registry.addContainer.called_once_with(mocked_quality_changes)