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()
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()
