Merge branch 'master' into tests-for-um3networkplugin

plugins/ChangeLogPlugin/ChangeLog.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2015 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.i18n import i18nCatalog
@@ -29,6 +29,7 @@ class ChangeLog(Extension, QObject,):
         self._change_logs = None
         Application.getInstance().engineCreatedSignal.connect(self._onEngineCreated)
         Application.getInstance().getPreferences().addPreference("general/latest_version_changelog_shown", "2.0.0") #First version of CURA with uranium
+        self.setMenuName(catalog.i18nc("@item:inmenu", "Changelog"))
         self.addMenuItem(catalog.i18nc("@item:inmenu", "Show Changelog"), self.showChangelog)
 
     def getChangeLogs(self):

plugins/LegacyProfileReader/DictionaryOfDoom.json

@@ -1,6 +1,6 @@
 {
     "source_version": "15.04",
-    "target_version": 3,
+    "target_version": "4.5",
 
     "translation": {
         "machine_nozzle_size": "nozzle_size",

plugins/LegacyProfileReader/LegacyProfileReader.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import configparser  # For reading the legacy profile INI files.
@@ -6,6 +6,7 @@ import io
 import json  # For reading the Dictionary of Doom.
 import math  # For mathematical operations included in the Dictionary of Doom.
 import os.path  # For concatenating the path to the plugin and the relative path to the Dictionary of Doom.
+from typing import Dict
 
 from UM.Application import Application  # To get the machine manager to create the new profile in.
 from UM.Logger import Logger  # Logging errors.
@@ -33,10 +34,11 @@ class LegacyProfileReader(ProfileReader):
     #   \param json The JSON file to load the default setting values from. This
     #   should not be a URL but a pre-loaded JSON handle.
     #   \return A dictionary of the default values of the legacy Cura version.
-    def prepareDefaults(self, json):
+    def prepareDefaults(self, json: Dict[str, Dict[str, str]]) -> Dict[str, str]:
         defaults = {}
-        for key in json["defaults"]:  # We have to copy over all defaults from the JSON handle to a normal dict.
-            defaults[key] = json["defaults"][key]
+        if "defaults" in json:
+            for key in json["defaults"]:  # We have to copy over all defaults from the JSON handle to a normal dict.
+                defaults[key] = json["defaults"][key]
         return defaults
 
     ##  Prepares the local variables that can be used in evaluation of computing
@@ -80,11 +82,10 @@ class LegacyProfileReader(ProfileReader):
         Logger.log("i", "Importing legacy profile from file " + file_name + ".")
         container_registry = ContainerRegistry.getInstance()
         profile_id = container_registry.uniqueName("Imported Legacy Profile")
-        profile = InstanceContainer(profile_id)  # Create an empty profile.
 
-        parser = configparser.ConfigParser(interpolation = None)
+        input_parser = configparser.ConfigParser(interpolation = None)
         try:
-            parser.read([file_name])  # Parse the INI file.
+            input_parser.read([file_name])  # Parse the INI file.
         except Exception as e:
             Logger.log("e", "Unable to open legacy profile %s: %s", file_name, str(e))
             return None
@@ -92,7 +93,7 @@ class LegacyProfileReader(ProfileReader):
         # Legacy Cura saved the profile under the section "profile_N" where N is the ID of a machine, except when you export in which case it saves it in the section "profile".
         # Since importing multiple machine profiles is out of scope, just import the first section we find.
         section = ""
-        for found_section in parser.sections():
+        for found_section in input_parser.sections():
             if found_section.startswith("profile"):
                 section = found_section
                 break
@@ -110,15 +111,13 @@ class LegacyProfileReader(ProfileReader):
             return None
 
         defaults = self.prepareDefaults(dict_of_doom)
-        legacy_settings = self.prepareLocals(parser, section, defaults) #Gets the settings from the legacy profile.
+        legacy_settings = self.prepareLocals(input_parser, section, defaults) #Gets the settings from the legacy profile.
 
-        #Check the target version in the Dictionary of Doom with this application version.
-        if "target_version" not in dict_of_doom:
-            Logger.log("e", "Dictionary of Doom has no target version. Is it the correct JSON file?")
-            return None
-        if InstanceContainer.Version != dict_of_doom["target_version"]:
-            Logger.log("e", "Dictionary of Doom of legacy profile reader (version %s) is not in sync with the current instance container version (version %s)!", dict_of_doom["target_version"], str(InstanceContainer.Version))
-            return None
+        # Serialised format into version 4.5. Do NOT upgrade this, let the version upgrader handle it.
+        output_parser = configparser.ConfigParser(interpolation = None)
+        output_parser.add_section("general")
+        output_parser.add_section("metadata")
+        output_parser.add_section("values")
 
         if "translation" not in dict_of_doom:
             Logger.log("e", "Dictionary of Doom has no translation. Is it the correct JSON file?")
@@ -127,7 +126,7 @@ class LegacyProfileReader(ProfileReader):
         quality_definition = current_printer_definition.getMetaDataEntry("quality_definition")
         if not quality_definition:
             quality_definition = current_printer_definition.getId()
-        profile.setDefinition(quality_definition)
+        output_parser["general"]["definition"] = quality_definition
         for new_setting in dict_of_doom["translation"]:  # Evaluate all new settings that would get a value from the translations.
             old_setting_expression = dict_of_doom["translation"][new_setting]
             compiled = compile(old_setting_expression, new_setting, "eval")
@@ -140,37 +139,34 @@ class LegacyProfileReader(ProfileReader):
             definitions = current_printer_definition.findDefinitions(key = new_setting)
             if definitions:
                 if new_value != value_using_defaults and definitions[0].default_value != new_value:  # Not equal to the default in the new Cura OR the default in the legacy Cura.
-                    profile.setProperty(new_setting, "value", new_value)  # Store the setting in the profile!
+                    output_parser["values"][new_setting] = str(new_value) # Store the setting in the profile!
 
-        if len(profile.getAllKeys()) == 0:
+        if len(output_parser["values"]) == 0:
             Logger.log("i", "A legacy profile was imported but everything evaluates to the defaults, creating an empty profile.")
 
-        profile.setMetaDataEntry("type", "profile")
-        # don't know what quality_type it is based on, so use "normal" by default
-        profile.setMetaDataEntry("quality_type", "normal")
-        profile.setName(profile_id)
-        profile.setDirty(True)
+        output_parser["general"]["version"] = "4"
+        output_parser["general"]["name"] = profile_id
+        output_parser["metadata"]["type"] = "quality_changes"
+        output_parser["metadata"]["quality_type"] = "normal" # Don't know what quality_type it is based on, so use "normal" by default.
+        output_parser["metadata"]["position"] = "0" # We only support single extrusion.
+        output_parser["metadata"]["setting_version"] = "5" # What the dictionary of doom is made for.
 
-        #Serialise and deserialise in order to perform the version upgrade.
-        parser = configparser.ConfigParser(interpolation = None)
-        data = profile.serialize()
-        parser.read_string(data)
-        parser["general"]["version"] = "1"
-        if parser.has_section("values"):
-            parser["settings"] = parser["values"]
-            del parser["values"]
+        # Serialise in order to perform the version upgrade.
         stream = io.StringIO()
-        parser.write(stream)
+        output_parser.write(stream)
         data = stream.getvalue()
-        profile.deserialize(data)
 
-        # The definition can get reset to fdmprinter during the deserialization's upgrade. Here we set the definition
-        # again.
-        profile.setDefinition(quality_definition)
+        profile = InstanceContainer(profile_id)
+        profile.deserialize(data) # Also performs the version upgrade.
+        profile.setDirty(True)
 
         #We need to return one extruder stack and one global stack.
         global_container_id = container_registry.uniqueName("Global Imported Legacy Profile")
+        # We duplicate the extruder profile into the global stack.
+        # This may introduce some settings that are global in the extruder stack and some settings that are per-extruder in the global stack.
+        # We don't care about that. The engine will ignore them anyway.
         global_profile = profile.duplicate(new_id = global_container_id, new_name = profile_id) #Needs to have the same name as the extruder profile.
+        del global_profile.getMetaData()["position"] # Has no position because it's global.
         global_profile.setDirty(True)
 
         profile_definition = "fdmprinter"

plugins/LegacyProfileReader/tests/TestLegacyProfileReader.py

@@ -0,0 +1,190 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import configparser # An input for some functions we're testing.
+import os.path # To find the integration test .ini files.
+import pytest # To register tests with.
+import unittest.mock # To mock the application, plug-in and container registry out.
+
+import UM.Application # To mock the application out.
+import UM.PluginRegistry # To mock the plug-in registry out.
+import UM.Settings.ContainerRegistry # To mock the container registry out.
+import UM.Settings.InstanceContainer # To intercept the serialised data from the read() function.
+
+import LegacyProfileReader as LegacyProfileReaderModule # To get the directory of the module.
+from LegacyProfileReader import LegacyProfileReader # The module we're testing.
+
+@pytest.fixture
+def legacy_profile_reader():
+    return LegacyProfileReader()
+
+test_prepareDefaultsData = [
+    {
+        "defaults":
+        {
+            "foo": "bar"
+        },
+        "cheese": "delicious"
+    },
+    {
+        "cat": "fluffy",
+        "dog": "floofy"
+    }
+]
+
+@pytest.mark.parametrize("input", test_prepareDefaultsData)
+def test_prepareDefaults(legacy_profile_reader, input):
+    output = legacy_profile_reader.prepareDefaults(input)
+    if "defaults" in input:
+        assert input["defaults"] == output
+    else:
+        assert output == {}
+
+test_prepareLocalsData = [
+    ( # Ordinary case.
+        { # Parser data.
+            "profile":
+            {
+                "layer_height": "0.2",
+                "infill_density": "30"
+            }
+        },
+        { # Defaults.
+            "layer_height": "0.1",
+            "infill_density": "20",
+            "line_width": "0.4"
+        }
+    ),
+    ( # Empty data.
+        { # Parser data.
+            "profile":
+            {
+            }
+        },
+        { # Defaults.
+        }
+    ),
+    ( # All defaults.
+        { # Parser data.
+            "profile":
+            {
+            }
+        },
+        { # Defaults.
+            "foo": "bar",
+            "boo": "far"
+        }
+    ),
+    ( # Multiple config sections.
+        { # Parser data.
+            "some_other_name":
+            {
+                "foo": "bar"
+            },
+            "profile":
+            {
+                "foo": "baz" #Not the same as in some_other_name
+            }
+        },
+        { # Defaults.
+            "foo": "bla"
+        }
+    )
+]
+
+@pytest.mark.parametrize("parser_data, defaults", test_prepareLocalsData)
+def test_prepareLocals(legacy_profile_reader, parser_data, defaults):
+    parser = configparser.ConfigParser()
+    parser.read_dict(parser_data)
+
+    output = legacy_profile_reader.prepareLocals(parser, "profile", defaults)
+
+    assert set(defaults.keys()) <= set(output.keys()) # All defaults must be in there.
+    assert set(parser_data["profile"]) <= set(output.keys()) # All overwritten values must be in there.
+    for key in output:
+        if key in parser_data["profile"]:
+            assert output[key] == parser_data["profile"][key] # If overwritten, must be the overwritten value.
+        else:
+            assert output[key] == defaults[key] # Otherwise must be equal to the default.
+
+test_prepareLocalsNoSectionErrorData = [
+    ( # Section does not exist.
+        { # Parser data.
+            "some_other_name":
+            {
+                "foo": "bar"
+            },
+        },
+        { # Defaults.
+            "foo": "baz"
+        }
+    )
+]
+
+##  Test cases where a key error is expected.
+@pytest.mark.parametrize("parser_data, defaults", test_prepareLocalsNoSectionErrorData)
+def test_prepareLocalsNoSectionError(legacy_profile_reader, parser_data, defaults):
+    parser = configparser.ConfigParser()
+    parser.read_dict(parser_data)
+
+    with pytest.raises(configparser.NoSectionError):
+        legacy_profile_reader.prepareLocals(parser, "profile", defaults)
+
+intercepted_data = ""
+
+@pytest.mark.parametrize("file_name", ["normal_case.ini"])
+def test_read(legacy_profile_reader, file_name):
+    # Mock out all dependencies. Quite a lot!
+    global_stack = unittest.mock.MagicMock()
+    global_stack.getProperty = unittest.mock.MagicMock(return_value = 1) # For machine_extruder_count setting.
+    def getMetaDataEntry(key, default_value = ""):
+        if key == "quality_definition":
+            return "mocked_quality_definition"
+        if key == "has_machine_quality":
+            return "True"
+    global_stack.definition.getMetaDataEntry = getMetaDataEntry
+    global_stack.definition.getId = unittest.mock.MagicMock(return_value = "mocked_global_definition")
+    application = unittest.mock.MagicMock()
+    application.getGlobalContainerStack = unittest.mock.MagicMock(return_value = global_stack)
+    application_getInstance = unittest.mock.MagicMock(return_value = application)
+    container_registry = unittest.mock.MagicMock()
+    container_registry_getInstance = unittest.mock.MagicMock(return_value = container_registry)
+    container_registry.uniqueName = unittest.mock.MagicMock(return_value = "Imported Legacy Profile")
+    container_registry.findDefinitionContainers = unittest.mock.MagicMock(return_value = [global_stack.definition])
+    UM.Settings.InstanceContainer.setContainerRegistry(container_registry)
+    plugin_registry = unittest.mock.MagicMock()
+    plugin_registry_getInstance = unittest.mock.MagicMock(return_value = plugin_registry)
+    plugin_registry.getPluginPath = unittest.mock.MagicMock(return_value = os.path.dirname(LegacyProfileReaderModule.__file__))
+
+    # Mock out the resulting InstanceContainer so that we can intercept the data before it's passed through the version upgrader.
+    def deserialize(self, data): # Intercepts the serialised data that we'd perform the version upgrade from when deserializing.
+        global intercepted_data
+        intercepted_data = data
+
+        parser = configparser.ConfigParser()
+        parser.read_string(data)
+        self._metadata["position"] = parser["metadata"]["position"]
+    def duplicate(self, new_id, new_name):
+        self._metadata["id"] = new_id
+        self._metadata["name"] = new_name
+        return self
+
+    with unittest.mock.patch.object(UM.Application.Application, "getInstance", application_getInstance):
+        with unittest.mock.patch.object(UM.Settings.ContainerRegistry.ContainerRegistry, "getInstance", container_registry_getInstance):
+            with unittest.mock.patch.object(UM.PluginRegistry.PluginRegistry, "getInstance", plugin_registry_getInstance):
+                with unittest.mock.patch.object(UM.Settings.InstanceContainer.InstanceContainer, "deserialize", deserialize):
+                    with unittest.mock.patch.object(UM.Settings.InstanceContainer.InstanceContainer, "duplicate", duplicate):
+                        result = legacy_profile_reader.read(os.path.join(os.path.dirname(__file__), file_name))
+
+    assert len(result) == 1
+
+    # Let's see what's inside the actual output file that we generated.
+    parser = configparser.ConfigParser()
+    parser.read_string(intercepted_data)
+    assert parser["general"]["definition"] == "mocked_quality_definition"
+    assert parser["general"]["version"] == "4" # Yes, before we upgraded.
+    assert parser["general"]["name"] == "Imported Legacy Profile" # Because we overwrote uniqueName.
+    assert parser["metadata"]["type"] == "quality_changes"
+    assert parser["metadata"]["quality_type"] == "normal"
+    assert parser["metadata"]["position"] == "0"
+    assert parser["metadata"]["setting_version"] == "5" # Yes, before we upgraded.

plugins/LegacyProfileReader/tests/normal_case.ini

@@ -0,0 +1,7 @@
+[profile]
+foo = bar
+boo = far
+fill_overlap = 3
+
+[alterations]
+some = values

plugins/PostProcessingPlugin/PostProcessingPlugin.py

@@ -32,7 +32,8 @@ class PostProcessingPlugin(QObject, Extension):
     def __init__(self, parent = None) -> None:
         QObject.__init__(self, parent)
         Extension.__init__(self)
-        self.addMenuItem(i18n_catalog.i18n("Modify G-Code"), self.showPopup)
+        self.setMenuName(i18n_catalog.i18nc("@item:inmenu", "Post Processing"))
+        self.addMenuItem(i18n_catalog.i18nc("@item:inmenu", "Modify G-Code"), self.showPopup)
         self._view = None
 
         # Loaded scripts are all scripts that can be used

plugins/Toolbox/src/PackagesModel.py

@@ -12,7 +12,7 @@ from UM.Qt.ListModel import ListModel
 from .ConfigsModel import ConfigsModel
 
 
-##  Model that holds cura packages. By setting the filter property the instances held by this model can be changed.
+##  Model that holds Cura packages. By setting the filter property the instances held by this model can be changed.
 class PackagesModel(ListModel):
     def __init__(self, parent = None):
         super().__init__(parent)
@@ -70,7 +70,7 @@ class PackagesModel(ListModel):
 
                 # Links is a list of dictionaries with "title" and "url". Convert this list into a dict so it's easier
                 # to process.
-                link_list = package['data']['links'] if 'links' in package['data'] else []
+                link_list = package["data"]["links"] if "links" in package["data"] else []
                 links_dict = {d["title"]: d["url"] for d in link_list}
 
             if "author_id" not in package["author"] or "display_name" not in package["author"]:

plugins/Toolbox/src/Toolbox.py

@@ -172,18 +172,18 @@ class Toolbox(QObject, Extension):
         self._cloud_api_version = self._getCloudAPIVersion()
         self._cloud_api_root = self._getCloudAPIRoot()
         self._api_url = "{cloud_api_root}/cura-packages/v{cloud_api_version}/cura/v{sdk_version}".format(
-            cloud_api_root=self._cloud_api_root,
-            cloud_api_version=self._cloud_api_version,
-            sdk_version=self._sdk_version
+            cloud_api_root = self._cloud_api_root,
+            cloud_api_version = self._cloud_api_version,
+            sdk_version = self._sdk_version
         )
         self._request_urls = {
-            "authors": QUrl("{base_url}/authors".format(base_url=self._api_url)),
-            "packages": QUrl("{base_url}/packages".format(base_url=self._api_url)),
-            "plugins_showcase": QUrl("{base_url}/showcase".format(base_url=self._api_url)),
-            "plugins_available": QUrl("{base_url}/packages?package_type=plugin".format(base_url=self._api_url)),
-            "materials_showcase": QUrl("{base_url}/showcase".format(base_url=self._api_url)),
-            "materials_available": QUrl("{base_url}/packages?package_type=material".format(base_url=self._api_url)),
-            "materials_generic": QUrl("{base_url}/packages?package_type=material&tags=generic".format(base_url=self._api_url))
+            "authors": QUrl("{base_url}/authors".format(base_url = self._api_url)),
+            "packages": QUrl("{base_url}/packages".format(base_url = self._api_url)),
+            "plugins_showcase": QUrl("{base_url}/showcase".format(base_url = self._api_url)),
+            "plugins_available": QUrl("{base_url}/packages?package_type=plugin".format(base_url = self._api_url)),
+            "materials_showcase": QUrl("{base_url}/showcase".format(base_url = self._api_url)),
+            "materials_available": QUrl("{base_url}/packages?package_type=material".format(base_url = self._api_url)),
+            "materials_generic": QUrl("{base_url}/packages?package_type=material&tags=generic".format(base_url = self._api_url))
         }
 
     # Get the API root for the packages API depending on Cura version settings.
@@ -209,11 +209,11 @@ class Toolbox(QObject, Extension):
     # Get the packages version depending on Cura version settings.
     def _getSDKVersion(self) -> Union[int, str]:
         if not hasattr(cura, "CuraVersion"):
-            return self._plugin_registry.APIVersion
+            return self._application.getAPIVersion().getMajor()
         if not hasattr(cura.CuraVersion, "CuraSDKVersion"):  # type: ignore
-            return self._plugin_registry.APIVersion
+            return self._application.getAPIVersion().getMajor()
         if not cura.CuraVersion.CuraSDKVersion:  # type: ignore
-            return self._plugin_registry.APIVersion
+            return self._application.getAPIVersion().getMajor()
         return cura.CuraVersion.CuraSDKVersion  # type: ignore
 
     @pyqtSlot()
@@ -299,7 +299,7 @@ class Toolbox(QObject, Extension):
         for plugin_id in old_plugin_ids:
             # Neither the installed packages nor the packages that are scheduled to remove are old plugins
             if plugin_id not in installed_package_ids and plugin_id not in scheduled_to_remove_package_ids:
-                Logger.log('i', 'Found a plugin that was installed with the old plugin browser: %s', plugin_id)
+                Logger.log("i", "Found a plugin that was installed with the old plugin browser: %s", plugin_id)
 
                 old_metadata = self._plugin_registry.getMetaData(plugin_id)
                 new_metadata = self._convertPluginMetadata(old_metadata)
@@ -511,7 +511,10 @@ class Toolbox(QObject, Extension):
         # version, we also need to check if the current one has a lower SDK version. If so, this package should also
         # be upgradable.
         elif remote_version == local_version:
-            can_upgrade = local_package.get("sdk_version", 0) < remote_package.get("sdk_version", 0)
+            # First read sdk_version_semver. If that doesn't exist, read just sdk_version (old version system).
+            remote_sdk_version = Version(remote_package.get("sdk_version_semver", remote_package.get("sdk_version", 0)))
+            local_sdk_version = Version(local_package.get("sdk_version_semver", local_package.get("sdk_version", 0)))
+            can_upgrade = local_sdk_version < remote_sdk_version
 
         return can_upgrade