1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
# Copyright (c) 2020 Ultimaker B.V.
# Cura is released under the terms of the LGPLv3 or higher.
from unittest.mock import MagicMock
import configparser # To read the profiles.
import os
import os.path
import pytest
from UM.FastConfigParser import FastConfigParser
from cura.CuraApplication import CuraApplication # To compare against the current SettingVersion.
from UM.Settings.DefinitionContainer import DefinitionContainer
from UM.Settings.InstanceContainer import InstanceContainer
from UM.VersionUpgradeManager import VersionUpgradeManager
def collectAllQualities():
result = []
for root, directories, filenames in os.walk(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "resources", "quality"))):
for filename in filenames:
result.append(os.path.join(root, filename))
return result
def collecAllDefinitionIds():
result = []
for root, directories, filenames in os.walk(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "resources", "definitions"))):
for filename in filenames:
result.append(os.path.basename(filename).split(".")[0])
return result
def collectAllSettingIds():
VersionUpgradeManager._VersionUpgradeManager__instance = VersionUpgradeManager(MagicMock())
CuraApplication._initializeSettingDefinitions()
definition_container = DefinitionContainer("whatever")
with open(os.path.join(os.path.dirname(__file__), "..", "..", "resources", "definitions", "fdmprinter.def.json"), encoding = "utf-8") as data:
definition_container.deserialize(data.read())
return definition_container.getAllKeys()
def collectAllVariants():
result = []
for root, directories, filenames in os.walk(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "resources", "variants"))):
for filename in filenames:
result.append(os.path.join(root, filename))
return result
def collectAllIntents():
result = []
for root, directories, filenames in os.walk(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "resources", "intent"))):
for filename in filenames:
result.append(os.path.join(root, filename))
return result
all_definition_ids = collecAllDefinitionIds()
quality_filepaths = collectAllQualities()
all_setting_ids = collectAllSettingIds()
variant_filepaths = collectAllVariants()
intent_filepaths = collectAllIntents()
def test_uniqueID():
"""Check if the ID's from the qualities, variants & intents are unique."""
all_paths = quality_filepaths + variant_filepaths + intent_filepaths
all_ids = {}
for path in all_paths:
profile_id = os.path.basename(path)
profile_id = profile_id.replace(".inst.cfg", "")
if profile_id not in all_ids:
all_ids[profile_id] = []
all_ids[profile_id].append(path)
duplicated_ids_with_paths = {profile_id: paths for profile_id, paths in all_ids.items() if len(paths) > 1}
if len(duplicated_ids_with_paths.keys()) == 0:
return # No issues!
assert False, "Duplicate profile ID's were detected! Ensure that every profile ID is unique: %s" % duplicated_ids_with_paths
@pytest.mark.parametrize("file_name", quality_filepaths)
def test_validateQualityProfiles(file_name):
"""Attempt to load all the quality profiles."""
try:
with open(file_name, encoding = "utf-8") as data:
serialized = data.read()
result = InstanceContainer._readAndValidateSerialized(serialized)
# Fairly obvious, but all the types here should be of the type quality
assert InstanceContainer.getConfigurationTypeFromSerialized(serialized) == "quality"
# All quality profiles must be linked to an existing definition.
assert result["general"]["definition"] in all_definition_ids, "The quality profile %s links to an unknown definition (%s)" % (file_name, result["general"]["definition"])
# We don't care what the value is, as long as it's there.
assert result["metadata"].get("quality_type", None) is not None
# Check that all the values that we say something about are known.
if "values" in result:
quality_setting_keys = set(result["values"])
# Prune all the comments from the values
quality_setting_keys = {key for key in quality_setting_keys if not key.startswith("#")}
has_unknown_settings = not quality_setting_keys.issubset(all_setting_ids)
if has_unknown_settings:
print("The following setting(s) %s are defined in the quality %s, but not in fdmprinter.def.json" % ([key for key in quality_setting_keys if key not in all_setting_ids], file_name))
assert False
except Exception as e:
# File can't be read, header sections missing, whatever the case, this shouldn't happen!
print("Got an Exception while reading the file [%s]: %s" % (file_name, e))
assert False
@pytest.mark.parametrize("file_name", intent_filepaths)
def test_validateIntentProfiles(file_name):
try:
with open(file_name, encoding = "utf-8") as f:
serialized = f.read()
result = InstanceContainer._readAndValidateSerialized(serialized)
assert InstanceContainer.getConfigurationTypeFromSerialized(serialized) == "intent", "The intent folder must only contain intent profiles."
assert result["general"]["definition"] in all_definition_ids, "The definition for this intent profile must exist."
assert result["metadata"].get("intent_category", None) is not None, "All intent profiles must have some intent category."
assert result["metadata"].get("quality_type", None) is not None, "All intent profiles must be linked to some quality type."
assert result["metadata"].get("material", None) is not None, "All intent profiles must be linked to some material."
assert result["metadata"].get("variant", None) is not None, "All intent profiles must be linked to some variant."
# Check that all the values that we say something about are known.
if "values" in result:
intent_setting_keys = set(result["values"])
unknown_settings = intent_setting_keys - all_setting_ids
assert len(unknown_settings) == 0, "The settings {setting_list} are defined in the intent {file_name}, but not in fdmprinter.def.json".format(setting_list = unknown_settings, file_name = file_name)
except Exception as e:
# File can't be read, header sections missing, whatever the case, this shouldn't happen!
assert False, "Got an exception while reading the file {file_name}: {err}".format(file_name = file_name, err = str(e))
@pytest.mark.parametrize("file_name", variant_filepaths)
def test_validateVariantProfiles(file_name):
"""Attempt to load all the variant profiles."""
try:
with open(file_name, encoding = "utf-8") as data:
serialized = data.read()
result = InstanceContainer._readAndValidateSerialized(serialized)
# Fairly obvious, but all the types here should be of the type quality
assert InstanceContainer.getConfigurationTypeFromSerialized(serialized) == "variant", "The profile %s should be of type variant, but isn't" % file_name
# All quality profiles must be linked to an existing definition.
assert result["general"]["definition"] in all_definition_ids, "The profile %s isn't associated with a definition" % file_name
# Check that all the values that we say something about are known.
if "values" in result:
variant_setting_keys = set(result["values"])
# Prune all the comments from the values
variant_setting_keys = {key for key in variant_setting_keys if not key.startswith("#")}
has_unknown_settings = not variant_setting_keys.issubset(all_setting_ids)
if has_unknown_settings:
assert False, "The following setting(s) %s are defined in the variant %s, but not in fdmprinter.def.json" % ([key for key in variant_setting_keys if key not in all_setting_ids], file_name)
except Exception as e:
# File can't be read, header sections missing, whatever the case, this shouldn't happen!
print("Got an Exception while reading the file [%s]: %s" % (file_name, e))
assert False
@pytest.mark.parametrize("file_name", quality_filepaths + variant_filepaths + intent_filepaths)
def test_versionUpToDate(file_name):
try:
with open(file_name, encoding = "utf-8") as data:
parser = FastConfigParser(data.read())
assert "general" in parser
assert "version" in parser["general"]
assert int(parser["general"]["version"]) == InstanceContainer.Version, "The version of this profile is not up to date!"
assert "metadata" in parser
assert "setting_version" in parser["metadata"]
assert int(parser["metadata"]["setting_version"]) == CuraApplication.SettingVersion, "The version of this profile is not up to date!"
except Exception as e:
# File can't be read, header sections missing, whatever the case, this shouldn't happen!
print("Got an exception while reading the file {file_name}: {err}".format(file_name = file_name, err = str(e)))
assert False
|
