mirror of
https://git.mirrors.martin98.com/https://github.com/Ultimaker/Cura
synced 2025-04-20 20:59:48 +08:00
388 lines
20 KiB
Python
388 lines
20 KiB
Python
import functools
|
|
from unittest.mock import MagicMock, patch, PropertyMock
|
|
import pytest
|
|
|
|
from cura.Settings.MachineManager import MachineManager
|
|
|
|
|
|
def createMockedStack(stack_id: str, name: str):
|
|
stack = MagicMock(name=name)
|
|
stack.getId = MagicMock(return_value=stack_id)
|
|
return stack
|
|
|
|
|
|
def getPropertyMocked(setting_key, setting_property, settings_dict):
|
|
"""
|
|
Mocks the getProperty function of containers so that it returns the setting values needed for a test.
|
|
|
|
Use this function as follows:
|
|
container.getProperty = functools.partial(getPropertyMocked, settings_dict = {"print_sequence": "one_at_a_time"})
|
|
|
|
:param setting_key: The key of the setting to be returned (e.g. "print_sequence", "infill_sparse_density" etc)
|
|
:param setting_property: The setting property (usually "value")
|
|
:param settings_dict: All the settings and their values expected to be returned by this mocked function
|
|
:return: The mocked setting value specified by the settings_dict
|
|
"""
|
|
if setting_property == "value":
|
|
return settings_dict.get(setting_key)
|
|
return None
|
|
|
|
|
|
@pytest.fixture()
|
|
def global_stack():
|
|
return createMockedStack("GlobalStack", "Global 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)
|
|
with patch.object(MachineManager, "updateNumberExtrudersEnabled", return_value = None):
|
|
manager._onGlobalContainerChanged()
|
|
|
|
return manager
|
|
|
|
|
|
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
|
|
# Since only test is in the registry, this should be None
|
|
assert MachineManager.getMachine("UnknownMachine") is None
|
|
|
|
|
|
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()
|
|
|
|
mocked_instance_container = MagicMock(name="UserSettingContainer")
|
|
mocked_instance_container.getNumInstances = MagicMock(return_value = 12)
|
|
mocked_stack.getTop = MagicMock(return_value = mocked_instance_container)
|
|
machine_manager._reCalculateNumUserSettings()
|
|
assert machine_manager.numUserSettings == 12
|
|
assert machine_manager.hasUserSettings
|
|
|
|
|
|
def test_hasUserSettingsExtruder(machine_manager, application):
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
extruder = createMockedExtruder("extruder")
|
|
|
|
mocked_instance_container_global = MagicMock(name="UserSettingContainerGlobal")
|
|
mocked_instance_container_global.getNumInstances = MagicMock(return_value=0)
|
|
mocked_stack.getTop = MagicMock(return_value=mocked_instance_container_global)
|
|
mocked_stack.extruderList = [extruder]
|
|
|
|
mocked_instance_container = MagicMock(name="UserSettingContainer")
|
|
mocked_instance_container.getNumInstances = MagicMock(return_value=200)
|
|
extruder.getTop = MagicMock(return_value = mocked_instance_container)
|
|
machine_manager._reCalculateNumUserSettings()
|
|
assert machine_manager.hasUserSettings
|
|
assert machine_manager.numUserSettings == 200
|
|
|
|
|
|
def test_hasUserSettingsEmptyUserChanges(machine_manager, application):
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
extruder = createMockedExtruder("extruder")
|
|
|
|
mocked_instance_container_global = MagicMock(name="UserSettingContainerGlobal")
|
|
mocked_instance_container_global.getNumInstances = MagicMock(return_value=0)
|
|
mocked_stack.getTop = MagicMock(return_value=mocked_instance_container_global)
|
|
mocked_stack.extruderList = [extruder]
|
|
|
|
mocked_instance_container = MagicMock(name="UserSettingContainer")
|
|
mocked_instance_container.getNumInstances = MagicMock(return_value=0)
|
|
extruder.getTop = MagicMock(return_value = mocked_instance_container)
|
|
machine_manager._reCalculateNumUserSettings()
|
|
assert not machine_manager.hasUserSettings
|
|
|
|
|
|
def test_totalNumberOfSettings(machine_manager):
|
|
registry = MagicMock()
|
|
mocked_definition = MagicMock()
|
|
mocked_definition.getAllKeys = MagicMock(return_value = ["omg", "zomg", "foo"])
|
|
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_globalVariantName(machine_manager, application):
|
|
global_stack = application.getGlobalContainerStack()
|
|
global_stack.variant = createMockedInstanceContainer("beep", "zomg")
|
|
assert machine_manager.globalVariantName == "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.extruderList = [extruder_1, extruder_2]
|
|
|
|
machine_manager.resetSettingForAllExtruders("whatever")
|
|
|
|
extruder_1.userChanges.removeInstance.assert_called_once_with("whatever")
|
|
extruder_2.userChanges.removeInstance.assert_called_once_with("whatever")
|
|
|
|
|
|
def test_setUnknownActiveMachine(machine_manager):
|
|
machine_action_manager = MagicMock()
|
|
machine_manager.getMachineActionManager = MagicMock(return_value = machine_action_manager)
|
|
|
|
machine_manager.setActiveMachine("UnknownMachine")
|
|
# The machine isn't known to us, so this should not happen!
|
|
machine_action_manager.addDefaultMachineActions.assert_not_called()
|
|
|
|
|
|
def test_clearActiveMachine(machine_manager):
|
|
machine_manager.setActiveMachine(None)
|
|
|
|
machine_manager._application.setGlobalContainerStack.assert_called_once_with(None)
|
|
|
|
|
|
def test_setActiveMachine(machine_manager):
|
|
registry = MagicMock()
|
|
machine_action_manager = MagicMock()
|
|
machine_manager._validateVariantsAndMaterials = MagicMock() # Not testing that function, so whatever.
|
|
machine_manager._application.getMachineActionManager = MagicMock(return_value=machine_action_manager)
|
|
global_stack = createMockedStack("NewMachine", "Newly created Machine")
|
|
|
|
# Ensure that the container stack will be found
|
|
registry.findContainerStacks = MagicMock(return_value = [global_stack])
|
|
with patch("cura.Settings.CuraContainerRegistry.CuraContainerRegistry.getInstance", MagicMock(return_value=registry)):
|
|
with patch("UM.Settings.ContainerRegistry.ContainerRegistry.getInstance", MagicMock(return_value=registry)):
|
|
with patch("cura.Settings.ExtruderManager.ExtruderManager.getInstance"): # Prevent the FixSingleExtruder from being called
|
|
machine_manager.setActiveMachine("NewMachine")
|
|
|
|
machine_action_manager.addDefaultMachineActions.assert_called_once_with(global_stack)
|
|
# Yeah sure. It's technically an implementation detail. But if this function wasn't called, it exited early somehow
|
|
machine_manager._validateVariantsAndMaterials.assert_called_once_with(global_stack)
|
|
|
|
|
|
def test_setInvalidActiveMachine(machine_manager):
|
|
registry = MagicMock()
|
|
global_stack = createMockedStack("InvalidMachine", "Newly created Machine")
|
|
|
|
# This machine is just plain wrong!
|
|
global_stack.isValid = MagicMock(return_value = False)
|
|
|
|
# Ensure that the container stack will be found
|
|
registry.findContainerStacks = MagicMock(return_value=[global_stack])
|
|
|
|
configuration_error_message = MagicMock()
|
|
|
|
with patch("cura.Settings.CuraContainerRegistry.CuraContainerRegistry.getInstance", MagicMock(return_value=registry)):
|
|
with patch("UM.Settings.ContainerRegistry.ContainerRegistry.getInstance", MagicMock(return_value=registry)):
|
|
with patch("cura.Settings.ExtruderManager.ExtruderManager.getInstance"): # Prevent the FixSingleExtruder from being called
|
|
with patch("UM.ConfigurationErrorMessage.ConfigurationErrorMessage.getInstance", MagicMock(return_value = configuration_error_message)):
|
|
machine_manager.setActiveMachine("InvalidMachine")
|
|
|
|
# Notification stuff should happen now!
|
|
configuration_error_message.addFaultyContainers.assert_called_once_with("InvalidMachine")
|
|
|
|
|
|
def test_clearUserSettingsAllCurrentStacks(machine_manager, application):
|
|
global_stack = application.getGlobalContainerStack()
|
|
extruder_1 = createMockedExtruder("extruder_1")
|
|
instance_container = createMockedInstanceContainer("user", "UserContainer")
|
|
extruder_1.getTop = MagicMock(return_value = instance_container)
|
|
global_stack.extruderList = [extruder_1]
|
|
|
|
machine_manager.clearUserSettingAllCurrentStacks("some_setting")
|
|
|
|
instance_container.removeInstance.assert_called_once_with("some_setting", postpone_emit=True)
|
|
|
|
|
|
def test_clearUserSettingsAllCurrentStacksLinkedSetting(machine_manager, application):
|
|
global_stack = application.getGlobalContainerStack()
|
|
extruder_1 = createMockedExtruder("extruder_1")
|
|
instance_container = createMockedInstanceContainer("user", "UserContainer")
|
|
instance_container_global = createMockedInstanceContainer("global_user", "GlobalUserContainer")
|
|
global_stack.getTop = MagicMock(return_value = instance_container_global)
|
|
extruder_1.getTop = MagicMock(return_value=instance_container)
|
|
global_stack.extruderList = [extruder_1]
|
|
|
|
global_stack.getProperty = MagicMock(side_effect = lambda key, prop: True if prop == "settable_per_extruder" else "-1" )
|
|
|
|
machine_manager.clearUserSettingAllCurrentStacks("some_setting")
|
|
|
|
instance_container.removeInstance.assert_not_called()
|
|
instance_container_global.removeInstance.assert_called_once_with("some_setting", postpone_emit = True)
|
|
|
|
|
|
def test_isActiveQualityExperimental(machine_manager):
|
|
quality_group = MagicMock(is_experimental = True)
|
|
machine_manager.activeQualityGroup = MagicMock(return_value = quality_group)
|
|
assert machine_manager.isActiveQualityExperimental
|
|
|
|
|
|
def test_isActiveQualityNotExperimental(machine_manager):
|
|
quality_group = MagicMock(is_experimental = False)
|
|
machine_manager.activeQualityGroup = MagicMock(return_value = quality_group)
|
|
assert not machine_manager.isActiveQualityExperimental
|
|
|
|
|
|
def test_isActiveQualityNotExperimental_noQualityGroup(machine_manager):
|
|
machine_manager.activeQualityGroup = MagicMock(return_value=None)
|
|
assert not machine_manager.isActiveQualityExperimental
|
|
|
|
|
|
def test_isActiveQualitySupported(machine_manager):
|
|
quality_group = MagicMock(is_available=True)
|
|
machine_manager.activeQualityGroup = MagicMock(return_value=quality_group)
|
|
assert machine_manager.isActiveQualitySupported
|
|
|
|
|
|
def test_isActiveQualityNotSupported(machine_manager):
|
|
quality_group = MagicMock(is_available=False)
|
|
machine_manager.activeQualityGroup = MagicMock(return_value=quality_group)
|
|
assert not machine_manager.isActiveQualitySupported
|
|
|
|
|
|
def test_isActiveQualityNotSupported_noQualityGroup(machine_manager):
|
|
machine_manager.activeQualityGroup = MagicMock(return_value=None)
|
|
assert not machine_manager.isActiveQualitySupported
|
|
|
|
|
|
def test_correctPrintSequence_globalStackHasAllAtOnce(machine_manager, application):
|
|
|
|
# Global container stack already has all_at_once
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
mocked_global_settings = {"print_sequence": "all_at_once"}
|
|
mocked_stack.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_global_settings)
|
|
|
|
mocked_user_changes_container = MagicMock(name="UserChangesContainer")
|
|
mocked_stack.userChanges = mocked_user_changes_container
|
|
|
|
machine_manager.correctPrintSequence()
|
|
|
|
# After the function is called, the user changes container should not have tried to change any properties
|
|
assert not mocked_user_changes_container.setProperty.called, "The Print Sequence should not be attempted to be changed when it is already 'all-at-once'"
|
|
|
|
|
|
def test_correctPrintSequence_OneEnabledExtruder(machine_manager, application):
|
|
# Global container stack reports print sequence as one_at_a_time
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
mocked_global_settings = {"print_sequence": "one_at_a_time"}
|
|
mocked_stack.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_global_settings)
|
|
|
|
# The definition changes container reports 1 enabled extruders, so the correctPrintSequence should not attempt to
|
|
# change the print sequence
|
|
mocked_definition_changes_container = MagicMock(name = "DefinitionChangesContainer")
|
|
mocked_definition_changes_settings = {"extruders_enabled_count": 1}
|
|
mocked_definition_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_definition_changes_settings)
|
|
mocked_stack.definitionChanges = mocked_definition_changes_container
|
|
|
|
mocked_user_changes_container = MagicMock(name = "UserChangesContainer")
|
|
mocked_stack.userChanges = mocked_user_changes_container
|
|
|
|
machine_manager.correctPrintSequence()
|
|
|
|
# After the function is called, the user changes container should not have tried to change any properties
|
|
assert not mocked_user_changes_container.setProperty.called, "The Print Sequence should not be attempted to be changed when there is only one enabled extruder."
|
|
|
|
|
|
def test_correctPrintSequence_TwoExtrudersEnabled_printSequenceIsOneAtATimeInUserSettings(machine_manager, application):
|
|
# Global container stack reports print sequence as one_at_a_time
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
mocked_global_settings = {"print_sequence": "one_at_a_time"}
|
|
mocked_stack.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_global_settings)
|
|
|
|
# The definition changes container reports 2 enabled extruders. Also the print sequence change is not saved in the
|
|
# quality changes container.
|
|
mocked_definition_changes_container = MagicMock(name = "DefinitionChangesContainer")
|
|
mocked_definition_changes_settings = {"extruders_enabled_count": 2, "print_sequence": None}
|
|
mocked_definition_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_definition_changes_settings)
|
|
mocked_stack.definitionChanges = mocked_definition_changes_container
|
|
|
|
# The user changes container reports print sequence as "one-at-a-time"
|
|
mocked_user_changes_container = MagicMock(name = "UserChangesContainer")
|
|
mocked_user_changes_settings = {"print_sequence": "one_at_a_time"}
|
|
mocked_user_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_user_changes_settings)
|
|
mocked_stack.userChanges = mocked_user_changes_container
|
|
|
|
machine_manager.correctPrintSequence()
|
|
|
|
# After the function is called, the user changes container should have tried to remove the print sequence from the
|
|
# user changes container
|
|
mocked_user_changes_container.removeInstance.assert_called_once_with("print_sequence")
|
|
|
|
|
|
def test_correctPrintSequence_TwoExtrudersEnabled_printSequenceIsOneAtATimeInDefinitionChangesSettings(machine_manager, application):
|
|
# Global container stack reports print sequence as one_at_a_time
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
mocked_global_settings = {"print_sequence": "one_at_a_time"}
|
|
mocked_stack.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_global_settings)
|
|
|
|
# The definition changes container reports 2 enabled extruders and contains the print_sequence change to "one-at-a-time"
|
|
mocked_definition_changes_container = MagicMock(name = "DefinitionChangesContainer")
|
|
mocked_definition_changes_settings = {"extruders_enabled_count": 2, "print_sequence": "one_at_a_time"}
|
|
mocked_definition_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_definition_changes_settings)
|
|
mocked_stack.definitionChanges = mocked_definition_changes_container
|
|
|
|
# The user changes container doesn't contain print_sequence
|
|
mocked_user_changes_container = MagicMock(name = "UserChangesContainer")
|
|
mocked_user_changes_settings = {"print_sequence": None}
|
|
mocked_user_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_user_changes_settings)
|
|
mocked_stack.userChanges = mocked_user_changes_container
|
|
|
|
machine_manager.correctPrintSequence()
|
|
|
|
# After the function is called, the print sequence should be set to "all-at-once" in the user changes container
|
|
mocked_user_changes_container.setProperty.assert_called_once_with("print_sequence", "value", "all_at_once")
|
|
|
|
|
|
def test_correctPrintSequence_TwoExtrudersEnabled_printSequenceInUserAndDefinitionChangesSettingsIsNone(machine_manager, application):
|
|
# Global container stack reports print sequence as one_at_a_time
|
|
mocked_stack = application.getGlobalContainerStack()
|
|
mocked_global_settings = {"print_sequence": "one_at_a_time"}
|
|
mocked_stack.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_global_settings)
|
|
|
|
# The definition changes container reports 2 enabled extruders but doesn't contain the print_sequence changes
|
|
mocked_definition_changes_container = MagicMock(name = "DefinitionChangesContainer")
|
|
mocked_definition_changes_settings = {"extruders_enabled_count": 2, "print_sequence": None}
|
|
mocked_definition_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_definition_changes_settings)
|
|
mocked_stack.definitionChanges = mocked_definition_changes_container
|
|
|
|
# The user changes container doesn't contain the print_sequence changes
|
|
mocked_user_changes_container = MagicMock(name = "UserChangesContainer")
|
|
mocked_user_changes_settings = {"print_sequence": None}
|
|
mocked_user_changes_container.getProperty = functools.partial(getPropertyMocked, settings_dict=mocked_user_changes_settings)
|
|
mocked_stack.userChanges = mocked_user_changes_container
|
|
|
|
machine_manager.correctPrintSequence()
|
|
|
|
# After the function is called, the print sequence should be set to "all-at-once" in the user changes container
|
|
mocked_user_changes_container.setProperty.assert_called_once_with("print_sequence", "value", "all_at_once")
|