def loadMachineDefinitions(self): dirs = Resources.getAllPathsForType(Resources.MachineDefinitions) for dir in dirs: if not os.path.isdir(dir): continue for file_name in os.listdir(dir): data = None path = os.path.join(dir, file_name) if os.path.isdir(path): continue definition = MachineDefinition(self, path) try: definition.loadMetaData() except Exception as e: Logger.log("e", "An error occurred loading Machine Definition %s: %s", path, str(e)) continue # Only add the definition if it did not exist yet. This prevents duplicates. if not self.findMachineDefinition(definition.getId(), definition.getVariantName()): self._machine_definitions.append(definition) self.machineDefinitionsChanged.emit()
def test_loadAndSave(self, machine_manager, definition_file_name, instance_file_name, profile_file_name, target_profile_file_name): profile = Profile(machine_manager) definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath(definition_file_name)) definition.loadMetaData() machine_manager.addMachineDefinition(definition) machine_instance = MachineInstance(machine_manager, definition = definition) machine_instance.loadFromFile(self._getInstancesFilePath(instance_file_name)) profile._active_instance = machine_instance profile.loadFromFile(self._getProfileFilePath(profile_file_name)) try: os.remove(self._getProfileFilePath(target_profile_file_name)) # Clear any previous tests except: pass profile.saveToFile(self._getProfileFilePath(target_profile_file_name)) config_loaded = configparser.ConfigParser() config_loaded.read(self._getProfileFilePath(instance_file_name)) config_saved = configparser.ConfigParser() config_saved.read(self._getProfileFilePath(target_profile_file_name)) for section in config_loaded.sections(): assert section in config_saved.sections() for key in config_loaded[section]: assert key in config_saved[section] assert config_loaded[section][key] == config_saved[section][key]
def test_loadFromFileExceptions(self, machine_manager, definition_file_name, instance_file_name, expected_exception): # Create a definition definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath(definition_file_name)) definition.loadMetaData() machine_instance = MachineInstance(machine_manager, definition = definition) with pytest.raises(expected_exception): machine_instance.loadFromFile(self._getInstancesFilePath(instance_file_name))
def test_construct(self, machine_manager, file_name, instance_name): # Create a definition definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath(file_name)) definition.loadMetaData() machine_instance = MachineInstance(machine_manager, definition = definition, name = instance_name) assert isinstance(machine_instance, MachineInstance) assert machine_instance.getMachineDefinition() == definition assert machine_instance.getName() == instance_name
def test_loadAll(self, machine_manager, file_name, expected): definition = MachineDefinition(machine_manager, self._getFilePath(file_name)) definition.loadAll() assert definition.getId() == expected["id"] assert len(definition.getMachineSettings()) == expected["machine_setting_count"] assert len(definition.getAllCategories()) == expected["category_count"] if "machine_settings" in expected: for expected_setting in expected["machine_settings"]: assert definition.isMachineSetting(expected_setting["id"]) assert definition.getSetting(expected_setting["id"]).getDefaultValue(None) == expected_setting["default"] if "categories" in expected: for expected_category in expected["categories"]: category = definition.getSettingsCategory(expected_category["id"]) assert category is not None assert category.getLabel() == expected_category["label"] assert category.isVisible() == expected_category["visible"] assert len(category.getAllSettings()) == expected_category["setting_count"] if "settings" in expected_category: for expected_setting in expected_category["settings"]: setting = category.getSetting(expected_setting["id"]) assert setting is not None assert setting.getLabel() == expected_setting["label"] assert setting.isVisible() == expected_setting["visible"] assert setting.getType() == expected_setting["type"] assert setting.getDefaultValue(None) == expected_setting["default"]
def _createProfile(self, machine_manager, definition_file): definition = MachineDefinition(machine_manager, os.path.join(os.path.dirname(os.path.abspath(__file__)), "definitions", definition_file)) definition.loadAll() machine_manager.addMachineDefinition(definition) instance = MachineInstance(machine_manager, definition = definition) machine_manager.addMachineInstance(instance) machine_manager.setActiveMachineInstance(instance) profile = Profile(machine_manager) machine_manager.addProfile(profile) machine_manager.setActiveProfile(profile) return (definition, profile)
def test_instanceOverride(self, machine_manager, definition_file_name, instance_file_name, expected_values): # Create a definition definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath(definition_file_name)) definition.loadMetaData() machine_manager.addMachineDefinition(definition) machine_instance = MachineInstance(machine_manager, definition = definition) machine_instance.loadFromFile(self._getInstancesFilePath(instance_file_name)) for key in expected_values: assert machine_instance.getSettingValue(key) == expected_values[key]
def test_addAndFindDefinition(self, machine_manager): definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath("basic.json")) machine_manager.addMachineDefinition(definition) # No data is loaded, the definition should not have a name (and thus, no machine with test_basic should be found!) assert machine_manager.findMachineDefinition("test_basic") == None definition.loadMetaData() # Data is now loaded, so finding the definition should be possible assert machine_manager.findMachineDefinition("test_basic") == definition assert machine_manager.getMachineDefinitions() == [definition] assert machine_manager.getMachineDefinitions(include_variants = False) == [definition]
def test_profileOverride(self, machine_manager, definition_file_name, instance_file_name, profile_file_name, expected_values): profile = Profile(machine_manager) definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath(definition_file_name)) definition.loadMetaData() machine_manager.addMachineDefinition(definition) machine_instance = MachineInstance(machine_manager, definition = definition) machine_instance.loadFromFile(self._getInstancesFilePath(instance_file_name)) profile._active_instance = machine_instance profile.loadFromFile(self._getProfileFilePath(profile_file_name)) for key in expected_values: assert profile.getSettingValue(key) == expected_values[key]
def test_instances(self, machine_manager): definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath("basic.json")) definition.loadMetaData() machine_manager.addMachineDefinition(definition) machine_instance = MachineInstance(machine_manager, definition = definition, name = "Basic Test") machine_manager.addMachineInstance(machine_instance) assert machine_manager.getMachineInstances() == [machine_instance] assert machine_manager.findMachineInstance("Basic Test") == machine_instance machine_manager.setActiveMachineInstance(machine_instance) assert machine_manager.getActiveMachineInstance() == machine_instance machine_manager.removeMachineInstance(machine_instance) assert machine_manager.getMachineInstances() == []
def test_loadMetaData(self, machine_manager, file_name, expected): definition = MachineDefinition(machine_manager, self._getFilePath(file_name)) definition.loadMetaData() assert definition.getId() == expected["id"] assert definition.getName() == expected["name"] assert definition.isVisible() == expected["visible"] assert definition.getVariantName() == expected["variant_name"] assert definition.getManufacturer() == expected["manufacturer"] assert definition.getAuthor() == expected["author"]
def _createProfile(self, machine_manager, definition_file): definition = MachineDefinition( machine_manager, os.path.join(os.path.dirname(os.path.abspath(__file__)), "definitions", definition_file)) definition.loadAll() machine_manager.addMachineDefinition(definition) instance = MachineInstance(machine_manager, definition=definition) machine_manager.addMachineInstance(instance) machine_manager.setActiveMachineInstance(instance) profile = Profile(machine_manager) machine_manager.addProfile(profile) machine_manager.setActiveProfile(profile) return (definition, profile)
def test_instances(self, machine_manager): definition = MachineDefinition( machine_manager, self._getDefinitionsFilePath("basic.json")) definition.loadMetaData() machine_manager.addMachineDefinition(definition) machine_instance = MachineInstance(machine_manager, definition=definition, name="Basic Test") machine_manager.addMachineInstance(machine_instance) assert machine_manager.getMachineInstances() == [machine_instance] assert machine_manager.findMachineInstance( "Basic Test") == machine_instance machine_manager.setActiveMachineInstance(machine_instance) assert machine_manager.getActiveMachineInstance() == machine_instance machine_manager.removeMachineInstance(machine_instance) assert machine_manager.getMachineInstances() == []
def test_profiles(self, machine_manager): profile_1 = Profile(machine_manager) profile_2 = Profile(machine_manager) definition = MachineDefinition(machine_manager, self._getDefinitionsFilePath("simple_machine.json")) definition.loadMetaData() machine_manager.addMachineDefinition(definition) machine_instance = MachineInstance(machine_manager, definition = definition, name = "Basic Test") machine_instance.loadFromFile(self._getInstancesFilePath("simple_machine.cfg")) machine_manager.addMachineInstance(machine_instance) profile_1._active_instance = machine_instance profile_2._active_instance = machine_instance profile_1.loadFromFile(self._getProfileFilePath("simple_machine_with_overrides.cfg")) profile_2.loadFromFile(self._getProfileFilePath("simple_machine_with_overrides.cfg")) machine_manager.addProfile(profile_1) assert machine_manager.getProfiles() == [profile_1] # Check if adding again has no effect machine_manager.addProfile(profile_1) assert machine_manager.getProfiles() == [profile_1] # Check that adding another profile with same name does not work with pytest.raises(DuplicateProfileError): machine_manager.addProfile(profile_2) # Changing the name and then adding it should work profile_2.setName("test") machine_manager.addProfile(profile_2) assert profile_1 in machine_manager.getProfiles() and profile_2 in machine_manager.getProfiles() assert machine_manager.findProfile("test") == profile_2 # Check if removing one of the profiles works machine_manager.removeProfile(profile_1) assert machine_manager.getProfiles() == [profile_2] machine_manager.setActiveProfile(profile_2) assert machine_manager.getActiveProfile() == profile_2 machine_manager.removeProfile(profile_2) assert machine_manager.getProfiles() == []
def test_variants(self, machine_manager): definition_1 = MachineDefinition(machine_manager, self._getDefinitionsFilePath("variant_1.json")) definition_1.loadMetaData() machine_manager.addMachineDefinition(definition_1) definition_2 = MachineDefinition(machine_manager, self._getDefinitionsFilePath("variant_2.json")) definition_2.loadMetaData() machine_manager.addMachineDefinition(definition_2) machine_instance = MachineInstance(machine_manager, definition = definition_1) machine_manager.addMachineInstance(machine_instance) machine_manager.setActiveMachineInstance(machine_instance) machine_manager.setActiveMachineVariant("Variant test 2") assert machine_manager.getActiveMachineInstance().getMachineDefinition() == definition_2 returned_definitions = machine_manager.getMachineDefinitions() assert definition_1 in returned_definitions and definition_2 in returned_definitions returned_definitions = machine_manager.getMachineDefinitions(include_variants = False) # Check if only one of the definitions is returned. assert (definition_1 in returned_definitions) != (definition_2 in returned_definitions) returned_definitions = machine_manager.getAllMachineVariants("variant") assert definition_1 in returned_definitions and definition_2 in returned_definitions assert machine_manager.findMachineDefinition("variant", "Variant test 1") == definition_1 assert machine_manager.findMachineDefinition("variant", "Variant test 2") == definition_2 assert machine_manager.findMachineDefinition("variant", "Not existing variant") is None
def loadMachineDefinitions(self): dirs = Resources.getAllPathsForType(Resources.MachineDefinitions) for dir in dirs: if not os.path.isdir(dir): continue for file_name in os.listdir(dir): data = None path = os.path.join(dir, file_name) if os.path.isdir(path): continue definition = MachineDefinition(self, path) try: definition.loadMetaData() except Exception as e: Logger.log( "e", "An error occurred loading Machine Definition %s: %s", path, str(e)) continue # Only add the definition if it did not exist yet. This prevents duplicates. if not self.findMachineDefinition(definition.getId(), definition.getVariantName()): self._machine_definitions.append(definition) self.machineDefinitionsChanged.emit()
def test_loadAll(self, machine_manager, file_name, expected): definition = MachineDefinition(machine_manager, self._getFilePath(file_name)) definition.loadAll() assert definition.getId() == expected["id"] assert len(definition.getMachineSettings() ) == expected["machine_setting_count"] assert len(definition.getAllCategories()) == expected["category_count"] if "machine_settings" in expected: for expected_setting in expected["machine_settings"]: assert definition.isMachineSetting(expected_setting["id"]) assert definition.getSetting( expected_setting["id"]).getDefaultValue( None) == expected_setting["default"] if "categories" in expected: for expected_category in expected["categories"]: category = definition.getSettingsCategory( expected_category["id"]) assert category is not None assert category.getLabel() == expected_category["label"] assert category.isVisible() == expected_category["visible"] assert len(category.getAllSettings() ) == expected_category["setting_count"] if "settings" in expected_category: for expected_setting in expected_category["settings"]: setting = category.getSetting(expected_setting["id"]) assert setting is not None assert setting.getLabel() == expected_setting["label"] assert setting.isVisible( ) == expected_setting["visible"] assert setting.getType() == expected_setting["type"] assert setting.getDefaultValue( None) == expected_setting["default"]
def test_variants(self, machine_manager): definition_1 = MachineDefinition( machine_manager, self._getDefinitionsFilePath("variant_1.json")) definition_1.loadMetaData() machine_manager.addMachineDefinition(definition_1) definition_2 = MachineDefinition( machine_manager, self._getDefinitionsFilePath("variant_2.json")) definition_2.loadMetaData() machine_manager.addMachineDefinition(definition_2) machine_instance = MachineInstance(machine_manager, definition=definition_1) machine_manager.addMachineInstance(machine_instance) machine_manager.setActiveMachineInstance(machine_instance) machine_manager.setActiveMachineVariant("Variant test 2") assert machine_manager.getActiveMachineInstance().getMachineDefinition( ) == definition_2 returned_definitions = machine_manager.getMachineDefinitions() assert definition_1 in returned_definitions and definition_2 in returned_definitions returned_definitions = machine_manager.getMachineDefinitions( include_variants=False) # Check if only one of the definitions is returned. assert (definition_1 in returned_definitions) != (definition_2 in returned_definitions) returned_definitions = machine_manager.getAllMachineVariants("variant") assert definition_1 in returned_definitions and definition_2 in returned_definitions assert machine_manager.findMachineDefinition( "variant", "Variant test 1") == definition_1 assert machine_manager.findMachineDefinition( "variant", "Variant test 2") == definition_2 assert machine_manager.findMachineDefinition( "variant", "Not existing variant") is None
def test_loadError(self, machine_manager, file_name, exception_type): definition = MachineDefinition(machine_manager, self._getFilePath(file_name)) with pytest.raises(exception_type): definition.loadAll()