id
int64 0
843k
| repository_name
stringlengths 7
55
| file_path
stringlengths 9
332
| class_name
stringlengths 3
290
| human_written_code
stringlengths 12
4.36M
| class_skeleton
stringlengths 19
2.2M
| total_program_units
int64 1
9.57k
| total_doc_str
int64 0
4.2k
| AvgCountLine
float64 0
7.89k
| AvgCountLineBlank
float64 0
300
| AvgCountLineCode
float64 0
7.89k
| AvgCountLineComment
float64 0
7.89k
| AvgCyclomatic
float64 0
130
| CommentToCodeRatio
float64 0
176
| CountClassBase
float64 0
48
| CountClassCoupled
float64 0
589
| CountClassCoupledModified
float64 0
581
| CountClassDerived
float64 0
5.37k
| CountDeclInstanceMethod
float64 0
4.2k
| CountDeclInstanceVariable
float64 0
299
| CountDeclMethod
float64 0
4.2k
| CountDeclMethodAll
float64 0
4.2k
| CountLine
float64 1
115k
| CountLineBlank
float64 0
9.01k
| CountLineCode
float64 0
94.4k
| CountLineCodeDecl
float64 0
46.1k
| CountLineCodeExe
float64 0
91.3k
| CountLineComment
float64 0
27k
| CountStmt
float64 1
93.2k
| CountStmtDecl
float64 0
46.1k
| CountStmtExe
float64 0
90.2k
| MaxCyclomatic
float64 0
759
| MaxInheritanceTree
float64 0
16
| MaxNesting
float64 0
34
| SumCyclomatic
float64 0
6k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
140,548 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyBaseReference
|
class TestPropertyBaseReference(TestCase):
def setUp(self) -> None:
super().setUp()
self.base_ref = _ReferenceProperty(json=dict(), client=None)
def test_prefilters(self):
with self.assertRaises(NotImplementedError):
self.base_ref.set_prefilters()
with self.assertRaises(NotImplementedError):
self.base_ref.get_prefilters()
|
class TestPropertyBaseReference(TestCase):
def setUp(self) -> None:
pass
def test_prefilters(self):
pass
| 3 | 0 | 5 | 1 | 4 | 0 | 1 | 0 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 74 | 11 | 2 | 9 | 4 | 6 | 0 | 9 | 4 | 6 | 1 | 2 | 1 | 2 |
140,549 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_workflows.py
|
tests.test_workflows.TestWorkflows
|
class TestWorkflows(TestBetamax):
"""
Test retrieval and scope attributes and methods.
"""
def setUp(self):
super().setUp()
self.workflow: Workflow = self.client.workflow(
"Simple Workflow", category=WorkflowCategory.CATALOG
)
def tearDown(self):
super().tearDown()
def test_workflow_attributes(self):
attributes = [
"id",
"name",
"description",
"ref",
"derived_from_id",
"created_at",
"updated_at",
"category",
"scope_id",
"statuses",
"transitions",
"options",
"active",
]
workflow = self.client.workflow(
"Simple Workflow", category=WorkflowCategory.CATALOG
)
for attr in attributes:
with self.subTest(attr):
self.assertTrue(
hasattr(workflow, attr),
f"Could not find '{attr}' in the workflow: '{workflow.__dict__.keys()}",
)
def test_single_workflow_retrieve_on_pk(self):
workflow_id = self.workflow.id
_ = self.client.workflow(pk=workflow_id)
def test_clone_workflow_to_scope(self):
"""Testing the 'import workflow'."""
catalog_workflow = self.client.workflow(
name="Simple Workflow", category=WorkflowCategory.CATALOG
)
imported_workflow = catalog_workflow.clone(
target_scope=self.project, name="___Imported Simple Workflow"
)
self.assertTrue(imported_workflow)
retrieved_imported_workflow = self.client.workflow(
name="___Imported Simple Workflow", scope=self.project
)
self.assertEqual(imported_workflow.id, retrieved_imported_workflow.id)
retrieved_imported_workflow.delete()
def test_import_workflow_in_a_scope_with_import_workflow_method_on_scope(self):
"""Test the create of a new workflow in a scope."""
imported_workflow = self.project.import_workflow(
workflow=self.workflow, name="___Imported Simple Flow"
)
self.assertEqual(imported_workflow.derived_from_id, self.workflow.id)
imported_workflow.delete()
def test_clone_workflow_in_a_scope_in_the_same_scope(self):
test_wf = self.project.import_workflow(workflow=self.workflow, name="__TEST")
cloned_wf = test_wf.clone(
target_scope=test_wf.scope_id, name="CLONED WITHIN THE SOCPE"
)
self.assertTrue(cloned_wf)
self.assertEqual(cloned_wf.derived_from_id, test_wf.id)
# teardown
test_wf.delete()
cloned_wf.delete()
def test_create_a_new_workflow_using_classmethod_create_workflow(self):
payload = dict(
name="___TEST WORKFLOW__DELETE_ME",
description="This is a test workflow created in a scope",
active=True,
options=dict(foo="bar"),
)
test_wf = Workflow.create(client=self.client, scope=self.project, **payload)
self.assertEqual(test_wf.name, payload["name"])
self.assertEqual(test_wf.description, payload["description"])
self.assertEqual(test_wf.active, payload["active"])
self.assertEqual(test_wf.category, WorkflowCategory.DEFINED)
test_wf.delete()
def test_create_a_new_workflow_using_client_create_workflow(self):
payload = dict(
name="___TEST WORKFLOW__DELETE_ME",
description="This is a test workflow created in a scope",
active=True,
options=dict(foo="bar"),
)
test_wf = self.client.create_workflow(scope=self.project, **payload)
self.assertEqual(test_wf.name, payload["name"])
self.assertEqual(test_wf.description, payload["description"])
self.assertEqual(test_wf.active, payload["active"])
self.assertEqual(test_wf.category, WorkflowCategory.DEFINED)
test_wf.delete()
def test_create_a_new_workflow_using_scope_create_workflow(self):
payload = dict(
name="___TEST WORKFLOW__DELETE_ME",
description="This is a test workflow created in a scope",
active=True,
options=dict(foo="bar"),
)
test_wf = self.project.create_workflow(**payload)
self.assertEqual(test_wf.name, payload["name"])
self.assertEqual(test_wf.description, payload["description"])
self.assertEqual(test_wf.active, payload["active"])
self.assertEqual(test_wf.category, WorkflowCategory.DEFINED)
test_wf.delete()
|
class TestWorkflows(TestBetamax):
'''
Test retrieval and scope attributes and methods.
'''
def setUp(self):
pass
def tearDown(self):
pass
def test_workflow_attributes(self):
pass
def test_single_workflow_retrieve_on_pk(self):
pass
def test_clone_workflow_to_scope(self):
'''Testing the 'import workflow'.'''
pass
def test_import_workflow_in_a_scope_with_import_workflow_method_on_scope(self):
'''Test the create of a new workflow in a scope.'''
pass
def test_clone_workflow_in_a_scope_in_the_same_scope(self):
pass
def test_create_a_new_workflow_using_classmethod_create_workflow(self):
pass
def test_create_a_new_workflow_using_client_create_workflow(self):
pass
def test_create_a_new_workflow_using_scope_create_workflow(self):
pass
| 11 | 3 | 12 | 1 | 10 | 0 | 1 | 0.06 | 1 | 4 | 2 | 0 | 10 | 3 | 10 | 85 | 132 | 23 | 103 | 30 | 92 | 6 | 57 | 29 | 46 | 2 | 3 | 2 | 11 |
140,550 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_create_with_properties.py
|
tests.test_parts_create_with_properties.TestPartCreateModelWithProperties
|
class TestPartCreateModelWithProperties(TestBetamax):
properties_fvalues = [
{"name": "char prop", "property_type": PropertyType.CHAR_VALUE},
{"name": "number prop", "property_type": PropertyType.FLOAT_VALUE, "value": 3.14},
{
"name": "boolean_prop",
"property_type": PropertyType.BOOLEAN_VALUE,
"value": False,
"value_options": {"validators": [RequiredFieldValidator().as_json()]},
},
]
def setUp(self):
super().setUp()
self.new_part = None
def tearDown(self):
if self.new_part is not None:
self.new_part.delete()
super().tearDown()
def test_create_model_with_properties(self):
parent = self.project.model(name__startswith="Catalog")
new_model = self.project.create_model_with_properties(
name="A new model",
parent=parent.id,
multiplicity=Multiplicity.ZERO_MANY,
properties_fvalues=self.properties_fvalues,
)
self.new_part = new_model
self.assertEqual(3, len(new_model.properties))
self.assertEqual(new_model.property("number prop").value, 3.14)
self.assertEqual(new_model.property("boolean_prop").value, False)
self.assertTrue(new_model.property("boolean_prop")._options)
def test_create_with_invalid_properties(self):
parent = self.project.model(name__startswith="Catalog")
with self.assertRaises(IllegalArgumentError):
self.new_part = self.project.create_model_with_properties(
name="A new model",
parent=parent.id,
multiplicity=Multiplicity.ZERO_MANY,
properties_fvalues=[{"property_type": PropertyType.CHAR_VALUE}],
)
|
class TestPartCreateModelWithProperties(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create_model_with_properties(self):
pass
def test_create_with_invalid_properties(self):
pass
| 5 | 0 | 8 | 1 | 7 | 0 | 1 | 0 | 1 | 4 | 3 | 0 | 4 | 1 | 4 | 79 | 47 | 7 | 40 | 10 | 35 | 0 | 21 | 10 | 16 | 2 | 3 | 1 | 5 |
140,551 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_copy_move.py
|
tests.test_parts_copy_move.TestPartsCopyMove
|
class TestPartsCopyMove(TestBetamax):
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"))
def setUp(self):
super().setUp()
self.base = self.project.model(name__startswith="Catalog")
self.cross_scope_project = self.client.scope(ref="cannondale-project")
self.cross_scope_bike = self.cross_scope_project.model(ref="cannondale-bike")
self.wheel = self.project.model(name="Wheel")
self.front_wheel, self.rear_wheel = self.project.part(
name="Front Wheel"
), self.project.part(name="Rear Wheel")
self.specify_wheel_diameter = self.project.activity(name="Specify wheel diameter")
self.model_to_be_copied = self.project.create_model(
parent=self.base,
name=f"__Model to be Copied @ {str(datetime.now())} [TEST]",
multiplicity=Multiplicity.ONE_MANY,
) # type Part
self.p_char_name = "__Property single text"
self.p_multi_name = "__Property multi text"
self.p_bool_name = "__Property boolean"
self.p_int_name = "__Property integer"
self.p_float_name = "__Property float"
self.p_date_name = "__Property date"
self.p_datetime_name = "__Property datetime"
self.p_time_name = "__Property time"
self.p_attach_name = "__Property attachment"
self.p_link_name = "__Property link"
self.p_single_select_name = "__Property single select"
self.p_multi_select_name = "__Property multi select"
self.p_part_reference_name = "__Property part reference"
self.p_part_reference_name_cross_scope = "__Property part reference cross scope"
self.p_geo_json_name = "__Property geographical"
self.p_weather_name = "__Property weather"
self.p_activity_reference_name = "__Property activity reference"
self.p_user_reference_name = "__Property user reference"
self.p_project_reference_name = "__Property project reference"
self.p_char_value = "test value"
self.p_multi_value = "test multi text value"
self.p_bool_value = True
self.p_int_value = 33
self.p_float_value = 42.42
self.p_date_value = str(date(2021, 12, 15))
self.p_datetime_value = str(datetime(1991, 4, 12, 13, 5, 5).isoformat())
self.p_time_value = str(time(12, 0, 4))
self.p_attach_value = self.project_root + "/requirements.txt"
self.p_link_value = "http://ke-chain.com"
self.p_select_value_choices = ["apples", "oranges", "bananas", "lemons"]
self.p_single_select_value = "bananas"
self.p_multi_select_value = ["apples", "bananas"]
self.test_manager = self.client.user(username="testmanager")
self.test_supervisor = self.client.user(username="testsupervisor")
self.p_user_reference_value = [self.test_manager.id, self.test_supervisor.id]
self.p_geojson_value = {
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"geometry": {"type": "Point", "coordinates": [4.390912, 51.9929856]},
"properties": {
"zoom": 16,
"address": "Rijksstraatweg 47, 2645 BS Delfgauw, Netherlands",
},
}
],
}
self.p_geojson_value_options = {
"representations": [
{"rtype": "geoCoordinate", "config": {"geoCoordinate": "approx_address"}}
]
}
self.p_weather_value = {
"current": {
"uv": 1,
"cloud": 0,
"is_day": 1,
"temp_c": 12,
"temp_f": 53.6,
"vis_km": 10,
"gust_kph": 11.2,
"gust_mph": 6.9,
"humidity": 88,
"wind_dir": "NE",
"wind_kph": 0,
"wind_mph": 0,
"condition": {
"code": 1000,
"icon": "//cdn.weatherapi.com/weather/64x64/day/113.png",
"text": "Sunny",
},
"precip_in": 0,
"precip_mm": 0,
"vis_miles": 6,
"feelslike_c": 11.9,
"feelslike_f": 53.5,
"pressure_in": 30.42,
"pressure_mb": 1030,
"wind_degree": 52,
"last_updated": "2021-09-21 09:30",
"last_updated_epoch": 1632209400,
},
"location": {
"lat": 51.99,
"lon": 4.39,
"name": "Delfgauw",
"tz_id": "Europe/Amsterdam",
"region": "South Holland",
"country": "Netherlands",
"localtime": "2021-09-21 9:39",
"localtime_epoch": 1632209956,
},
}
self.sub_part1 = self.model_to_be_copied.add_model(
name="__subpart 1", multiplicity=Multiplicity.ONE
)
self.sub_part2 = self.model_to_be_copied.add_model(
name="__subpart 2", multiplicity=Multiplicity.ZERO_MANY
)
self.model_to_be_copied.add_property(
name=self.p_char_name,
description="Description of Property single text",
unit="mm",
default_value=self.p_char_value,
property_type=PropertyType.CHAR_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_multi_name,
unit="mm",
default_value=self.p_multi_value,
property_type=PropertyType.TEXT_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_bool_name,
default_value=self.p_bool_value,
property_type=PropertyType.BOOLEAN_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_int_name,
default_value=self.p_int_value,
property_type=PropertyType.INT_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_float_name,
default_value=self.p_float_value,
property_type=PropertyType.FLOAT_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_date_name,
default_value=self.p_date_value,
property_type=PropertyType.DATE_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_datetime_name,
default_value=self.p_datetime_value,
property_type=PropertyType.DATETIME_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_time_name,
default_value=self.p_time_value,
property_type=PropertyType.TIME_VALUE,
)
self.attachment_property = self.model_to_be_copied.add_property(
name=self.p_attach_name, property_type=PropertyType.ATTACHMENT_VALUE
)
self.attachment_property.upload(self.p_attach_value)
self.model_to_be_copied.add_property(
name=self.p_link_name,
default_value=self.p_link_value,
property_type=PropertyType.LINK_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_single_select_name,
options=dict(value_choices=self.p_select_value_choices),
default_value=self.p_single_select_value,
property_type=PropertyType.SINGLE_SELECT_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_multi_select_name,
default_value=self.p_multi_select_value,
options=dict(value_choices=self.p_select_value_choices),
property_type=PropertyType.MULTI_SELECT_VALUE,
)
self.model_to_be_copied.add_property(
name=self.p_part_reference_name,
default_value=self.sub_part2,
property_type=PropertyType.REFERENCES_VALUE,
)
self.ref_property = self.model_to_be_copied.add_property(
name=self.p_part_reference_name_cross_scope,
default_value=self.wheel,
property_type=PropertyType.REFERENCES_VALUE,
)
self.ref_property.set_prefilters(
property_models=[self.wheel.property(name="Rim Material"),
self.wheel.property(name="Country of manufacture")],
values=['Aliminium', 'United States'],
filters_type=[FilterType.CONTAINS, FilterType.CONTAINS],
)
self.model_to_be_copied.add_property(
name=self.p_geo_json_name,
property_type=PropertyType.GEOJSON_VALUE,
default_value=self.p_geojson_value,
value_options=self.p_geojson_value_options,
)
self.model_to_be_copied.add_property(
name=self.p_weather_name,
property_type=PropertyType.WEATHER_VALUE,
default_value=self.p_weather_value,
)
self.model_to_be_copied.add_property(
name=self.p_activity_reference_name,
property_type=PropertyType.ACTIVITY_REFERENCES_VALUE,
default_value=[self.specify_wheel_diameter.id],
)
self.model_to_be_copied.add_property(
name=self.p_user_reference_name,
property_type=PropertyType.USER_REFERENCES_VALUE,
default_value=self.p_user_reference_value,
)
self.model_to_be_copied.add_property(
name=self.p_project_reference_name,
property_type=PropertyType.SCOPE_REFERENCES_VALUE,
default_value=[self.project.id],
)
self.sub_part2.add_property(
name=self.p_bool_name,
default_value=False,
property_type=PropertyType.BOOLEAN_VALUE,
)
self.sub_part2.add_property(
name=self.p_int_name,
default_value=3,
property_type=PropertyType.INT_VALUE,
)
self.model_to_be_copied.property(self.p_part_reference_name).set_excluded_propmodels(
[self.sub_part2.property(self.p_bool_name)]
)
self.model_to_be_copied.property(self.p_part_reference_name).set_prefilters(
property_models=[self.sub_part2.property(self.p_int_name)],
values=[3],
filters_type=[FilterType.GREATER_THAN_EQUAL],
)
self.model_to_be_copied.property(self.p_project_reference_name).set_prefilters(
[ScopeFilter(tag='bike'), ScopeFilter(status=ScopeStatus.ACTIVE)]
)
self.model_target_parent = self.project.model(ref="bike")
self.instance_to_be_copied = self.model_to_be_copied.instances()[0]
self.sub_part2_instance = self.instance_to_be_copied.add(model=self.sub_part2)
self.instance_to_be_copied.property(name=self.p_part_reference_name).value = [
self.sub_part2_instance
]
self.instance_to_be_copied.property(name=self.p_part_reference_name_cross_scope).value = [
self.front_wheel
]
self.instance_target_parent = self.model_to_be_copied.parent().instances()[0]
self.dump_part = None
def tearDown(self):
self.model_to_be_copied.delete()
if self.dump_part:
self.dump_part.delete()
super().tearDown()
def test_copy_part_model_given_name_include_children(self):
model_target_parent = self.project.model("Bike")
copied_model = self.model_to_be_copied.copy(
target_parent=model_target_parent,
name="__Copied model under Bike",
include_children=True,
include_instances=False,
)
copied_model.refresh()
copied_model.populate_descendants()
self.dump_part = copied_model
# testing
self.assertTrue(copied_model)
self.assertEqual(len(copied_model.properties), len(self.model_to_be_copied.properties))
self.assertEqual(
copied_model.property(name=self.p_char_name)._json_data["description"],
"Description of Property single text",
)
self.assertEqual(copied_model.property(name=self.p_char_name)._json_data["unit"], "mm")
self.assertEqual(copied_model.property(name=self.p_int_name).value, self.p_int_value)
self.assertEqual(copied_model.property(name=self.p_char_name).value, self.p_char_value)
self.assertEqual(copied_model.property(name=self.p_multi_name).value, self.p_multi_value)
self.assertEqual(copied_model.property(name=self.p_int_name).value, self.p_int_value)
self.assertEqual(copied_model.property(name=self.p_float_name).value, self.p_float_value)
self.assertEqual(copied_model.property(name=self.p_bool_name).value, self.p_bool_value)
self.assertEqual(copied_model.property(name=self.p_date_name).value, self.p_date_value)
self.assertIn(
self.p_datetime_value, copied_model.property(name=self.p_datetime_name).value
)
self.assertIn(copied_model.property(name=self.p_attach_name).filename, self.p_attach_value)
self.assertEqual(copied_model.property(name=self.p_link_name).value, self.p_link_value)
self.assertEqual(
copied_model.property(name=self.p_single_select_name).value, self.p_single_select_value
)
self.assertEqual(
copied_model.property(name=self.p_multi_select_name).value, self.p_multi_select_value
)
list_of_user_ids = [
user.id for user in copied_model.property(name=self.p_user_reference_name).value
]
self.assertIn(
self.sub_part2.name,
[part.name for part in copied_model.property(name=self.p_part_reference_name).value],
)
self.assertNotEqual(
self.sub_part2.id, copied_model.property(name=self.p_part_reference_name).value[0].id
)
self.assertIn(
self.wheel.id,
[
part.id
for part in copied_model.property(
name=self.p_part_reference_name_cross_scope
).value
],
)
self.assertDictEqual(
self.p_geojson_value, copied_model.property(name=self.p_geo_json_name).value
)
self.assertDictEqual(
self.p_weather_value, copied_model.property(name=self.p_weather_name).value
)
self.assertIn(
self.specify_wheel_diameter.id,
[act.id for act in copied_model.property(name=self.p_activity_reference_name).value],
)
self.assertIn(
self.project.id,
[
scope.id
for scope in copied_model.property(name=self.p_project_reference_name).value
],
)
self.assertIn(self.test_manager.id, list_of_user_ids)
self.assertIn(self.test_supervisor.id, list_of_user_ids)
self.assertEqual(
copied_model.property(name=self.p_single_select_name).options,
self.p_select_value_choices,
)
self.assertEqual(
copied_model.property(name=self.p_multi_select_name).options,
self.p_select_value_choices,
)
self.assertEqual(len(copied_model._cached_children), 2)
def test_copy_part_model_include_instances(self):
model_target_parent = self.project.model("Bike")
self.dump_part = self.model_to_be_copied.copy(
target_parent=model_target_parent,
name="__Copied model under Bike",
include_children=True,
include_instances=True,
)
bike_part = self.project.part("Bike")
copied_instance = [child for child in bike_part.children() if "Copied" in child.name][0]
copied_instance.populate_descendants()
# testing
self.assertTrue(copied_instance)
self.assertEqual(len(copied_instance.properties), len(self.model_to_be_copied.properties))
self.assertEqual(copied_instance.property(name=self.p_char_name).value, self.p_char_value)
self.assertEqual(
copied_instance.property(name=self.p_multi_name).value, self.p_multi_value
)
self.assertEqual(copied_instance.property(name=self.p_int_name).value, self.p_int_value)
self.assertEqual(
copied_instance.property(name=self.p_float_name).value, self.p_float_value
)
self.assertEqual(copied_instance.property(name=self.p_bool_name).value, self.p_bool_value)
self.assertEqual(copied_instance.property(name=self.p_date_name).value, self.p_date_value)
self.assertIn(
self.p_datetime_value, copied_instance.property(name=self.p_datetime_name).value
)
self.assertEqual(copied_instance.property(name=self.p_link_name).value, self.p_link_value)
self.assertEqual(
copied_instance.property(name=self.p_single_select_name).value,
self.p_single_select_value,
)
self.assertEqual(
copied_instance.property(name=self.p_multi_select_name).value,
self.p_multi_select_value,
)
list_of_user_ids = [
user.id for user in copied_instance.property(name=self.p_user_reference_name).value
]
self.assertIn(
self.sub_part2.name,
[
part.name
for part in copied_instance.property(name=self.p_part_reference_name).value
],
)
self.assertNotEqual(
self.sub_part2.id,
copied_instance.property(name=self.p_part_reference_name).value[0].id,
)
self.assertIn(
self.front_wheel.id,
[
part.id
for part in copied_instance.property(
name=self.p_part_reference_name_cross_scope
).value
],
)
self.assertDictEqual(
self.p_geojson_value, copied_instance.property(name=self.p_geo_json_name).value
)
self.assertDictEqual(
self.p_weather_value, copied_instance.property(name=self.p_weather_name).value
)
self.assertIn(
self.specify_wheel_diameter.id,
[
act.id
for act in copied_instance.property(name=self.p_activity_reference_name).value
],
)
self.assertIn(
self.project.id,
[
scope.id
for scope in copied_instance.property(name=self.p_project_reference_name).value
],
)
self.assertIn(self.test_manager.id, list_of_user_ids)
self.assertIn(self.test_supervisor.id, list_of_user_ids)
self.assertEqual(len(copied_instance._cached_children), 2)
def test_copy_part_model_empty_name_not_include_children(self):
# setUp
model_target_parent = self.project.model("Bike")
name_of_part = "__Copied model under Bike"
copied_model = self.model_to_be_copied.copy(
target_parent=model_target_parent,
name=name_of_part,
include_children=False,
include_instances=False,
)
copied_model.populate_descendants()
self.dump_part = copied_model
# testing
self.assertTrue(copied_model)
self.assertEqual(copied_model.name, name_of_part)
self.assertEqual(len(copied_model.properties), len(self.model_to_be_copied.properties))
self.assertEqual(len(copied_model._cached_children), 0)
def test_copy_internal_references_on_model(self):
child_model = self.model_to_be_copied.children()[0]
self.model_to_be_copied.add_property(
name="__Property internal reference",
default_value=child_model,
property_type=PropertyType.REFERENCES_VALUE,
)
model_target_parent = self.project.model("Bike")
self.dump_part = self.model_to_be_copied.copy(
target_parent=model_target_parent,
name="__Copied model under Bike",
include_children=True,
include_instances=False,
)
self.dump_part.refresh()
copied_child = self.dump_part.children()[0]
reference_property = self.dump_part.property(name="__Property internal reference")
self.assertEqual(copied_child, reference_property.value[0])
def test_copy_internal_references_on_instance(self):
prop_name = "__Property internal reference"
child_model = self.model_to_be_copied.children()[0]
self.model_to_be_copied.add_property(
name=prop_name, default_value=child_model, property_type=PropertyType.REFERENCES_VALUE
)
self.instance_to_be_copied.refresh() # to load the new property
self.instance_to_be_copied.property(
name=prop_name
).value = self.instance_to_be_copied.children()[0]
instance_target_parent = self.project.part("Bike")
copied_instance = self.instance_to_be_copied.copy(
target_parent=instance_target_parent,
name="__Copied instance under Bike",
include_children=True,
)
self.dump_part = copied_instance.model()
copied_child = copied_instance.children()[0]
reference_property = copied_instance.property(name=prop_name)
self.assertTrue(reference_property.has_value())
self.assertEqual(copied_child, reference_property.value[0])
def test_move_part_model(self):
# setUp
model_target_parent = self.project.model("Bike")
original_model_to_be_copied_name = self.model_to_be_copied.name
self.model_to_be_copied = self.model_to_be_copied.move(
target_parent=model_target_parent, name="__New part under bike", include_children=True
)
# testing
with self.assertRaises(NotFoundError):
self.project.model(name=original_model_to_be_copied_name)
def test_copy_part_instance(self):
# setUp
instance_to_be_copied = self.model_to_be_copied.instances()[0]
instance_to_be_copied.property(name=self.p_attach_name).upload(self.p_attach_value)
instance_to_be_copied.property(name=self.p_part_reference_name_cross_scope).value = [
self.front_wheel,
self.rear_wheel,
]
instance_target_parent = self.project.part("Bike")
copied_instance = instance_to_be_copied.copy(
target_parent=instance_target_parent, name="__Copied instance", include_children=True
)
copied_instance.populate_descendants()
self.dump_part = copied_instance.model()
# testing
self.assertTrue(copied_instance)
self.assertEqual(copied_instance.name, "__Copied instance")
self.assertEqual(len(copied_instance.properties), len(self.model_to_be_copied.properties))
self.assertEqual(copied_instance.property(name=self.p_char_name).value, self.p_char_value)
self.assertEqual(
copied_instance.property(name=self.p_multi_name).value, self.p_multi_value
)
self.assertEqual(copied_instance.property(name=self.p_int_name).value, self.p_int_value)
self.assertEqual(
copied_instance.property(name=self.p_float_name).value, self.p_float_value
)
self.assertEqual(copied_instance.property(name=self.p_bool_name).value, self.p_bool_value)
self.assertEqual(copied_instance.property(name=self.p_date_name).value, self.p_date_value)
self.assertIn(
self.p_datetime_value, copied_instance.property(name=self.p_datetime_name).value
)
self.assertIn('requirements.txt',
copied_instance.property(name=self.p_attach_name).filename)
self.assertIn('requirements.txt', self.p_attach_value)
self.assertEqual(copied_instance.property(name=self.p_link_name).value, self.p_link_value)
self.assertEqual(
copied_instance.property(name=self.p_single_select_name).value,
self.p_single_select_value,
)
self.assertEqual(
copied_instance.property(name=self.p_multi_select_name).value,
self.p_multi_select_value,
)
list_of_parts_ids = [
part.id
for part in copied_instance.property(name=self.p_part_reference_name_cross_scope).value
]
list_of_user_ids = [
user.id for user in copied_instance.property(name=self.p_user_reference_name).value
]
self.assertIn(self.front_wheel.id, list_of_parts_ids)
self.assertIn(self.rear_wheel.id, list_of_parts_ids)
self.assertIn(
self.specify_wheel_diameter.id,
[
act.id
for act in copied_instance.property(name=self.p_activity_reference_name).value
],
)
self.assertIn(
self.project.id,
[
scope.id
for scope in copied_instance.property(name=self.p_project_reference_name).value
],
)
self.assertIn(self.test_manager.id, list_of_user_ids)
self.assertIn(self.test_supervisor.id, list_of_user_ids)
self.assertEqual(len(copied_instance._cached_children), 2)
def test_move_part_instance(self):
# setUp
multiplicity_model = self.model_to_be_copied.add_model(
name="__multiplicity part", multiplicity=Multiplicity.ZERO_MANY
)
multiplicity_part1 = self.instance_to_be_copied.add(
model=multiplicity_model,
name="__multiplicity part instance 1",
)
multiplicity_part2 = self.instance_to_be_copied.add(
model=multiplicity_model,
name="__multiplicity part instance 2",
)
clone_of_original_instance = multiplicity_part2.clone()
moved_instance = clone_of_original_instance.move(
target_parent=self.project.part("Bike"),
name="__Moved clone instance",
include_children=False,
)
moved_instance.populate_descendants()
self.dump_part = moved_instance.model()
# testing
with self.assertRaises(NotFoundError):
self.project.model(name=clone_of_original_instance.name)
self.assertTrue(moved_instance)
self.assertEqual(len(moved_instance.properties), 0)
def test_copy_different_categories(self):
target_instance = self.project.part(name="Bike")
with self.assertRaisesRegex(IllegalArgumentError, "must have the same category"):
self.model_to_be_copied.copy(target_parent=target_instance)
def test_move_different_categories(self):
target_instance = self.project.part(name="Bike")
with self.assertRaisesRegex(IllegalArgumentError, "must have the same category"):
self.model_to_be_copied.move(target_parent=target_instance)
def test_copy_target_parent_inside_tree(self):
with self.assertRaises(IllegalArgumentError):
self.model_to_be_copied.copy(
target_parent=self.sub_part1,
)
def test_copy_missing_target_parent_instance(self):
target_parent = self.project.product_root_model.add_model(
name="__ZERO+ MODEL",
multiplicity=Multiplicity.ZERO_MANY,
)
self.dump_part = target_parent
with self.assertRaises(IllegalArgumentError):
self.model_to_be_copied.copy(
target_parent=target_parent,
include_instances=True,
)
def test_copy_too_many_target_parent_instances(self):
target_parent = self.project.product_root_model.add_model(
name="__ONE+ MODEL",
multiplicity=Multiplicity.ONE_MANY,
)
self.project.product_root_instance.add(model=target_parent)
self.dump_part = target_parent
with self.assertRaises(IllegalArgumentError):
self.model_to_be_copied.copy(
target_parent=target_parent,
include_instances=True,
)
def test_copy_attachments(self):
names = [
"__Property attachment_1",
"__Property attachment_2",
]
for name in names:
self.model_to_be_copied.add_property(
name=name,
property_type=PropertyType.ATTACHMENT_VALUE,
)
self.instance_to_be_copied.refresh()
for name in names:
p_attachment = self.instance_to_be_copied.property(name)
file = os.path.join(os.path.dirname(os.path.dirname(__file__)), "requirements.txt")
p_attachment.upload(file)
self.dump_part = self.model_to_be_copied.copy(
target_parent=self.model_target_parent,
)
copied_instance = self.dump_part.instance()
for name in names:
copied_prop = copied_instance.property(name)
self.assertTrue(copied_prop.has_value())
def test_cross_scope_copy(self):
name_of_part = "__Copied model under Bike"
self.dump_part = self.model_to_be_copied.copy(
target_parent=self.cross_scope_bike,
name=name_of_part,
include_children=True,
include_instances=True,
)
self.dump_part.refresh()
copied_options = self.dump_part.property(self.p_part_reference_name_cross_scope)._options
self.assertTrue(self.model_to_be_copied.scope_id == copied_options.get("scope_id"))
copied_sub_part2_int_prop = self.dump_part(self.sub_part2.name).property(self.p_int_name)
copied_sub_part2_bool_prop = self.dump_part(self.sub_part2.name).property(self.p_bool_name)
copied_part_ref_options = self.dump_part.property(self.p_part_reference_name)._options
copied_scope_ref_options = self.dump_part.property(self.p_project_reference_name)._options
self.assertTrue(self.dump_part.scope_id == copied_part_ref_options.get("scope_id"))
self.assertTrue(
copied_sub_part2_bool_prop.id in copied_part_ref_options.get("propmodels_excl"))
self.assertTrue(
copied_sub_part2_int_prop.id in copied_part_ref_options["prefilters"]["property_value"]
)
self.assertEqual(ScopeStatus.ACTIVE, copied_scope_ref_options["prefilters"]["status__in"])
self.assertEqual("bike", copied_scope_ref_options["prefilters"]["tags__contains"])
|
class TestPartsCopyMove(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_copy_part_model_given_name_include_children(self):
pass
def test_copy_part_model_include_instances(self):
pass
def test_copy_part_model_empty_name_not_include_children(self):
pass
def test_copy_internal_references_on_model(self):
pass
def test_copy_internal_references_on_instance(self):
pass
def test_move_part_model(self):
pass
def test_copy_part_instance(self):
pass
def test_move_part_instance(self):
pass
def test_copy_different_categories(self):
pass
def test_move_different_categories(self):
pass
def test_copy_target_parent_inside_tree(self):
pass
def test_copy_missing_target_parent_instance(self):
pass
def test_copy_too_many_target_parent_instances(self):
pass
def test_copy_attachments(self):
pass
def test_cross_scope_copy(self):
pass
| 18 | 0 | 41 | 2 | 39 | 1 | 1 | 0.02 | 1 | 13 | 7 | 0 | 17 | 55 | 17 | 92 | 723 | 55 | 658 | 121 | 640 | 12 | 286 | 121 | 268 | 4 | 3 | 1 | 21 |
140,552 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts.py
|
tests.test_parts.TestPartsClassificationForm
|
class TestPartsClassificationForm(TestBetamax):
def setUp(self):
super().setUp()
self._part = None
def tearDown(self):
if self._part:
self._part.delete()
super().tearDown()
def test_classification_forms_exist(self):
parts = self.project.parts(category=None, classification=Classification.FORM)
for p in parts:
self.assertEqual(p.classification, Classification.FORM)
parent = p.parent()
if parent.name == "Root":
self.assertEqual(parent.classification, "ROOT")
else:
self.assertEqual(parent.classification, Classification.FORM)
|
class TestPartsClassificationForm(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_classification_forms_exist(self):
pass
| 4 | 0 | 6 | 0 | 5 | 0 | 2 | 0 | 1 | 2 | 1 | 0 | 3 | 1 | 3 | 78 | 20 | 3 | 17 | 8 | 13 | 0 | 16 | 8 | 12 | 3 | 3 | 2 | 6 |
140,553 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts.py
|
tests.test_parts.TestParts
|
class TestParts(TestBetamax):
def setUp(self):
super().setUp()
self._part = None
def tearDown(self):
if self._part:
self._part.delete()
super().tearDown()
def test_retrieve_parts(self):
parts = self.project.parts()
# Check if there are parts
self.assertTrue(len(parts))
self.assertIsInstance(parts[0], Part)
def test_retrieve_single_part(self):
part_to_retrieve = self.project.parts()[0]
part = self.project.part(part_to_retrieve.name)
self.assertTrue(part)
def test_base_comparison(self):
all_parts = self.project.parts()
tip = " See Base.__eq__() method."
self.assertFalse(
all_parts[0] == all_parts[1], msg="2 different parts must not be equal." + tip
)
self.assertTrue(all_parts[0] == all_parts[0], msg="The same part must be equal." + tip)
self.assertFalse(
all_parts[0] == 5, msg="A part must not be equal to a non-pykechain object." + tip
)
def test_base_hash(self):
wheel = self.project.model("Wheel")
a_dict = dict()
try:
a_dict[wheel] = 3
except TypeError:
self.assertTrue(False, msg="Parts must be hashable See Base.__hash__() method.")
def test_part_attributes(self):
attributes = [
"_client",
"_json_data",
"id",
"name",
"created_at",
"updated_at",
"ref",
"category",
"classification",
"parent_id",
"description",
"multiplicity",
"_cached_children",
"properties",
]
obj = self.project.parts(limit=1)[0]
for attribute in attributes:
with self.subTest(msg=attribute):
self.assertTrue(
hasattr(obj, attribute),
"Could not find '{}' in the object: '{}'".format(
attribute, obj.__dict__.keys()
),
)
def test_retrieve_single_unknown(self):
with self.assertRaises(NotFoundError):
self.project.part("123lladadwd")
def test_retrieve_single_multiple(self):
with self.assertRaises(MultipleFoundError):
self.project.part()
def test_retrieve_models(self):
wheel = self.project.model("Wheel")
self.assertTrue(self.project.parts(model=wheel))
def test_retrieve_model_unknown(self):
with self.assertRaises(NotFoundError):
self.client.model("123lladadwd")
def test_retrieve_model_multiple(self):
with self.assertRaises(MultipleFoundError):
self.project.model()
def test_scope(self):
first_part = self.project.parts()[0]
self.assertEqual(first_part.scope(), self.project)
def test_part_set_iterator(self):
for part in self.project.parts():
self.assertTrue(part.name)
def test_part_set_get_item_invalid(self):
part_set = self.project.parts()
with self.assertRaises(NotImplementedError):
# noinspection PyStatementEffect
part_set["testing"]
def test_wrongly_create_model(self):
# setUp
bike_model = self.project.model(name="Bike")
# testing
with self.assertRaises(IllegalArgumentError):
self.client.create_model(
name="Multiplicity does not exist", parent=bike_model, multiplicity="TEN"
)
def test_part_add_delete_part(self):
bike = self.project.part("Bike")
wheel_model = self.project.model("Wheel")
wheel = bike.add(wheel_model, name="Test Wheel")
wheel.delete()
wheel = wheel_model.add_to(bike)
wheel.delete()
with self.assertRaises(APIError):
bike.delete()
def test_create_part_where_parent_is_model(self):
# setUp
bike_model = self.project.model(name="Bike")
# testing
with self.assertRaises(IllegalArgumentError):
self._part = self.client.create_part(
name="Parent should be instance", parent=bike_model, model=bike_model
)
def test_create_part_where_model_is_instance(self):
# setUp
bike_instance = self.project.part(name="Bike")
# testing
with self.assertRaises(IllegalArgumentError):
self._part = self.client.create_part(
name="Model should not be instance", parent=bike_instance, model=bike_instance
)
def test_create_model_where_parent_is_instance(self):
# setUp
bike_instance = self.project.part(name="Bike")
# testing
with self.assertRaises(IllegalArgumentError):
self._part = self.client.create_model(
name="Parent should be model", parent=bike_instance, multiplicity=Multiplicity.ONE
)
def test_create_proxy_model_where_model_is_instance(self):
# setUp
bike_instance = self.project.part(name="Bike")
# testing
with self.assertRaises(IllegalArgumentError):
self._part = self.client.create_proxy_model(
name="Model should not be instance", model=bike_instance, parent=bike_instance
)
def test_create_proxy_model_where_parent_is_instance(self):
# setUp
bike_instance = self.project.part(name="Bike")
bike_model = self.project.model(name="Bike")
# testing
with self.assertRaises(IllegalArgumentError):
self._part = self.client.create_proxy_model(
name="Parent should not be instance", model=bike_model, parent=bike_instance
)
def test_add_to_wrong_categories(self):
# This test has the purpose of testing of whether APIErrors are raised when illegal operations are
# performed (e.g. operation that should be performed on part instances but instead are being performed
# on part models and vice versa)
project = self.project
bike_model = project.model("Bike")
bike_instance = project.part("Bike")
wheel_model = project.model("Wheel")
with self.assertRaises(APIError):
self._part = bike_model.add(wheel_model)
front_fork_instance = project.part("Front Fork")
with self.assertRaises(APIError):
self._part = front_fork_instance.add_to(bike_instance)
with self.assertRaises(APIError):
self._part = bike_instance.add_model("Engine")
with self.assertRaises(APIError):
self._part = bike_instance.add_property("Electrical Power")
with self.assertRaises(APIError):
self._part = bike_model.add_with_properties(wheel_model)
def test_part_html_table(self):
part = self.project.part("Front Wheel")
self.assertIn("</table>", part._repr_html_())
def test_part_set_html_table(self):
parts = self.project.parts()
self.assertIn("</table>", parts._repr_html_())
def test_part_set_html_categories(self):
parts = self.project.parts(category=None)
self.assertIn("<th>Category</th>", parts._repr_html_())
# version 1.1.2 and later
def test_part_set_with_limit(self):
limit = 5
parts = self.project.parts(limit=limit)
self.assertEqual(len(parts), limit)
def test_part_set_with_batch(self):
batch = 5
parts = self.project.parts(batch=batch)
self.assertTrue(len(parts) >= batch)
# version 1.1.3 and later
def test_retrieve_parent_of_part(self):
frame = self.project.part("Frame") # type: Part
self.assertTrue(hasattr(frame, "parent_id"))
parent_of_frame = frame.parent()
self.assertIsInstance(parent_of_frame, type(frame))
def test_retrieve_children_of_part(self):
bike = self.project.part("Bike") # type: Part
self.assertIsInstance(bike, Part)
children_of_bike = bike.children()
self.assertIsInstance(children_of_bike, (PartSet, list))
self.assertTrue(len(children_of_bike) >= 1) # eg. Wheels ...
def test_retrieve_siblings_of_part(self):
"""Test if the siblings of a part is the same as the children of the parent of the part"""
frame = self.project.part("Frame") # type: Part
siblings_of_frame = frame.siblings()
self.assertIsInstance(siblings_of_frame, PartSet)
self.assertTrue(len(siblings_of_frame) >= 1) # eg. Wheels ...
# double check that the children of the parent of frame are the same as the siblings of frame
children_of_parent_of_frame = frame.parent().children() # type: PartSet
self.assertEqual(len(children_of_parent_of_frame), len(siblings_of_frame))
children_of_parent_of_frame_ids = [p.id for p in children_of_parent_of_frame]
for sibling in siblings_of_frame:
self.assertIn(
sibling.id,
children_of_parent_of_frame_ids,
"sibling {} is appearing in the siblings method and not in the children of "
"parent method".format(sibling),
)
# new in 1.3+
def test_kwargs_on_part_retrieval(self):
# test that the additional kwargs are added to the query filter on the api
bikes = self.project.parts("Bike", order=True) # type:PartSet
self.assertTrue(len(bikes) == 1)
self.assertTrue(self.client.last_url.find("order"))
# new in 1.5+
def test_edit_part_instance_name(self):
front_fork = self.project.part("Front Fork")
front_fork_old_name = str(front_fork.name)
front_fork.edit(name="Front Fork - updated")
front_fork_updated = self.project.part("Front Fork - updated")
self.assertEqual(front_fork.id, front_fork_updated.id)
self.assertEqual(front_fork.name, front_fork_updated.name)
self.assertEqual(front_fork.name, "Front Fork - updated")
with self.assertRaises(IllegalArgumentError):
front_fork.edit(name=True)
# teardown
front_fork.edit(name=front_fork_old_name)
def test_edit_part_instance_description(self):
front_fork = self.project.part("Front Fork")
front_fork_old_description = str(front_fork._json_data.get("description"))
front_fork.edit(description="A normal Front Fork")
front_fork_updated = self.project.part("Front Fork")
self.assertEqual(front_fork.id, front_fork_updated.id)
with self.assertRaises(IllegalArgumentError):
front_fork.edit(description=42)
# teardown
front_fork.edit(description=front_fork_old_description)
def test_edit_part_model_name(self):
front_fork = self.project.model("Front Fork")
front_fork_oldname = str(front_fork.name)
front_fork.edit(name="Front Fork - updated")
front_fork_updated = self.project.model("Front Fork - updated")
self.assertEqual(front_fork.id, front_fork_updated.id)
self.assertEqual(front_fork.name, front_fork_updated.name)
# teardown
front_fork.edit(name=front_fork_oldname)
# test added due to #847 - providing no inputs overwrites values
def test_edit_part_clear_values(self):
# setup
front_fork = self.project.part("Front Fork")
front_fork_name = str(front_fork.name)
front_fork_description = str(front_fork.description)
front_fork.edit(name=None, description=None)
# testing
self.assertEqual(front_fork.name, front_fork_name)
self.assertEqual(front_fork.description, "")
# tearDown
front_fork.edit(description=front_fork_description)
def test_create_model(self):
bike = self.project.model("Bike")
pedal = self.project.create_model(bike, "Pedal", multiplicity=Multiplicity.ONE)
self._part = pedal
pedal_model = self.project.model("Pedal")
self.assertTrue(pedal.id, pedal_model.id)
self.assertTrue(pedal._json_data["multiplicity"], "ONE")
def test_add_proxy_to(self):
catalog_container = self.project.model(name__startswith="Catalog")
bearing_catalog_model = catalog_container.add_model(
"Bearing", multiplicity=Multiplicity.ZERO_MANY
)
wheel_model = self.project.model("Wheel")
bearing_proxy_model = bearing_catalog_model.add_proxy_to(
wheel_model, "Bearing", Multiplicity.ZERO_ONE
)
self.assertTrue(bearing_proxy_model.category, Category.MODEL)
self.assertTrue(bearing_proxy_model.parent(), wheel_model)
# teardown
all_bearing_proxies = self.project.parts(
name="Bearing", category=Category.MODEL, parent=wheel_model.id
)
self.assertGreaterEqual(len(all_bearing_proxies), 1)
for bearing_proxy in all_bearing_proxies:
bearing_proxy.delete()
all_bearing_catalog_models = self.project.parts(name="Bearing", category=Category.MODEL)
self.assertGreaterEqual(len(all_bearing_catalog_models), 1)
for bearing_catalog_model in all_bearing_catalog_models:
bearing_catalog_model.delete()
all_bearing_models = self.project.parts(name="Bearing", category=Category.MODEL)
self.assertEqual(len(all_bearing_models), 0)
# new in 1.6
def test_retrieve_model(self):
front_fork = self.project.part("Front Fork")
front_fork_model = self.project.model("Front Fork")
front_fork_retrieved_model = front_fork.model()
# Added to improve coverage. Assert whether NotFoundError is raised when model() method is applied to
# a part that has no model
with self.assertRaises(NotFoundError):
front_fork_model.model()
self.assertEqual(front_fork_model.id, front_fork_retrieved_model.id)
def test_count_instances(self):
front_fork_model = self.project.model("Wheel")
nr = front_fork_model.count_instances()
self.assertIsInstance(nr, int)
self.assertEqual(2, nr)
bike_part = self.project.part("Bike")
with self.assertRaises(IllegalArgumentError):
bike_part.count_instances()
def test_count_children(self):
bike_instance = self.project.part("Bike")
bike_model = self.project.model("Bike")
nr = bike_instance.count_children()
self.assertIsInstance(nr, int)
self.assertEqual(7, nr)
nr = bike_model.count_children()
self.assertEqual(5, nr)
nr = bike_instance.count_children(name__contains="Wheel")
self.assertEqual(2, nr)
def test_retrieve_catalog_model_of_proxy(self):
catalog_container = self.project.model(name__startswith="Catalog")
bearing_catalog_model = catalog_container.add_model(
"Bearing", multiplicity=Multiplicity.ZERO_MANY
)
wheel_model = self.project.model("Wheel")
# add proxy model to product Bike > Wheel based on catalog model 'Bearing'
bearing_proxy_model = bearing_catalog_model.add_proxy_to(
wheel_model, "Bearing", Multiplicity.ZERO_ONE
)
self.assertTrue(bearing_proxy_model.category, Category.MODEL)
self.assertTrue(bearing_proxy_model.parent(), wheel_model)
# the call to test here
re_retrieved_bearing_catalog_model = self.project.model(
"Bearing", classification=Classification.CATALOG
)
self.assertEqual(bearing_catalog_model, re_retrieved_bearing_catalog_model)
# teardown
all_bearing_proxies = self.project.parts(
name="Bearing", category=Category.MODEL, parent=wheel_model.id
)
self.assertGreaterEqual(len(all_bearing_proxies), 1)
for bearing_proxy in all_bearing_proxies:
bearing_proxy.delete()
all_bearing_catalog_models = self.project.parts(name="Bearing", category=Category.MODEL)
self.assertGreaterEqual(len(all_bearing_catalog_models), 1)
for bearing_catalog_model in all_bearing_catalog_models:
bearing_catalog_model.delete()
all_bearing_models = self.project.parts(name="Bearing", category=Category.MODEL)
self.assertEqual(len(all_bearing_models), 0)
def test_retrieve_non_existent_proxies_of_a_catalog_model_raises_error(self):
# Added to improve coverage. Assert whether NotFoundError is raised when proxy_model() method is applied to
# a part that is not a proxy
catalog_model = self.project.model("Model", classification=Classification.CATALOG)
with self.assertRaises(NotFoundError):
catalog_model.proxy_model()
def test_retrieve_proxy_of_instance(self):
instance = self.project.part("Rear Wheel")
with self.assertRaises(IllegalArgumentError):
instance.proxy_model()
# new in 1.8+
def test_retrieve_part_multiplicity(self):
bike_model = self.project.model("Bike")
self.assertEqual(bike_model.multiplicity, Multiplicity.ONE_MANY, bike_model.multiplicity)
# new in 1.9
def test_retrieve_part_properties_in_a_dict(self):
# Retrieve the bike part
bike = self.project.part("Bike")
# Call the function to be tested
bike_properties = bike.as_dict()
# Check whether bike_properties contains all the property names in bike
for prop in bike.properties:
self.assertTrue(prop.name in bike_properties)
# new in 1.12
def test_retrieve_children_of_part_with_additional_arguments(self):
bike = self.project.part("Bike") # type: Part
self.assertIsInstance(bike, Part)
children_of_bike = bike.children(name__icontains="Wheel")
self.assertIsInstance(children_of_bike, PartSet)
self.assertTrue(len(children_of_bike) >= 1) # eg. Wheels ...
def test_retrieve_siblings_of_part_with_additional_arguments(self):
"""Test if the siblings of a part is the same as the children of the parent of the part"""
frame = self.project.part("Frame") # type: Part
siblings_of_frame = frame.siblings(name__icontains="Wheel")
self.assertIsInstance(siblings_of_frame, PartSet)
self.assertTrue(len(siblings_of_frame) >= 1) # eg. Wheels ...
# new in 2.3
def test_clone_model(self):
# setUp
model_name = "Seat"
seat = self.project.model(model_name)
self._part = seat.clone()
# testing
clone_seat_model = self.project.model(f"CLONE - {model_name}")
self.assertTrue(clone_seat_model)
def test_clone_instance(self):
instance_name = "Front Wheel"
wheel = self.project.part(instance_name)
self._part = wheel.clone()
# testing
clone_spoke_instance = self.project.part(f"CLONE - {instance_name}")
self.assertTrue(clone_spoke_instance)
def test_clone_instance_with_multiplicity_violation(self):
instance_name = "Seat"
seat = self.project.part(instance_name)
seat_model = seat.model()
# testing
self.assertEqual(Multiplicity.ONE, seat_model.multiplicity)
with self.assertRaises(APIError):
self._part = seat.clone()
|
class TestParts(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_retrieve_parts(self):
pass
def test_retrieve_single_part(self):
pass
def test_base_comparison(self):
pass
def test_base_hash(self):
pass
def test_part_attributes(self):
pass
def test_retrieve_single_unknown(self):
pass
def test_retrieve_single_multiple(self):
pass
def test_retrieve_models(self):
pass
def test_retrieve_model_unknown(self):
pass
def test_retrieve_model_multiple(self):
pass
def test_scope(self):
pass
def test_part_set_iterator(self):
pass
def test_part_set_get_item_invalid(self):
pass
def test_wrongly_create_model(self):
pass
def test_part_add_delete_part(self):
pass
def test_create_part_where_parent_is_model(self):
pass
def test_create_part_where_model_is_instance(self):
pass
def test_create_model_where_parent_is_instance(self):
pass
def test_create_proxy_model_where_model_is_instance(self):
pass
def test_create_proxy_model_where_parent_is_instance(self):
pass
def test_add_to_wrong_categories(self):
pass
def test_part_html_table(self):
pass
def test_part_set_html_table(self):
pass
def test_part_set_html_categories(self):
pass
def test_part_set_with_limit(self):
pass
def test_part_set_with_batch(self):
pass
def test_retrieve_parent_of_part(self):
pass
def test_retrieve_children_of_part(self):
pass
def test_retrieve_siblings_of_part(self):
'''Test if the siblings of a part is the same as the children of the parent of the part'''
pass
def test_kwargs_on_part_retrieval(self):
pass
def test_edit_part_instance_name(self):
pass
def test_edit_part_instance_description(self):
pass
def test_edit_part_model_name(self):
pass
def test_edit_part_clear_values(self):
pass
def test_create_model_where_parent_is_instance(self):
pass
def test_add_proxy_to(self):
pass
def test_retrieve_models(self):
pass
def test_count_instances(self):
pass
def test_count_children(self):
pass
def test_retrieve_catalog_model_of_proxy(self):
pass
def test_retrieve_non_existent_proxies_of_a_catalog_model_raises_error(self):
pass
def test_retrieve_proxy_of_instance(self):
pass
def test_retrieve_part_multiplicity(self):
pass
def test_retrieve_part_properties_in_a_dict(self):
pass
def test_retrieve_children_of_part_with_additional_arguments(self):
pass
def test_retrieve_siblings_of_part_with_additional_arguments(self):
'''Test if the siblings of a part is the same as the children of the parent of the part'''
pass
def test_clone_model(self):
pass
def test_clone_instance(self):
pass
def test_clone_instance_with_multiplicity_violation(self):
pass
| 52 | 2 | 9 | 1 | 7 | 1 | 1 | 0.18 | 1 | 15 | 7 | 0 | 51 | 1 | 51 | 126 | 529 | 120 | 357 | 159 | 305 | 63 | 302 | 159 | 250 | 3 | 3 | 2 | 61 |
140,554 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts.py
|
tests.test_parts.TestBulkPartsDeletion
|
class TestBulkPartsDeletion(TestBetamax):
def setUp(self):
super().setUp()
self.parts = list()
self.wheel_model = self.project.model(name="Wheel")
self.bike_instance = self.project.part(name="Bike")
self.diameter_prop = self.wheel_model.property(name="Diameter")
self.spokes_prop = self.wheel_model.property(name="Spokes")
self.rim_material_prop = self.wheel_model.property(name="Rim Material")
self.tire_thickness_prop = self.wheel_model.property(name="Tire Thickness")
for idx in range(1, 5):
part_dict = {
"name": f"Wheel {idx}",
"parent_id": self.bike_instance.id,
"description": "",
"model_id": self.wheel_model.id,
"properties": [
{
"name": self.diameter_prop.name,
"value": float(f"{idx}.{idx}"),
"model_id": self.diameter_prop.id,
},
{
"name": self.spokes_prop.name,
"value": f"{idx}",
"model_id": self.spokes_prop.id,
},
{
"name": self.rim_material_prop.name,
"value": f"Material {idx}",
"model_id": self.rim_material_prop.id,
},
{
"name": self.tire_thickness_prop.name,
"value": float(f"{idx}.{idx}"),
"model_id": self.tire_thickness_prop.id,
},
],
}
self.parts.append(part_dict)
self.parts_created = list(self.client._create_parts_bulk(parts=self.parts))
def tearDown(self):
for part in self.parts_created:
# In case the parts have not been deleted and a clean up is required
try:
part.delete()
except APIError:
pass
def test_bulk_delete_parts(self):
input_parts_and_uuids = [
self.parts_created[0],
self.parts_created[1],
self.parts_created[2].id,
self.parts_created[3].id,
]
self.client._delete_parts_bulk(parts=input_parts_and_uuids)
for idx in range(1, 5):
with self.subTest(idx=idx):
with self.assertRaises(NotFoundError):
self.project.part(name=f"Wheel {idx}")
def test_bulk_delete_parts_with_wrong_input(self):
wrong_input = [self.project.activity(name="Specify wheel diameter")]
with self.assertRaises(IllegalArgumentError):
self.client._delete_parts_bulk(parts=wrong_input)
|
class TestBulkPartsDeletion(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_bulk_delete_parts(self):
pass
def test_bulk_delete_parts_with_wrong_input(self):
pass
| 5 | 0 | 16 | 1 | 16 | 0 | 2 | 0.02 | 1 | 7 | 3 | 0 | 4 | 8 | 4 | 79 | 69 | 5 | 63 | 19 | 58 | 1 | 31 | 19 | 26 | 3 | 3 | 3 | 8 |
140,555 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts.py
|
tests.test_parts.TestBulkPartsCreation
|
class TestBulkPartsCreation(TestBetamax):
def setUp(self):
super().setUp()
self.product_model = self.project.model(name="Product")
self.part_model = self.project.create_model(name="Part", parent=self.product_model)
self.text_prop = self.part_model.add_property(
name="Text Property", property_type=PropertyType.TEXT_VALUE, unit="mm"
)
self.char_prop = self.part_model.add_property(
name="Char Property", property_type=PropertyType.CHAR_VALUE
)
self.int_prop = self.part_model.add_property(
name="Int Property", property_type=PropertyType.INT_VALUE
)
self.float_prop = self.part_model.add_property(
name="Float Property", property_type=PropertyType.FLOAT_VALUE
)
self.bool_prop = self.part_model.add_property(
name="Boolean Property", property_type=PropertyType.BOOLEAN_VALUE
)
self.date_prop = self.part_model.add_property(
name="Date Property", property_type=PropertyType.DATE_VALUE
)
self.datetime_prop = self.part_model.add_property(
name="Datetime Property", property_type=PropertyType.DATETIME_VALUE
)
self.attachment_prop = self.part_model.add_property(
name="Attach Property", property_type=PropertyType.ATTACHMENT_VALUE
)
self.link_prop = self.part_model.add_property(
name="Link Property", property_type=PropertyType.LINK_VALUE
)
self.ss_prop = self.part_model.add_property(
name="SS Property", property_type=PropertyType.SINGLE_SELECT_VALUE
)
self.ss_prop.options = ["1", "2", "3", "4", "5"]
self.ms_prop = self.part_model.add_property(
name="MS Property",
property_type=PropertyType.MULTI_SELECT_VALUE,
options={"value_choices": ["1", "2", "3", "4", "5"]},
)
self.part_ref_prop = self.part_model.add_property(
name="Part ref Property",
property_type=PropertyType.REFERENCES_VALUE,
default_value=self.project.model(name="Wheel").id,
)
self.geo_info_prop = self.part_model.add_property(
name="Geo Property", property_type=PropertyType.GEOJSON_VALUE
)
self.weather_prop = self.part_model.add_property(
name="Weather Property", property_type=PropertyType.WEATHER_VALUE
)
self.act_ref_prop = self.part_model.add_property(
name="Act Property", property_type=PropertyType.ACTIVITY_REFERENCES_VALUE
)
self.product_part = self.project.part(name="Product")
self.part_dict = {
"name": "Dummy name",
"parent_id": self.product_part.id,
"description": "",
"model_id": self.part_model.id,
"properties": [
{
"name": self.text_prop.name,
"value": "Dummy value",
"model_id": self.text_prop.id,
}
],
}
def tearDown(self):
if self.part_model:
self.part_model.delete()
super().tearDown()
"""Bulk parts creation"""
def test_bulk_create_parts(self):
new_parts = list()
for idx in range(1, 5):
part_dict = {
"name": idx,
"parent_id": self.product_part.id,
"description": f"Description part {idx}",
"model_id": self.part_model.id,
"properties": [
{
"name": self.text_prop.name,
"value": f"{idx}",
"model_id": self.text_prop.id,
},
{
"name": self.char_prop.name,
"value": f"{idx}",
"model_id": self.char_prop.id,
},
{"name": self.int_prop.name, "value": idx, "model_id": self.int_prop.id},
{
"name": self.float_prop.name,
"value": float(f"{idx}.{idx}"),
"model_id": self.float_prop.id,
},
{
"name": self.bool_prop.name,
"value": True if idx % 2 == 0 else False,
"model_id": self.bool_prop.id,
},
{
"name": self.date_prop.name,
"value": datetime.date(2020, idx, idx).isoformat(),
"model_id": self.date_prop.id,
},
{
"name": self.datetime_prop.name,
"value": datetime.datetime(2020, idx, idx, 15, 00, 00).isoformat("T"),
"model_id": self.datetime_prop.id,
},
{
"name": self.link_prop.name,
"value": f"http://{idx}.com",
"model_id": self.link_prop.id,
},
{"name": self.ss_prop.name, "value": f"{idx}", "model_id": self.ss_prop.id},
{"name": self.ms_prop.name, "value": [f"{idx}"], "model_id": self.ms_prop.id},
{
"name": self.part_ref_prop.name,
"value": [self.project.part(name="Front Wheel").id],
"model_id": self.part_ref_prop.id,
},
{
"name": self.act_ref_prop.name,
"value": [self.project.activity(name="Specify wheel diameter").id],
"model_id": self.act_ref_prop.id,
},
],
}
new_parts.append(part_dict)
parts_created = self.client._create_parts_bulk(parts=new_parts)
# testing
self.assertEqual(len(parts_created), 4)
for part_created in parts_created:
idx = int(part_created.name)
self.assertEqual(part_created.description, f"Description part {idx}")
self.assertEqual(part_created.category, Category.INSTANCE)
self.assertEqual(len(part_created.properties), 15)
self.assertEqual(part_created.property(name=self.text_prop.name).value, str(idx))
self.assertEqual(part_created.property(name=self.char_prop.name).value, str(idx))
self.assertEqual(part_created.property(name=self.int_prop.name).value, idx)
self.assertEqual(
part_created.property(name=self.float_prop.name).value, float(f"{idx}.{idx}")
)
self.assertEqual(
part_created.property(name=self.bool_prop.name).value,
True if idx % 2 == 0 else False,
)
self.assertEqual(
part_created.property(name=self.date_prop.name).value,
datetime.date(2020, idx, idx).isoformat(),
)
self.assertEqual(
part_created.property(name=self.datetime_prop.name).value.split("+")[0],
datetime.datetime(2020, idx, idx, 15, 00, 00).isoformat("T"),
)
self.assertEqual(
part_created.property(name=self.link_prop.name).value, f"http://{idx}.com"
)
self.assertEqual(part_created.property(name=self.ss_prop.name).value, f"{idx}")
self.assertEqual(part_created.property(name=self.ms_prop.name).value, [f"{idx}"])
self.assertEqual(
part_created.property(name=self.part_ref_prop.name).value[0].name, "Front Wheel"
)
self.assertEqual(
part_created.property(name=self.act_ref_prop.name).value[0].name,
"Specify wheel diameter",
)
self.assertEqual(part_created.property(name=self.weather_prop.name).value, dict())
self.assertEqual(part_created.property(name=self.geo_info_prop.name).value, dict())
def test_bulk_create_parts_without_name(self):
self.part_dict.pop("name")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
def test_bulk_create_parts_without_parent_id(self):
self.part_dict.pop("parent_id")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
def test_bulk_create_parts_without_model_id(self):
self.part_dict.pop("model_id")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
def test_bulk_create_parts_without_properties(self):
self.part_dict.pop("properties")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
def test_bulk_create_parts_without_property_name(self):
self.part_dict["properties"][0].pop("name")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
def test_bulk_create_parts_without_property_model_id(self):
self.part_dict["properties"][0].pop("model_id")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
def test_bulk_create_parts_without_property_value(self):
self.part_dict["properties"][0].pop("value")
with self.assertRaises(IllegalArgumentError):
self.client._create_parts_bulk(parts=[self.part_dict])
|
class TestBulkPartsCreation(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_bulk_create_parts(self):
pass
def test_bulk_create_parts_without_name(self):
pass
def test_bulk_create_parts_without_parent_id(self):
pass
def test_bulk_create_parts_without_model_id(self):
pass
def test_bulk_create_parts_without_properties(self):
pass
def test_bulk_create_parts_without_property_name(self):
pass
def test_bulk_create_parts_without_property_model_id(self):
pass
def test_bulk_create_parts_without_property_value(self):
pass
| 11 | 0 | 20 | 0 | 20 | 0 | 2 | 0.01 | 1 | 12 | 3 | 0 | 10 | 19 | 10 | 85 | 216 | 14 | 200 | 35 | 189 | 2 | 81 | 35 | 70 | 5 | 3 | 1 | 15 |
140,556 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_notifications.py
|
tests.test_notifications._TestNotification
|
class _TestNotification(TestBetamax):
SUBJECT = "_TEST_SUBJECT"
MESSAGE = "_TEST_MESSAGE"
USER_ID = 1
def setUp(self) -> None:
super().setUp()
self.USER = self.client.user(pk=self.USER_ID)
self.TEAM = self.client.teams()[0]
for old_notification in self.client.notifications(subject=self.SUBJECT):
old_notification.delete()
|
class _TestNotification(TestBetamax):
def setUp(self) -> None:
pass
| 2 | 0 | 7 | 1 | 6 | 0 | 2 | 0 | 1 | 1 | 0 | 2 | 1 | 2 | 1 | 76 | 12 | 2 | 10 | 8 | 8 | 0 | 10 | 8 | 8 | 2 | 3 | 1 | 2 |
140,557 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_notifications.py
|
tests.test_notifications.TestNotifications
|
class TestNotifications(_TestNotification):
def setUp(self):
super().setUp()
self.notification = self.client.create_notification(
subject=self.SUBJECT,
message=self.MESSAGE,
recipients=[self.USER_ID],
team=self.TEAM,
)
def tearDown(self):
self.notification.delete()
super().tearDown()
def test_all_notifications_retrieval(self):
# setUp
notifications = self.client.notifications()
number_of_notification = len(notifications)
dummy_notification = self.client.create_notification(
subject="Dummy subject", message="Dummy message"
)
notifications_retrieved_again = self.client.notifications()
# testing
self.assertTrue(len(notifications_retrieved_again) == number_of_notification + 1)
# tearDown
self.client.delete_notification(notification=dummy_notification)
def test_retrieve_notification(self):
# testing
retrieved_notification = self.client.notification(
message=self.MESSAGE, subject=self.SUBJECT
)
self.assertIsInstance(retrieved_notification, Notification)
self.assertEqual(self.notification, retrieved_notification)
def test_retrieve_notification_raise_not_found(self):
with self.assertRaises(NotFoundError):
self.client.notification(message="Doesn't exist")
def test_retrieve_notification_raise_multiple_found(self):
# setUp
clone_testing_notification = self.client.create_notification(
subject=self.SUBJECT, message=self.MESSAGE
)
# testing
with self.assertRaises(MultipleFoundError):
self.client.notification(message=self.MESSAGE, subject=self.SUBJECT)
# tearDown
clone_testing_notification.delete()
def test_get_recipient_users(self):
recipients = self.notification.get_recipient_users()
# testing
self.assertIsInstance(recipients, list)
self.assertTrue(recipients)
first_recipient = recipients[0]
self.assertIsInstance(first_recipient, User)
self.assertEqual("superuser", first_recipient.username)
def test_get_from_user(self):
from_user = self.notification.get_from_user()
self.assertTrue(from_user)
self.assertIsInstance(from_user, User)
self.assertEqual("pykechain_user", from_user.username)
def test_get_team(self):
team = self.notification.get_team()
self.assertIsInstance(team, Team)
self.assertEqual(self.TEAM, team)
def test_edit(self):
subject = "NEW SUBJECT"
message = "NEW MESSAGE"
status = NotificationStatus.ARCHIVED
recipients = [4]
from_user = 4
event = NotificationEvent.EXPORT_ACTIVITY_ASYNC
channel = NotificationChannels.APP
self.notification.edit(
subject=subject,
message=message,
status=status,
recipients=recipients,
team=self.TEAM,
from_user=from_user,
event=event,
channel=channel,
)
self.assertEqual(subject, self.notification.subject)
self.assertEqual(message, self.notification.message)
self.assertEqual(status, self.notification.status)
self.assertListEqual(recipients, self.notification.recipient_user_ids)
self.assertEqual(self.TEAM.id, self.notification.team_id)
self.assertEqual(from_user, self.notification.from_user_id)
self.assertEqual(event, self.notification.event)
self.assertEqual(channel, self.notification.channels[0])
def test_edit_incorrect_inputs(self):
with self.assertRaises(IllegalArgumentError):
self.notification.edit(subject=["Not a string"])
with self.assertRaises(IllegalArgumentError):
self.notification.edit(message=False)
with self.assertRaises(IllegalArgumentError):
self.notification.edit(status="Deleting")
with self.assertRaises(IllegalArgumentError):
self.notification.edit(recipients=True)
with self.assertRaises(IllegalArgumentError):
self.notification.edit(recipients=["Not a user ID"])
with self.assertRaises(IllegalArgumentError):
self.notification.edit(team=5)
with self.assertRaises(IllegalArgumentError):
self.notification.edit(from_user="self")
with self.assertRaises(IllegalArgumentError):
self.notification.edit(from_user=5.3)
with self.assertRaises(IllegalArgumentError):
self.notification.edit(event="Update")
with self.assertRaises(IllegalArgumentError):
self.notification.edit(channel=[NotificationChannels.APP])
# test added due to #847 - providing no inputs overwrites values
def test_edit_notification_clear_values(self):
# setup
initial_subject = "NEW SUBJECT"
initial_message = "NEW MESSAGE"
initial_status = NotificationStatus.ARCHIVED
initial_recipients = [4]
initial_from_user = 4
initial_event = NotificationEvent.EXPORT_ACTIVITY_ASYNC
initial_channel = NotificationChannels.APP
self.notification.edit(
subject=initial_subject,
message=initial_message,
status=initial_status,
recipients=initial_recipients,
team=self.TEAM,
from_user=initial_from_user,
event=initial_event,
channel=initial_channel,
)
# Edit without mentioning values, everything should stay the same
new_subject = "AWESOME SUBJECT NEW"
self.notification.edit(subject=new_subject)
# testing
self.assertEqual(self.notification.subject, new_subject)
self.assertEqual(self.notification.message, initial_message)
self.assertEqual(self.notification.status, initial_status)
self.assertEqual(self.notification.recipient_user_ids, initial_recipients)
self.assertEqual(self.notification.from_user_id, initial_from_user)
self.assertEqual(self.notification.event, initial_event)
self.assertEqual(self.notification.channels, [initial_channel])
# Edit with clearing the values, name and status cannot be cleared
self.notification.edit(
subject=None,
message=None,
status=None,
recipients=None,
team=None,
from_user=None,
event=None,
channel=None,
)
self.assertEqual(self.notification.subject, new_subject)
self.assertEqual(self.notification.message, initial_message)
self.assertEqual(self.notification.status, initial_status)
self.assertEqual(self.notification.recipient_user_ids, list())
self.assertEqual(self.notification.from_user_id, None)
self.assertEqual(self.notification.event, initial_event)
self.assertEqual(self.notification.channels, [initial_channel])
|
class TestNotifications(_TestNotification):
def setUp(self):
pass
def tearDown(self):
pass
def test_all_notifications_retrieval(self):
pass
def test_retrieve_notification(self):
pass
def test_retrieve_notification_raise_not_found(self):
pass
def test_retrieve_notification_raise_multiple_found(self):
pass
def test_get_recipient_users(self):
pass
def test_get_from_user(self):
pass
def test_get_team(self):
pass
def test_edit(self):
pass
def test_edit_incorrect_inputs(self):
pass
def test_edit_notification_clear_values(self):
pass
| 13 | 0 | 15 | 2 | 12 | 1 | 1 | 0.09 | 1 | 9 | 7 | 0 | 12 | 4 | 12 | 88 | 187 | 30 | 144 | 42 | 131 | 13 | 106 | 39 | 93 | 1 | 4 | 1 | 12 |
140,558 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_notifications.py
|
tests.test_notifications.TestNotificationCreation
|
class TestNotificationCreation(_TestNotification):
def setUp(self):
super().setUp()
self.bucket = list()
def tearDown(self):
for obj in self.bucket:
try:
obj.delete()
except APIError:
pass
super().tearDown()
def test_create(self):
# setUp
notification = self.client.create_notification(subject=self.SUBJECT, message=self.MESSAGE)
self.bucket.append(notification)
# testing
self.assertIsInstance(notification, Notification)
self.assertEqual(self.SUBJECT, notification.subject)
self.assertEqual(self.MESSAGE, notification.message)
def test_create_with_inputs(self):
notification = self.client.create_notification(
subject=self.SUBJECT,
message=self.MESSAGE,
status=NotificationStatus.READY,
recipients=[self.USER_ID],
team=self.TEAM,
from_user=self.USER_ID,
event=NotificationEvent.EXPORT_ACTIVITY_ASYNC,
channel=NotificationChannels.EMAIL,
)
self.bucket.append(notification)
self.assertIsInstance(notification, Notification)
self.assertEqual(NotificationStatus.READY, notification.status)
self.assertEqual(self.USER_ID, notification.recipient_user_ids[0])
self.assertEqual(self.TEAM, notification.get_team())
self.assertEqual(self.USER, notification.get_from_user())
self.assertEqual(NotificationEvent.EXPORT_ACTIVITY_ASYNC, notification.event)
self.assertEqual(NotificationChannels.EMAIL, notification.channels[0])
def test_create_invalid_inputs(self):
kwargs = dict(subject=self.SUBJECT, message=self.MESSAGE)
with self.assertRaises(IllegalArgumentError):
self.bucket.append(
self.client.create_notification(subject=False, message=self.MESSAGE)
)
with self.assertRaises(IllegalArgumentError):
self.bucket.append(
self.client.create_notification(subject=self.SUBJECT, message=[self.MESSAGE])
)
with self.assertRaises(IllegalArgumentError):
self.bucket.append(self.client.create_notification(status="sending", **kwargs))
with self.assertRaises(IllegalArgumentError):
self.bucket.append(self.client.create_notification(recipients="not a list", **kwargs))
with self.assertRaises(IllegalArgumentError):
self.bucket.append(
self.client.create_notification(recipients=["not a user id"], **kwargs)
)
with self.assertRaises(IllegalArgumentError):
self.bucket.append(self.client.create_notification(team=0, **kwargs))
with self.assertRaises(IllegalArgumentError):
self.bucket.append(self.client.create_notification(from_user="Myself", **kwargs))
with self.assertRaises(IllegalArgumentError):
self.bucket.append(self.client.create_notification(event="Update", **kwargs))
with self.assertRaises(IllegalArgumentError):
self.bucket.append(
self.client.create_notification(channel=[NotificationChannels.EMAIL], **kwargs)
)
def test_delete_notification_from_client(self):
# setUp
notification = self.client.create_notification(message=self.MESSAGE, subject=self.SUBJECT)
self.client.delete_notification(notification=notification)
# testing
with self.assertRaises(NotFoundError):
self.client.notification(message=self.MESSAGE, subject=self.SUBJECT)
def test_delete_notification(self):
# setUp
notification = self.client.create_notification(message=self.MESSAGE, subject=self.SUBJECT)
notification.delete()
# testing
with self.assertRaises(NotFoundError):
self.client.notification(message=self.MESSAGE, subject=self.SUBJECT)
|
class TestNotificationCreation(_TestNotification):
def setUp(self):
pass
def tearDown(self):
pass
def test_create(self):
pass
def test_create_with_inputs(self):
pass
def test_create_invalid_inputs(self):
pass
def test_delete_notification_from_client(self):
pass
def test_delete_notification_from_client(self):
pass
| 8 | 0 | 12 | 1 | 10 | 1 | 1 | 0.08 | 1 | 10 | 7 | 0 | 7 | 5 | 7 | 83 | 90 | 10 | 74 | 18 | 66 | 6 | 57 | 15 | 49 | 3 | 4 | 2 | 9 |
140,559 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_helpers.py
|
tests.test_helpers.TestGetProjectHelperNotForTravis
|
class TestGetProjectHelperNotForTravis(TestBetamax):
def setUp(self):
super().setUp()
# unset all environment variables in the self.env protected env world
for kec_env in KechainEnv.values():
self.env.unset(kec_env)
def test_get_project__not_for_travis(self):
self.env.set(KechainEnv.KECHAIN_FORCE_ENV_USE, "false")
with self.env:
project = get_project(TEST_URL, token=TEST_TOKEN, scope=TEST_SCOPE_NAME)
self.assertEqual(project.name, TEST_SCOPE_NAME)
# 1.12.1
def test_get_project__force_env_use_no_vars(self):
"""Test the get_project by using KECHAIN_FORCE_ENV_USE=True"""
self.env.set("KECHAIN_FORCE_ENV_USE", "True")
with self.env:
self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE))
with self.assertRaisesRegex(ClientError, "should be provided as environment variable"):
# KECHAIN_SCOPE or KECHAIN_SCOPE_ID should be provided as environment variable
get_project()
def test_get_project__force_env_use__only_url(self):
self.env.update(dict(KECHAIN_URL=TEST_URL, KECHAIN_FORCE_ENV_USE="True"))
with self.env:
self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE))
with self.assertRaisesRegex(ClientError, "should be provided as environment variable"):
# Error: KECHAIN_SCOPE or KECHAIN_SCOPE_ID should be provided as environment variable
get_project()
def test_get_project__force_env_use__url_and_token(self):
self.env.update(
dict(KECHAIN_URL=TEST_URL, KECHAIN_TOKEN=TEST_TOKEN, KECHAIN_FORCE_ENV_USE="True")
)
with self.env:
self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE))
with self.assertRaisesRegex(ClientError, "should be provided as environment variable"):
# Error: KECHAIN_SCOPE or KECHAIN_SCOPE_ID should be provided as environment variable
get_project()
def test_get_project__force_env_use__url_token_and_name(self):
self.env.update(
dict(
KECHAIN_URL=TEST_URL,
KECHAIN_TOKEN=TEST_TOKEN,
KECHAIN_SCOPE_ID=TEST_SCOPE_ID,
KECHAIN_FORCE_ENV_USE="True",
)
)
with self.env:
self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE))
self.assertEqual(get_project().name, TEST_SCOPE_NAME)
def test_get_project__force_env_use__other_things_provided(self):
self.env.update(
dict(
KECHAIN_URL=TEST_URL,
KECHAIN_TOKEN=TEST_TOKEN,
KECHAIN_SCOPE_ID=TEST_SCOPE_ID,
KECHAIN_FORCE_ENV_USE="True",
)
)
with self.env:
self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE))
self.assertEqual(
get_project(url="http://whatever", token=PSEUDO_TOKEN).name, TEST_SCOPE_NAME
)
def test_test_get_project_with_scope_id__not_for_travis(self):
project = get_project(TEST_URL, token=TEST_TOKEN, scope_id=TEST_SCOPE_ID)
self.assertEqual(project.name, TEST_SCOPE_NAME)
def test_get_project_from_env__not_for_travis(self):
# setup
self.env.update(
dict(KECHAIN_URL=TEST_URL, KECHAIN_TOKEN=TEST_TOKEN, KECHAIN_SCOPE=TEST_SCOPE_NAME)
)
with self.env:
project = get_project()
self.assertEqual(project.name, self.env["KECHAIN_SCOPE"])
|
class TestGetProjectHelperNotForTravis(TestBetamax):
def setUp(self):
pass
def test_get_project__not_for_travis(self):
pass
def test_get_project__force_env_use_no_vars(self):
'''Test the get_project by using KECHAIN_FORCE_ENV_USE=True'''
pass
def test_get_project__force_env_use__only_url(self):
pass
def test_get_project__force_env_use__url_and_token(self):
pass
def test_get_project__force_env_use__url_token_and_name(self):
pass
def test_get_project__force_env_use__other_things_provided(self):
pass
def test_test_get_project_with_scope_id__not_for_travis(self):
pass
def test_get_project_from_env__not_for_travis(self):
pass
| 10 | 1 | 8 | 0 | 7 | 1 | 1 | 0.11 | 1 | 5 | 2 | 0 | 9 | 0 | 9 | 84 | 83 | 10 | 66 | 14 | 56 | 7 | 46 | 14 | 36 | 2 | 3 | 2 | 10 |
140,560 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_helpers.py
|
tests.test_helpers.TestGetProjectHelper
|
class TestGetProjectHelper(TestBetamax):
def test_project_raises_error__no_auth(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(url=TEST_URL)
def test_project_raises_error__token_and_no_scope(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(url=TEST_URL, token=TEST_TOKEN)
def test_project_raises_error__no_pass(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(url=TEST_URL, username="auser", scope="Scope")
def test_project_raises_error__auth_and_no_scope(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(url=TEST_URL, username="auser", password=PSEUDO_PASSWORD)
def test_project_raises_error__scope_id_and_no_pass(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(url=TEST_URL, username="auser", scope_id=PSEUDO_SCOPE_ID)
def test_project_raises_error__auth_and_no_url(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(username="auser", password=PSEUDO_PASSWORD, scope_id=PSEUDO_SCOPE_ID)
def test_project_raises_error__token_and_no_url(self):
with self.assertRaisesRegex(ClientError, "Error: insufficient arguments"):
get_project(token=PSEUDO_TOKEN, scope_id=PSEUDO_SCOPE_ID)
|
class TestGetProjectHelper(TestBetamax):
def test_project_raises_error__no_auth(self):
pass
def test_project_raises_error__token_and_no_scope(self):
pass
def test_project_raises_error__no_pass(self):
pass
def test_project_raises_error__auth_and_no_scope(self):
pass
def test_project_raises_error__scope_id_and_no_pass(self):
pass
def test_project_raises_error__auth_and_no_url(self):
pass
def test_project_raises_error__token_and_no_url(self):
pass
| 8 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 7 | 0 | 7 | 82 | 28 | 6 | 22 | 8 | 14 | 0 | 22 | 8 | 14 | 1 | 3 | 1 | 7 |
140,561 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_forms.py
|
tests.test_forms.TestFormsPreFillPartMethods
|
class TestFormsPreFillPartMethods(TestBetamax):
"""
Test linking and unlinking contexts to forms.
"""
def setUp(self):
super().setUp()
self.workflow = self.client.workflow(
name="Simple Form Flow", category=WorkflowCategory.CATALOG
)
self.form_model_name = "__TEST__FORM_MODEL"
self.form_model = self.client.create_form_model(
name=self.form_model_name,
scope=self.project,
workflow=self.workflow,
category=FormCategory.MODEL,
contexts=[],
)
self.form_model_root = self.form_model.form_model_root
self.a_part_model = self.client.create_model(
parent=self.form_model_root,
name="A Part Model",
multiplicity=Multiplicity.ZERO_MANY,
)
self.p1 = self.client.create_property(
model=self.a_part_model, name="p1", property_type=PropertyType.CHAR_VALUE
)
def tearDown(self):
super().tearDown()
if self.form_model:
try:
self.form_model.delete()
except (ForbiddenError, APIError):
pass
def test_form_prefill_parts_can_be_set(self):
prefill_parts = {
self.a_part_model.id: [
dict(
name="1st instance",
part_properties=[dict(property_id=self.p1.id, value=1)],
),
dict(
name="2nd instance",
part_properties=[dict(property_id=self.p1.id, value=2)]
)
]
}
self.assertDictEqual(self.form_model._prefill_parts, {})
self.form_model.set_prefill_parts(prefill_parts=prefill_parts)
self.assertDictEqual(prefill_parts, self.form_model._prefill_parts)
def test_form_prefill_parts_with_wrong_payload(self):
prefill_parts = {"foo": "bar"}
self.assertDictEqual(self.form_model._prefill_parts, {})
with self.assertRaisesRegex(jsonschema.ValidationError, "'foo' does not match"):
self.form_model.set_prefill_parts(prefill_parts=prefill_parts)
prefill_parts = {str(uuid.uuid4()): ["bar"]}
self.assertDictEqual(self.form_model._prefill_parts, {})
with self.assertRaisesRegex(jsonschema.ValidationError, "'bar' is not of type 'object'"):
self.form_model.set_prefill_parts(prefill_parts=prefill_parts)
prefill_parts = {str(uuid.uuid4()): [{"name": "bar"}]}
self.assertDictEqual(self.form_model._prefill_parts, {})
with self.assertRaisesRegex(jsonschema.ValidationError, "'part_properties' is a required property"):
self.form_model.set_prefill_parts(prefill_parts=prefill_parts)
prefill_parts = {str(uuid.uuid4()): [{"name": "bar", "part_properties": {}}]}
self.assertDictEqual(self.form_model._prefill_parts, {})
with self.assertRaisesRegex(jsonschema.ValidationError, "{} is not of type 'array'"):
self.form_model.set_prefill_parts(prefill_parts=prefill_parts)
|
class TestFormsPreFillPartMethods(TestBetamax):
'''
Test linking and unlinking contexts to forms.
'''
def setUp(self):
pass
def tearDown(self):
pass
def test_form_prefill_parts_can_be_set(self):
pass
def test_form_prefill_parts_with_wrong_payload(self):
pass
| 5 | 1 | 17 | 1 | 16 | 0 | 2 | 0.05 | 1 | 10 | 6 | 0 | 4 | 7 | 4 | 79 | 74 | 8 | 63 | 14 | 58 | 3 | 38 | 13 | 33 | 3 | 3 | 2 | 6 |
140,562 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_forms.py
|
tests.test_forms.TestFormsMethods
|
class TestFormsMethods(TestBetamax):
"""
Test linking and unlinking contexts to forms.
"""
def setUp(self):
super().setUp()
self.workflow = self.client.workflow(
name="Simple Form Flow", category=WorkflowCategory.CATALOG
)
self.discipline_context = self.project.context(name="Discipline 1")
self.asset_context = self.project.context(name="Object 1")
self.location_context = self.project.context(name="Location 1")
self.form_model_name = "__TEST__FORM_MODEL"
self.form_model = self.client.create_form_model(
name=self.form_model_name,
scope=self.project,
workflow=self.workflow,
category=FormCategory.MODEL,
contexts=[self.asset_context],
)
self.form_instance_to_link = self.form_model.instantiate(
name="__TEST_FORM_INSTANCE_LINK"
)
self.form_instance_to_unlink = self.form_model.instantiate(
name="__TEST_FORM_INSTANCE_UNLINK",
contexts=[
self.asset_context,
self.discipline_context,
self.location_context,
],
)
self.form_instance_to_set_assignees = self.form_model.instantiate(
name="__TEST_FORM_INSTANCE_SET_STATUS_ASSIGNEES"
)
self.form_instance_to_transition = self.form_model.instantiate(
name="__TEST_FORM_INSTANCE_APPLY_TRANSITION"
)
def tearDown(self):
super().tearDown()
if self.form_instance_to_link:
try:
self.form_instance_to_link.delete()
except (ForbiddenError, APIError):
pass
if self.form_instance_to_unlink:
try:
self.form_instance_to_unlink.delete()
except (ForbiddenError, APIError):
pass
if self.form_instance_to_set_assignees:
try:
self.form_instance_to_set_assignees.delete()
except (ForbiddenError, APIError):
pass
if self.form_instance_to_transition:
try:
self.form_instance_to_transition.delete()
except (ForbiddenError, APIError):
pass
if self.form_model:
try:
self.form_model.delete()
except (ForbiddenError, APIError):
pass
def test_link_contexts_to_form_model(self):
self.form_model.link_contexts(
contexts=[self.discipline_context, self.location_context]
)
self.assertIn(
self.asset_context.id,
[context["id"] for context in self.form_model._json_data["contexts"]],
)
self.assertIn(
self.discipline_context.id,
[context["id"] for context in self.form_model._json_data["contexts"]],
)
self.assertIn(
self.location_context.id,
[context["id"] for context in self.form_model._json_data["contexts"]],
)
self.assertEqual(len(self.form_model._json_data["contexts"]), 3)
def test_link_contexts_to_form_instance(self):
self.form_instance_to_link.link_contexts(contexts=[self.location_context])
self.assertIn(
self.location_context.id,
[
context["id"]
for context in self.form_instance_to_link._json_data["contexts"]
],
)
self.assertEqual(len(self.form_instance_to_link._json_data["contexts"]), 1)
def test_unlink_contexts_to_form_model(self):
self.form_model.unlink_contexts(contexts=[self.asset_context])
self.assertEqual(len(self.form_model._json_data["contexts"]), 0)
def test_unlink_contexts_to_form_instance(self):
self.form_instance_to_unlink.unlink_contexts(
contexts=[self.location_context, self.asset_context]
)
self.assertIn(
self.discipline_context.id,
[
context["id"]
for context in self.form_instance_to_unlink._json_data["contexts"]
],
)
self.assertEqual(len(self.form_instance_to_unlink._json_data["contexts"]), 1)
def test_unlink_non_connected_contexts_from_form(self):
with self.assertRaises(APIError):
self.form_model.unlink_contexts(
contexts=[self.discipline_context, self.asset_context]
)
def test_set_status_assignees(self):
status_assignees_list = list()
test_manager = self.client.user("testmanager")
supervisor = self.client.user("supervisor")
test_lead = self.client.user("testlead")
for status_form in self.form_instance_to_set_assignees.status_forms:
status_dict = {
"status": status_form.status,
"assignees": [test_manager, supervisor, test_lead],
}
status_assignees_list.append(status_dict)
self.form_instance_to_set_assignees.set_status_assignees(
statuses=status_assignees_list
)
for status_form in self.form_instance_to_set_assignees._status_assignees:
self.assertIn(
test_manager.id,
[status_assignee["id"] for status_assignee in status_form["assignees"]],
)
self.assertEqual(len(status_form["assignees"]), 3)
def test_set_status_assignees_with_wrong_format(self):
status_assignees_list = list()
test_manager = self.client.user("testmanager")
for status_form in self.form_instance_to_set_assignees.status_forms:
status_dict = {"id": status_form.status, "assignees": [test_manager]}
status_assignees_list.append(status_dict)
with self.assertRaises(IllegalArgumentError):
self.form_instance_to_set_assignees.set_status_assignees(
statuses=status_assignees_list
)
def test_set_status_assignees_with_wrong_input(self):
status_assignees_list = list()
test_manager = self.client.user("testmanager")
for status_form in self.form_instance_to_set_assignees.status_forms:
status_dict = {
"status": status_form.id, # This should be status_form.status
"assignees": [test_manager],
}
status_assignees_list.append(status_dict)
with self.assertRaises(APIError):
self.form_instance_to_set_assignees.set_status_assignees(
statuses=status_assignees_list
)
def test_apply_transition(self):
in_progress_transition = self.workflow.transition("In progress")
done_transition = self.workflow.transition("Done")
self.assertEqual(
self.form_instance_to_transition.active_status["status_category"],
StatusCategory.TODO,
)
self.form_instance_to_transition.apply_transition(
transition=in_progress_transition
)
self.assertEqual(
self.form_instance_to_transition.active_status["status_category"],
StatusCategory.INPROGRESS,
)
self.form_instance_to_transition.apply_transition(transition=done_transition)
self.assertEqual(
self.form_instance_to_transition.active_status["status_category"],
StatusCategory.DONE,
)
def test_apply_transition_with_wrong_input(self):
with self.assertRaises(IllegalArgumentError):
self.form_instance_to_transition.apply_transition(transition=self.workflow)
def test_retrieve_possible_transitions(self):
possible_transitions = self.form_instance_to_transition.possible_transitions()
for transition in possible_transitions:
self.assertIn(transition.id, [t.id for t in self.workflow.transitions])
self.assertEqual(len(possible_transitions), 5)
|
class TestFormsMethods(TestBetamax):
'''
Test linking and unlinking contexts to forms.
'''
def setUp(self):
pass
def tearDown(self):
pass
def test_link_contexts_to_form_model(self):
pass
def test_link_contexts_to_form_instance(self):
pass
def test_unlink_contexts_to_form_model(self):
pass
def test_unlink_contexts_to_form_instance(self):
pass
def test_unlink_non_connected_contexts_from_form(self):
pass
def test_set_status_assignees(self):
pass
def test_set_status_assignees_with_wrong_format(self):
pass
def test_set_status_assignees_with_wrong_input(self):
pass
def test_apply_transition(self):
pass
def test_apply_transition_with_wrong_input(self):
pass
def test_retrieve_possible_transitions(self):
pass
| 14 | 1 | 14 | 0 | 14 | 0 | 2 | 0.02 | 1 | 8 | 6 | 0 | 13 | 11 | 13 | 88 | 194 | 13 | 178 | 43 | 164 | 4 | 104 | 42 | 90 | 11 | 3 | 2 | 28 |
140,563 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_validators.py
|
tests.models.test_validators.TestFileExtensionValidator
|
class TestFileExtensionValidator(TestCase):
def test_validator_valid_json_with_settings(self):
validator = FileExtensionValidator(accept=[".csv"])
self.assertIsNone(validator.validate_json())
def test_validator_valid_json_without_settings(self):
validator = FileExtensionValidator()
self.assertIsNone(validator.validate_json())
def test_fileextensionvalidator_on_extension(self):
validator = FileExtensionValidator(accept=[".csv"])
self.assertTrue(validator.is_valid("file.csv"))
self.assertFalse(validator.is_valid("file.tsv"))
self.assertFalse(validator.is_valid("file.txt"))
def test_fileextensionvalidator_on_extensions(self):
validator = FileExtensionValidator(accept=[".csv", ".pdf"])
self.assertTrue(validator.is_valid("file.csv"))
self.assertTrue(validator.is_valid("file.pdf"))
self.assertFalse(validator.is_valid("file.docx"))
with self.assertRaises(ValueError):
# noinspection PyTypeChecker
FileExtensionValidator(accept=True)
def test_fileextensionvalidator_on_extensions_csv(self):
validator = FileExtensionValidator(accept=".csv,.pdf")
self.assertTrue(validator.is_valid("file.csv"))
self.assertTrue(validator.is_valid("file.pdf"))
self.assertFalse(validator.is_valid("file.docx"))
def test_fileextensionvalidator_on_mimetype(self):
validator = FileExtensionValidator(accept=["application/pdf"])
self.assertTrue(validator.is_valid("file.pdf"))
self.assertFalse(validator.is_valid("file.docx"))
def test_fileextensionvalidator_on_expanded_mimetypes(self):
validator = FileExtensionValidator(accept=["video/*"])
self.assertTrue(validator.is_valid("file.mp4"))
self.assertTrue(validator.is_valid("file.mov"))
self.assertTrue(validator.is_valid("file.mpeg"))
self.assertTrue(validator.is_valid("file.flv"))
self.assertTrue(validator.is_valid("file.wmv"))
self.assertTrue(validator.is_valid("file.webm"))
def test_fileextensionvalidator_on_mixed_mode(self):
validator = FileExtensionValidator(accept=[".csv", "application/pdf"])
self.assertTrue(validator.is_valid("file.csv"))
self.assertTrue(validator.is_valid("file.pdf"))
self.assertFalse(validator.is_valid("file.docx"))
def test_fileextensionvalidator_on_excel(self):
validator = FileExtensionValidator(accept=[".xls", ".xlsx"])
self.assertTrue(validator.is_valid("file.xls"))
self.assertTrue(validator.is_valid("file.xlsx"))
self.assertFalse(validator.is_valid("file.docx"))
def test_fileextensionvalidator_being_none(self):
validator = FileExtensionValidator(accept=["video/*"])
self.assertIsNone(validator.is_valid(None))
|
class TestFileExtensionValidator(TestCase):
def test_validator_valid_json_with_settings(self):
pass
def test_validator_valid_json_without_settings(self):
pass
def test_fileextensionvalidator_on_extension(self):
pass
def test_fileextensionvalidator_on_extensions(self):
pass
def test_fileextensionvalidator_on_extensions_csv(self):
pass
def test_fileextensionvalidator_on_mimetype(self):
pass
def test_fileextensionvalidator_on_expanded_mimetypes(self):
pass
def test_fileextensionvalidator_on_mixed_mode(self):
pass
def test_fileextensionvalidator_on_excel(self):
pass
def test_fileextensionvalidator_being_none(self):
pass
| 11 | 0 | 5 | 0 | 5 | 0 | 1 | 0.02 | 1 | 2 | 1 | 0 | 10 | 0 | 10 | 82 | 61 | 11 | 49 | 21 | 38 | 1 | 49 | 21 | 38 | 1 | 2 | 1 | 10 |
140,564 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_validators.py
|
tests.models.test_validators.TestFileSizeValidator
|
class TestFileSizeValidator(TestCase):
def test_validator_valid_json_with_settings(self):
validator = FileSizeValidator(max_size=100)
self.assertIsNone(validator.validate_json())
def test_validator_valid_json_without_settings(self):
validator = FileSizeValidator()
self.assertIsNone(validator.validate_json())
def test_validator_valid_json_with_additional_arguments(self):
validator = FileSizeValidator(max_size=100, another_argument=False)
# another_argument is not found in the json
validator.validate_json()
validator.as_json()
# noinspection PyTypeChecker
def test_validator_invalid_arguments(self):
with self.assertRaisesRegex(ValueError, "should be a number"):
FileSizeValidator(max_size=set())
with self.assertRaisesRegex(ValueError, "should be a number"):
FileSizeValidator(max_size=list())
with self.assertRaisesRegex(ValueError, "should be a number"):
FileSizeValidator(max_size=dict())
with self.assertRaisesRegex(ValueError, "should be a number"):
FileSizeValidator(max_size=tuple())
with self.assertRaisesRegex(ValueError, "should be a number"):
FileSizeValidator(max_size=tuple())
with self.assertRaisesRegex(ValueError, "should be a number"):
FileSizeValidator(max_size="100")
def test_filesizevalidator_being_valid(self):
validator = FileSizeValidator(max_size=100)
self.assertTrue(validator.is_valid(100))
self.assertTrue(validator.is_valid(100.0))
self.assertTrue(validator.is_valid(99))
self.assertTrue(validator.is_valid(0))
self.assertTrue(validator.is_valid("text"))
self.assertTrue(validator.is_valid(list()))
self.assertTrue(validator.is_valid(tuple()))
self.assertTrue(validator.is_valid(dict()))
self.assertTrue(validator.is_valid(set()))
def test_filesizevalidator_being_invalid(self):
validator = FileSizeValidator(max_size=100)
self.assertFalse(validator.is_valid(101*1024**2))
self.assertFalse(validator.is_valid(101*1024**2))
self.assertFalse(validator.is_valid(-1))
def test_filesizevalidator_being_none(self):
validator = FileSizeValidator(max_size=100)
self.assertIsNone(validator.is_valid(None))
|
class TestFileSizeValidator(TestCase):
def test_validator_valid_json_with_settings(self):
pass
def test_validator_valid_json_without_settings(self):
pass
def test_validator_valid_json_with_additional_arguments(self):
pass
def test_validator_invalid_arguments(self):
pass
def test_filesizevalidator_being_valid(self):
pass
def test_filesizevalidator_being_invalid(self):
pass
def test_filesizevalidator_being_none(self):
pass
| 8 | 0 | 7 | 1 | 6 | 0 | 1 | 0.05 | 1 | 6 | 1 | 0 | 7 | 0 | 7 | 79 | 55 | 10 | 43 | 14 | 35 | 2 | 43 | 14 | 35 | 1 | 2 | 1 | 7 |
140,565 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_validators.py
|
tests.models.test_validators.TestNumericRangeValidator
|
class TestNumericRangeValidator(TestCase):
def test_numeric_range_without_settings_validated_json(self):
validator = NumericRangeValidator()
as_json = validator.as_json()
self.assertIsNone(validator.validate_json())
self.assertIsInstance(as_json, dict)
self.assertDictEqual(as_json, {"config": {}, "vtype": "numericRangeValidator"})
def test_numeric_range_validates_with_lower_bound(self):
validator = NumericRangeValidator(minvalue=0)
self.assertTrue(validator.is_valid(1))
validator = NumericRangeValidator(minvalue=5)
self.assertTrue(validator.is_valid(6))
def test_numeric_range_validates_with_max_bound(self):
validator = NumericRangeValidator(maxvalue=0)
self.assertTrue(validator.is_valid(-3))
validator = NumericRangeValidator(maxvalue=10)
self.assertTrue(validator.is_valid(1))
def test_numeric_range_validates_with_min_max_bound(self):
validator = NumericRangeValidator(maxvalue=10, minvalue=0)
self.assertTrue(validator.is_valid(1))
def test_numeric_range_invalidates_with_lower_bound(self):
validator = NumericRangeValidator(minvalue=0)
self.assertFalse(validator.is_valid(-1))
validator = NumericRangeValidator(minvalue=5)
self.assertFalse(validator.is_valid(2))
def test_numeric_range_invalidates_with_max_bound(self):
validator = NumericRangeValidator(maxvalue=0)
self.assertFalse(validator.is_valid(1))
validator = NumericRangeValidator(maxvalue=5)
self.assertFalse(validator.is_valid(6))
def test_numeric_range_invalidates_with_min_max_bound(self):
validator = NumericRangeValidator(maxvalue=10, minvalue=0)
self.assertFalse(validator.is_valid(-1))
def test_numeric_range_validates_with_min_max_bound_float(self):
validator = NumericRangeValidator(maxvalue=10.0, minvalue=0.0)
self.assertTrue(validator.is_valid(1.5))
def test_numeric_range_validates_with_stepsize_float(self):
validator = NumericRangeValidator(stepsize=0.2, enforce_stepsize=True)
self.assertTrue(validator.is_valid(1.2))
self.assertTrue(validator.is_invalid(1.3))
def test_numeric_range_validates_with_stepsize_int_with_minvalue(self):
validator = NumericRangeValidator(
minvalue=11, stepsize=2, enforce_stepsize=True
)
self.assertTrue(validator.is_valid(13))
self.assertTrue(validator.is_invalid(16))
def test_numeric_range_raises_exception_when_min_is_greater_than_max(self):
with self.assertRaisesRegex(Exception, "should be smaller than the maxvalue"):
NumericRangeValidator(minvalue=11, maxvalue=-11)
def test_numeric_range_raises_exception_when_enforce_stepsize_without_stepsize(
self,
):
with self.assertRaisesRegex(
Exception, "The stepsize should be provided when enforcing stepsize"
):
NumericRangeValidator(stepsize=None, enforce_stepsize=True)
def test_numeric_range_does_not_respect_max_issue_435(self):
"""With reference to issue #435
In KE-chain I've added a property with numeric range validators min = unbound and max = 1000.
A value of 3333 simply returns as valid in pykechain:
_validation_reasons =>'Value \'3333\' is between -inf and inf'
"""
validator = NumericRangeValidator(maxvalue=1000)
self.assertFalse(validator.is_valid(3333))
self.assertRegex(
validator.get_reason(), "Value '3333' should be between -inf and 1000"
)
|
class TestNumericRangeValidator(TestCase):
def test_numeric_range_without_settings_validated_json(self):
pass
def test_numeric_range_validates_with_lower_bound(self):
pass
def test_numeric_range_validates_with_max_bound(self):
pass
def test_numeric_range_validates_with_min_max_bound(self):
pass
def test_numeric_range_invalidates_with_lower_bound(self):
pass
def test_numeric_range_invalidates_with_max_bound(self):
pass
def test_numeric_range_invalidates_with_min_max_bound(self):
pass
def test_numeric_range_validates_with_min_max_bound_float(self):
pass
def test_numeric_range_validates_with_stepsize_float(self):
pass
def test_numeric_range_validates_with_stepsize_int_with_minvalue(self):
pass
def test_numeric_range_raises_exception_when_min_is_greater_than_max(self):
pass
def test_numeric_range_raises_exception_when_enforce_stepsize_without_stepsize(
self,
):
pass
def test_numeric_range_does_not_respect_max_issue_435(self):
'''With reference to issue #435
In KE-chain I've added a property with numeric range validators min = unbound and max = 1000.
A value of 3333 simply returns as valid in pykechain:
_validation_reasons =>'Value '3333' is between -inf and inf'
'''
pass
| 14 | 1 | 5 | 0 | 5 | 0 | 1 | 0.08 | 1 | 3 | 1 | 0 | 13 | 0 | 13 | 85 | 81 | 14 | 62 | 28 | 46 | 5 | 54 | 26 | 40 | 1 | 2 | 1 | 13 |
140,566 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_validators.py
|
tests.models.test_validators.TestOddEvenNumberValidator
|
class TestOddEvenNumberValidator(TestCase):
def test_even_number_validator_without_settings(self):
validator = EvenNumberValidator()
self.assertIsNone(validator.validate_json())
self.assertIsInstance(validator.as_json(), dict)
self.assertDictEqual(
validator.as_json(), {"config": {}, "vtype": "evenNumberValidator"}
)
def test_odd_number_validator_without_settings(self):
validator = OddNumberValidator()
self.assertIsNone(validator.validate_json())
self.assertIsInstance(validator.as_json(), dict)
self.assertDictEqual(
validator.as_json(), {"config": {}, "vtype": "oddNumberValidator"}
)
def test_even_number_validator_is_valid(self):
validator = EvenNumberValidator()
self.assertTrue(validator.is_valid(2))
def test_odd_number_validator_is_valid(self):
validator = OddNumberValidator()
self.assertTrue(validator.is_valid(3))
def test_even_number_validator_is_invalid(self):
validator = EvenNumberValidator()
self.assertFalse(validator.is_valid(3))
def test_odd_number_validator_is_invalid(self):
validator = OddNumberValidator()
self.assertFalse(validator.is_valid(4))
def test_even_number_validator_is_none(self):
validator = EvenNumberValidator()
self.assertIsNone(validator.is_valid(None))
def test_odd_number_validator_is_none(self):
validator = OddNumberValidator()
self.assertIsNone(validator.is_valid(None))
def test_even_number_validator_float_valid(self):
validator = EvenNumberValidator()
self.assertTrue(validator.is_valid(4.5))
self.assertTrue(validator.is_valid(4.0))
self.assertTrue(validator.is_valid(3.9999999999999999)) # rounding accuracy
def test_odd_number_validator_float_valid(self):
validator = OddNumberValidator()
self.assertTrue(validator.is_valid(3.0))
self.assertTrue(validator.is_valid(4.9999999999999999)) # rounding accuracy
def test_even_number_validator_float_invalid(self):
validator = EvenNumberValidator()
self.assertFalse(validator.is_valid(3.99))
self.assertFalse(validator.is_valid(5.5))
def test_odd_number_validator_float_invalid(self):
validator = OddNumberValidator()
self.assertFalse(validator.is_valid(4.99))
self.assertFalse(validator.is_valid(6.0))
def test_even_number_validator_invalid_input(self):
validator = EvenNumberValidator()
self.assertFalse(validator.is_valid(dict()))
self.assertFalse(validator.is_valid(list))
self.assertFalse(validator.is_valid(set()))
self.assertFalse(validator.is_valid(tuple()))
self.assertFalse(validator.is_valid("3"))
def test_odd_number_validator_invalid_input(self):
validator = OddNumberValidator()
self.assertFalse(validator.is_valid(dict()))
self.assertFalse(validator.is_valid(list))
self.assertFalse(validator.is_valid(set()))
self.assertFalse(validator.is_valid(tuple()))
self.assertFalse(validator.is_valid("3"))
|
class TestOddEvenNumberValidator(TestCase):
def test_even_number_validator_without_settings(self):
pass
def test_odd_number_validator_without_settings(self):
pass
def test_even_number_validator_is_valid(self):
pass
def test_odd_number_validator_is_valid(self):
pass
def test_even_number_validator_is_invalid(self):
pass
def test_odd_number_validator_is_invalid(self):
pass
def test_even_number_validator_is_none(self):
pass
def test_odd_number_validator_is_none(self):
pass
def test_even_number_validator_float_valid(self):
pass
def test_odd_number_validator_float_valid(self):
pass
def test_even_number_validator_float_invalid(self):
pass
def test_odd_number_validator_float_invalid(self):
pass
def test_even_number_validator_invalid_input(self):
pass
def test_odd_number_validator_invalid_input(self):
pass
| 15 | 0 | 5 | 0 | 5 | 0 | 1 | 0.03 | 1 | 6 | 2 | 0 | 14 | 0 | 14 | 86 | 77 | 13 | 64 | 29 | 49 | 2 | 60 | 29 | 45 | 1 | 2 | 0 | 14 |
140,567 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_validators.py
|
tests.models.test_validators.TestPropertyValidatorClass
|
class TestPropertyValidatorClass(TestCase):
def test_propertyvalidator_produces_valid_json(self):
pv = PropertyValidator()
pv.validate_json()
|
class TestPropertyValidatorClass(TestCase):
def test_propertyvalidator_produces_valid_json(self):
pass
| 2 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 73 | 4 | 0 | 4 | 3 | 2 | 0 | 4 | 3 | 2 | 1 | 2 | 0 | 1 |
140,568 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyContextReference
|
class TestPropertyContextReference(TestBetamax):
def setUp(self):
super().setUp()
root = self.project.model(name="Product")
self.part = self.project.create_model(
name="TEST_CONTEXT_REFERENCE_PART",
parent=root,
multiplicity=Multiplicity.ONE,
)
self.context_ref_prop_model = self.part.add_property(
name="context ref", property_type=PropertyType.CONTEXT_REFERENCES_VALUE
)
self.context_ref_prop_instance = self.part.instance().property(
name=self.context_ref_prop_model.name
)
self.context_1 = self.client.create_context(
name="__testing_context_1",
context_type=ContextType.TIME_PERIOD,
context_group=ContextGroup.DISCIPLINE,
scope=self.project.id,
tags=["testing"],
) # type: Context
self.context_2 = self.client.create_context(
name="__testing_context_2",
context_type=ContextType.STATIC_LOCATION,
context_group=ContextGroup.LOCATION,
scope=self.project.id,
tags=["testing"],
) # type: Context
def tearDown(self):
if self.part:
self.part.delete()
if self.context_1:
self.context_1.delete()
if self.context_2:
self.context_2.delete()
super().tearDown()
def test_create(self):
self.assertIsInstance(self.context_ref_prop_model, ContextReferencesProperty)
def test_value_model(self):
self.context_ref_prop_model.value = [self.context_1]
self.assertIsNotNone(self.context_ref_prop_model.value)
self.assertEqual(self.context_ref_prop_model.value[0].id, self.context_1.id)
self.assertEqual(len(self.context_ref_prop_model.value), 1)
def test_no_value_model(self):
self.assertIsNone(self.context_ref_prop_model.value)
def test_value_instance(self):
self.context_ref_prop_instance.value = [self.context_1]
self.assertIsNotNone(self.context_ref_prop_instance.value)
self.assertEqual(self.context_ref_prop_instance.value[0].id, self.context_1.id)
self.assertEqual(len(self.context_ref_prop_instance.value), 1)
def test_no_value_instance(self):
self.assertIsNone(self.context_ref_prop_instance.value)
def test_multiple_values(self):
self.context_ref_prop_instance.value = [self.context_1, self.context_2]
self.assertEqual(len(self.context_ref_prop_instance.value), 2)
self.assertIn(
self.context_1.id,
[value.id for value in self.context_ref_prop_instance.value],
)
self.assertIn(
self.context_2.id,
[value.id for value in self.context_ref_prop_instance.value],
)
|
class TestPropertyContextReference(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create(self):
pass
def test_value_model(self):
pass
def test_no_value_model(self):
pass
def test_value_instance(self):
pass
def test_no_value_instance(self):
pass
def test_multiple_values(self):
pass
| 9 | 0 | 8 | 1 | 8 | 0 | 1 | 0.03 | 1 | 6 | 5 | 0 | 8 | 5 | 8 | 83 | 75 | 11 | 64 | 15 | 55 | 2 | 38 | 15 | 29 | 4 | 3 | 1 | 11 |
140,569 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_create_with_properties.py
|
tests.test_parts_create_with_properties.TestPartCreateWithProperties
|
class TestPartCreateWithProperties(TestBetamax):
def setUp(self):
super().setUp()
self.parent = self.project.part("Bike") # type: Part
self.wheel_model = self.project.model("Wheel") # type: Part
self.new_wheel = None
def tearDown(self):
if self.new_wheel:
self.new_wheel.delete()
super().tearDown()
def test_create_part_with_properties_no_bulk(self):
"""Test create a part with the properties when bulk = False for old API compatibility"""
update_dict = {"Diameter": 42.42, "Spokes": 42, "Rim Material": "Unobtanium"}
self.new_wheel = self.parent.add_with_properties(
self.wheel_model,
"Fresh Wheel",
update_dict=update_dict,
bulk=False,
)
self.assertIsInstance(self.new_wheel, Part)
self.assertTrue(self.new_wheel.property("Diameter"), 42.42)
def test_create_part_with_properties_names_with_bulk(self):
"""Test create a part with the properties when bulk = False for old API compatibility"""
update_dict = {"Diameter": 42.43, "Spokes": 42, "Rim Material": "Unobtanium"}
self.new_wheel = self.parent.add_with_properties(
self.wheel_model,
"Fresh Wheel",
update_dict=update_dict,
bulk=True,
)
self.assertIsInstance(self.new_wheel, Part)
self.assertTrue(self.new_wheel.property("Diameter"), 42.43)
def test_create_part_with_properties_ids_with_bulk(self):
"""Test create a part with the properties when bulk = False for old API compatibility"""
update_dict = {
self.wheel_model.property("Diameter").id: 42.43,
self.wheel_model.property("Spokes").id: 42,
self.wheel_model.property("Rim Material").id: "Unobtanium",
}
# check if the keys are really a UUID
self.assertTrue(any([is_uuid(key) for key in update_dict.keys()]))
self.new_wheel = self.parent.add_with_properties(
self.wheel_model,
"Fresh Wheel",
update_dict=update_dict,
bulk=True,
)
self.assertIsInstance(self.new_wheel, Part)
self.assertTrue(self.new_wheel.property("Diameter"), 42.43)
|
class TestPartCreateWithProperties(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create_part_with_properties_no_bulk(self):
'''Test create a part with the properties when bulk = False for old API compatibility'''
pass
def test_create_part_with_properties_names_with_bulk(self):
'''Test create a part with the properties when bulk = False for old API compatibility'''
pass
def test_create_part_with_properties_ids_with_bulk(self):
'''Test create a part with the properties when bulk = False for old API compatibility'''
pass
| 6 | 3 | 11 | 1 | 9 | 1 | 1 | 0.13 | 1 | 1 | 0 | 0 | 5 | 3 | 5 | 80 | 60 | 11 | 45 | 12 | 39 | 6 | 26 | 12 | 20 | 2 | 3 | 1 | 6 |
140,570 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.ImageFitValue
|
class ImageFitValue(Enum):
"""
Options to fit an image on a CardWidget or AttachmentViewerWidget.
This is a subset from the `object-fit property`_ in HTML.
:cvar CONTAIN: scale the image to fit within the widget
:cvar COVER: scale the image to cover the entire widget
.. _object-fit property: https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit
"""
CONTAIN = "contain"
COVER = "cover"
|
class ImageFitValue(Enum):
'''
Options to fit an image on a CardWidget or AttachmentViewerWidget.
This is a subset from the `object-fit property`_ in HTML.
:cvar CONTAIN: scale the image to fit within the widget
:cvar COVER: scale the image to cover the entire widget
.. _object-fit property: https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 2.33 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 14 | 4 | 3 | 3 | 2 | 7 | 3 | 3 | 2 | 0 | 1 | 0 | 0 |
140,571 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_import.py
|
tests.test_parts_import.TestPartsImport
|
class TestPartsImport(TestBetamax):
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)).replace('\\', '/'))
def setUp(self):
super(TestPartsImport, self).setUp()
self.task = self.project.create_activity(name="widget_test_task") # type: Activity
self.wm = self.task.widgets() # type: WidgetsManager
self.imported_parts = list()
self.file = self.project_root + '/tests/files/test_import_parts/Wheel.xlsx'
def tearDown(self):
for part in self.imported_parts:
part.delete()
self.task.delete()
super(TestPartsImport, self).tearDown()
def test_import_parts_from_client(self):
part_model = self.project.model(name='Wheel')
parent_instance = self.project.part(name='Bike')
self.wm.add_filteredgrid_widget(
part_model=part_model,
parent_instance=parent_instance,
edit=True,
delete=True,
all_writable=True,
collapse_filters=False,
)
self.client.import_parts(
model=part_model,
parent=parent_instance,
activity=self.task,
file=self.file,
async_mode=False
)
self.imported_parts = list(self.client.parts(name="Mid Wheel"))
self.assertEqual(len(self.imported_parts), 1)
mid_wheel = self.imported_parts[0]
self.assertEqual(mid_wheel.property(name="Diameter").value, 65.4)
self.assertEqual(mid_wheel.property(name="Spokes").value, 22)
self.assertEqual(mid_wheel.property(name="Rim Material").value, "Titanium")
self.assertEqual(mid_wheel.property(name="Tire Thickness").value, 2.3)
|
class TestPartsImport(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_import_parts_from_client(self):
pass
| 4 | 0 | 12 | 0 | 12 | 1 | 1 | 0.05 | 1 | 2 | 0 | 0 | 3 | 4 | 3 | 78 | 42 | 4 | 38 | 13 | 34 | 2 | 25 | 13 | 21 | 2 | 3 | 1 | 4 |
140,572 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_retrieve.py
|
tests.test_parts_retrieve.TestPartRetrieve
|
class TestPartRetrieve(TestBetamax):
# 1.8
def test_get_instances_of_a_model(self):
wheel_model = self.project.model("Wheel")
wheel_instances = wheel_model.instances()
self.assertIsInstance(wheel_instances, PartSet)
for wheel_instance in wheel_instances:
self.assertEqual(wheel_instance.category, Category.INSTANCE)
self.assertEqual(wheel_instance.model().id, wheel_model.id)
def test_get_instances_of_an_instances_raises_notfound(self):
wheel_instance = self.project.part("Rear Wheel", category=Category.INSTANCE)
with self.assertRaises(NotFoundError):
wheel_instance.instances()
def test_get_single_instance_of_a_model(self):
bike_model = self.project.model("Bike")
bike_instance = bike_model.instance()
self.assertEqual(bike_instance.category, Category.INSTANCE)
def test_get_single_instance_of_a_multiplicity_model_raises_multiplefounderror(
self,
):
wheel_model = self.project.model("Wheel")
with self.assertRaises(MultipleFoundError):
wheel_model.instance()
# test added in 1.12.7
def test_get_single_instance_of_a_model_without_instances_raises_notfounderror(
self,
):
catalog = self.project.model(name__startswith="Catalog")
model_without_instances = self.project.create_model(
parent=catalog,
name="model_without_instances",
multiplicity=Multiplicity.ZERO_ONE,
)
with self.assertRaises(NotFoundError):
model_without_instances.instance()
# tearDown
model_without_instances.delete()
# test added in 2.1, changed in 3.2
def test_get_parts_with_descendants_tree(self):
# setUp
root = self.project.part(name="Product")
root.populate_descendants()
# testing
self.assertIsInstance(root._cached_children, list)
self.assertEqual(
1,
len(root._cached_children),
msg="Number of instances has changed, expected 1",
)
# follow-up
bike_part = find(root._cached_children, lambda d: d.name == "Bike")
self.assertIsNotNone(bike_part._cached_children)
self.assertEqual(
8,
len(bike_part._cached_children),
msg="Number of child instances has changed, expected 7",
)
# test added in 2.1, changed in 3.2
def test_get_models_with_descendants_tree(self):
# setUp
root = self.project.model(name="Product")
root.populate_descendants()
# testing
self.assertIsInstance(root._cached_children, list)
self.assertEqual(
1,
len(root._cached_children),
msg="Number of models has changed, expected 1",
)
# follow-up
bike_model = find(root._cached_children, lambda d: d.name == "Bike")
self.assertIsNotNone(bike_model._cached_children)
self.assertEqual(
5,
len(bike_model._cached_children),
msg="Number of child models has changed, expected 5",
)
# test added in 3.0
def test_retrieve_parts_with_refs(self):
# setup
front_fork_ref = "front-fork"
front_fork_name = "Front Fork"
front_fork_part = self.project.part(ref=front_fork_ref)
front_fork_model = self.project.model(ref=front_fork_ref)
# testing
self.assertIsInstance(front_fork_part, Part)
self.assertEqual(front_fork_name, front_fork_part.name)
self.assertEqual(Category.INSTANCE, front_fork_part.category)
self.assertIsInstance(front_fork_model, Part)
self.assertEqual(front_fork_name, front_fork_model.name)
self.assertEqual(Category.MODEL, front_fork_model.category)
def test_child(self):
root = self.project.model(name="Product")
bike = root.child(name="Bike")
self.assertIsInstance(bike, Part)
self.assertEqual(bike.parent_id, root.id)
bike_via__call__ = root("Bike")
self.assertEqual(bike, bike_via__call__)
def test_child_caching(self):
root = self.project.model(name="Product")
self.assertIsNone(root._cached_children, msg="No cached children yet")
root.children()
self.assertTrue(root._cached_children, msg="Children should be cached")
bike = root.child(name="Bike")
self.assertTrue(
root._cached_children, msg="Cache was used and should still be intact"
)
bike_again = root.child(pk=bike.id)
self.assertEqual(
bike, bike_again, msg="Bike should be retrieved from cache, based on ID"
)
still_the_bike = root.child(name=bike.name)
self.assertEqual(
bike,
still_the_bike,
msg="Bike should be retrieved from cache, based on name",
)
root._cached_children = None
more_bike = root.child(pk=bike.id)
self.assertEqual(
bike,
more_bike,
msg="Cache should be cleared, bike has to be retrieved anew.",
)
def test_child_invalid(self):
root = self.project.model(name="Product")
with self.assertRaises(IllegalArgumentError):
root.child()
second_bike_model = root.add_model(name="Bike")
with self.assertRaises(MultipleFoundError):
root.child(name="Bike")
second_bike_model.delete()
with self.assertRaises(NotFoundError):
root.child(name="It's only a model")
def test_all_children(self):
root = self.project.model(name="Product")
all_children = root.all_children()
self.assertIsInstance(all_children, list)
self.assertEqual(
6, len(all_children), msg="Number of models has changed, expected 6"
)
def test_child_after_construction(self):
"""Test retrieval of child after creating the model via another Part object of the same KE-chain Part."""
bike_for_adding = self.project.model(name="Bike")
bike_for_getting = self.project.model(name="Bike")
current_children = bike_for_getting.children()
self.assertEqual(5, len(current_children))
child = bike_for_adding.add_model(name="__Temp child")
try:
retrieved_child = bike_for_getting.child("__Temp child")
self.assertEqual(child, retrieved_child)
except NotFoundError as e:
raise e
finally:
# tearDown
child.delete()
|
class TestPartRetrieve(TestBetamax):
def test_get_instances_of_a_model(self):
pass
def test_get_instances_of_an_instances_raises_notfound(self):
pass
def test_get_single_instance_of_a_model(self):
pass
def test_get_single_instance_of_a_multiplicity_model_raises_multiplefounderror(
self,
):
pass
def test_get_single_instance_of_a_model_without_instances_raises_notfounderror(
self,
):
pass
def test_get_parts_with_descendants_tree(self):
pass
def test_get_models_with_descendants_tree(self):
pass
def test_retrieve_parts_with_refs(self):
pass
def test_child(self):
pass
def test_child_caching(self):
pass
def test_child_invalid(self):
pass
def test_all_children(self):
pass
def test_child_after_construction(self):
'''Test retrieval of child after creating the model via another Part object of the same KE-chain Part.'''
pass
| 14 | 1 | 14 | 2 | 11 | 1 | 1 | 0.11 | 1 | 6 | 5 | 0 | 13 | 0 | 13 | 88 | 197 | 41 | 140 | 53 | 122 | 16 | 101 | 48 | 87 | 2 | 3 | 1 | 15 |
140,573 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterTag
|
class TestScopeFilterTag(BaseTest._TestScopeFilter):
VALUE = "Calculation"
VALUE_2 = "Not a calculation"
INVALID_VALUE = 3
FIELD = "tags__contains"
ATTR = "tag"
|
class TestScopeFilterTag(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,574 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterStatus
|
class TestScopeFilterStatus(BaseTest._TestScopeFilter):
VALUE = ScopeStatus.CLOSED
VALUE_2 = ScopeStatus.ACTIVE
INVALID_VALUE = "Just a fleshwound"
FIELD = "status__in"
ATTR = "status"
|
class TestScopeFilterStatus(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,575 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterStartDateLTE
|
class TestScopeFilterStartDateLTE(BaseTest._TestScopeFilter):
VALUE = TIMESTAMP
VALUE_2 = TIMESTAMP_2
INVALID_VALUE = 3
FIELD = "start_date__lte"
ATTR = "start_date_lte"
|
class TestScopeFilterStartDateLTE(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,576 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterStartDateGTE
|
class TestScopeFilterStartDateGTE(BaseTest._TestScopeFilter):
VALUE = TIMESTAMP
VALUE_2 = TIMESTAMP_2
INVALID_VALUE = 3
FIELD = "start_date__gte"
ATTR = "start_date_gte"
|
class TestScopeFilterStartDateGTE(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,577 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterProgressLTE
|
class TestScopeFilterProgressLTE(BaseTest._TestScopeFilter):
VALUE = 0.2
VALUE_2 = 0.3
INVALID_VALUE = "completed"
FIELD = "progress__lte"
ATTR = "progress_lte"
|
class TestScopeFilterProgressLTE(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,578 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterProgressGTE
|
class TestScopeFilterProgressGTE(BaseTest._TestScopeFilter):
VALUE = 0.2
VALUE_2 = 0.3
INVALID_VALUE = "completed"
FIELD = "progress__gte"
ATTR = "progress_gte"
|
class TestScopeFilterProgressGTE(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,579 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterName
|
class TestScopeFilterName(BaseTest._TestScopeFilter):
VALUE = "My project"
VALUE_2 = "Not my project"
INVALID_VALUE = 3
FIELD = "name__icontains"
ATTR = "name"
|
class TestScopeFilterName(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,580 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterDueDateLTE
|
class TestScopeFilterDueDateLTE(BaseTest._TestScopeFilter):
VALUE = TIMESTAMP
VALUE_2 = TIMESTAMP_2
INVALID_VALUE = 3
FIELD = "due_date__lte"
ATTR = "due_date_lte"
|
class TestScopeFilterDueDateLTE(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,581 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterDueDateGTE
|
class TestScopeFilterDueDateGTE(BaseTest._TestScopeFilter):
VALUE = TIMESTAMP
VALUE_2 = TIMESTAMP_2
INVALID_VALUE = 3
FIELD = "due_date__gte"
ATTR = "due_date_gte"
|
class TestScopeFilterDueDateGTE(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,582 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestPropertyValueFilter
|
class TestPropertyValueFilter(TestBetamax):
def setUp(self):
super().setUp()
self.bike = self.project.product_root_model("Bike")
self.filter = PropertyValueFilter(
property_model=self.bike.property(name="Gears"),
value=15,
filter_type=FilterType.GREATER_THAN_EQUAL,
)
self.new_part = self.bike.add_model(
name="__TEST_PART__", multiplicity=Multiplicity.ZERO_MANY
)
self.new_test_property = self.new_part.add_property(
name="__test_propERTY__", property_type=PropertyType.TEXT_VALUE
)
def tearDown(self):
self.new_part.delete()
super().tearDown()
# noinspection PyTypeChecker
def test_creation(self):
with self.assertRaises(IllegalArgumentError):
PropertyValueFilter(property_model=self.bike, value=15, filter_type=FilterType.EXACT)
with self.assertRaises(IllegalArgumentError):
PropertyValueFilter(
property_model=self.bike.property(name="Gears"),
value=15,
filter_type="this one plz",
)
def test_repr(self):
representation = self.filter.__repr__()
self.assertIsInstance(representation, str)
def test_format(self):
string = self.filter.format()
self.assertIsInstance(string, str)
self.assertIn(":", string)
def test_validate(self):
self.filter.validate(part_model=self.bike)
with self.assertRaises(IllegalArgumentError):
self.filter.validate(part_model="Not a part model")
bike_instance = self.bike.instance()
property_instance = bike_instance.property(name="Gears")
invalid_filter = PropertyValueFilter(
property_model=property_instance,
value=15,
filter_type=FilterType.GREATER_THAN_EQUAL,
)
with self.assertRaises(IllegalArgumentError, msg="Property instance is not allowed"):
invalid_filter.validate(part_model=bike_instance)
with self.assertRaises(
IllegalArgumentError, msg="Property instance should not match the bike model"
):
invalid_filter.validate(part_model=self.bike)
boolean = self.bike.property(name="Sale?")
boolean_filter = PropertyValueFilter(
property_model=boolean,
value=False,
filter_type=FilterType.CONTAINS,
)
with self.assertWarns(Warning, msg="Using any filter but EXACT should be warned against"):
boolean_filter.validate(part_model=self.bike)
self.assertIn(
"false",
boolean_filter.format(),
msg="Boolean value should have been parsed to a string",
)
def test_parse_options(self):
for options in [
dict(),
dict(prefilters=dict()),
dict(prefilters=dict(property_value="")),
]:
with self.subTest():
prefilters = PropertyValueFilter.parse_options(options=options)
self.assertIsInstance(prefilters, list)
self.assertEqual(0, len(prefilters))
prefilters = PropertyValueFilter.parse_options(
dict(prefilters=dict(property_value=self.filter.format()))
)
self.assertIsInstance(prefilters, list)
self.assertEqual(1, len(prefilters))
def test_write_options(self):
options_dict = PropertyValueFilter.write_options(filters=[self.filter])
self.assertIsInstance(options_dict, dict)
with self.assertRaises(IllegalArgumentError):
ScopeFilter.write_options(filters=[self.filter])
def test__eq__(self):
second_filter = PropertyValueFilter(
self.bike.property("Gears"), 15, FilterType.GREATER_THAN_EQUAL
)
third_filter = PropertyValueFilter(
self.bike.property("Gears"), 16, FilterType.GREATER_THAN_EQUAL
)
fourth_filter = PropertyValueFilter(
self.bike.property("Total height"), 15, FilterType.GREATER_THAN_EQUAL
)
fifth_filter = PropertyValueFilter(
self.bike.property("Gears"), 15, FilterType.LOWER_THAN_EQUAL
)
self.assertEqual(self.filter, second_filter)
self.assertNotEqual(self.filter, "Coffee filter")
self.assertNotEqual(self.filter, third_filter)
self.assertNotEqual(self.filter, fourth_filter)
self.assertNotEqual(self.filter, fifth_filter)
|
class TestPropertyValueFilter(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_creation(self):
pass
def test_repr(self):
pass
def test_format(self):
pass
def test_validate(self):
pass
def test_parse_options(self):
pass
def test_write_options(self):
pass
def test__eq__(self):
pass
| 10 | 0 | 13 | 2 | 11 | 0 | 1 | 0.01 | 1 | 11 | 6 | 0 | 9 | 4 | 9 | 84 | 130 | 27 | 102 | 28 | 92 | 1 | 62 | 28 | 52 | 2 | 3 | 2 | 10 |
140,583 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestPropertyFilterAllPropertyTypes
|
class TestPropertyFilterAllPropertyTypes(TestBetamax):
def setUp(self):
super().setUp()
self.bike = self.project.product_root_model("Bike")
self.bike_instance = self.bike.instance()
self.root = self.project.activity(name=ActivityRootNames.WORKFLOW_ROOT)
self.wheel = self.project.model(name="Wheel")
self.test_activity = self.project.create_activity(
name="__TEST__FILTERS__",
activity_type=ActivityType.TASK,
)
self.wm = self.test_activity.widgets()
self.prop_test_name = "__PROP TEST"
self.new_wheel = self.bike_instance.add(model=self.wheel, name="Wheel, Wheel")
self.new_part = self.bike.add_model(
name="__TEST_PART__", multiplicity=Multiplicity.ZERO_MANY
)
self.filter_types = FilterType.values()
def tearDown(self):
if self.test_activity:
self.test_activity.delete()
if self.new_part:
self.new_part.delete()
if self.new_wheel:
self.new_wheel.delete()
super().tearDown()
def test_text_property_filter_in_grid(self):
filter_value = "sample"
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.TEXT_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "sample text"}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "just text"}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
f"{test_prop.id}:{filter_value}:{filter_type}",
)
self.assertEqual(len(w), 4)
def test_multi_test_property_filter_in_grid(self):
filter_value = "sample"
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.CHAR_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "sample text"}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "just text"}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
f"{test_prop.id}:{filter_value}:{filter_type}",
)
self.assertEqual(len(w), 4)
def test_int_property_filter_in_grid(self):
filter_value = 17
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.INT_VALUE
)
self.bike_instance.add_with_properties(model=self.new_part, update_dict={test_prop.id: 15})
self.bike_instance.add_with_properties(model=self.new_part, update_dict={test_prop.id: 24})
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
f"{test_prop.id}:{filter_value}:{filter_type}",
)
self.assertEqual(len(w), 3)
def test_float_property_filter_in_grid(self):
filter_value = 22.55
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.FLOAT_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: 15.5}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: 24.4}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
f"{test_prop.id}:{filter_value}:{filter_type}",
)
self.assertEqual(len(w), 3)
def test_boolean_property_filter_in_grid(self):
filter_value = True
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.BOOLEAN_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: False}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: True}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, str(filter_value).lower(), filter_type),
)
self.assertEqual(len(w), 4)
def test_date_property_filter_in_grid(self):
filter_value = str(datetime.date(2021, 5, 4))
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.DATE_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: str(datetime.date(2021, 5, 2))}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: str(datetime.date(2021, 5, 8))}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, filter_value, filter_type),
)
self.assertEqual(len(w), 3)
def test_link_property_filter_in_grid(self):
filter_value = "nl"
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.LINK_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "https://ke-chain.com"}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "https://ke-chain.nl"}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, filter_value, filter_type),
)
self.assertEqual(len(w), 4)
def test_single_select_property_filter_in_grid(self):
filter_value = "apples"
test_prop = self.new_part.add_property(
name=self.prop_test_name,
options=dict(value_choices=["apples", "oranges", "bananas", "lemons"]),
property_type=PropertyType.SINGLE_SELECT_VALUE,
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "apples"}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: "bananas"}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, filter_value, filter_type),
)
self.assertEqual(len(w), 4)
def test_multi_select_property_filter_in_grid(self):
filter_value = "apples"
test_prop = self.new_part.add_property(
name=self.prop_test_name,
options=dict(value_choices=["apples", "oranges", "bananas", "lemons"]),
property_type=PropertyType.MULTI_SELECT_VALUE,
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: ["apples", "bananas"]}
)
self.bike_instance.add_with_properties(
model=self.new_part, update_dict={test_prop.id: ["bananas", "lemons"]}
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, filter_value, filter_type),
)
self.assertEqual(len(w), 4)
def test_part_reference_property_filter_in_grid(self):
filter_value = "Rear Wheel"
test_prop = self.new_part.add_property(
name=self.prop_test_name,
default_value=self.wheel,
property_type=PropertyType.REFERENCES_VALUE,
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={test_prop.id: [self.project.part(name="Front Wheel")]},
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={
test_prop.id: [
self.project.part(name="Front Wheel"),
self.project.part(name="Rear Wheel"),
]
},
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, urllib.parse.quote(filter_value), filter_type),
)
self.assertEqual(len(w), 4)
def test_part_reference_property_filter_in_grid_with_commas(self):
filter_value = self.new_wheel.name
test_prop = self.new_part.add_property(
name=self.prop_test_name,
default_value=self.wheel,
property_type=PropertyType.REFERENCES_VALUE,
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={test_prop.id: [self.project.part(name="Front Wheel")]},
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={
test_prop.id: [
self.project.part(name="Front Wheel"),
self.project.part(name="Rear Wheel"),
]
},
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, urllib.parse.quote(filter_value), filter_type),
)
self.assertEqual(len(w), 4)
def test_activity_reference_property_filter_in_grid(self):
filter_value = "Specify wheel diameter"
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.ACTIVITY_REFERENCES_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={test_prop.id: [self.project.activity(name="Subprocess")]},
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={
test_prop.id: [
self.project.activity(name="Specify wheel diameter"),
self.project.activity(name="Subprocess"),
]
},
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, urllib.parse.quote(filter_value), filter_type),
)
self.assertEqual(len(w), 4)
def test_user_reference_property_filter_in_grid(self):
filter_value = "Test"
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.USER_REFERENCES_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={test_prop.id: [self.client.user(username="superuser")]},
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={
test_prop.id: [
self.client.user(username="testuser"),
self.client.user(username="superuser"),
]
},
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, filter_value, filter_type),
)
self.assertEqual(len(w), 4)
def test_scope_reference_property_filter_in_grid(self):
filter_value = "Bike"
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.SCOPE_REFERENCES_VALUE
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={test_prop.id: [self.client.scope("Cannondale Project")]},
)
self.bike_instance.add_with_properties(
model=self.new_part,
update_dict={
test_prop.id: [
self.client.scope("Cannondale Project"),
self.client.scope("Bike Project"),
]
},
)
with warnings.catch_warnings(record=True) as w:
for filter_type in self.filter_types:
prefilter = PropertyValueFilter(
property_model=test_prop, value=filter_value, filter_type=filter_type
)
widget = self.wm.add_filteredgrid_widget(
title=filter_type,
part_model=self.new_part,
readable_models=list(),
writable_models=[test_prop],
custom_height=300,
parent_instance=self.bike_instance,
prefilters=[prefilter],
)
self.assertEqual(
widget.meta.get("prefilters").get("property_value"),
"{}:{}:{}".format(test_prop.id, filter_value, filter_type),
)
self.assertEqual(len(w), 4)
def test_part_reference_property_prefilter(self):
filter_type = FilterType.GREATER_THAN_EQUAL
filter_value = 4.2
filter_property_model = self.wheel.property("Tire Thickness")
test_prop = self.new_part.add_property(
name=self.prop_test_name,
default_value=self.wheel,
property_type=PropertyType.REFERENCES_VALUE,
)
prefilter = PropertyValueFilter(
property_model=filter_property_model, value=filter_value, filter_type=filter_type
)
test_prop.set_prefilters(prefilters=[prefilter])
self.assertEqual(
test_prop._options.get("prefilters").get("property_value"),
f"{filter_property_model.id}:{filter_value}:{filter_type}",
)
def test_activity_reference_property_prefilter(self):
test_prop = self.new_part.add_property(
name=self.prop_test_name, property_type=PropertyType.SCOPE_REFERENCES_VALUE
)
prefilters = [
ScopeFilter(tag="bike"),
ScopeFilter(tag="bmx"),
ScopeFilter(progress_gte=1.0),
]
test_prop.set_prefilters(prefilters=prefilters)
self.assertEqual(test_prop._options.get("prefilters").get("tags__contains"), "bike,bmx")
self.assertEqual(test_prop._options.get("prefilters").get("progress__gte"), 1.0)
|
class TestPropertyFilterAllPropertyTypes(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_text_property_filter_in_grid(self):
pass
def test_multi_test_property_filter_in_grid(self):
pass
def test_int_property_filter_in_grid(self):
pass
def test_float_property_filter_in_grid(self):
pass
def test_boolean_property_filter_in_grid(self):
pass
def test_date_property_filter_in_grid(self):
pass
def test_link_property_filter_in_grid(self):
pass
def test_single_select_property_filter_in_grid(self):
pass
def test_multi_select_property_filter_in_grid(self):
pass
def test_part_reference_property_filter_in_grid(self):
pass
def test_part_reference_property_filter_in_grid_with_commas(self):
pass
def test_activity_reference_property_filter_in_grid(self):
pass
def test_user_reference_property_filter_in_grid(self):
pass
def test_scope_reference_property_filter_in_grid(self):
pass
def test_part_reference_property_prefilter(self):
pass
def test_activity_reference_property_prefilter(self):
pass
| 19 | 0 | 29 | 0 | 29 | 0 | 2 | 0 | 1 | 13 | 7 | 0 | 18 | 10 | 18 | 93 | 532 | 18 | 514 | 120 | 495 | 0 | 189 | 106 | 170 | 4 | 3 | 2 | 35 |
140,584 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.BaseTest
|
class BaseTest:
class _TestScopeFilter(TestCase):
VALUE = None
VALUE_2 = None
INVALID_VALUE = None
FIELD = None
ATTR = None
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
if cls.VALUE == cls.VALUE_2: # pragma: no cover
raise ValueError(f"Test needs 2 different values ({cls.VALUE}, {cls.VALUE_2})")
def setUp(self) -> None:
super().setUp()
self.filter = ScopeFilter(**{self.ATTR: self.VALUE})
def test__repr__(self):
representation = self.filter.__repr__()
self.assertIsInstance(representation, str)
def test__eq__(self):
second_filter = ScopeFilter(**{self.ATTR: self.VALUE})
third_filter = ScopeFilter(**{self.ATTR: self.VALUE_2})
self.assertEqual(self.filter, second_filter)
self.assertNotEqual(self.filter, third_filter)
def test_write_options(self):
filter_2 = ScopeFilter(**{self.ATTR: self.VALUE_2})
filters = [self.filter, filter_2]
options_dict = ScopeFilter.write_options(filters=filters)
self.assertIsInstance(options_dict, dict)
with self.assertRaises(IllegalArgumentError):
PropertyValueFilter.write_options(filters=[self.filter])
def test_parse_options(self):
options = ScopeFilter.write_options(filters=[self.filter])
scope_filters = ScopeFilter.parse_options(options=options)
self.assertTrue(scope_filters)
self.assertIsInstance(scope_filters, list)
self.assertTrue(all(isinstance(sf, ScopeFilter) for sf in scope_filters))
def test_creation(self):
if self.INVALID_VALUE is not None:
with self.assertRaises(IllegalArgumentError):
ScopeFilter(**{self.ATTR: self.INVALID_VALUE})
with self.assertRaises(IllegalArgumentError):
ScopeFilter(tag="My scope tag", status=ScopeStatus.ACTIVE)
|
class BaseTest:
class _TestScopeFilter(TestCase):
@classmethod
def setUpClass(cls) -> None:
pass
def setUpClass(cls) -> None:
pass
def test__repr__(self):
pass
def test__eq__(self):
pass
def test_write_options(self):
pass
def test_parse_options(self):
pass
def test_creation(self):
pass
| 10 | 0 | 6 | 1 | 5 | 0 | 1 | 0.02 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 58 | 16 | 42 | 24 | 32 | 1 | 41 | 23 | 32 | 2 | 0 | 2 | 9 |
140,585 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_properties_multi_attachment.py
|
tests.test_properties_multi_attachment.TestMultiAttachmentProperties
|
class TestMultiAttachmentProperties(TestBetamax):
def setUp(self):
super().setUp()
self.test_files_dir = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
)
self.upload_path = os.path.join(
self.test_files_dir,
"tests",
"files",
"test_upload_image_to_attachment_property",
"test_upload_image.png",
)
self.wheel_model = self.project.model("Wheel")
self.bike_model = self.project.model("Bike")
self.prop_name = "__Test MAP property"
self.prop_model = self.bike_model.add_property(
name=self.prop_name,
property_type=PropertyType.STOREDFILE_REFERENCES_VALUE,
description="description of the property",
unit="unit of the property",
validators=[SingleReferenceValidator],
)
self.bike = self.bike_model.instance()
self.prop = self.bike.property(name=self.prop_name)
def tearDown(self):
if self.prop_model:
self.prop_model.delete()
super().tearDown()
def test_get_multi_attachment_property_single_ref_validators(self):
self.prop_model.validators = (SingleReferenceValidator(),)
self.prop.refresh()
self.assertTrue(self.prop.has_validator(SingleReferenceValidator))
def test_single_stored_file_references_property_value_gets_replaces(self):
self.prop_model.validators = (SingleReferenceValidator(),)
self.prop.refresh()
self.prop.upload(self.upload_path)
self.prop.refresh()
self.assertIsInstance(self.prop.value, list)
self.assertEqual(len(self.prop.value), 1)
self.assertIsInstance(self.prop.value[0], StoredFile)
# replace
self.prop.upload(self.upload_path)
self.prop.refresh()
self.assertEqual(len(self.prop.value), 1)
self.assertIsInstance(self.prop.value[0], StoredFile)
|
class TestMultiAttachmentProperties(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_get_multi_attachment_property_single_ref_validators(self):
pass
def test_single_stored_file_references_property_value_gets_replaces(self):
pass
| 5 | 0 | 12 | 1 | 11 | 0 | 1 | 0.02 | 1 | 5 | 3 | 0 | 4 | 8 | 4 | 79 | 51 | 5 | 45 | 13 | 40 | 1 | 31 | 13 | 26 | 2 | 3 | 1 | 5 |
140,586 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_properties.py
|
tests.test_properties.TestPropertyCreation
|
class TestPropertyCreation(TestBetamax):
def setUp(self):
super().setUp()
root = self.project.model(name="Product")
self.part_model = self.project.create_model(
name="__Test model",
parent=root,
multiplicity=Multiplicity.ONE,
)
self.part_instance = self.part_model.instance()
def tearDown(self):
self.part_model.delete()
super().tearDown()
def test_create_and_delete_property_model(self):
new_property = self.client.create_property(
model=self.part_model,
name="New property",
description="Nice prop",
property_type=PropertyType.CHAR_VALUE,
default_value="EUREKA!",
)
# check whether the property has been created and whether it's name and type are correct
self.part_model.refresh()
new_prop = self.part_model.property(name="New property")
self.assertEqual(new_property, new_prop)
self.assertIsInstance(new_prop, Property)
self.assertEqual(new_prop.value, "EUREKA!")
self.assertEqual(new_prop._json_data["property_type"], PropertyType.CHAR_VALUE)
# Now delete the property model
new_property.delete()
# Retrieve the model again
self.part_model.refresh()
# Check whether it still has the property model that has just been deleted
with self.assertRaises(NotFoundError):
self.part_model.property("New property")
def test_create_property_unknown_type(self):
with self.assertRaises(IllegalArgumentError):
self.part_model.add_property(
name="Incorrect property type", property_type="Incorrect property type"
)
def test_create_property_on_instance(self):
with self.assertRaises(IllegalArgumentError):
self.client.create_property(
name="Properties are created on models only", model=self.part_instance
)
def test_create_property_incorrect_value(self):
with self.assertRaises(APIError):
self.part_model.add_property(
name="Boolean",
property_type=PropertyType.BOOLEAN_VALUE,
default_value="Not gonna work",
)
# 1.16
def test_creation_of_all_property_model_types(self):
# set up
types = [
PropertyType.CHAR_VALUE,
PropertyType.TEXT_VALUE,
PropertyType.BOOLEAN_VALUE,
PropertyType.INT_VALUE,
PropertyType.FLOAT_VALUE,
PropertyType.DATETIME_VALUE,
PropertyType.DATE_VALUE,
PropertyType.TIME_VALUE,
PropertyType.ATTACHMENT_VALUE,
PropertyType.LINK_VALUE,
PropertyType.SINGLE_SELECT_VALUE,
PropertyType.MULTI_SELECT_VALUE,
PropertyType.REFERENCES_VALUE,
PropertyType.ACTIVITY_REFERENCES_VALUE,
PropertyType.SCOPE_REFERENCES_VALUE,
PropertyType.FORM_REFERENCES_VALUE,
PropertyType.CONTEXT_REFERENCES_VALUE,
PropertyType.STOREDFILE_REFERENCES_VALUE,
PropertyType.STATUS_REFERENCES_VALUE,
PropertyType.SIGNATURE_VALUE,
PropertyType.USER_REFERENCES_VALUE,
PropertyType.GEOJSON_VALUE,
PropertyType.WEATHER_VALUE,
]
values = [
"string",
"text",
True,
0,
3.1415,
datetime.now(),
date.today(),
time(17, 45, 13),
None,
"https://google.com",
None,
None,
None,
[self.project.activity(name="Specify wheel diameter").id],
[self.project.id],
[self.project.form(name="Test").id],
[c.id for c in self.project.contexts(context_group=ContextGroup.ASSET)],
None,
None,
None,
None,
None,
]
for property_type, value in zip(types, values):
with self.subTest(msg=property_type):
# setUp
prop = self.part_model.add_property(
name=property_type,
property_type=property_type,
default_value=value,
)
# testing
if value is not None:
self.assertTrue(prop.has_value())
else:
self.assertFalse(prop.has_value())
# tearDown
prop.delete()
|
class TestPropertyCreation(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create_and_delete_property_model(self):
pass
def test_create_property_unknown_type(self):
pass
def test_create_property_on_instance(self):
pass
def test_create_property_incorrect_value(self):
pass
def test_creation_of_all_property_model_types(self):
pass
| 8 | 0 | 18 | 1 | 16 | 1 | 1 | 0.08 | 1 | 11 | 6 | 0 | 7 | 2 | 7 | 82 | 134 | 15 | 110 | 17 | 102 | 9 | 40 | 17 | 32 | 3 | 3 | 3 | 9 |
140,587 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_properties.py
|
tests.test_properties.TestPropertiesWithReferenceProperty
|
class TestPropertiesWithReferenceProperty(TestBetamax):
def setUp(self):
super().setUp()
self.wheel_model = self.project.model("Wheel")
self.bike = self.project.model("Bike")
self.test_ref_property_model = self.bike.add_property(
name=f"__Test ref property @ {datetime.now()}",
property_type=PropertyType.REFERENCES_VALUE,
description="Description of test ref property",
unit="no unit",
default_value=[self.wheel_model],
)
self.test_ref_property_model.validators = [SingleReferenceValidator()]
def tearDown(self):
self.test_ref_property_model.delete()
super().tearDown()
def test_copy_reference_property_with_options(self):
# setUp
copied_ref_property = self.test_ref_property_model.copy(
target_part=self.wheel_model, name="__Copied ref property"
)
# testing
self.assertEqual(copied_ref_property.name, "__Copied ref property")
self.assertEqual(
copied_ref_property.description, self.test_ref_property_model.description
)
self.assertEqual(copied_ref_property.unit, self.test_ref_property_model.unit)
self.assertEqual(copied_ref_property.value, self.test_ref_property_model.value)
self.assertEqual(
copied_ref_property._options, self.test_ref_property_model._options
)
# tearDown
copied_ref_property.delete()
|
class TestPropertiesWithReferenceProperty(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_copy_reference_property_with_options(self):
pass
| 4 | 0 | 12 | 1 | 10 | 1 | 1 | 0.1 | 1 | 4 | 2 | 0 | 3 | 3 | 3 | 78 | 39 | 6 | 30 | 8 | 26 | 3 | 18 | 8 | 14 | 1 | 3 | 0 | 3 |
140,588 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_properties.py
|
tests.test_properties.TestPropertiesUpdateProperties
|
class TestPropertiesUpdateProperties(TestBetamax):
def setUp(self):
super().setUp()
self.bike = self.project.model("Bike")
self.submodel = self.project.create_model(
name="_test submodel", parent=self.bike
)
self.prop_1 = self.submodel.add_property(
name=PropertyType.CHAR_VALUE, property_type=PropertyType.CHAR_VALUE
)
self.prop_2 = self.submodel.add_property(
name=PropertyType.TEXT_VALUE, property_type=PropertyType.TEXT_VALUE
)
self.props = [self.prop_1, self.prop_2]
def tearDown(self):
self.submodel.delete()
super().tearDown()
def _refresh_prop(self, p):
return self.client.property(pk=p.id, category=p.category)
def test_bulk_update(self):
"""Test the API using the Client method."""
update = [dict(id=p.id, value="new value") for p in self.props]
updated_properties = self.client.update_properties(properties=update)
# testing
self.assertIsInstance(updated_properties, list)
self.assertTrue(all(p1 == p2 for p1, p2 in zip(self.props, updated_properties)))
self.assertTrue(all(isinstance(p, Property) for p in updated_properties))
self.assertTrue(all(p.value == "new value" for p in updated_properties))
def test_bulk_update_manual(self):
"""Test storing of value updates in the Property class."""
# setUp
Property.set_bulk_update(True)
self.prop_1.value = "new value"
self.prop_2.value = "another value"
# testing
self.assertIsNone(self._refresh_prop(self.prop_1).value)
self.assertIsNone(self._refresh_prop(self.prop_2).value)
Property.update_values(client=self.client)
self.assertEqual(self._refresh_prop(self.prop_1).value, "new value")
self.assertEqual(self._refresh_prop(self.prop_2).value, "another value")
def test_bulk_update_reset(self):
"""Test whether bulk update is reset to `False` after update is performed."""
# setUp
Property.set_bulk_update(True)
self.prop_1.value = "new value"
# testing
self.assertIsNone(self._refresh_prop(self.prop_1).value)
Property.update_values(client=self.client)
self.assertEqual(self._refresh_prop(self.prop_1).value, "new value")
self.assertFalse(Property._USE_BULK_UPDATE)
# setUp 2
Property.set_bulk_update(True)
self.prop_2.value = "another value"
# testing 2
self.assertIsNone(self._refresh_prop(self.prop_2).value)
Property.update_values(client=self.client, use_bulk_update=True)
self.assertEqual(self._refresh_prop(self.prop_2).value, "another value")
self.assertTrue(Property._USE_BULK_UPDATE)
# tearDown
Property.set_bulk_update(False)
|
class TestPropertiesUpdateProperties(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def _refresh_prop(self, p):
pass
def test_bulk_update(self):
'''Test the API using the Client method.'''
pass
def test_bulk_update_manual(self):
'''Test storing of value updates in the Property class.'''
pass
def test_bulk_update_reset(self):
'''Test whether bulk update is reset to `False` after update is performed.'''
pass
| 7 | 3 | 12 | 2 | 8 | 2 | 1 | 0.22 | 1 | 5 | 1 | 0 | 6 | 6 | 6 | 81 | 76 | 16 | 49 | 15 | 42 | 11 | 43 | 14 | 36 | 1 | 3 | 0 | 6 |
140,589 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_properties.py
|
tests.test_properties.TestPropertiesContextReferencesPropertyPrefilters
|
class TestPropertiesContextReferencesPropertyPrefilters(TestBetamax):
def setUp(self):
super().setUp()
self.wheel_model = self.project.model("Wheel")
self.bike = self.project.model("Bike")
self.context_references_property = self.bike.add_property(
name=f"__Test context ref property @ {datetime.now()}",
property_type=PropertyType.CONTEXT_REFERENCES_VALUE,
description="Description of test ref property",
unit="no unit",
)
def tearDown(self):
self.context_references_property.delete()
super().tearDown()
def test_set_prefilters_no_params(self):
self.context_references_property.set_prefilters()
self.assertEqual(
self.context_references_property._options.get("prefilters", {}), {}
)
def test_set_prefilters_with_prefilters(self):
with self.assertRaises(IllegalArgumentError):
self.context_references_property.set_prefilters(
prefilters={"something": "test"}
)
def test_set_prefilters_with_clear(self):
self.context_references_property._options["prefilters"] = {
"context_group": ContextGroup.ASSET
}
self.context_references_property.set_prefilters(clear=True)
self.assertEqual(
self.context_references_property._options.get("prefilters", {}), {}
)
def test_set_prefilters_with_valid_context_group(self):
self.context_references_property.set_prefilters(
context_group=ContextGroup.ASSET
)
filter_option = self.context_references_property._options.get(
"prefilters", {}
).get("context_group")
self.assertEqual(filter_option, ContextGroup.ASSET)
def test_set_prefilters_with_invalid_context_group(self):
with self.assertRaises(IllegalArgumentError):
self.context_references_property.set_prefilters(context_group="invalid")
|
class TestPropertiesContextReferencesPropertyPrefilters(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_set_prefilters_no_params(self):
pass
def test_set_prefilters_with_prefilters(self):
pass
def test_set_prefilters_with_clear(self):
pass
def test_set_prefilters_with_valid_context_group(self):
pass
def test_set_prefilters_with_invalid_context_group(self):
pass
| 8 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 5 | 3 | 0 | 7 | 3 | 7 | 82 | 51 | 8 | 43 | 12 | 35 | 0 | 26 | 12 | 18 | 1 | 3 | 1 | 7 |
140,590 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_properties.py
|
tests.test_properties.TestProperties
|
class TestProperties(TestBetamax):
def setUp(self):
super().setUp()
self.wheel_model = self.project.model("Wheel")
self.bike_model = self.project.model("Bike")
self.prop_name = "__Test property"
self.prop_model = self.bike_model.add_property(
name=self.prop_name,
property_type=PropertyType.INT_VALUE,
description="description of the property",
unit="unit of the property",
default_value=42,
)
self.bike = self.bike_model.instance()
self.prop = self.bike.property(name=self.prop_name)
def tearDown(self):
if self.prop_model:
self.prop_model.delete()
super().tearDown()
def test_retrieve_properties(self):
properties = self.project.properties("Diameter")
self.assertIsInstance(properties, list)
self.assertTrue(len(properties) > 0)
def test_retrieve_property(self):
prop = self.project.property(name="Cheap?", category=Category.MODEL)
self.assertIsInstance(prop, Property)
self.assertTrue(prop)
def test_retrieve_property_model(self):
model = self.prop.model()
self.assertEqual(self.prop_model, model)
models_model = self.prop_model.model()
self.assertEqual(self.prop_model, models_model)
def test_property_attributes(self):
attributes = [
"_client",
"_json_data",
"id",
"name",
"created_at",
"updated_at",
"ref",
"output",
"_value",
"_options",
"type",
"category",
"_validators",
]
obj = self.project.property(name="Cheap?", category=Category.MODEL)
for attribute in attributes:
with self.subTest(msg=attribute):
self.assertTrue(
hasattr(obj, attribute),
f"Could not find '{attribute}' in the object: '{obj.__dict__.keys()}'",
)
def test_retrieve_properties_with_kwargs(self):
# setUp
properties_with_kwargs = self.client.properties(part_id=self.bike.id)
self.assertTrue(properties_with_kwargs)
# testing
for prop in properties_with_kwargs:
with self.subTest(msg=prop.name):
self.assertEqual(prop.part.id, self.bike.id)
def test_get_property_by_name(self):
gears_property = self.project.properties(
name="Gears", category=Category.INSTANCE
)[0]
self.assertEqual(self.bike.property("Gears"), gears_property)
def test_get_property_by_uuid(self):
gears_id = self.bike.property("Gears").id
gears_property = self.project.properties(
pk=gears_id, category=Category.INSTANCE
)[0]
self.assertEqual(self.bike.property(gears_id), gears_property)
def test_get_invalid_property(self):
with self.assertRaises(NotFoundError):
self.bike.property("Price")
def test_set_property(self):
new_value = self.prop.value * 2
self.assertNotEqual(new_value, self.prop.value)
self.prop.value = new_value
refreshed_prop = self.bike.property(name=self.prop_name)
self.assertEqual(new_value, self.prop.value)
self.assertEqual(new_value, self.prop._value)
self.assertEqual(new_value, self.prop._json_data.get("value"))
self.assertEqual(self.prop, refreshed_prop)
self.assertEqual(self.prop.value, refreshed_prop.value)
def test_part_of_property(self):
bike2 = self.bike.property("Gears").part
self.assertEqual(self.bike.id, bike2.id)
# 1.11
def test_edit_property_model_name(self):
# setUp
new_name = "Cogs"
self.prop_model.edit(name=new_name)
reloaded_prop = self.bike_model.property(name=new_name)
# testing
self.assertEqual(self.prop_model.id, reloaded_prop.id)
self.assertEqual(new_name, reloaded_prop.name)
self.assertEqual(self.prop_model.name, reloaded_prop.name)
with self.assertRaises(IllegalArgumentError):
self.prop_model.edit(name=True)
def test_edit_property_model_description(self):
# setUp
new_description = "Cogs, definitely cogs."
self.prop_model.edit(description=new_description)
reloaded_prop = self.bike_model.property(name=self.prop_name)
# testing
self.assertEqual(self.prop_model.id, reloaded_prop.id)
self.assertEqual(self.prop_model.description, reloaded_prop.description)
with self.assertRaises(IllegalArgumentError):
self.prop_model.edit(description=True)
def test_edit_property_model_unit(self):
# setUp
new_unit = "Totally new units"
self.prop_model.edit(unit=new_unit)
reloaded_prop = self.bike_model.property(name=self.prop_name)
# testing
self.assertEqual(self.prop_model.id, reloaded_prop.id)
self.assertEqual(self.prop_model.unit, reloaded_prop.unit)
with self.assertRaises(IllegalArgumentError):
self.prop_model.edit(unit=4)
# test added due to #847 - providing no inputs overwrites values
def test_edit_property_clear_values(self):
# setup
initial_name = "Property first name"
initial_description = "Property created to test clearing values."
initial_unit = "mm"
self.prop_model.edit(
name=initial_name, description=initial_description, unit=initial_unit
)
# Edit without mentioning values, everything should stay the same
new_name = "Property second name"
self.prop_model.edit(name=new_name)
# testing
self.assertEqual(self.prop_model.name, new_name)
self.assertEqual(self.prop_model.description, initial_description)
self.assertEqual(self.prop_model.unit, initial_unit)
# Edit with clearing the values, name and status cannot be cleared
self.prop_model.edit(name=None, description=None, unit=None)
self.assertEqual(self.prop_model.name, new_name)
self.assertEqual(self.prop_model.description, "")
self.assertEqual(self.prop_model.unit, "")
# 2.5.4
def test_property_type(self):
self.assertEqual(PropertyType.INT_VALUE, str(self.prop_model.type))
def test_property_unit(self):
self.assertEqual("unit of the property", str(self.prop_model.unit))
def test_property_description(self):
self.assertEqual(
"description of the property", str(self.prop_model.description)
)
# 3.0
def test_copy_property_model(self):
# setUp
copied_property = self.prop_model.copy(
target_part=self.wheel_model, name="Copied property"
)
# testing
self.assertEqual(copied_property.name, "Copied property")
self.assertEqual(copied_property.description, self.prop_model.description)
self.assertEqual(copied_property.unit, self.prop_model.unit)
self.assertEqual(copied_property.value, self.prop_model.value)
# tearDown
copied_property.delete()
def test_copy_property_instance(self):
# setUp
self.prop.value = 200
copied_property = self.prop.copy(
target_part=self.project.part(name="Front Wheel"),
name="Copied property instance",
)
# testing
self.assertEqual(copied_property.name, "Copied property instance")
self.assertEqual(copied_property.description, self.prop.description)
self.assertEqual(copied_property.unit, self.prop.unit)
self.assertEqual(copied_property.value, self.prop.value)
# tearDown
copied_property.model().delete()
def test_copy_property_instance_to_model(self):
with self.assertRaises(IllegalArgumentError):
self.prop.copy(target_part=self.prop_model)
def test_move_property_model(self):
# setUp
moved_property = self.prop_model.move(
target_part=self.wheel_model, name="Moved property"
)
# testing
self.assertEqual(moved_property.name, "Moved property")
self.assertEqual(moved_property.description, self.prop_model.description)
self.assertEqual(moved_property.unit, self.prop_model.unit)
self.assertEqual(moved_property.value, self.prop_model.value)
with self.assertRaises(NotFoundError):
self.project.property(id=self.prop_model.id)
# tearDown
# for a correct teardown in the unittest we need to -reassign- the moved one to the self.test_property_model
self.prop_model = moved_property
def test_move_property_instance(self):
# setUp
moved_property = self.prop.move(
target_part=self.wheel_model.instances()[0], name="moved property"
)
# testing
with self.assertRaises(APIError):
self.project.property(id=self.prop_model.id)
# tearDown
# for a correct teardown in the unittest we need to -reassign- the moved one to the self.test_property_model
self.prop_model = moved_property.model()
def test_retrieve_properties_with_refs(self):
# setup
dual_pad_ref = "dual-pad"
dual_pad_name = "Dual Pad?"
dual_pad_property = self.project.property(ref=dual_pad_ref)
dual_pad_property_model = self.project.property(
ref=dual_pad_ref, category=Category.MODEL
)
seat_part = self.project.part(name="Seat")
dual_pad_prop_retrieved_from_seat = seat_part.property(dual_pad_ref)
# testing
self.assertIsInstance(dual_pad_property, Property)
self.assertEqual(dual_pad_name, dual_pad_property.name)
self.assertEqual(Category.INSTANCE, dual_pad_property.category)
self.assertIsInstance(dual_pad_property_model, Property)
self.assertEqual(dual_pad_name, dual_pad_property_model.name)
self.assertEqual(Category.MODEL, dual_pad_property_model.category)
self.assertIsInstance(dual_pad_prop_retrieved_from_seat, Property)
self.assertEqual(dual_pad_name, dual_pad_prop_retrieved_from_seat.name)
self.assertEqual(Category.INSTANCE, dual_pad_prop_retrieved_from_seat.category)
self.assertEqual(dual_pad_property.id, dual_pad_prop_retrieved_from_seat.id)
|
class TestProperties(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_retrieve_properties(self):
pass
def test_retrieve_property(self):
pass
def test_retrieve_property_model(self):
pass
def test_property_attributes(self):
pass
def test_retrieve_properties_with_kwargs(self):
pass
def test_get_property_by_name(self):
pass
def test_get_property_by_uuid(self):
pass
def test_get_invalid_property(self):
pass
def test_set_property(self):
pass
def test_part_of_property(self):
pass
def test_edit_property_model_name(self):
pass
def test_edit_property_model_description(self):
pass
def test_edit_property_model_unit(self):
pass
def test_edit_property_clear_values(self):
pass
def test_property_type(self):
pass
def test_property_unit(self):
pass
def test_property_description(self):
pass
def test_copy_property_model(self):
pass
def test_copy_property_instance(self):
pass
def test_copy_property_instance_to_model(self):
pass
def test_move_property_model(self):
pass
def test_move_property_instance(self):
pass
def test_retrieve_properties_with_refs(self):
pass
| 26 | 0 | 11 | 2 | 8 | 1 | 1 | 0.16 | 1 | 8 | 5 | 0 | 25 | 6 | 25 | 100 | 292 | 63 | 197 | 67 | 171 | 32 | 155 | 67 | 129 | 2 | 3 | 2 | 28 |
140,591 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_update.py
|
tests.test_parts_update.TestPartUpdate
|
class TestPartUpdate(TestBetamax):
def setUp(self):
super().setUp()
self.model = self.project.model("Wheel")
bike = self.project.part("Bike")
self.wheel = bike.add(model=self.model, name="_WHEEL") # type: Part
def tearDown(self):
self.wheel.delete()
super().tearDown()
def test(self):
update_dict = {"Diameter": 432.1, "Spokes": 0, "Rim Material": "Adamantium"}
self.wheel.update(
name="Better wheel",
update_dict=update_dict,
)
live_wheel = self.project.part(pk=self.wheel.id)
self.assertEqual(live_wheel.name, "Better wheel")
for name, value in update_dict.items():
self.assertEqual(
value,
live_wheel.property(name=name).value,
f"property {name} with value {value} did not match contents with KEC",
)
def test_model(self):
update_dict = {"Diameter": 432.1, "Spokes": 0, "Rim Material": "Adamantium"}
self.model.update(update_dict=update_dict)
def test_with_missing_property(self):
update_dict = {"Unknown Property": "Woot!"}
with self.assertRaises(NotFoundError):
self.wheel.update(update_dict=update_dict)
# noinspection PyTypeChecker
def test_invalid_inputs(self):
with self.assertRaises(IllegalArgumentError):
self.wheel.update(name=12)
with self.assertRaises(IllegalArgumentError):
self.wheel.update(update_dict=("Diameter", 41.2))
with self.assertRaises(IllegalArgumentError):
self.wheel.update(properties_fvalues=("Diameter", 41.2))
# new in 1.14.1
def test_with_property_ids(self):
update_dict = dict()
for p in self.wheel.properties:
if p.name == "Diameter":
update_dict[p.id] = 1.5
elif p.name == "Spokes":
update_dict[p.id] = 20
elif p.name == "Rim Material":
update_dict[p.id] = "Adamantium"
# do tests
self.wheel.update(update_dict=update_dict)
def test_with_attachment(self):
# setup
bike_part = self.project.part("Bike") # type: Part
bike_part.property(name="Picture").value = None
project_root = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
)
attachment_path = project_root + "/requirements.txt"
update_dict = {
"Picture": attachment_path,
}
# do tests
bike_part.update(update_dict=update_dict)
bike_part.refresh()
attachment_prop = bike_part.property(name="Picture")
self.assertTrue(attachment_prop.has_value(), msg="Attachment was not uploaded.")
self.assertIn("requirements", attachment_prop.filename, msg="filename changed.")
# tearDown
attachment_prop.value = None
def test_bulk_update(self):
from pykechain.models import Property
Property.set_bulk_update(True)
# setUp
frame = self.project.part("Frame")
front_wheel = self.project.part("Front Wheel")
old_data = frame.as_dict()
update_dict = {
"Material": "Kevlar",
"Color": "Black",
"Ref to wheel": self.wheel,
}
# testing
frame.update(update_dict=update_dict)
self.assertEqual("Kevlar", frame.property("Material").value)
self.assertEqual("Black", frame.property("Color").value)
self.assertEqual(self.wheel.id, frame.property("Ref to wheel").value_ids()[0])
self.assertEqual(self.wheel, frame.property("Ref to wheel").value[0])
live_frame = self.project.part("Frame")
self.assertIsNot(
frame,
live_frame,
msg="Frames must be 2 different Python objects, by memory allocation",
)
self.assertEqual(
frame, live_frame, msg="Frames must be identical KE-chain objects, by UUID"
)
self.assertEqual("Aluminum", live_frame.property("Material").value)
self.assertEqual("KE-works orange", live_frame.property("Color").value)
self.assertEqual(front_wheel, live_frame.property("Ref to wheel").value[0])
Property.update_values(client=self.client)
live_frame.refresh()
self.assertEqual("Kevlar", live_frame.property("Material").value)
self.assertEqual("Black", live_frame.property("Color").value)
self.assertEqual(self.wheel, live_frame.property("Ref to wheel").value[0])
# tearDown
frame.update(update_dict=old_data)
|
class TestPartUpdate(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test(self):
pass
def test_model(self):
pass
def test_with_missing_property(self):
pass
def test_invalid_inputs(self):
pass
def test_with_property_ids(self):
pass
def test_with_attachment(self):
pass
def test_bulk_update(self):
pass
| 10 | 0 | 13 | 2 | 11 | 1 | 2 | 0.11 | 1 | 4 | 2 | 0 | 9 | 2 | 9 | 84 | 131 | 25 | 97 | 31 | 86 | 11 | 74 | 31 | 63 | 5 | 3 | 2 | 14 |
140,592 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_parts_reorder_properties.py
|
tests.test_parts_reorder_properties.TestPartsReorderProperties
|
class TestPartsReorderProperties(TestBetamax):
# new in 1.10
def test_reorder_properties_using_names(self):
# Retrieve the front fork model
front_fork_model = self.project.model("Front Fork")
# Sort the properties of the front fork model based on their original order
original_sorted_list_of_props = sorted(
front_fork_model.properties, key=lambda k: k._json_data["order"]
)
# Make a new list with only the names of the properties sorted by order. This will later be used to
# reverse the order to the initial status
original_list_of_prop_names = [prop.name for prop in original_sorted_list_of_props]
# Instantiate the list that will be used to reorder the properties
desired_order_list = ["Material", "Height", "Color"]
# Make the call to re-order the properties according to the above list
front_fork_model.order_properties(property_list=desired_order_list)
# Re-retrieve the front fork model
front_fork_model = self.project.model("Front Fork")
# Do the same steps as above. This will be used to check whether the action performed correctly.
new_sorted_list_of_props = sorted(
front_fork_model.properties, key=lambda k: k._json_data["order"]
)
new_list_of_prop_names = [prop.name for prop in new_sorted_list_of_props]
# Check the new list with the desired one
self.assertEqual(desired_order_list, new_list_of_prop_names)
# Return the front fork model to the initial status
front_fork_model.order_properties(property_list=original_list_of_prop_names)
def test_reorder_properties_using_objects(self):
# Retrieve the front fork model
front_fork_model = self.project.model("Front Fork")
# Sort the properties of the front fork model based on their original order
original_sorted_list_of_props = sorted(
front_fork_model.properties, key=lambda k: k._json_data["order"]
)
# Instantiate the list that will be used to reorder the properties
desired_order_list = [
front_fork_model.property("Material"),
front_fork_model.property("Height"),
front_fork_model.property("Color"),
]
# Make the call to re-order the properties according to the above list
front_fork_model.order_properties(property_list=desired_order_list)
# Re-retrieve the front fork model
front_fork_model = self.project.model("Front Fork")
# Create a list of property id's, after the properties have been sorted.
# This will be used to check whether the action performed correctly.
new_sorted_list_of_props = sorted(
front_fork_model.properties, key=lambda k: k._json_data["order"]
)
new_list_of_prop_ids = [prop.id for prop in new_sorted_list_of_props]
# Create a list of property id's, based on the desired order.
desired_order_list_ids = [prop.id for prop in desired_order_list]
# Check the new list with the desired one
self.assertEqual(desired_order_list_ids, new_list_of_prop_ids)
# Return the front fork model to the initial status
front_fork_model.order_properties(property_list=original_sorted_list_of_props)
def test_reorder_wrong_properties(self):
# Retrieve the front fork model
front_fork_model = self.project.model("Front Fork")
# Instantiate a wrong list that will be used to reorder the properties.
desired_order_list = ["Material", "Height", "Color", "Width (mm)"]
with self.assertRaises(NotFoundError):
front_fork_model.order_properties(property_list=desired_order_list)
def test_reorder_not_list(self):
# Retrieve the front fork model
front_fork_model = self.project.model("Front Fork")
# Instantiate a wrong list that will be used to reorder the properties.
desired_order_list = "Material Height Color"
with self.assertRaises(IllegalArgumentError):
front_fork_model.order_properties(property_list=desired_order_list)
def test_reorder_properties_of_instance(self):
# Retrieve the front fork model
front_fork_instance = self.project.part(name="Front Fork", category="INSTANCE")
# Instantiate a list that will be used to reorder the properties.
desired_order_list = ["Material", "Height", "Color"]
with self.assertRaises(APIError):
front_fork_instance.order_properties(property_list=desired_order_list)
|
class TestPartsReorderProperties(TestBetamax):
def test_reorder_properties_using_names(self):
pass
def test_reorder_properties_using_objects(self):
pass
def test_reorder_wrong_properties(self):
pass
def test_reorder_not_list(self):
pass
def test_reorder_properties_of_instance(self):
pass
| 6 | 0 | 19 | 4 | 10 | 5 | 1 | 0.54 | 1 | 3 | 3 | 0 | 5 | 0 | 5 | 80 | 103 | 26 | 50 | 24 | 44 | 27 | 38 | 24 | 32 | 1 | 3 | 1 | 5 |
140,593 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.GeoCoordinateConfig
|
class GeoCoordinateConfig(Enum):
"""GeoCoordinate Configuration Enumerations.
:cvar APPROX_ADDRESS: represent the coordinate as approximate address (lookup by Google)
:cvar RD_AMERSFOORT: represent the coordinate as Amersfoort / RN New (epsg: 28992)
:cvar DD: represent the coordinate as Decimal Degrees (WGS84, epsg:4326)
:cvar DMS: represent the coordinate as as Degrees Minutes Seconds (WGS84, epsg:4326)
"""
APPROX_ADDRESS = "approx_address" # As approximated address
# Amersfoort/RD (epsg: 28992) https://www.spatialreference.org/ref/epsg/amersfoort-rd-new/
RD_AMERSFOORT = "rd_amersfoort"
DD = (
# As WSG84 (epsg:4326) decimal degrees representation first lat (-90,+90) then lng
# (-180,+180)
"dd"
)
DMS = (
# As WSG84 (epsg:4326) degrees, minutes, seconds representation first lat N/S then lng E/W
"dms"
)
|
class GeoCoordinateConfig(Enum):
'''GeoCoordinate Configuration Enumerations.
:cvar APPROX_ADDRESS: represent the coordinate as approximate address (lookup by Google)
:cvar RD_AMERSFOORT: represent the coordinate as Amersfoort / RN New (epsg: 28992)
:cvar DD: represent the coordinate as Decimal Degrees (WGS84, epsg:4326)
:cvar DMS: represent the coordinate as as Degrees Minutes Seconds (WGS84, epsg:4326)
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1.22 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 22 | 3 | 9 | 5 | 8 | 11 | 5 | 5 | 4 | 0 | 1 | 0 | 0 |
140,594 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.FontAwesomeMode
|
class FontAwesomeMode(Enum):
"""
Options to display the same icon.
Source:
https://fontawesome.com/how-to-use/on-the-web/setup/getting-started
:cvar SOLID: "solid"
:cvar REGULAR: "regular"
:cvar LIGHT: "light"
"""
SOLID = "solid"
REGULAR = "regular"
LIGHT = "light"
|
class FontAwesomeMode(Enum):
'''
Options to display the same icon.
Source:
https://fontawesome.com/how-to-use/on-the-web/setup/getting-started
:cvar SOLID: "solid"
:cvar REGULAR: "regular"
:cvar LIGHT: "light"
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 15 | 3 | 4 | 4 | 3 | 8 | 4 | 4 | 3 | 0 | 1 | 0 | 0 |
140,595 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_forms.py
|
tests.test_forms.TestFormsBulk
|
class TestFormsBulk(TestBetamax):
"""
Test bulk forms attributes and methods.
"""
def setUp(self):
super().setUp()
self.workflow = self.client.workflow(
name="Simple Form Flow", category=WorkflowCategory.CATALOG
)
self.discipline_context = self.project.context(name="Discipline 1")
self.asset_context = self.project.context(name="Object 1")
self.form_model_name = "__TEST__FORM_MODEL"
self.form_model = self.client.create_form_model(
name=self.form_model_name,
scope=self.project,
workflow=self.workflow,
category=FormCategory.MODEL,
contexts=[self.asset_context, self.discipline_context],
)
self.new_forms = list()
for idx in range(1, 5):
form_dict = {
"form": self.form_model,
"values": {
"name": f"Form {idx}",
"contexts": [self.asset_context],
},
}
self.new_forms.append(form_dict)
self.forms_created = None
def tearDown(self):
super().tearDown()
if self.forms_created:
for form in self.forms_created:
try:
form.delete()
except APIError:
pass
if self.form_model:
try:
self.form_model.delete()
except (ForbiddenError, APIError):
pass
def test_bulk_instantiate_forms(self):
self.forms_created = self.client._create_forms_bulk(
forms=self.new_forms, retrieve_instances=True
)
for form in self.forms_created:
self.assertIsInstance(form, Form)
self.assertEqual(form.category, FormCategory.INSTANCE)
self.assertEqual(form.model_id, self.form_model.id)
def test_bulk_delete_forms(self):
self.forms_created = self.client._create_forms_bulk(
forms=self.new_forms, retrieve_instances=True
)
input_forms_and_uuids = [
self.forms_created[0],
self.forms_created[1],
self.forms_created[2].id,
self.forms_created[3].id,
]
self.client._delete_forms_bulk(forms=input_forms_and_uuids)
for idx in range(1, 5):
with self.subTest(idx=idx):
with self.assertRaises(NotFoundError):
self.project.form(name=f"Form {idx}")
def test_bulk_delete_forms_with_wrong_input(self):
wrong_input = [self.project.activity(name="Specify wheel diameter")]
with self.assertRaises(IllegalArgumentError):
self.client._delete_forms_bulk(forms=wrong_input)
|
class TestFormsBulk(TestBetamax):
'''
Test bulk forms attributes and methods.
'''
def setUp(self):
pass
def tearDown(self):
pass
def test_bulk_instantiate_forms(self):
pass
def test_bulk_delete_forms(self):
pass
def test_bulk_delete_forms_with_wrong_input(self):
pass
| 6 | 1 | 13 | 0 | 13 | 0 | 3 | 0.04 | 1 | 10 | 7 | 0 | 5 | 8 | 5 | 80 | 75 | 5 | 67 | 21 | 61 | 3 | 44 | 20 | 38 | 6 | 3 | 3 | 13 |
140,596 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_utils.py
|
tests.test_utils.TestTimezoneHelperFunctions
|
class TestTimezoneHelperFunctions(TestBetamax):
def setUp(self):
super().setUp()
self.user_with_timezone = self.client.user("testlead")
self.user_without_timezone = self.client.user("radu.test")
def test_retrieve_offset_from_user_timezone(self):
offset = get_offset_from_user_timezone(user=self.user_with_timezone)
self.assertEqual(offset, -600)
def test_retrieve_timezone_from_user(self):
timezone = get_timezone_from_user(user=self.user_with_timezone)
self.assertEqual(str(timezone), "Pacific/Guam")
def test_retrieve_timezone_from_user_without_timezone(self):
timezone = get_timezone_from_user(user=self.user_without_timezone)
self.assertEqual(str(timezone), "UTC")
|
class TestTimezoneHelperFunctions(TestBetamax):
def setUp(self):
pass
def test_retrieve_offset_from_user_timezone(self):
pass
def test_retrieve_timezone_from_user(self):
pass
def test_retrieve_timezone_from_user_without_timezone(self):
pass
| 5 | 0 | 4 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 0 | 0 | 4 | 2 | 4 | 79 | 18 | 4 | 14 | 10 | 9 | 0 | 14 | 10 | 9 | 1 | 3 | 0 | 4 |
140,597 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestSetTitle
|
class TestSetTitle(TestCase):
def test_interface(self):
title_in = "title"
meta_in = dict()
output = _set_title(meta_in, title_in)
self.assertIsInstance(output, tuple)
self.assertTrue(len(output) == 2)
meta, title = output
self.assertIsInstance(meta, dict)
self.assertIsInstance(title, str)
self.assertIs(meta_in, meta, msg="Meta must be updated in-place!")
self.assertIn("showTitleValue", meta)
self.assertIn("customTitle", meta)
def test_title(self):
"""Test parser when changing the `title` input."""
title_in = "title"
meta, title = _set_title(dict(), title=title_in)
self.assertEqual(title_in, title)
self.assertEqual(title_in, meta["customTitle"])
self.assertEqual(WidgetTitleValue.CUSTOM_TITLE, meta["showTitleValue"])
title_in = False
meta, title = _set_title(dict(), title=title_in)
self.assertIsNone(title)
self.assertIsNone(meta["customTitle"])
self.assertEqual(WidgetTitleValue.DEFAULT, meta["showTitleValue"])
title_in = None
meta, title = _set_title(dict(), title=title_in)
self.assertIsNone(title)
self.assertIsNone(meta["customTitle"])
self.assertEqual(WidgetTitleValue.NO_TITLE, meta["showTitleValue"])
def test_show_title_value(self):
"""Test parser when changing the `show_title_value` input."""
title_in = "title"
meta, title = _set_title(
dict(), title=title_in, show_title_value=WidgetTitleValue.NO_TITLE
)
self.assertEqual(title_in, title)
self.assertEqual(title_in, meta["customTitle"])
self.assertEqual(WidgetTitleValue.NO_TITLE, meta["showTitleValue"])
meta, title = _set_title(
dict(), title=title_in, show_title_value=WidgetTitleValue.CUSTOM_TITLE
)
self.assertEqual(title_in, title)
self.assertEqual(title_in, meta["customTitle"])
self.assertEqual(WidgetTitleValue.CUSTOM_TITLE, meta["showTitleValue"])
meta, title = _set_title(
dict(), title=title_in, show_title_value=WidgetTitleValue.DEFAULT
)
self.assertIsNone(title)
self.assertIsNone(meta["customTitle"])
self.assertEqual(WidgetTitleValue.DEFAULT, meta["showTitleValue"])
with self.assertRaises(
IllegalArgumentError, msg="Unrecognized show_title_value must be caught!"
):
# noinspection PyTypeChecker
_set_title(dict(), "title", show_title_value="Maybe")
|
class TestSetTitle(TestCase):
def test_interface(self):
pass
def test_title(self):
'''Test parser when changing the `title` input.'''
pass
def test_show_title_value(self):
'''Test parser when changing the `show_title_value` input.'''
pass
| 4 | 2 | 22 | 4 | 17 | 1 | 1 | 0.06 | 1 | 5 | 2 | 0 | 3 | 0 | 3 | 75 | 70 | 14 | 53 | 12 | 49 | 3 | 45 | 12 | 41 | 1 | 2 | 1 | 3 |
140,598 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetDownloadAsExcel
|
class TestWidgetDownloadAsExcel(TestBetamax):
def setUp(self):
super().setUp()
task = self.project.activity(name="Task - Form + Tables + Service")
all_widgets = task.widgets() # type: List[Widget]
self.grid_widget = find(
all_widgets, lambda w: w.widget_type == WidgetTypes.FILTEREDGRID
)
self.form_widget = find(
all_widgets, lambda w: w.widget_type == WidgetTypes.PROPERTYGRID
)
def tearDown(self):
super().tearDown()
def test_download_as_excel(self):
file_name = "My excel file"
with temp_chdir() as target_dir:
path = self.grid_widget.download_as_excel(
target_dir=target_dir,
file_name=file_name,
)
self.assertTrue(os.path.exists(path))
self.assertIn(slugify_ref(file_name), path)
def test_timezone_aware(self):
file_name = "My excel file.xls"
user = self.client.user("testuser")
timezone_definition = user._json_data["timezone"]
self.assertEqual("Europe/Amsterdam", timezone_definition)
with temp_chdir() as target_dir:
path = self.grid_widget.download_as_excel(
target_dir=target_dir,
file_name=file_name,
user=user,
)
self.assertTrue(os.path.exists(path))
# noinspection PyTypeChecker
def test_invalid_inputs(self):
with self.assertRaises(IllegalArgumentError):
self.form_widget.download_as_excel()
with self.assertRaises(IllegalArgumentError):
self.grid_widget.download_as_excel(target_dir=3)
with self.assertRaises(IllegalArgumentError):
self.grid_widget.download_as_excel(file_name=15.3)
with self.assertRaises(IllegalArgumentError):
self.grid_widget.download_as_excel(user="Testuser")
|
class TestWidgetDownloadAsExcel(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_download_as_excel(self):
pass
def test_timezone_aware(self):
pass
def test_invalid_inputs(self):
pass
| 6 | 0 | 10 | 2 | 8 | 0 | 1 | 0.05 | 1 | 3 | 2 | 0 | 5 | 2 | 5 | 80 | 58 | 14 | 43 | 18 | 37 | 2 | 32 | 16 | 26 | 1 | 3 | 1 | 5 |
140,599 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetManager
|
class TestWidgetManager(TestBetamax):
def setUp(self):
super().setUp()
self.wm = self.project.activity(
"Task - Form + Tables + Service"
).widgets() # type: WidgetsManager
def test_widget_manager_creation(self):
with self.assertRaises(IllegalArgumentError):
WidgetsManager(widgets=[], activity="Run away!")
def test_widget_not_found(self):
with self.assertRaises(NotFoundError):
widget = self.wm["unladen swallow"]
def test_activity_has_metapanel_in_widget_manager(self):
self.assertIsInstance(self.wm, WidgetsManager)
self.assertTrue(len(self.wm) >= 5)
self.assertTrue(self.wm[0].widget_type, WidgetTypes.METAPANEL)
def test_widget_can_be_found_with_uuid_in_widget_manager(self):
meta_panel = self.wm[0]
self.assertTrue(meta_panel, WidgetTypes.METAPANEL)
self.assertEqual(self.wm[meta_panel.id], meta_panel)
def test_widget_in_widget_manager(self):
for key in [0, self.wm[0], self.wm[0].id]:
with self.subTest(msg=f"key: {type(key)} {key}"):
widget = self.wm[key]
self.assertIn(widget, self.wm)
def test_widgetmanager_has_activity_and_client(self):
self.assertIsNotNone(self.wm._client)
self.assertIsInstance(self.wm.activity, Activity)
self.assertIsInstance(self.wm._client, self.client.__class__)
|
class TestWidgetManager(TestBetamax):
def setUp(self):
pass
def test_widget_manager_creation(self):
pass
def test_widget_not_found(self):
pass
def test_activity_has_metapanel_in_widget_manager(self):
pass
def test_widget_can_be_found_with_uuid_in_widget_manager(self):
pass
def test_widget_in_widget_manager(self):
pass
def test_widgetmanager_has_activity_and_client(self):
pass
| 8 | 0 | 4 | 0 | 4 | 0 | 1 | 0.03 | 1 | 6 | 4 | 0 | 7 | 1 | 7 | 82 | 37 | 8 | 29 | 13 | 21 | 1 | 27 | 13 | 19 | 2 | 3 | 2 | 8 |
140,600 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetManagerInActivity
|
class TestWidgetManagerInActivity(TestBetamax):
def setUp(self):
super().setUp()
self.task = self.project.create_activity(
name="widget_test_task"
) # type: Activity
self.wm = self.task.widgets() # type: WidgetsManager
def tearDown(self):
if self.task:
self.task.delete()
super().tearDown()
def test_new_widget_using_widget_manager(self):
self.assertEqual(len(self.wm), 1)
metapanel = self.wm[0]
htmlwidget = self.wm.create_widget(
widget_type=WidgetTypes.HTML,
title="Test HTML widget",
meta=dict(htmlContent="Hello"),
)
self.assertIsInstance(metapanel, MetapanelWidget)
self.assertIsInstance(htmlwidget, HtmlWidget)
self.assertEqual(len(self.wm), 1 + 1)
def test_edit_widget_meta(self):
bike_part = self.project.part("Bike")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
)
widget.meta.update(
{"showColumns": [ShowColumnTypes.UNIT, ShowColumnTypes.DESCRIPTION]}
)
widget.edit(meta=widget.meta)
live_widget = self.client.widget(pk=widget.id)
self.assertEqual(widget.meta, live_widget.meta)
def test_edit_widget_title(self):
bike_part = self.project.part("Bike")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
)
new_title = "My customly edited title"
widget.edit(title=new_title)
live_widget = self.client.widget(pk=widget.id)
self.assertEqual(new_title, live_widget.meta.get("customTitle"))
self.assertEqual("Custom title", live_widget.meta.get("showTitleValue"))
self.assertEqual(new_title, live_widget.title_visible)
def test_edit_widget_title_is_none(self):
bike_part = self.project.part("Bike")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
)
widget.edit(title=None)
live_widget = self.client.widget(pk=widget.id)
self.assertFalse(live_widget.title)
self.assertIsNone(live_widget.title_visible)
self.assertEqual(
WidgetTitleValue.NO_TITLE, live_widget.meta.get("showTitleValue")
)
widget.edit(title=False)
live_widget = self.client.widget(pk=widget.id)
self.assertFalse(live_widget.title)
self.assertEqual("Bike", live_widget.title_visible)
self.assertEqual(
WidgetTitleValue.DEFAULT, live_widget.meta.get("showTitleValue")
)
def test_edit_widget_title_and_meta(self):
bike_part = self.project.part("Bike")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
)
new_title = "New title"
new_meta = dict(widget.meta)
new_meta.update(
{"showColumns": [ShowColumnTypes.UNIT, ShowColumnTypes.DESCRIPTION]}
)
widget.edit(
title=new_title,
meta=new_meta,
)
live_widget = self.client.widget(pk=widget.id)
self.assertEqual(new_title, live_widget.title_visible)
self.assertEqual(
[ShowColumnTypes.UNIT, ShowColumnTypes.DESCRIPTION],
live_widget.meta["showColumns"],
)
def test_widget_title(self):
title = "Hidden title"
bike_part = self.project.part("Bike")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
title=title,
show_title_value=WidgetTitleValue.NO_TITLE,
)
self.assertEqual(title, widget.title)
self.assertNotEqual(widget.title_visible, widget.title)
self.assertIsNone(widget.title_visible)
self.assertEqual(slugify_ref(title), widget.ref)
self.assertEqual(WidgetTitleValue.NO_TITLE, widget.meta.get("showTitleValue"))
def test_property_grid_with_associations_using_widget_manager(self):
frame = self.project.part(name="Frame")
frame_model = self.project.model(name="Frame")
widget = self.wm.create_widget(
widget_type=WidgetTypes.PROPERTYGRID,
title="Frame Property Grid",
meta=dict(activityId=str(self.task.id), partInstanceId=str(frame.id)),
writable_models=frame_model.properties,
readable_models=[],
)
self.assertIsInstance(widget, PropertygridWidget)
self.assertEqual(len(self.wm), 1 + 1)
def test_add_attachment_widget(self):
picture_instance = self.project.part("Bike").property("Picture")
widget = self.wm.add_attachmentviewer_widget(
attachment_property=picture_instance,
)
self.assertIsInstance(widget, AttachmentviewerWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual("Picture", widget.title_visible)
def test_add_attachment_widget_with_associations_using_widget_manager(self):
photo_property = self.project.property("Picture")
widget = self.wm.add_attachmentviewer_widget(
title="Attachment Viewer",
attachment_property=photo_property,
)
self.assertEqual("Attachment Viewer", widget.title_visible)
self.assertIsInstance(widget, AttachmentviewerWidget)
self.assertEqual(len(self.wm), 1 + 1)
def test_add_attachment_widget_with_editable_association(self):
photo_property = self.project.property("Picture")
widget = self.wm.add_attachmentviewer_widget(
title="Attachment Viewer",
attachment_property=photo_property,
editable=True,
)
self.assertIsInstance(widget, AttachmentviewerWidget)
self.assertEqual(len(self.wm), 1 + 1)
def test_add_super_grid_widget(self):
part_model = self.project.model(name="Wheel")
parent_instance = self.project.part(name="Bike")
widget = self.wm.add_supergrid_widget(
part_model=part_model,
parent_instance=parent_instance,
edit=False,
emphasize_edit=True,
all_readable=True,
incomplete_rows=True,
)
self.assertIsInstance(widget, SupergridWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(part_model.name, widget.title_visible)
def test_add_filtered_grid_widget(self):
part_model = self.project.model(name="Wheel")
parent_instance = self.project.part(name="Bike")
widget = self.wm.add_filteredgrid_widget(
part_model=part_model,
parent_instance=parent_instance,
edit=True,
# sort_property=part_model.property(name='Diameter'),
emphasize_edit=True,
all_writable=True,
collapse_filters=False,
)
self.assertIsInstance(widget, FilteredgridWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(part_model.name, widget.title_visible)
def test_add_filtered_grid_widget_with_prefilters_and_excluded_propmodels(self):
part_model = self.project.model(name="Wheel")
parent_instance = self.project.part(name="Bike")
excluded_propmodels = [part_model.property(name="Spokes")]
prefilters = dict(
property_models=[part_model.property(name="Diameter")],
values=[66],
filters_type=[FilterType.LOWER_THAN_EQUAL],
)
widget = self.wm.add_filteredgrid_widget(
part_model=part_model,
parent_instance=parent_instance,
custom_height=500,
edit=True,
sort_name=True,
emphasize_edit=True,
all_writable=True,
collapse_filters=False,
prefilters=prefilters,
excluded_propmodels=excluded_propmodels,
)
self.assertIsInstance(widget, FilteredgridWidget)
self.assertEqual(len(self.wm), 1 + 1)
def test_add_propertygrid_widget(self):
bike_part = self.project.part(name="Bike")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
show_headers=False,
show_columns=[ShowColumnTypes.UNIT],
readable_models=bike_part.model().properties[:2],
writable_models=bike_part.model().properties[3:],
)
self.assertIsInstance(widget, PropertygridWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(bike_part.name, widget.title_visible)
def test_add_signature_widget(self):
bike_part = self.project.part(name="Bike")
picture = bike_part.property(name="Picture")
widget1 = self.wm.add_signature_widget(
attachment_property=picture,
title="Yes, my precious",
custom_undo_button_text="Remove za widget",
custom_button_text="Sign za widget, plz",
show_name_and_date=False,
)
widget2 = self.wm.add_signature_widget(
attachment_property=picture,
title=False,
custom_undo_button_text=False,
custom_button_text=False,
)
widget3 = self.wm.add_signature_widget(attachment_property=picture)
self.assertIsInstance(widget1, SignatureWidget)
self.assertIsInstance(widget2, SignatureWidget)
self.assertIsInstance(widget3, SignatureWidget)
self.assertEqual(len(self.wm), 1 + 3)
with self.assertRaises(IllegalArgumentError):
self.wm.add_signature_widget(attachment_property="Failed script")
def test_add_card_widget(self):
# setUp
bike_part = self.project.part(name="Bike")
picture = bike_part.property(name="Picture")
process = self.project.activities(activity_type=ActivityType.PROCESS)[0]
widget1 = self.wm.add_card_widget(description="Some description")
widget2 = self.wm.add_card_widget(
image=picture,
title=False,
image_fit=ImageFitValue.COVER,
link=self.task.id,
link_target=LinkTargets.SAME_TAB,
)
widget3 = self.wm.add_card_widget(
title="Tree view", description="Process opens in tree view", link=process
)
# testing
self.assertEqual(len(self.wm), 1 + 3)
self.assertEqual(self.project.name, widget1.title_visible)
self.assertIsInstance(widget1, CardWidget)
self.assertIsNone(widget1.meta.get("customLink"))
self.assertIsInstance(widget2, CardWidget)
self.assertEqual(ImageFitValue.COVER, widget2.meta.get("imageFit"))
self.assertEqual(CardWidgetLinkTarget.SAME_TAB, widget2.meta.get("linkTarget"))
self.assertIsInstance(widget3, CardWidget)
self.assertEqual(
CardWidgetLinkValue.TREE_VIEW, widget3.meta.get("showLinkValue")
)
with self.assertRaises(IllegalArgumentError):
self.wm.add_card_widget(title=12)
with self.assertRaises(IllegalArgumentError):
self.wm.add_card_widget(description=bike_part)
with self.assertRaises(IllegalArgumentError):
self.wm.add_card_widget(image="this should not work")
with self.assertRaises(IllegalArgumentError):
self.wm.add_card_widget(link=self.task, link_target="_somewhere")
with self.assertRaises(IllegalArgumentError):
# noinspection PyTypeChecker
self.wm.add_card_widget(image_fit=3)
def test_add_card_widget_ke_chain_pages(self):
for native_page_name in KEChainPages.values():
with self.subTest(msg=f"Page {native_page_name}"):
card_widget = self.wm.add_card_widget(
title=native_page_name, link=native_page_name
)
self.assertIsInstance(card_widget, CardWidget)
self.assertEqual(
len(self.wm),
13,
msg=(
"New KE-chain page has been added to the Enum, "
"check if the mapping dicts in enums.py need updating too!"
),
)
def test_add_service_widget(self):
service_gears_successful = self.project.service("Service Gears - Successful")
widget1 = self.wm.add_service_widget(service=service_gears_successful)
widget2 = self.wm.add_service_widget(
service=service_gears_successful,
title=None,
custom_button_text="Run this script (Custom!) and no title",
emphasize_run=True,
download_log=True,
)
widget3 = self.wm.add_service_widget(
service=service_gears_successful,
title="Also a custom title, but no log",
custom_button_text="Run this script (Custom!)",
emphasize_run=False,
show_log=False,
)
self.assertIsInstance(widget1, ServiceWidget)
self.assertIsInstance(widget2, ServiceWidget)
self.assertIsInstance(widget3, ServiceWidget)
self.assertEqual(len(self.wm), 1 + 3)
self.assertEqual(service_gears_successful.name, widget1.title_visible)
def test_add_html_widget(self):
widget_1 = self.wm.add_markdown_widget(markdown="Or is this just fantasy?",
title="Is this the real life?")
self.assertIsInstance(widget_1, HtmlWidget)
self.assertEqual(len(self.wm), 1 + 1)
widget_2 = self.wm.add_markdown_widget(markdown="No escape from reality",
title="Caught in a landslide",
show_title_value=WidgetTitleValue.NO_TITLE)
self.assertEqual(widget_2.ref, slugify_ref("Caught in a landslide"))
def test_add_metapanel_widget(self):
widget = self.wm.add_metapanel_widget(
show_all=True, show_progress=True, show_progressbar=True
)
self.assertEqual(len(self.wm), 1 + 1)
self.assertIsNone(widget.title_visible)
def test_add_metapanel_with_progress_settings(self):
progress_bar = dict(
height=15, showProgressText=False, colorCompleted=ProgressBarColors.RED
)
self.wm.add_metapanel_widget(
show_all=False,
show_progress=False,
show_progressbar=True,
progress_bar=progress_bar,
)
self.assertEqual(len(self.wm), 1 + 1)
def test_add_progress_widget(self):
self.wm.add_progress_widget(custom_height=35, show_progress_text=False)
self.assertEqual(len(self.wm), 1 + 1)
def test_delete_all_widgets(self):
"""Delete all widgets from an activity"""
self.assertEqual(len(self.wm), 1)
self.wm.delete_all_widgets()
self.assertEqual(len(self.wm), 0)
self.assertEqual(len(self.task.widgets()), 0)
def test_delete_widget(self):
"""Delete single widget from an activity"""
self.assertEqual(len(self.wm), 1)
self.wm.delete_widget(0)
self.assertEqual(len(self.wm), 0)
self.assertEqual(len(self.task.widgets()), 0)
def test_delete_widget_stand_alone(self):
"""Delete a widget by itself and check the manager"""
widget_one = self.wm[0]
widget_one.delete()
self.assertNotIn(widget_one, self.wm)
def test_add_notebook_widget(self):
notebook = self.project.service(name="Service Gears - Successful")
widget1 = self.wm.add_notebook_widget(notebook=notebook, title=False)
widget2 = self.wm.add_notebook_widget(
notebook=notebook, title="With custom title"
)
widget3 = self.wm.add_notebook_widget(
notebook=notebook.id,
title="With no padding and custom height",
customHeight=400,
noPadding=True,
)
self.assertIsInstance(widget1, NotebookWidget)
self.assertIsInstance(widget2, NotebookWidget)
self.assertIsInstance(widget3, NotebookWidget)
self.assertEqual(len(self.wm), 1 + 3)
with self.assertRaises(IllegalArgumentError):
self.wm.add_notebook_widget(notebook="This will raise an error")
def test_add_multicolumn_widget(self):
bike_part = self.project.part("Bike")
picture_instance = bike_part.property("Picture")
picture_model = picture_instance.model()
multi_column_widget = self.wm.add_multicolumn_widget(
title="Multi column Grid + Attachment"
)
widget1 = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=[picture_model],
parent_widget=multi_column_widget,
)
widget2 = self.wm.add_attachmentviewer_widget(
attachment_property=picture_instance, parent_widget=multi_column_widget.id
)
self.assertIsInstance(multi_column_widget, MulticolumnWidget)
self.assertIsInstance(widget1, PropertygridWidget)
self.assertIsInstance(widget2, AttachmentviewerWidget)
self.assertEqual(len(self.wm), 1 + 3)
def test_parent(self):
multi_column_widget = self.wm.add_multicolumn_widget(
title="Multi column widget"
)
child_widget = self.wm.add_markdown_widget(markdown="Text", title="Text widget",
parent_widget=multi_column_widget)
parent_widget = child_widget.parent()
self.assertEqual(multi_column_widget, parent_widget)
with self.assertRaises(NotFoundError):
parent_widget.parent()
def test_add_scope_widget(self):
scope_widget = self.wm.add_scope_widget()
self.assertIsInstance(scope_widget, ScopeWidget)
def test_scope_widget_invalid_inputs(self):
for inputs in [
dict(team="5"),
dict(add=1),
dict(edit=0),
dict(emphasize_add="True"),
dict(emphasize_edit=1.0),
dict(show_columns="All", show_all_columns=False),
dict(show_columns=["Any"], show_all_columns=False),
dict(show_all_columns=0),
dict(page_size=0),
dict(tags="one"),
dict(tags=["one", 2, "three"]),
dict(sorted_column="Project name"),
dict(sorted_direction="Alphabetical"),
dict(active_filter="Active"),
dict(search_filter="Project"),
]:
with self.subTest(msg=inputs):
with self.assertRaises(IllegalArgumentError):
self.wm.add_scope_widget(**inputs)
def test_insert_widget(self):
bike_part = self.project.part("Bike")
w0 = self.wm[0] # meta panel
w1, w2, w3 = (
self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
title="Original widget {i} (w{i})".format(i=i + 1),
)
for i in range(3)
)
# if widget order is `[w0,w1,w2]` and inserting `w3` at index 1 (before Widget1);
# index: 0 ^1 2
# the list will be `[w0,w3,w1,w2]`
self.wm.insert(1, w3)
self.assertTrue(w0.widget_type, WidgetTypes.METAPANEL)
self.assertEqual(self.wm[w0.id].order, 0)
self.assertEqual(self.wm[w3.id].order, 1)
self.assertEqual(self.wm[w1.id].order, 2)
self.assertEqual(self.wm[w2.id].order, 3)
added_widget = self.wm.add_propertygrid_widget(
part_instance=bike_part,
writable_models=bike_part.model().properties,
title="Widget Finally Positioned Under Metapanel",
order=1,
)
self.assertEqual(added_widget.order, 1)
self.assertEqual(self.wm[w3.id].order, 2)
self.assertEqual(self.wm[w1.id].order, 3)
self.assertEqual(self.wm[w2.id].order, 4)
def test_create_widgets(self):
# setUp
new_widgets = self.wm.create_widgets(
widgets=[
dict(
widget_type=WidgetTypes.HTML,
title="A new text widget",
meta=dict(htmlContent="This is HTML text."),
),
dict(
widget_type=WidgetTypes.HTML,
title="Another HTML widget",
meta=dict(htmlContent="They keep on multiplying."),
),
]
)
# testing
self.assertIsInstance(new_widgets, list)
self.assertTrue(all(isinstance(w, Widget) for w in new_widgets))
self.assertEqual(len(new_widgets), 2)
self.assertIn(new_widgets[0], self.wm._widgets)
# tearDown
[w.delete() for w in new_widgets]
def test_add_service_card_widget(self):
# setUp
service_gears_successful = self.project.service("Service Gears - Successful")
bike_part = self.project.part(name="Bike")
picture = bike_part.property(name="Picture")
title = "Service card title"
description = "The description"
widget = self.wm.add_service_card_widget(
service=service_gears_successful,
image=picture,
title=title,
description=description,
custom_button_text=False,
link=KEChainPages.EXPLORER,
link_target=LinkTargets.SAME_TAB,
image_fit=ImageFitValue.COVER,
)
self.assertEqual(len(self.wm), 1 + 1)
self.assertIsInstance(widget, ServicecardWidget)
self.assertEqual(widget.title, title)
self.assertEqual(widget.meta.get("customText"), service_gears_successful.name)
self.assertEqual(widget.meta.get("customDescription"), description)
self.assertIn(picture.id, widget.meta.get("customImage"))
self.assertEqual(ImageFitValue.COVER, widget.meta.get("imageFit"))
self.assertEqual(CardWidgetLinkTarget.SAME_TAB, widget.meta.get("linkTarget"))
def test_add_dashboard_widget(self):
# setUp
title_widget_1 = "Dashboard widget"
title_widget_2 = "Tagged projects widget"
title_widget_3 = "Form dashboard widget"
widget_current_project = self.wm.add_dashboard_widget(
title=title_widget_1, show_assignees=True
)
widget_tagged_projects = self.wm.add_dashboard_widget(
title=title_widget_2,
source_scopes_tags=["catalog-scope"],
show_tasks=[
DashboardWidgetShowTasks.UNASSIGNED_TASKS,
DashboardWidgetShowTasks.CLOSED_TASKS,
],
show_scopes=[DashboardWidgetShowScopes.CLOSED_SCOPES],
show_assignees=False,
)
widget_forms = self.wm.add_dashboard_widget(
title=title_widget_3,
show_forms=True,
show_form_status=[
DashboardWidgetShowForms.DONE_FORMS,
DashboardWidgetShowForms.TOTAL_FORMS,
],
show_form_status_per_assignees=True,
show_assignees_for_form_statuses=True,
show_status_category_forms=False,
)
# testing
self.assertIsInstance(widget_current_project, DashboardWidget)
self.assertIsInstance(widget_tagged_projects, DashboardWidget)
self.assertIsInstance(widget_forms, DashboardWidget)
self.assertEqual(widget_current_project.title, title_widget_1)
self.assertEqual(widget_tagged_projects.title, title_widget_2)
self.assertEqual(widget_forms.title, title_widget_3)
self.assertTrue(
all(elem["selected"] for elem in widget_current_project.meta["showNumbers"])
)
self.assertTrue(
all(
elem["selected"]
for elem in widget_current_project.meta["showNumbersProjects"]
)
)
self.assertTrue(
any(
elem["selected"] is False
for elem in widget_tagged_projects.meta["showNumbers"]
)
)
self.assertTrue(
any(
elem["selected"] is False
for elem in widget_tagged_projects.meta["showNumbersProjects"]
)
)
self.assertTrue(widget_current_project.meta["showAssignees"])
self.assertFalse(widget_tagged_projects.meta["showAssignees"])
self.assertTrue(
any(
elem["selected"] is False
for elem in widget_forms.meta["showNumbersForForms"]
)
)
self.assertTrue(widget_forms.meta["showFormStatusPerAssignees"])
self.assertTrue(widget_forms.meta["showAssigneesForFormStatuses"])
self.assertFalse(widget_forms.meta["showStatusCategoryForms"])
def test_add_tasks_widget(self):
tasks_widget = self.wm.add_tasks_widget()
self.assertIsInstance(tasks_widget, TasksWidget)
def test_add_tasks_widget_with_filters(self):
tasks_widget = self.wm.add_tasks_widget(
parent_activity=self.wm.activity.parent(),
status_filter=ActivityStatus.OPEN,
assigned_filter=TasksAssignmentFilterTypes.FILTER_ASSIGNED_TO_USER,
activity_type_filter=ActivityType.TASK,
classification_filter=ActivityClassification.CATALOG,
tags_filter=["One", "Two", "Five"],
)
self.assertIsInstance(tasks_widget, TasksWidget)
def test_add_scopemembers_widget(self):
scope_members_widget = self.wm.add_scopemembers_widget()
self.assertIsInstance(scope_members_widget, ScopemembersWidget)
def test_add_project_info_widget(self):
title = "__TEST_PROJECT_TEAM"
project_info_widget = self.wm.add_project_info_widget(
title=title, collapsible=True, collapsed=True
)
self.assertEqual(project_info_widget.title, title)
|
class TestWidgetManagerInActivity(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_new_widget_using_widget_manager(self):
pass
def test_edit_widget_meta(self):
pass
def test_edit_widget_title(self):
pass
def test_edit_widget_title_is_none(self):
pass
def test_edit_widget_title_and_meta(self):
pass
def test_widget_title(self):
pass
def test_property_grid_with_associations_using_widget_manager(self):
pass
def test_add_attachment_widget(self):
pass
def test_add_attachment_widget_with_associations_using_widget_manager(self):
pass
def test_add_attachment_widget_with_editable_association(self):
pass
def test_add_super_grid_widget(self):
pass
def test_add_filtered_grid_widget(self):
pass
def test_add_filtered_grid_widget_with_prefilters_and_excluded_propmodels(self):
pass
def test_add_propertygrid_widget(self):
pass
def test_add_signature_widget(self):
pass
def test_add_card_widget(self):
pass
def test_add_card_widget_ke_chain_pages(self):
pass
def test_add_service_widget(self):
pass
def test_add_html_widget(self):
pass
def test_add_metapanel_widget(self):
pass
def test_add_metapanel_with_progress_settings(self):
pass
def test_add_progress_widget(self):
pass
def test_delete_all_widgets(self):
'''Delete all widgets from an activity'''
pass
def test_delete_widget(self):
'''Delete single widget from an activity'''
pass
def test_delete_widget_stand_alone(self):
'''Delete a widget by itself and check the manager'''
pass
def test_add_notebook_widget(self):
pass
def test_add_multicolumn_widget(self):
pass
def test_parent(self):
pass
def test_add_scope_widget(self):
pass
def test_scope_widget_invalid_inputs(self):
pass
def test_insert_widget(self):
pass
def test_create_widgets(self):
pass
def test_add_service_card_widget(self):
pass
def test_add_dashboard_widget(self):
pass
def test_add_tasks_widget(self):
pass
def test_add_tasks_widget_with_filters(self):
pass
def test_add_scopemembers_widget(self):
pass
def test_add_project_info_widget(self):
pass
| 41 | 3 | 17 | 2 | 14 | 0 | 1 | 0.03 | 1 | 41 | 36 | 0 | 40 | 2 | 40 | 115 | 714 | 127 | 571 | 144 | 530 | 19 | 310 | 144 | 269 | 2 | 3 | 3 | 43 |
140,601 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyFormReference
|
class TestPropertyFormReference(TestBetamax):
def setUp(self):
super().setUp()
root = self.project.model(name="Product")
self.part = self.project.create_model(
name="TEST_FORM_REFERENCE_PART", parent=root, multiplicity=Multiplicity.ONE
)
self.form_ref_prop_model = self.part.add_property(
name="form ref", property_type=PropertyType.FORM_REFERENCES_VALUE
)
self.workflow = self.client.workflow(
name="Simple Form Flow", category=WorkflowCategory.CATALOG
)
self.approval_workflow = self.client.workflow(
name="Strict Approval Workflow", category=WorkflowCategory.CATALOG
)
self.discipline_context = self.project.context(name="Discipline 1")
self.asset_context = self.project.context(name="Object 1")
self.form_model_name = "__TEST__FORM_MODEL"
self.form_model = self.client.create_form_model(
name=self.form_model_name,
scope=self.project,
workflow=self.workflow,
category=FormCategory.MODEL,
contexts=[self.asset_context, self.discipline_context],
)
self.form_ref_prop_instance = self.part.instance().property(
name=self.form_ref_prop_model.name
)
self.form_instance_1 = self.form_model.instantiate(
name="__FIRST_TEST_FORM_INSTANCE"
)
self.form_instance_2 = self.form_model.instantiate(
name="__SECOND_TEST_FORM_INSTANCE "
)
def tearDown(self):
if self.part:
self.part.delete()
if self.form_instance_1:
self.form_instance_1.delete()
if self.form_instance_2:
self.form_instance_2.delete()
if self.form_model:
self.form_model.delete()
super().tearDown()
def test_create(self):
self.assertIsInstance(self.form_ref_prop_model, FormReferencesProperty)
def test_value_model(self):
self.form_ref_prop_model.value = [self.form_model]
self.assertIsNotNone(self.form_ref_prop_model.value)
self.assertEqual(self.form_ref_prop_model.value[0].id, self.form_model.id)
self.assertEqual(len(self.form_ref_prop_model.value), 1)
def test_no_value_model(self):
self.assertIsInstance(self.form_ref_prop_model, FormReferencesProperty)
self.assertIsNone(self.form_ref_prop_model.value)
def test_value_instance(self):
self.form_ref_prop_model.value = [self.form_model]
self.form_ref_prop_instance.value = [self.form_instance_1]
self.assertEqual(len(self.form_ref_prop_instance.value), 1)
self.assertEqual(
self.form_ref_prop_instance.value[0].id, self.form_instance_1.id
)
self.form_ref_prop_instance.value = [self.form_instance_1, self.form_instance_2]
self.assertEqual(len(self.form_ref_prop_instance.value), 2)
self.assertIn(
self.form_instance_1.id,
[value.id for value in self.form_ref_prop_instance.value],
)
self.assertIn(
self.form_instance_2.id,
[value.id for value in self.form_ref_prop_instance.value],
)
|
class TestPropertyFormReference(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create(self):
pass
def test_value_model(self):
pass
def test_no_value_model(self):
pass
def test_value_instance(self):
pass
| 7 | 0 | 13 | 1 | 12 | 0 | 2 | 0 | 1 | 6 | 5 | 0 | 6 | 12 | 6 | 81 | 82 | 10 | 72 | 20 | 65 | 0 | 44 | 19 | 37 | 5 | 3 | 1 | 10 |
140,602 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyMultiReferenceProperty
|
class TestPropertyMultiReferenceProperty(TestBetamax):
def setUp(self):
super().setUp()
# reference Part target (model and 1 instance)
_wheel_model = self.project.model(ref="wheel")
props = [
PropertyType.DATETIME_VALUE,
PropertyType.SINGLE_SELECT_VALUE,
PropertyType.BOOLEAN_VALUE,
PropertyType.FLOAT_VALUE,
PropertyType.INT_VALUE,
PropertyType.CHAR_VALUE,
]
self.target_model = self.project.create_model_with_properties(
parent=_wheel_model.parent_id,
name="__Wheel",
multiplicity=Multiplicity.ONE_MANY,
properties_fvalues=[dict(name=p, property_type=p) for p in props],
)
# reference property model (with a value pointing to a reference target part model
self.part_model = self.project.model("Bike")
self.datetime_prop = self.target_model.property(PropertyType.DATETIME_VALUE)
self.ssl_prop = self.target_model.property(PropertyType.SINGLE_SELECT_VALUE)
self.bool_prop = self.target_model.property(PropertyType.BOOLEAN_VALUE)
self.float_prop = self.target_model.property(PropertyType.FLOAT_VALUE)
self.integer_prop = self.target_model.property(PropertyType.INT_VALUE)
self.char_prop = self.target_model.property(PropertyType.CHAR_VALUE)
self.ref_prop_name = "__Test reference property"
self.ref_prop_model = self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=self.target_model.id,
) # type: MultiReferenceProperty
# reference property instance holding the value
part_instance = self.part_model.instance()
self.ref = find(
part_instance.properties, lambda p: p.model_id == self.ref_prop_model.id
) # type: MultiReferenceProperty
def tearDown(self):
self.target_model.delete()
self.ref_prop_model.delete()
super().tearDown()
def test_referencing_a_model(self):
# setUp
wheel_model = self.project.model("Wheel")
self.ref_prop_model.value = [wheel_model]
# testing
self.assertEqual(len(list(self.ref_prop_model.value)), 1)
def test_referencing_multiple_instances_using_parts(self):
# setUp
wheel_model = self.project.model("Wheel")
self.ref_prop_model.value = [wheel_model]
wheel_instances = wheel_model.instances()
wheel_instances_list = [instance for instance in wheel_instances]
# set ref value
self.ref.value = wheel_instances_list
# testing
self.assertTrue(len(self.ref.value) >= 2)
def test_referencing_multiple_instances_using_ids(self):
# setUp
wheel_model = self.project.model("Wheel")
self.ref_prop_model.value = [wheel_model]
wheel_instances = wheel_model.instances()
wheel_instances_list = [instance.id for instance in wheel_instances]
# set ref value
self.ref.value = wheel_instances_list
self.ref._cached_values = None
# testing
self.assertTrue(len(self.ref.value) >= 2)
def test_referencing_a_list_with_no_parts(self):
# setUp
fake_part = [15, 21, 26]
# testing
with self.assertRaises(ValueError):
self.ref.value = fake_part
def test_value_if_multi_ref_gives_back_all_parts(self):
"""because of #276 problem"""
# setUp
self.ref_prop_model.value = [self.target_model]
wheel_instances = self.target_model.instances()
wheel_instances_list = [instance.id for instance in wheel_instances]
# set ref value
self.ref.value = wheel_instances_list
self.ref.refresh()
# testing
all_referred_parts = self.ref.value
self.assertEqual(len(all_referred_parts), len(self.ref._value))
def test_value_if_nothing_is_referenced(self):
# setUp
value_of_multi_ref = self.ref.value
# testing
self.assertFalse(self.ref.has_value())
self.assertIsNone(value_of_multi_ref)
def test_value_ids(self):
wheel_instances = self.target_model.instances()
wheel_instances_list = [instance.id for instance in wheel_instances]
self.ref.value = wheel_instances_list
self.ref.refresh()
ids = self.ref.value_ids()
self.assertIsInstance(ids, list)
self.assertTrue(all(isinstance(v, str) for v in ids))
def test_multi_ref_choices(self):
# setUp
self.project.part(ref="bike").add_with_properties(
name="__Wheel 2",
model=self.target_model,
update_dict={
PropertyType.BOOLEAN_VALUE: True,
},
)
self.ref_prop_model.value = [self.target_model]
possible_options = self.ref.choices()
# testing
self.assertEqual(2, len(possible_options))
self.ref_prop_model.set_prefilters(
property_models=[self.target_model.property(PropertyType.BOOLEAN_VALUE)],
values=[True],
filters_type=[FilterType.EXACT],
)
self.ref.refresh()
possible_options = self.ref.choices()
self.assertEqual(1, len(possible_options))
def test_create_ref_property_referencing_part_in_list(self):
# setUp
new_reference_to_wheel = self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=[self.target_model],
)
# testing
self.assertTrue(self.ref_prop_model.value[0].id, self.target_model.id)
# tearDown
new_reference_to_wheel.delete()
def test_create_ref_property_referencing_id_in_list(self):
# setUp
new_reference_to_wheel = self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=[self.target_model.id],
)
# testing
self.assertTrue(self.ref_prop_model.value[0].id, self.target_model.id)
# tearDown
new_reference_to_wheel.delete()
def test_create_ref_property_wrongly_referencing_in_list(self):
# testing
with self.assertRaises(IllegalArgumentError):
self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=[12],
)
def test_create_ref_property_referencing_part(self):
# setUp
new_reference_to_wheel = self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=self.target_model,
)
# testing
self.assertTrue(self.ref_prop_model.value[0].id, self.target_model.id)
# tearDown
new_reference_to_wheel.delete()
def test_create_ref_property_referencing_id(self):
# setUp
new_reference_to_wheel = self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=self.target_model.id,
)
# testing
self.assertTrue(self.ref_prop_model.value[0].id, self.target_model.id)
# tearDown
new_reference_to_wheel.delete()
def test_create_ref_property_wrongly_referencing(self):
# testing
with self.assertRaises(IllegalArgumentError):
self.part_model.add_property(
name=self.ref_prop_name,
property_type=PropertyType.REFERENCES_VALUE,
default_value=True,
)
# new in 3.0
def test_set_prefilters_on_reference_property(self):
# setUp
diameter_property = self.float_prop # decimal property
spokes_property = self.integer_prop # integer property
rim_material_property = self.char_prop # single line text
self.ref_prop_model.set_prefilters(
property_models=[
diameter_property,
spokes_property,
rim_material_property,
self.datetime_prop,
self.ssl_prop,
self.bool_prop,
],
values=[30.5, 7, "Al", self.time, "Michelin", True],
filters_type=[
FilterType.GREATER_THAN_EQUAL,
FilterType.LOWER_THAN_EQUAL,
FilterType.CONTAINS,
FilterType.GREATER_THAN_EQUAL,
FilterType.CONTAINS,
FilterType.EXACT,
],
)
self.assertIn("property_value", self.ref_prop_model._options["prefilters"])
filter_string = self.ref_prop_model._options["prefilters"]["property_value"]
filters = set(filter_string.split(","))
# testing
self.assertIn(
"{}:{}:{}".format(
diameter_property.id, 30.5, FilterType.GREATER_THAN_EQUAL
),
filters,
)
self.assertIn(
f"{spokes_property.id}:{7}:{FilterType.LOWER_THAN_EQUAL}",
filters,
)
self.assertIn(
"{}:{}:{}".format(rim_material_property.id, "Al", FilterType.CONTAINS),
filters,
)
self.assertIn(
"{}:{}:{}".format(self.bool_prop.id, "true", FilterType.EXACT), filters
)
self.assertIn(
"{}:{}:{}".format(self.ssl_prop.id, "Michelin", FilterType.CONTAINS),
filters,
)
self.assertIn(
"{}:{}:{}".format(
self.datetime_prop.id, self.time, FilterType.GREATER_THAN_EQUAL
),
filters,
)
def test_set_prefilters_with_tuples(self):
prefilters_set = [
PropertyValueFilter(self.float_prop, 15.3, FilterType.GREATER_THAN_EQUAL),
PropertyValueFilter(self.char_prop, "Al", FilterType.CONTAINS),
]
self.ref_prop_model.set_prefilters(prefilters=prefilters_set)
prefilters_get = self.ref_prop_model.get_prefilters()
self.assertTrue(prefilters_get, msg="No prefilters returned")
first_filter = prefilters_get[0]
self.assertEqual(self.float_prop.id, first_filter.id)
self.assertEqual("15.3", first_filter.value)
self.assertEqual(FilterType.GREATER_THAN_EQUAL, first_filter.type)
def test_set_prefilters_with_validation(self):
prefilter_good = PropertyValueFilter(
self.float_prop, 15.3, FilterType.GREATER_THAN_EQUAL
)
prefilter_bad = PropertyValueFilter(
self.part_model.property("Gears"), 15.3, FilterType.GREATER_THAN_EQUAL
)
# Validate automatically
self.ref_prop_model.set_prefilters(prefilters=[prefilter_good])
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_prefilters(prefilters=[prefilter_bad])
# Validate by providing the referenced model
self.ref_prop_model.set_prefilters(
prefilters=[prefilter_good], validate=self.target_model
)
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_prefilters(
prefilters=[prefilter_bad], validate=self.target_model
)
# Dont validate
self.ref_prop_model.set_prefilters(prefilters=[prefilter_good], validate=False)
self.ref_prop_model.set_prefilters(prefilters=[prefilter_bad], validate=None)
def test_set_prefilters_on_reference_property_with_excluded_propmodels_and_validators(
self,
):
# The excluded propmodels and validators already set on the property should not be erased when
# setting prefilters
# setUp
diameter_property = self.float_prop
spokes_property = self.integer_prop
self.ref_prop_model.set_excluded_propmodels(
property_models=[diameter_property, spokes_property]
)
self.ref_prop_model.validators = [RequiredFieldValidator()]
self.ref_prop_model.set_prefilters(
property_models=[diameter_property],
values=[15.13],
filters_type=[FilterType.GREATER_THAN_EQUAL],
)
# testing Filters
self.assertIn(
"{}:{}:{}".format(
diameter_property.id, 15.13, FilterType.GREATER_THAN_EQUAL
),
self.ref_prop_model._options["prefilters"]["property_value"],
)
# testing Excluded props
self.assertIn(
PropertyReferenceOptions.PROPMODELS_EXCLUDED, self.ref_prop_model._options
)
excluded = self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
self.assertEqual(len(excluded), 2)
self.assertIn(diameter_property.id, excluded)
self.assertIn(spokes_property.id, excluded)
# testing Validators
self.assertTrue(self.ref_prop_model.validators)
self.assertIsInstance(
self.ref_prop_model._validators[0], RequiredFieldValidator
)
def test_clear_prefilters(self):
# setUp
prefilter_1 = PropertyValueFilter(
property_model=self.float_prop,
value=15.13,
filter_type=FilterType.GREATER_THAN_EQUAL,
)
self.ref_prop_model.set_prefilters(prefilters=[prefilter_1])
# Add filter for different property, see if the first one is removed (clear = True)
prefilter_2 = PropertyValueFilter(
property_model=self.integer_prop,
value=13,
filter_type=FilterType.EXACT,
)
self.ref_prop_model.set_prefilters(
prefilters=[prefilter_2],
clear=True,
)
self.ref_prop_model.refresh()
live_prefilters = self.ref_prop_model.get_prefilters()
# testing
self.assertTrue(live_prefilters, msg="Expected at least 1 prefilter")
self.assertEqual(1, len(live_prefilters), msg="Expected 1 prefilter")
self.assertEqual(prefilter_2, live_prefilters[0])
def test_overwrite_prefilters(self):
# setUp
prefilter_1 = PropertyValueFilter(
property_model=self.float_prop,
value=15.13,
filter_type=FilterType.GREATER_THAN_EQUAL,
)
prefilter_2 = PropertyValueFilter(
property_model=self.integer_prop,
value=13,
filter_type=FilterType.EXACT,
)
prefilter_3 = PropertyValueFilter(
property_model=self.float_prop,
value=15.13,
filter_type=FilterType.EXACT,
)
# Set the initial filters
self.ref_prop_model.set_prefilters(prefilters=[prefilter_1, prefilter_2])
# Add another filter for the same property to see if the first one is removed (overwrite = True)
self.ref_prop_model.set_prefilters(prefilters=[prefilter_3], overwrite=True)
self.ref_prop_model.refresh()
live_prefilters = self.ref_prop_model.get_prefilters()
# testing
self.assertTrue(live_prefilters, msg="Expected at least 1 prefilter")
self.assertEqual(2, len(live_prefilters), msg="Expected 2 prefilters")
self.assertIn(prefilter_2, live_prefilters)
self.assertIn(prefilter_3, live_prefilters)
def test_set_prefilters_on_reference_property_using_uuid(self):
# setUp
diameter_property = self.float_prop
spokes_property = self.integer_prop
self.ref_prop_model.set_prefilters(
property_models=[diameter_property.id, spokes_property.id],
values=[30.5, 7],
filters_type=[FilterType.GREATER_THAN_EQUAL, FilterType.LOWER_THAN_EQUAL],
)
# testing
self.assertTrue("property_value" in self.ref_prop_model._options["prefilters"])
self.assertTrue(
f"{diameter_property.id}:{30.5}:{FilterType.GREATER_THAN_EQUAL}"
in self.ref_prop_model._options["prefilters"]["property_value"]
)
self.assertTrue(
f"{spokes_property.id}:{7}:{FilterType.LOWER_THAN_EQUAL}"
in self.ref_prop_model._options["prefilters"]["property_value"]
)
def test_set_prefilters_on_reference_property_the_wrong_way(self):
# setUp
bike_gears_property = self.part_model.property(name="Gears")
instance_diameter_property = self.target_model.instances()[0].property(
PropertyType.FLOAT_VALUE
)
diameter_property = self.float_prop
# testing
# When prefilters are being set, but the property does not belong to the referenced part
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_prefilters(
property_models=[bike_gears_property],
values=[2],
filters_type=[FilterType.GREATER_THAN_EQUAL],
)
# When prefilters are being set, but the property is an instance, not a model
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_prefilters(
property_models=[instance_diameter_property],
values=[3.33],
filters_type=[FilterType.GREATER_THAN_EQUAL],
)
# When prefilters are being set, but the size of lists is not consistent
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_prefilters(
property_models=[diameter_property],
values=[3.33, 1.51],
filters_type=[FilterType.GREATER_THAN_EQUAL, FilterType.CONTAINS],
)
# When prefilters are being set, but no UUIDs or `Property` objects are being used in property_models
with self.assertRaises(IllegalArgumentError):
# noinspection PyTypeChecker
self.ref_prop_model.set_prefilters(
property_models=[False, 301],
values=[3.33, 1.51],
filters_type=[FilterType.GREATER_THAN_EQUAL, FilterType.CONTAINS],
)
def test_set_excluded_propmodels_on_reference_property(self):
# setUp
diameter_property = self.float_prop
spokes_property = self.integer_prop
self.ref_prop_model.set_excluded_propmodels(
property_models=[diameter_property, spokes_property]
)
# testing
self.assertEqual(
len(
self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
),
2,
)
self.assertTrue(
diameter_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
self.assertTrue(
spokes_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
def test_set_excluded_propmodels_with_validation(self):
excluded_model_good = self.float_prop
excluded_model_bad = self.part_model.property("Gears")
# Validate automatically
self.ref_prop_model.set_excluded_propmodels(
property_models=[excluded_model_good]
)
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_excluded_propmodels(
property_models=[excluded_model_bad]
)
# Validate by providing the referenced model
self.ref_prop_model.set_excluded_propmodels(
property_models=[excluded_model_good], validate=self.target_model
)
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_excluded_propmodels(
property_models=[excluded_model_bad], validate=self.target_model
)
# Dont validate
self.ref_prop_model.set_excluded_propmodels(
property_models=[excluded_model_good], validate=False
)
self.ref_prop_model.set_excluded_propmodels(
property_models=[excluded_model_bad], validate=None
)
def test_set_excluded_propmodels_on_reference_property_using_uuid(self):
# setUp
diameter_property = self.float_prop
spokes_property = self.integer_prop
self.ref_prop_model.set_excluded_propmodels(
property_models=[diameter_property.id, spokes_property.id]
)
# testing
self.assertEqual(
len(
self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
),
2,
)
self.assertTrue(
diameter_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
self.assertTrue(
spokes_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
def test_set_excluded_propmodels_on_reference_property_with_prefilters_and_validators(
self,
):
# The prefilters and validators already set on the property should not be erased when setting
# excluded propmodels
# setUp
diameter_property = self.float_prop
spokes_property = self.integer_prop
self.ref_prop_model.set_prefilters(
property_models=[diameter_property],
values=[15.13],
filters_type=[FilterType.GREATER_THAN_EQUAL],
)
self.ref_prop_model.validators = [RequiredFieldValidator()]
self.ref_prop_model.set_excluded_propmodels(
property_models=[diameter_property, spokes_property]
)
# testing
self.assertTrue("property_value" in self.ref_prop_model._options["prefilters"])
self.assertTrue(
"{}:{}:{}".format(
diameter_property.id, 15.13, FilterType.GREATER_THAN_EQUAL
)
in self.ref_prop_model._options["prefilters"]["property_value"]
)
self.assertEqual(
len(
self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
),
2,
)
self.assertTrue(
diameter_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
self.assertTrue(
spokes_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
self.assertTrue(
isinstance(self.ref_prop_model._validators[0], RequiredFieldValidator)
)
def test_get_prefilters(self):
# setUp
self.ref_prop_model.set_prefilters(
property_models=[self.float_prop],
values=[15.13],
filters_type=[FilterType.GREATER_THAN_EQUAL],
)
prefilters = self.ref_prop_model.get_prefilters()
self.assertTrue(prefilters, msg="A prefilter should be set")
self.assertIsInstance(
prefilters, list, msg="By default, prefilters should be a list of tuples!"
)
self.assertTrue(
all(isinstance(pf, PropertyValueFilter) for pf in prefilters),
msg="Not every prefilter is a PropertyValueFilter object!",
)
prefilters = self.ref_prop_model.get_prefilters(as_lists=True)
self.assertIsInstance(
prefilters, tuple, msg="Prefilters should be a tuple of 3 lists!"
)
self.assertEqual(3, len(prefilters), msg="Expected 3 lists!")
property_model_ids, values, filters = prefilters
self.assertEqual(len(property_model_ids), len(values), len(filters))
def test_set_excluded_propmodels_on_reference_property_the_wrong_way(self):
# setUp
bike_gears_property = self.part_model.property(name="Gears")
instance_diameter_property = self.target_model.instances()[0].property(
PropertyType.FLOAT_VALUE
)
# testing
# When excluded propmodels are being set, but the property does not belong to the referenced part
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_excluded_propmodels(
property_models=[bike_gears_property]
)
# When excluded propmodels are being set, but the property is an instance, not a model
with self.assertRaises(IllegalArgumentError):
self.ref_prop_model.set_excluded_propmodels(
property_models=[instance_diameter_property]
)
# When excluded propmodels are being set, but no UUIDs or `Property` objects are being used in property_models
with self.assertRaises(IllegalArgumentError):
# noinspection PyTypeChecker
self.ref_prop_model.set_excluded_propmodels(property_models=[False, 301])
def test_add_excluded_propmodels_to_reference_property(self):
# Set the initial excluded propmodels
self.ref_prop_model.set_excluded_propmodels(property_models=[self.float_prop])
# Add others, checks whether the initial ones are remembered (overwrite = False)
self.ref_prop_model.set_excluded_propmodels(
property_models=[self.integer_prop], overwrite=False
)
# testing
self.assertEqual(
len(
self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
),
2,
)
self.assertTrue(
self.float_prop.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
self.assertTrue(
self.integer_prop.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
def test_overwrite_excluded_propmodels_on_reference_property(self):
# setUp
diameter_property = self.float_prop
spokes_property = self.integer_prop
# Set the initial excluded propmodels
self.ref_prop_model.set_excluded_propmodels(property_models=[diameter_property])
# Overwrite them
self.ref_prop_model.set_excluded_propmodels(
property_models=[spokes_property], overwrite=True
)
# testing
self.assertEqual(
len(
self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
),
1,
)
self.assertTrue(
diameter_property.id
not in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
self.assertTrue(
spokes_property.id
in self.ref_prop_model._options[
PropertyReferenceOptions.PROPMODELS_EXCLUDED
]
)
def test_get_excluded_propmodel_ids(self):
# setUp
self.ref_prop_model.set_excluded_propmodels(property_models=[self.float_prop])
excluded_propmodel_ids = self.ref_prop_model.get_excluded_propmodel_ids()
self.assertTrue(excluded_propmodel_ids, msg="Excluded propmodels should be set")
self.assertIsInstance(excluded_propmodel_ids, list)
self.assertTrue(all(is_uuid(pk) for pk in excluded_propmodel_ids))
def test_retrieve_scope_id(self):
frame = self.project.part(name="Frame")
ref_to_wheel = frame.property(name="Ref to wheel")
self.assertEqual(ref_to_wheel.scope_id, self.project.id)
def test_property_clear_selected_part_model(self):
# setUp
wheel_model = self.project.model("Wheel")
self.ref_prop_model.value = [wheel_model]
self.assertTrue(wheel_model.id == self.ref_prop_model.value[0].id)
self.ref_prop_model.value = None
# testing
self.assertIsNone(self.ref_prop_model.value)
def test_property_clear_referenced_part_instances(self):
# setUp
wheel_model = self.project.model("Wheel")
self.ref_prop_model.value = [wheel_model]
wheel_instances = wheel_model.instances()
wheel_instances_list = [instance.id for instance in wheel_instances]
# set ref value
self.ref.value = wheel_instances_list
# clear referenced part instances
self.ref.value = None
# testing
self.assertIsNone(self.ref.value)
self.assertIsNotNone(self.ref_prop_model.value)
def test_copy_reference_property_with_options(self):
# setUp
copied_ref_property = self.ref_prop_model.copy(
target_part=self.part_model, name="__Copied ref property"
)
# testing
self.assertEqual(copied_ref_property.name, "__Copied ref property")
self.assertEqual(
copied_ref_property.description, self.ref_prop_model.description
)
self.assertEqual(copied_ref_property.unit, self.ref_prop_model.unit)
self.assertEqual(copied_ref_property.value, self.ref_prop_model.value)
self.assertDictEqual(copied_ref_property._options, self.ref_prop_model._options)
# tearDown
copied_ref_property.delete()
def test_set_sorting_on_property(self):
self.ref_prop_model.set_sorting(
sort_property=self.float_prop, sort_direction=SortTable.DESCENDING
)
self.assertIn(
PropertyReferenceOptions.SORTED_COLUMN, self.ref_prop_model._options
)
self.assertIn(
PropertyReferenceOptions.SORTED_DIRECTION, self.ref_prop_model._options
)
self.assertEqual(
self.ref_prop_model._options[PropertyReferenceOptions.SORTED_COLUMN],
self.float_prop.id,
)
self.assertEqual(
self.ref_prop_model._options[PropertyReferenceOptions.SORTED_DIRECTION],
SortTable.DESCENDING,
)
def test_set_sorting_on_name(self):
self.ref_prop_model.set_sorting(
sort_name=True, sort_direction=SortTable.ASCENDING
)
self.assertIn(
PropertyReferenceOptions.SORTED_COLUMN, self.ref_prop_model._options
)
self.assertIn(
PropertyReferenceOptions.SORTED_DIRECTION, self.ref_prop_model._options
)
self.assertEqual(
self.ref_prop_model._options[PropertyReferenceOptions.SORTED_COLUMN],
PropertyReferenceOptions.NAME,
)
self.assertEqual(
self.ref_prop_model._options[PropertyReferenceOptions.SORTED_DIRECTION],
SortTable.ASCENDING,
)
def test_clear_sorting(self):
self.ref_prop_model.set_sorting(
sort_name=True, sort_direction=SortTable.ASCENDING
)
self.assertIn(
PropertyReferenceOptions.SORTED_COLUMN, self.ref_prop_model._options
)
self.assertIn(
PropertyReferenceOptions.SORTED_DIRECTION, self.ref_prop_model._options
)
self.assertEqual(
self.ref_prop_model._options[PropertyReferenceOptions.SORTED_COLUMN],
PropertyReferenceOptions.NAME,
)
self.assertEqual(
self.ref_prop_model._options[PropertyReferenceOptions.SORTED_DIRECTION],
SortTable.ASCENDING,
)
self.ref_prop_model.set_sorting(
sort_name=True, sort_direction=SortTable.ASCENDING, clear=True
)
self.assertNotIn(
PropertyReferenceOptions.SORTED_COLUMN, self.ref_prop_model._options
)
self.assertNotIn(
PropertyReferenceOptions.SORTED_DIRECTION, self.ref_prop_model._options
)
def test_get_sorting(self):
self.ref_prop_model.set_sorting(
sort_name=True, sort_direction=SortTable.ASCENDING
)
sorting_options = self.ref_prop_model.get_sorting()
self.assertIn(PropertyReferenceOptions.SORTED_COLUMN, sorting_options)
self.assertIn(PropertyReferenceOptions.SORTED_DIRECTION, sorting_options)
self.assertEqual(
sorting_options[PropertyReferenceOptions.SORTED_COLUMN],
PropertyReferenceOptions.NAME,
)
self.assertEqual(
sorting_options[PropertyReferenceOptions.SORTED_DIRECTION],
SortTable.ASCENDING,
)
|
class TestPropertyMultiReferenceProperty(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_referencing_a_model(self):
pass
def test_referencing_multiple_instances_using_parts(self):
pass
def test_referencing_multiple_instances_using_ids(self):
pass
def test_referencing_a_list_with_no_parts(self):
pass
def test_value_if_multi_ref_gives_back_all_parts(self):
'''because of #276 problem'''
pass
def test_value_if_nothing_is_referenced(self):
pass
def test_value_ids(self):
pass
def test_multi_ref_choices(self):
pass
def test_create_ref_property_referencing_part_in_list(self):
pass
def test_create_ref_property_referencing_id_in_list(self):
pass
def test_create_ref_property_wrongly_referencing_in_list(self):
pass
def test_create_ref_property_referencing_part_in_list(self):
pass
def test_create_ref_property_referencing_id_in_list(self):
pass
def test_create_ref_property_wrongly_referencing_in_list(self):
pass
def test_set_prefilters_on_reference_property(self):
pass
def test_set_prefilters_with_tuples(self):
pass
def test_set_prefilters_with_validation(self):
pass
def test_set_prefilters_on_reference_property_with_excluded_propmodels_and_validators(
self,
):
pass
def test_clear_prefilters(self):
pass
def test_overwrite_prefilters(self):
pass
def test_set_prefilters_on_reference_property_using_uuid(self):
pass
def test_set_prefilters_on_reference_property_the_wrong_way(self):
pass
def test_set_excluded_propmodels_on_reference_property(self):
pass
def test_set_excluded_propmodels_with_validation(self):
pass
def test_set_excluded_propmodels_on_reference_property_using_uuid(self):
pass
def test_set_excluded_propmodels_on_reference_property_with_prefilters_and_validators(
self,
):
pass
def test_get_prefilters(self):
pass
def test_set_excluded_propmodels_on_reference_property_the_wrong_way(self):
pass
def test_add_excluded_propmodels_to_reference_property(self):
pass
def test_overwrite_excluded_propmodels_on_reference_property(self):
pass
def test_get_excluded_propmodel_ids(self):
pass
def test_retrieve_scope_id(self):
pass
def test_property_clear_selected_part_model(self):
pass
def test_property_clear_referenced_part_instances(self):
pass
def test_copy_reference_property_with_options(self):
pass
def test_set_sorting_on_property(self):
pass
def test_set_sorting_on_name(self):
pass
def test_clear_sorting(self):
pass
def test_get_sorting(self):
pass
| 42 | 1 | 21 | 2 | 17 | 2 | 1 | 0.15 | 1 | 15 | 8 | 0 | 41 | 12 | 41 | 116 | 918 | 141 | 679 | 129 | 633 | 103 | 316 | 124 | 274 | 1 | 3 | 1 | 41 |
140,603 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyMultiReferencePropertyXScope
|
class TestPropertyMultiReferencePropertyXScope(TestBetamax):
def setUp(self):
super().setUp()
self.x_scope = self.client.create_scope(
name="Cross_reference scope", tags=["x-scope-target"]
)
self.part_model = self.project.model("Bike")
# Create reference property and retrieve its instance
prop_name = "cross-scope reference property"
self.x_reference_model = self.part_model.add_property(
name=prop_name,
property_type=PropertyType.REFERENCES_VALUE,
)
self.x_reference = self.part_model.instance().property(prop_name)
# Define target model and create an instance
product_root = self.x_scope.model("Product")
self.x_target_model = product_root.add_model(
name="Reference target", multiplicity=Multiplicity.ZERO_MANY
)
self.x_target = product_root.instance().add(
model=self.x_target_model, name="Target instance"
)
def tearDown(self):
self.x_reference_model.delete()
self.x_scope.delete()
super().tearDown()
def test_set_model_value(self):
# setUp
self.x_reference_model.value = [self.x_target_model]
self.x_reference_model.refresh()
# testing
self.assertEqual(self.x_scope.id, self.x_reference_model.value[0].scope_id)
self.assertEqual(self.x_target_model.id, self.x_reference_model.value[0].id)
def test_set_model_value_using_id(self):
# setUp
self.x_reference_model.value = [self.x_target_model.id]
self.x_reference_model.refresh()
# testing
self.assertEqual(self.x_scope.id, self.x_reference_model.value[0].scope_id)
self.assertEqual(self.x_target_model.id, self.x_reference_model.value[0].id)
def test_set_value(self):
# setUp
self.x_reference_model.value = [self.x_target_model.id]
self.x_reference.refresh()
self.x_reference.value = [self.x_target]
self.assertTrue(len(self.x_reference.value) == 1)
self.assertEqual(self.x_target.id, self.x_reference.value[0].id)
|
class TestPropertyMultiReferencePropertyXScope(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_set_model_value(self):
pass
def test_set_model_value_using_id(self):
pass
def test_set_value(self):
pass
| 6 | 0 | 10 | 1 | 8 | 1 | 1 | 0.17 | 1 | 3 | 2 | 0 | 5 | 6 | 5 | 80 | 57 | 10 | 40 | 14 | 34 | 7 | 31 | 14 | 25 | 1 | 3 | 0 | 5 |
140,604 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyScopeReference
|
class TestPropertyScopeReference(TestBetamax):
def setUp(self):
super().setUp()
root = self.project.model(name="Product")
self.part = self.project.create_model(
name="Test part", parent=root, multiplicity=Multiplicity.ONE
)
self.scope_ref_prop = self.part.add_property(
name="scope ref", property_type=PropertyType.SCOPE_REFERENCES_VALUE
) # type: ScopeReferencesProperty
def tearDown(self):
if self.part:
self.part.delete()
super().tearDown()
def test_create(self):
self.assertIsInstance(self.scope_ref_prop, ScopeReferencesProperty)
def test_value(self):
bike_project = self.client.scope(name="Bike Project")
self.scope_ref_prop.value = [bike_project]
self.assertIsInstance(self.scope_ref_prop, ScopeReferencesProperty)
self.assertIsNotNone(self.scope_ref_prop.value)
self.assertEqual(bike_project, self.scope_ref_prop.value[0])
def test_value_ids(self):
bike_project = self.client.scope(name="Bike Project")
self.scope_ref_prop.value = [bike_project]
self.scope_ref_prop.refresh()
ids = self.scope_ref_prop.value_ids()
self.assertIsInstance(ids, list)
self.assertTrue(all(isinstance(v, str) for v in ids))
def test_no_value(self):
self.assertIsInstance(self.scope_ref_prop, ScopeReferencesProperty)
self.assertIsNone(self.scope_ref_prop.value)
def test_reload(self):
reloaded_prop = self.client.reload(obj=self.scope_ref_prop)
self.assertFalse(
self.scope_ref_prop is reloaded_prop,
msg="Must be different Python objects, based on memory allocation",
)
self.assertEqual(
self.scope_ref_prop,
reloaded_prop,
msg="Must be the same KE-chain prop, based on hashed UUID",
)
def test_prefilters(self):
live_filters = self.scope_ref_prop.get_prefilters()
self.assertFalse(live_filters)
tags = ["project", "catalog"]
filters = [ScopeFilter(tag=tag) for tag in tags]
self.scope_ref_prop.set_prefilters(
prefilters=filters,
)
self.scope_ref_prop.refresh()
live_filters = self.scope_ref_prop.get_prefilters()
self.assertTrue(live_filters)
self.assertIsInstance(live_filters, list)
self.assertTrue(all(isinstance(pf, ScopeFilter) for pf in live_filters))
self.scope_ref_prop.set_prefilters(clear=True)
self.scope_ref_prop.refresh()
live_filters = self.scope_ref_prop.get_prefilters()
self.assertFalse(live_filters)
with self.assertRaises(IllegalArgumentError):
# noinspection PyTypeChecker
self.scope_ref_prop.set_prefilters(prefilters=filters[0])
def test_set_columns(self):
self.scope_ref_prop.set_columns(
list_of_columns=[
ScopeReferenceColumns.PROGRESS,
ScopeReferenceColumns.DUE_DATE,
]
)
self.assertIn("columns", self.scope_ref_prop._options)
self.assertIn(
ScopeReferenceColumns.PROGRESS, self.scope_ref_prop._options["columns"]
)
self.assertIn(
ScopeReferenceColumns.DUE_DATE, self.scope_ref_prop._options["columns"]
)
self.assertNotIn(
ScopeReferenceColumns.START_DATE, self.scope_ref_prop._options["columns"]
)
self.assertNotIn(
ScopeReferenceColumns.STATUS, self.scope_ref_prop._options["columns"]
)
self.assertNotIn(
ScopeReferenceColumns.TAGS, self.scope_ref_prop._options["columns"]
)
def test_set_active_switch(self):
self.scope_ref_prop.set_active_filter_switch(switch_visible=True)
self.assertIn("show_active_status_filter", self.scope_ref_prop._options)
self.assertTrue(self.scope_ref_prop._options["show_active_status_filter"])
self.scope_ref_prop.set_active_filter_switch(switch_visible=False)
self.assertIn("show_active_status_filter", self.scope_ref_prop._options)
self.assertFalse(self.scope_ref_prop._options["show_active_status_filter"])
|
class TestPropertyScopeReference(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create(self):
pass
def test_value(self):
pass
def test_value_ids(self):
pass
def test_no_value(self):
pass
def test_reload(self):
pass
def test_prefilters(self):
pass
def test_set_columns(self):
pass
def test_set_active_switch(self):
pass
| 11 | 0 | 11 | 1 | 9 | 0 | 1 | 0.02 | 1 | 9 | 6 | 0 | 10 | 2 | 10 | 85 | 116 | 23 | 92 | 21 | 81 | 2 | 64 | 21 | 53 | 2 | 3 | 1 | 11 |
140,605 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/client_utils.py
|
pykechain.client_utils.PykeRetry
|
class PykeRetry(Retry):
"""
Pykechain Implementation of urllib3.Retry function.
It contains a fast bailout of any SSLCertificate Errors.
"""
def increment(
self,
method=None,
url=None,
response=None,
error=None,
_pool=None,
_stacktrace=None,
):
"""In case of failed verification of self signed certificate we short circuit the retry routine."""
if self._is_ssl_error(error):
raise MaxRetryError(_pool, url, error)
return super().increment(
method=method,
url=url,
response=response,
error=error,
_pool=_pool,
_stacktrace=_stacktrace,
)
def _is_ssl_error(self, error):
return error and isinstance(error, SSLError)
|
class PykeRetry(Retry):
'''
Pykechain Implementation of urllib3.Retry function.
It contains a fast bailout of any SSLCertificate Errors.
'''
def increment(
self,
method=None,
url=None,
response=None,
error=None,
_pool=None,
_stacktrace=None,
):
'''In case of failed verification of self signed certificate we short circuit the retry routine.'''
pass
def _is_ssl_error(self, error):
pass
| 3 | 2 | 12 | 1 | 11 | 1 | 2 | 0.23 | 1 | 2 | 0 | 0 | 2 | 0 | 2 | 18 | 31 | 4 | 22 | 11 | 11 | 5 | 7 | 3 | 4 | 2 | 1 | 1 | 3 |
140,606 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetManagerWeatherWidget
|
class TestWidgetManagerWeatherWidget(TestBetamax):
def setUp(self):
super().setUp()
self.task = self.project.create_activity(
name="widget_test_task"
) # type: Activity
self.wm = self.task.widgets() # type: WidgetsManager
catalog_root_model = self.project.part(
name="Catalog",
classification=Classification.CATALOG,
category=Category.MODEL,
)
self.part_model_with_weather_prop = self.project.create_model_with_properties(
parent=catalog_root_model,
name="___TEST PART",
multiplicity=Multiplicity.ONE,
properties_fvalues=[
dict(name="weather", property_type=PropertyType.WEATHER_VALUE)
],
)
self.weather_prop_instance = self.part_model_with_weather_prop.instances()[
0
].property("weather")
def tearDown(self):
if self.task:
self.task.delete()
if self.part_model_with_weather_prop:
self.part_model_with_weather_prop.delete()
super().tearDown()
def test_weather_widget(self):
"""Testing the weather widget."""
self.weather_widget = self.wm.add_weather_widget(
weather_property=self.weather_prop_instance,
)
|
class TestWidgetManagerWeatherWidget(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_weather_widget(self):
'''Testing the weather widget.'''
pass
| 4 | 1 | 11 | 0 | 11 | 1 | 2 | 0.09 | 1 | 6 | 4 | 0 | 3 | 5 | 3 | 78 | 37 | 3 | 33 | 10 | 29 | 3 | 16 | 10 | 12 | 3 | 3 | 1 | 5 |
140,607 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetNavigationBarWidget
|
class TestWidgetNavigationBarWidget(TestBetamax):
def setUp(self):
super().setUp()
self.task = self.project.create_activity(
name="widget_test_task"
) # type: Activity
self.wm = self.task.widgets() # type: WidgetsManager
self.frame = self.project.part(name="Frame")
self.frame_model = self.project.model(name="Frame")
activity_1 = self.project.activity("Task - Basic Table")
activity_2 = self.project.activity("Task - Form")
activity_3 = self.project.activity("Task - Service Increase Gears")
self.nav_bar_config = [
{"activityId": activity_1, "emphasize": True},
{"activityId": activity_2, "customText": "Hit me baby!"},
{"activityId": activity_3},
]
def tearDown(self):
if self.task:
self.task.delete()
super().tearDown()
def test_add_navbar_widget(self):
widget = self.wm.add_tasknavigationbar_widget(
activities=self.nav_bar_config, title="Navbar", alignment=Alignment.LEFT
)
self.assertIsInstance(widget, TasknavigationbarWidget)
self.assertEqual(len(self.wm), 1 + 1)
def test_add_navbar_widget_in_place(self):
"""
Test whether the inputs to the function are updated in-place (incorrect) or not (correct).
For example, activity objects are replaced by their IDs and customText is converted to a string.
"""
self.nav_bar_config[0]["customText"] = False
import copy
original_bar = copy.deepcopy(self.nav_bar_config)
self.wm.add_tasknavigationbar_widget(
activities=self.nav_bar_config,
alignment=Alignment.LEFT,
)
self.assertEqual(original_bar, self.nav_bar_config)
def test_add_navbar_widget_incorrect_keys(self):
self.nav_bar_config[0]["emphasizeButton"] = True
with self.assertRaises(IllegalArgumentError):
self.wm.add_tasknavigationbar_widget(
activities=self.nav_bar_config,
alignment=Alignment.LEFT,
)
def test_add_navbar_external_link(self):
link = "https://www.google.com"
button_1 = self.nav_bar_config[0]
button_1.pop("activityId")
button_1["link"] = link
widget = self.wm.add_tasknavigationbar_widget(
activities=self.nav_bar_config,
alignment=Alignment.LEFT,
)
self.assertEqual(widget.meta["taskButtons"][0]["link"], link)
def test_add_navbar_disabled_button(self):
button_1 = self.nav_bar_config[0]
button_1["isDisabled"] = True
widget = self.wm.add_tasknavigationbar_widget(
activities=self.nav_bar_config,
alignment=Alignment.LEFT,
)
self.assertTrue(widget.meta["taskButtons"][0]["isDisabled"])
|
class TestWidgetNavigationBarWidget(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_add_navbar_widget(self):
pass
def test_add_navbar_widget_in_place(self):
'''
Test whether the inputs to the function are updated in-place (incorrect) or not (correct).
For example, activity objects are replaced by their IDs and customText is converted to a string.
'''
pass
def test_add_navbar_widget_incorrect_keys(self):
pass
def test_add_navbar_external_link(self):
pass
def test_add_navbar_disabled_button(self):
pass
| 8 | 1 | 11 | 2 | 9 | 1 | 1 | 0.1 | 1 | 4 | 3 | 0 | 7 | 5 | 7 | 82 | 85 | 20 | 61 | 24 | 52 | 6 | 41 | 24 | 32 | 2 | 3 | 1 | 8 |
140,608 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgets
|
class TestWidgets(TestBetamax):
def setUp(self):
super().setUp()
self.activity = self.project.activity("Specify wheel diameter")
self.new_widget = None
def tearDown(self):
if self.new_widget:
self.new_widget.delete()
super().tearDown()
def test_retrieve_widgets_in_activity(self):
widget_set = self.activity.widgets()
self.assertIsInstance(widget_set, WidgetsManager)
for w in widget_set:
with self.subTest(msg=w):
self.assertIsInstance(w, Widget)
self.assertEqual(self.activity, w.activity())
def test_create_widget_in_activity(self):
self.new_widget = self.client.create_widget(
title="Test_widget",
activity=self.activity,
widget_type=WidgetTypes.UNDEFINED,
meta={},
order=100,
)
self.assertIsInstance(self.new_widget, UndefinedWidget)
def test_widget_attributes(self):
attributes = [
"_client",
"_json_data",
"id",
"created_at",
"updated_at",
"ref",
"widget_type",
"title",
"meta",
"order",
"_activity_id",
"_parent_id",
"has_subwidgets",
"_scope_id",
]
first_widget = self.activity.widgets()[0]
self.assertIsInstance(first_widget, Widget)
for attribute in attributes:
with self.subTest(msg=attribute):
self.assertTrue(hasattr(first_widget, attribute))
def test_widget_meta_attribute_is_not_None(self):
first_widget = self.activity.widgets()[0]
self.assertIsInstance(first_widget, Widget)
self.assertIsNotNone(first_widget.meta)
def test_associated_parts(self):
task = self.project.activity(name="Task - Basic Table")
grid_widget = list(task.widgets())[0]
associated_parts = grid_widget.associated_parts()
self.assertTrue(associated_parts)
self.assertIsInstance(associated_parts, tuple)
self.assertTrue(len(associated_parts) == 2)
models, instances = associated_parts
self.assertIsInstance(models, list)
self.assertTrue(all(isinstance(p, Part) for p in models))
self.assertTrue(all(p.category == Category.MODEL for p in models))
self.assertTrue(all(p.category == Category.INSTANCE for p in models))
def test_bulk_update(self):
parent = self.project.activity(name="Tasks with Widgets")
task = self.project.activity(name="Task - Form + Tables + Service")
test_task = task.clone(
parent=parent,
name="BULK WIDGET TEST TASK",
)
self.new_widget = test_task # for teardown
widgets = list(test_task.widgets())[1:] # remove meta-panel
self.client.update_widgets(
widgets=[
dict(id=w.id, title=f"widget {i + 1}") for i, w in enumerate(widgets)
]
)
with self.assertRaises(IllegalArgumentError):
double_update = [widgets[0], widgets[0], widgets[1]]
self.client.update_widgets(
widgets=[
dict(id=w.id, title=f"widget {i + 1}")
for i, w in enumerate(double_update)
]
)
|
class TestWidgets(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_retrieve_widgets_in_activity(self):
pass
def test_create_widget_in_activity(self):
pass
def test_widget_attributes(self):
pass
def test_widget_meta_attribute_is_not_None(self):
pass
def test_associated_parts(self):
pass
def test_bulk_update(self):
pass
| 9 | 0 | 12 | 1 | 11 | 0 | 1 | 0.02 | 1 | 11 | 6 | 0 | 8 | 2 | 8 | 83 | 102 | 17 | 85 | 26 | 76 | 2 | 52 | 26 | 43 | 2 | 3 | 2 | 11 |
140,609 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetsCopyMove
|
class TestWidgetsCopyMove(TestBetamax):
def setUp(self):
super().setUp()
self.task = self.project.create_activity(
name="widget_test_task"
) # type: Activity
self.task_2 = self.project.create_activity(
name="test_copy_widget"
) # type: Activity
def tearDown(self):
self.task.delete()
self.task_2.delete()
super().tearDown()
def test_copy_widget(self):
# setUp
title = "Widget to copy"
bike_part = self.project.part("Bike")
widget_manager = self.task.widgets() # type: WidgetsManager
widget_1 = widget_manager.add_propertygrid_widget(
part_instance=bike_part, all_writable=True, title=title
)
widget_1.copy(target_activity=self.task_2, order=0)
widget_manager_2 = self.task_2.widgets() # type: WidgetsManager
associated_model = widget_manager_2[0].parts(category=Category.MODEL)[0]
# testing
self.assertEqual(widget_manager_2[0].widget_type, WidgetTypes.PROPERTYGRID)
self.assertEqual(widget_manager_2[0].title, title)
self.assertTrue(all(prop.output for prop in associated_model.properties))
self.assertEqual(len(self.task.widgets()), 2)
def test_copy_widget_with_wrong_target(self):
# setUp
title = "Widget to copy"
bike_part = self.project.part("Bike")
self.wm = self.task.widgets() # type: WidgetsManager
widget_1 = self.wm.add_propertygrid_widget(
part_instance=bike_part, all_writable=True, title=title
)
# testing
with self.assertRaises(IllegalArgumentError):
widget_1.copy(target_activity=self.project, order=0)
def test_move_widget(self):
# setUp
title = "Widget to move"
bike_part = self.project.part("Bike")
widget_manager = self.task.widgets() # type: WidgetsManager
widget_1 = widget_manager.add_propertygrid_widget(
part_instance=bike_part, all_writable=True, title=title
)
widget_1.move(target_activity=self.task_2, order=0)
widget_manager_2 = self.task_2.widgets() # type: WidgetsManager
associated_model = widget_manager_2[0].parts(category=Category.MODEL)[0]
# testing
self.assertEqual(widget_manager_2[0].widget_type, WidgetTypes.PROPERTYGRID)
self.assertEqual(widget_manager_2[0].title, title)
self.assertTrue(all(prop.output for prop in associated_model.properties))
self.assertEqual(1, len(self.task.widgets()))
|
class TestWidgetsCopyMove(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_copy_widget(self):
pass
def test_copy_widget_with_wrong_target(self):
pass
def test_move_widget(self):
pass
| 6 | 0 | 12 | 1 | 10 | 3 | 1 | 0.26 | 1 | 4 | 3 | 0 | 5 | 4 | 5 | 80 | 63 | 7 | 50 | 25 | 44 | 13 | 40 | 24 | 34 | 1 | 3 | 1 | 5 |
140,610 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_widgets.py
|
tests.test_widgets.TestWidgetsInForm
|
class TestWidgetsInForm(TestBetamax):
def setUp(self):
super().setUp()
self.cross_scope = self.project.clone(asynchronous=False) # type: Scope
self.workflow = self.client.workflow(
name="Simple Form Flow", category=WorkflowCategory.CATALOG
)
self.form_model_name = "__TEST__FORM_MODEL"
self.form_model = self.client.create_form_model(
name=self.form_model_name,
scope=self.project,
workflow=self.workflow,
contexts=[],
)
self.activity_to_do = self.form_model.status_forms[0].activity
self.form_part_model = self.project.model(name=self.form_model_name)
self.exactly_1_part_model = self.form_part_model.add_model(
name="__EXACTLY_1_FORM_MODEL",
multiplicity=Multiplicity.ONE,
)
self.attachment_property_model = self.exactly_1_part_model.add_property(
name="__ATTACHMENT_PROPERTY_FORM",
property_type=PropertyType.ATTACHMENT_VALUE,
)
self.form_parent_part = self.project.part(name="Form")
self.bike_model = self.project.model(name="Bike")
self.form_bike_model = _copy_part_model(
part=self.bike_model,
target_parent=self.form_part_model,
name="__BIKE_FORM_MODEL",
include_children=True,
)
self.weather_prop_model = self.form_bike_model.add_property(
name="weather_prop", property_type=PropertyType.WEATHER_VALUE
)
self.wm = self.activity_to_do.widgets()
def tearDown(self):
super().tearDown()
if self.form_model:
try:
self.form_model.delete()
except (ForbiddenError, APIError):
pass
if self.cross_scope:
try:
self.cross_scope.delete()
except (ForbiddenError, APIError):
pass
def test_add_attachment_widget(self):
widget = self.wm.add_attachmentviewer_widget(
attachment_property=self.attachment_property_model, editable=True
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget = cloned_wm[-1]
self.assertIsInstance(widget, AttachmentviewerWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(self.attachment_property_model.name, widget.title_visible)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget, AttachmentviewerWidget)
self.assertEqual(len(cloned_wm), 1 + 1)
self.assertEqual(
self.attachment_property_model.name, cloned_widget.title_visible
)
def test_add_attachment_widget_with_editable_association(self):
widget = self.wm.add_attachmentviewer_widget(
title="Attachment Viewer",
attachment_property=self.attachment_property_model,
editable=True,
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget = cloned_wm[-1]
self.assertIsInstance(widget, AttachmentviewerWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual("Attachment Viewer", widget.title_visible)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget, AttachmentviewerWidget)
self.assertEqual(len(cloned_wm), 1 + 1)
self.assertEqual("Attachment Viewer", cloned_widget.title_visible)
def test_add_super_grid_widget(self):
bike_part_model = self.project.model(name="__BIKE_FORM_MODEL")
wheel_form_part_model = self.project.model(name="Wheel", parent=bike_part_model)
widget = self.wm.add_supergrid_widget(
part_model=wheel_form_part_model,
parent_instance=bike_part_model,
edit=False,
emphasize_edit=True,
all_readable=True,
incomplete_rows=True,
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget = cloned_wm[-1]
self.assertIsInstance(widget, SupergridWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(wheel_form_part_model.name, widget.title_visible)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget, SupergridWidget)
self.assertEqual(len(cloned_wm), 1 + 1)
self.assertEqual(wheel_form_part_model.name, cloned_widget.title_visible)
def test_add_filtered_grid_widget(self):
bike_part_model = self.project.model(name="__BIKE_FORM_MODEL")
wheel_form_part_model = self.project.model(name="Wheel", parent=bike_part_model)
widget = self.wm.add_filteredgrid_widget(
part_model=wheel_form_part_model,
parent_instance=bike_part_model,
edit=False,
emphasize_edit=True,
all_readable=True,
incomplete_rows=True,
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget = cloned_wm[-1]
self.assertIsInstance(widget, FilteredgridWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(wheel_form_part_model.name, widget.title_visible)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget, FilteredgridWidget)
self.assertEqual(len(cloned_wm), 1 + 1)
self.assertEqual(wheel_form_part_model.name, cloned_widget.title_visible)
def test_add_propertygrid_widget(self):
bike_part_model = self.project.model(name="__BIKE_FORM_MODEL")
widget = self.wm.add_propertygrid_widget(
part_instance=bike_part_model,
show_headers=False,
show_columns=[ShowColumnTypes.UNIT],
readable_models=bike_part_model.properties[:2],
writable_models=bike_part_model.properties[3:],
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget = cloned_wm[-1]
self.assertIsInstance(widget, PropertygridWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(bike_part_model.name, widget.title_visible)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget, PropertygridWidget)
self.assertEqual(len(cloned_wm), 1 + 1)
self.assertEqual(bike_part_model.name, cloned_widget.title_visible)
def test_add_signature_widget(self):
widget1 = self.wm.add_signature_widget(
attachment_property=self.attachment_property_model,
title="Yes, my precious",
custom_undo_button_text="Remove za widget",
custom_button_text="Sign za widget, plz",
show_name_and_date=False,
)
widget2 = self.wm.add_signature_widget(
attachment_property=self.attachment_property_model,
title=False,
custom_undo_button_text=False,
custom_button_text=False,
)
widget3 = self.wm.add_signature_widget(
attachment_property=self.attachment_property_model
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget1 = cloned_wm[-3]
cloned_widget2 = cloned_wm[-2]
cloned_widget3 = cloned_wm[-1]
self.assertIsInstance(widget1, SignatureWidget)
self.assertIsInstance(widget2, SignatureWidget)
self.assertIsInstance(widget3, SignatureWidget)
self.assertEqual(len(self.wm), 1 + 3)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget1, SignatureWidget)
self.assertIsInstance(cloned_widget2, SignatureWidget)
self.assertIsInstance(cloned_widget3, SignatureWidget)
self.assertEqual(len(cloned_wm), 1 + 3)
with self.assertRaises(IllegalArgumentError):
self.wm.add_signature_widget(attachment_property="Failed script")
def test_weather_widget(self):
"""Testing the weather widget."""
widget = self.wm.add_weather_widget(
weather_property=self.weather_prop_model,
)
cloned_form_model = self.form_model.clone(
name=self.form_model_name, target_scope=self.cross_scope
)
cloned_activity_to_do = cloned_form_model.status_forms[0].activity
cloned_wm = cloned_activity_to_do.widgets()
cloned_widget = cloned_wm[-1]
self.assertIsInstance(widget, WeatherWidget)
self.assertEqual(len(self.wm), 1 + 1)
self.assertEqual(self.weather_prop_model.name, widget.title_visible)
self.assertIsInstance(self.cross_scope.form(name=self.form_model_name), Form)
self.assertIsInstance(cloned_widget, WeatherWidget)
self.assertEqual(len(cloned_wm), 1 + 1)
self.assertEqual(self.weather_prop_model.name, cloned_widget.title_visible)
|
class TestWidgetsInForm(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_add_attachment_widget(self):
pass
def test_add_attachment_widget_with_editable_association(self):
pass
def test_add_super_grid_widget(self):
pass
def test_add_filtered_grid_widget(self):
pass
def test_add_propertygrid_widget(self):
pass
def test_add_signature_widget(self):
pass
def test_weather_widget(self):
'''Testing the weather widget.'''
pass
| 10 | 1 | 25 | 1 | 23 | 0 | 1 | 0.01 | 1 | 15 | 14 | 0 | 9 | 14 | 9 | 84 | 230 | 20 | 209 | 68 | 199 | 2 | 132 | 67 | 122 | 5 | 3 | 2 | 13 |
140,611 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.ActivityClassification
|
class ActivityClassification(Enum):
"""The classification of Activities that are accepted by KE-chain.
.. versionadded:: 2.0
.. versionchanged:: 3.2
Add 'APP' environment for KE-chain versions > 3.1
.. versionchanged:: 3.14
Add 'FORM' envornment for KE-chain versions > v2021.10
:cvar WORKFLOW: Classification of the activity is WORKFLOW
:cvar CATALOG: Classification of the activity is CATALOG
:cvar APP: Classification of the activity is APP
:cvar FORM: Classification of the activity is FORM
"""
WORKFLOW = "WORKFLOW"
CATALOG = "CATALOG"
APP = "APP"
FORM = "FORM"
|
class ActivityClassification(Enum):
'''The classification of Activities that are accepted by KE-chain.
.. versionadded:: 2.0
.. versionchanged:: 3.2
Add 'APP' environment for KE-chain versions > 3.1
.. versionchanged:: 3.14
Add 'FORM' envornment for KE-chain versions > v2021.10
:cvar WORKFLOW: Classification of the activity is WORKFLOW
:cvar CATALOG: Classification of the activity is CATALOG
:cvar APP: Classification of the activity is APP
:cvar FORM: Classification of the activity is FORM
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 2.2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 20 | 4 | 5 | 5 | 4 | 11 | 5 | 5 | 4 | 0 | 1 | 0 | 0 |
140,612 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.ActivityRootNames
|
class ActivityRootNames(Enum):
"""The classification of Activities that are accepted by KE-chain.
.. versionadded:: 2.0
.. versionchanged:: 3.2
Add 'APP' environment for KE-chain versions > 3.1
.. versionchanged:: 3.14
Add 'FORM' environment for KE-chain versions >= v2021.10
:cvar WORKFLOW_ROOT: Root of the activity is WORKFLOW_ROOT
:cvar CATALOG_ROOT: Root of the activity is CATALOG_ROOT (below are CATALOG tasks)
:cvar APP_ROOT: Root of the activity is APP_ROOT (below are APP 'tasks' ie. 'screems')
"""
WORKFLOW_ROOT = "WORKFLOW_ROOT"
CATALOG_ROOT = "CATALOG_ROOT"
APP_ROOT = "APP_ROOT"
FORM_ROOT = "FORM_ROOT"
|
class ActivityRootNames(Enum):
'''The classification of Activities that are accepted by KE-chain.
.. versionadded:: 2.0
.. versionchanged:: 3.2
Add 'APP' environment for KE-chain versions > 3.1
.. versionchanged:: 3.14
Add 'FORM' environment for KE-chain versions >= v2021.10
:cvar WORKFLOW_ROOT: Root of the activity is WORKFLOW_ROOT
:cvar CATALOG_ROOT: Root of the activity is CATALOG_ROOT (below are CATALOG tasks)
:cvar APP_ROOT: Root of the activity is APP_ROOT (below are APP 'tasks' ie. 'screems')
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 18 | 3 | 5 | 5 | 4 | 10 | 5 | 5 | 4 | 0 | 1 | 0 | 0 |
140,613 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.ActivityStatus
|
class ActivityStatus(Enum):
"""The various Activity statuses that are accepted by KE-chain.
:cvar OPEN: status of activity is open
:cvar COMPLETED: status of activity is completed
"""
OPEN = "OPEN"
COMPLETED = "COMPLETED"
|
class ActivityStatus(Enum):
'''The various Activity statuses that are accepted by KE-chain.
:cvar OPEN: status of activity is open
:cvar COMPLETED: status of activity is completed
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1.33 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 9 | 2 | 3 | 3 | 2 | 4 | 3 | 3 | 2 | 0 | 1 | 0 | 0 |
140,614 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.ActivityType
|
class ActivityType(Enum):
"""The various Activity types that are accepted by KE-chain.
.. versionadded:: 2.0
:cvar TASK: a normal task
:cvar PROCESS: a subprocess (container) containing other tasks
"""
PROCESS = "PROCESS"
TASK = "TASK"
|
class ActivityType(Enum):
'''The various Activity types that are accepted by KE-chain.
.. versionadded:: 2.0
:cvar TASK: a normal task
:cvar PROCESS: a subprocess (container) containing other tasks
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1.67 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 11 | 3 | 3 | 3 | 2 | 5 | 3 | 3 | 2 | 0 | 1 | 0 | 0 |
140,615 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_utils.py
|
tests.test_utils.TestIsURL
|
class TestIsURL(TestCase):
def test_is_url_returns_true_on_valid_url(self):
addresses = [
"http://foobar.dk",
"http://foobar.museum/foobar",
"http://fo.com",
"http://FOO.com",
"http://foo.com/blah_blah",
"http://foo.com/blah_blah/",
"http://foo.com/blah_blah_(wikipedia)",
"http://foo.com/blah_blah_(wikipedia)_(again)",
"http://www.example.com/wpstyle/?p=364",
"https://www.example.com/foo/?bar=baz&inga=42&quux",
"https://www.example.com?bar=baz",
"http://✪df.ws/123",
"http://userid:password@example.com:8080",
"http://userid@example.com",
"http://userid@example.com:8080/",
"http://userid:password@example.com",
"http://142.42.1.1/",
"http://142.42.1.1:8080/",
"http://⌘.ws/",
"http://foo.com/blah_(wikipedia)#cite-1",
"http://foo.com/unicode_(✪)_in_parens",
"http://foo.com/(something)?after=parens",
"http://☺.damowmow.com/",
"http://code.google.com/events/#&product=browser",
"http://j.mp",
"ftp://foo.bar/baz",
"http://foo.bar/?q=Test%20URL-encoded%20stuff",
"http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com",
"http://1337.net",
"http://a.b-c.de",
"http://223.255.255.254",
"http://127.0.10.150",
"http://localhost",
"http://localhost:8000",
"http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html",
"http://[1080:0:0:0:8:800:200C:417A]/index.html",
"http://[3ffe:2a00:100:7031::1]",
"http://[1080::8:800:200C:417A]/foo",
"http://[::192.9.5.5]/ipng",
"http://[::FFFF:129.144.52.38]:80/index.html",
"http://[2010:836B:4179::836B:4179]",
]
for address in addresses:
with self.subTest(address):
self.assertTrue(is_url(address), f"should be a valid address: '{address}'")
def test_is_url_returns_False_on_failed_url(self):
failed_addresses = [
"http://foobar",
"foobar.dk",
"http://127.0.0/asdf",
"http://foobar.d",
"http://foobar.12",
"http://foobar",
"htp://foobar.com",
"http://foobar..com",
"http://fo..com",
"http://",
"http://.",
"http://..",
"http://../",
"http://?",
"http://??",
"http://??/",
"http://#",
"http://##",
"http://##/",
"http://foo.bar?q=Spaces should be encoded",
"//",
"//a",
"///a",
"///",
"http:///a",
"foo.com",
"rdar://1234",
"h://test",
"http:// shouldfail.com",
":// should fail",
"http://foo.bar/foo(bar)baz quux",
"ftps://foo.bar/",
"http://-error-.invalid/",
"http://a.b--c.de/",
"http://-a.b.co",
"http://a.b-.co",
"http://0.0.0.0",
"http://10.1.1.0",
"http://10.1.1.255",
"http://224.1.1.1",
"http://1.1.1.1.1",
"http://123.123.123",
"http://3628126748",
"http://.www.foo.bar/",
"http://www.foo.bar./",
"http://.www.foo.bar./",
"http://127.12.0.260",
'http://example.com/">user@example.com',
"http://[2010:836B:4179::836B:4179",
"http://2010:836B:4179::836B:4179",
"http://2010:836B:4179::836B:4179:80/index.html",
]
for address in failed_addresses:
with self.subTest(address):
self.assertFalse(is_url(address), f"should be a invalid address: '{address}'")
|
class TestIsURL(TestCase):
def test_is_url_returns_true_on_valid_url(self):
pass
def test_is_url_returns_False_on_failed_url(self):
pass
| 3 | 0 | 52 | 0 | 52 | 3 | 2 | 0.05 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 74 | 106 | 1 | 105 | 7 | 102 | 5 | 11 | 7 | 8 | 2 | 2 | 2 | 4 |
140,616 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_utils.py
|
tests.test_utils.TestIsEmail
|
class TestIsEmail(TestCase):
def test_is_email_returns_true_on_valid_url(self):
valid_addresses = [
"some@domain.org",
"email@example.com",
"firstname.lastname@example.com",
"email@subdomain.example.com",
"firstname+lastname@example.com",
"email@123.123.123.123",
"email@[123.123.123.123]",
'"email"@example.com',
"1234567890@example.com",
"email@example-one.com",
"_______@example.com",
"email@example.name",
"email@example.museum",
"email@example.co.jp",
"firstname-lastname@example.com",
]
for email in valid_addresses:
with self.subTest(email):
self.assertTrue(is_valid_email(email), f"should be a valid address: '{email}'")
def test_is_email_returns_false_on_invalid_url(self):
invalid_addresses = [
"plainaddress",
"#@%^%#$@#$@#.com",
"@example.com",
"Joe Smith <email@example.com>",
"email.example.com",
"email@example@example.com",
".email@example.com",
"email.@example.com",
"email..email@example.com",
"あいうえお@example.com",
"email@example.com (Joe Smith)",
"email@example",
"email@-example.com",
"email@example..com",
"Abc..123@example.com",
r"”(),:;<>[\]@example.com",
"just”not”right@example.com",
'this\\ is"really"not\allowed@example.com',
]
for email in invalid_addresses:
with self.subTest(email):
self.assertFalse(is_valid_email(email), f"should be an invalid address: '{email}'")
|
class TestIsEmail(TestCase):
def test_is_email_returns_true_on_valid_url(self):
pass
def test_is_email_returns_false_on_invalid_url(self):
pass
| 3 | 0 | 23 | 0 | 23 | 1 | 2 | 0.02 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 74 | 47 | 1 | 46 | 7 | 43 | 1 | 11 | 7 | 8 | 2 | 2 | 2 | 4 |
140,617 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_utils.py
|
tests.test_utils.TestEmpty
|
class TestEmpty(TestCase):
def test_singleton(self):
empty_1 = Empty()
empty_2 = Empty()
self.assertEqual(empty_1, empty_2)
self.assertIs(empty_1, empty_2)
self.assertIsNot(empty_1, Empty)
|
class TestEmpty(TestCase):
def test_singleton(self):
pass
| 2 | 0 | 7 | 1 | 6 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 73 | 8 | 1 | 7 | 4 | 5 | 0 | 7 | 4 | 5 | 1 | 2 | 0 | 1 |
140,618 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_utils.py
|
tests.test_utils.TestChunks
|
class TestChunks(TestCase):
def test_get_in_chunks(self):
chunks = get_in_chunks(
lst=list(range(77)),
chunk_size=9,
)
import types
self.assertIsInstance(chunks, types.GeneratorType)
chunks_list = list(chunks)
self.assertEqual(9, len(chunks_list))
|
class TestChunks(TestCase):
def test_get_in_chunks(self):
pass
| 2 | 0 | 12 | 3 | 9 | 0 | 1 | 0 | 1 | 2 | 0 | 0 | 1 | 0 | 1 | 73 | 13 | 3 | 10 | 5 | 7 | 0 | 7 | 5 | 4 | 1 | 2 | 0 | 1 |
140,619 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterTeam
|
class TestScopeFilterTeam(BaseTest._TestScopeFilter):
VALUE = "a2a0631b-d771-4807-bd22-c5ccde581e79"
VALUE_2 = "9bab05df-5597-4a7a-af65-73cc65fee22a"
INVALID_VALUE = 3
FIELD = "team__in"
ATTR = "team"
|
class TestScopeFilterTeam(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,620 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_property_value_filter.py
|
tests.test_property_value_filter.TestScopeFilterUnknown
|
class TestScopeFilterUnknown(BaseTest._TestScopeFilter):
VALUE = 1
VALUE_2 = 2
INVALID_VALUE = None
FIELD = "new_filter__type"
ATTR = "new_filter_type"
|
class TestScopeFilterUnknown(BaseTest._TestScopeFilter):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 79 | 6 | 0 | 6 | 6 | 5 | 0 | 6 | 6 | 5 | 0 | 3 | 0 | 0 |
140,621 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_retry.py
|
tests.test_retry.TestPykeRetry
|
class TestPykeRetry(TestCase):
def test_short_circuit_on_self_signed_cert_error(self):
"""Retry should return early if self signed cert verification fails"""
retry = PykeRetry(
total=RETRY_TOTAL,
connect=RETRY_ON_CONNECTION_ERRORS,
read=RETRY_ON_READ_ERRORS,
redirect=RETRY_ON_REDIRECT_ERRORS,
backoff_factor=RETRY_BACKOFF_FACTOR,
)
with self.assertRaises(MaxRetryError):
retry.increment(
error=SSLError(
"[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self signed"
" certificate"
)
)
|
class TestPykeRetry(TestCase):
def test_short_circuit_on_self_signed_cert_error(self):
'''Retry should return early if self signed cert verification fails'''
pass
| 2 | 1 | 17 | 1 | 15 | 1 | 1 | 0.06 | 1 | 2 | 1 | 0 | 1 | 0 | 1 | 73 | 18 | 1 | 16 | 3 | 14 | 1 | 5 | 3 | 3 | 1 | 2 | 1 | 1 |
140,622 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_scope.py
|
tests.test_scope.TestScopeEdit
|
class TestScopeEdit(TestBetamax):
"""
Test modifications to a scope.
"""
def setUp(self):
super().setUp()
testing_project = self.project
self.project = None
self.project_info = [{
"id": 0,
"name": "Project name",
"value": "Bike project wannabe",
"property_type": PropertyType.CHAR_VALUE,
},
{
"id": 1,
"name": "Project number",
"value": 12,
"property_type": PropertyType.INT_VALUE,
}]
self.scope = testing_project.clone()
def tearDown(self):
if self.scope:
self.scope.delete()
super().tearDown()
# 2.2.0+
# noinspection PyTypeChecker
def test_edit_scope(self):
# setUp
new_scope_name = "Pykechain testing (bike project)"
new_scope_description = (
"Project used to build a Bike. Part-time job is to also test Pykechain."
)
new_start_date = datetime.datetime(2018, 12, 5, tzinfo=None)
new_due_date = datetime.datetime(2018, 12, 8, tzinfo=None)
new_tags = ["tag_one", "tag_two"]
self.scope.edit(
name=new_scope_name,
description=new_scope_description,
tags=new_tags,
start_date=new_start_date,
due_date=new_due_date,
status=ScopeStatus.CLOSED,
category=ScopeCategory.TEMPLATE_SCOPE,
)
retrieved_project = self.client.scope(id=self.scope.id, status=ScopeStatus.CLOSED)
# testing
self.assertEqual(new_scope_name, retrieved_project.name)
self.assertEqual(new_scope_description, retrieved_project.description)
self.assertIn(
retrieved_project._json_data["start_date"],
("2018-12-05T00:00:00Z", "2018-12-05T00:00:00+00:00"),
)
self.assertIn(
retrieved_project._json_data["due_date"],
("2018-12-08T00:00:00Z", "2018-12-08T00:00:00+00:00"),
)
self.assertEqual(ScopeStatus.CLOSED, retrieved_project.status)
self.assertEqual(ScopeCategory.TEMPLATE_SCOPE, retrieved_project.category)
self.assertEqual(new_tags, retrieved_project.tags)
with self.assertRaises(IllegalArgumentError):
self.scope.edit(name=True)
with self.assertRaises(IllegalArgumentError):
self.scope.edit(description=new_start_date)
with self.assertRaises(IllegalArgumentError):
self.scope.edit(start_date="Yes, man!")
with self.assertRaises(IllegalArgumentError):
self.scope.edit(due_date="Wrong")
with self.assertRaises(IllegalArgumentError):
self.scope.edit(status="ILLEGAL_STATUS_WILL_CAUSE_ERR")
with self.assertRaises(IllegalArgumentError):
self.scope.edit(category="Ice scoop")
with self.assertRaises(IllegalArgumentError):
self.scope.edit(tags="tags must be a list of strings")
# test added due to #847 - providing no inputs overwrites values
def test_edit_scope_clearing_values(self):
# setUp
initial_name = "Pykechain testing (bike project)"
initial_description = (
"Project used to build a Bike. Part-time job is to also test Pykechain."
)
initial_start_date = datetime.datetime(2018, 12, 5, tzinfo=None)
initial_due_date = datetime.datetime(2018, 12, 8, tzinfo=None)
initial_tags = ["tag_one", "tag_two"]
team_one, team_two = self.client.teams()[:2]
self.scope.edit(
name=initial_name,
description=initial_description,
tags=initial_tags,
start_date=initial_start_date,
due_date=initial_due_date,
team=team_two,
)
# Edit without mentioning values, everything should stay the same
new_name = "Just Pykechain testing (bike project)"
self.scope.edit(name=new_name)
# testing
self.assertEqual(self.scope.name, new_name)
self.assertEqual(self.scope.description, initial_description)
self.assertEqual(
self.scope.start_date.strftime("%Y/%m/%d, %H:%M:%S"),
initial_start_date.strftime("%Y/%m/%d, %H:%M:%S"),
)
self.assertEqual(
self.scope.due_date.strftime("%Y/%m/%d, %H:%M:%S"),
initial_due_date.strftime("%Y/%m/%d, %H:%M:%S"),
)
self.assertEqual(self.scope.tags, initial_tags)
# Edit with clearing the values, name and status cannot be cleared
self.scope.edit(
name=None, description=None, tags=None, start_date=None, due_date=None, status=None
)
self.scope.refresh()
self.assertEqual(self.scope.name, new_name)
self.assertEqual(self.scope.description, "")
self.assertEqual(self.scope.start_date, None)
self.assertEqual(self.scope.due_date, None)
self.assertEqual(self.scope.tags, list())
# v2.3.3
def test_edit_scope_team(self):
"""Test capabilities of changing team scope"""
team_one, team_two = self.client.teams()[:2]
self.scope.edit(team=team_one)
self.assertEqual(self.scope.team, team_one)
self.scope.edit(team=team_two)
self.assertEqual(self.scope.team, team_two)
def test_edit_project_info(self):
self.scope.edit(project_info=self.project_info)
retrieved_project_info = self.scope.get_project_info()
self.assertIsInstance(retrieved_project_info, list)
self.assertListEqual(retrieved_project_info, self.project_info)
def test_clear_project_info_edit_project(self):
self.scope.set_project_info(project_info=self.project_info)
retrieved_project_info = self.scope.get_project_info()
self.assertIsInstance(retrieved_project_info, list)
self.assertListEqual(retrieved_project_info, self.project_info)
# clean up the project info
self.scope.edit(project_info=list())
retrieved_project_info = self.scope.get_project_info()
self.assertIsInstance(retrieved_project_info, list)
self.assertListEqual(retrieved_project_info, [])
def test_set_landing_page(self):
tasks = [
self.scope.activities()[0],
KEChainPages.DATA_MODEL,
]
for task in tasks:
with self.subTest(msg=task):
self.scope.set_landing_page(activity=task)
def test_get_landing_page(self):
landing_page = self.scope.get_landing_page_url()
self.assertIsNone(landing_page)
self.scope.set_landing_page(activity=self.scope.activities()[0])
landing_page = self.scope.get_landing_page_url()
self.assertIsInstance(landing_page, str)
self.assertTrue(is_url(self.client.api_root + landing_page))
def test_set_project_info(self):
self.scope.set_project_info(project_info=self.project_info)
retrieved_project_info = self.scope.get_project_info()
self.assertIsInstance(retrieved_project_info, list)
self.assertListEqual(retrieved_project_info, self.project_info)
def test_get_project_info(self):
retrieved_project_info = self.scope.get_project_info()
self.assertListEqual(retrieved_project_info, [])
self.scope.set_project_info(project_info=self.project_info)
retrieved_project_info = self.scope.get_project_info()
self.assertListEqual(retrieved_project_info, self.project_info)
def test_set_project_info_with_wrong_attributes(self):
with self.assertRaises(ValidationError):
self.scope.set_project_info(project_info={})
with self.assertRaises(ValidationError):
project_info_too_many_attributes = self.project_info
for prop_dict in project_info_too_many_attributes:
prop_dict['some_key'] = "some value"
self.scope.set_project_info(project_info=project_info_too_many_attributes)
with self.assertRaises(ValidationError):
for prop in self.project_info:
prop.pop('id')
self.scope.set_project_info(project_info=self.project_info)
def test_empty_project_info(self):
self.scope.set_project_info(project_info=self.project_info)
retrieved_project_info = self.scope.get_project_info()
self.assertIsInstance(retrieved_project_info, list)
self.assertListEqual(retrieved_project_info, self.project_info)
# clean up the project info
self.scope.set_project_info(project_info=list())
retrieved_project_info = self.scope.get_project_info()
self.assertIsInstance(retrieved_project_info, list)
self.assertListEqual(retrieved_project_info, [])
|
class TestScopeEdit(TestBetamax):
'''
Test modifications to a scope.
'''
def setUp(self):
pass
def tearDown(self):
pass
def test_edit_scope(self):
pass
def test_edit_scope_clearing_values(self):
pass
def test_edit_scope_team(self):
'''Test capabilities of changing team scope'''
pass
def test_edit_project_info(self):
pass
def test_clear_project_info_edit_project(self):
pass
def test_set_landing_page(self):
pass
def test_get_landing_page(self):
pass
def test_set_project_info(self):
pass
def test_get_project_info(self):
pass
def test_set_project_info_with_wrong_attributes(self):
pass
def test_empty_project_info(self):
pass
| 14 | 2 | 17 | 3 | 13 | 1 | 1 | 0.09 | 1 | 10 | 5 | 0 | 13 | 3 | 13 | 88 | 241 | 52 | 173 | 43 | 159 | 16 | 126 | 43 | 112 | 3 | 3 | 2 | 17 |
140,623 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_scope.py
|
tests.test_scope.TestScopeMembers
|
class TestScopeMembers(TestBetamax):
"""
Tests user assignment to a scope.
"""
DEFAULTS = {
ScopeRoles.MANAGER: [
"superuser",
"testmanager",
],
ScopeRoles.LEADMEMBER: [
"superuser",
"testlead",
],
ScopeRoles.SUPERVISOR: ["supervisor"],
ScopeRoles.MEMBER: [
"testuser",
],
}
def _reset_members(self):
"""Reset the scope members by removing all members and adding the defaults"""
[
self.project.remove_member(member=member["username"])
for member in self.project.members()
]
for role in [
ScopeRoles.MANAGER,
ScopeRoles.LEADMEMBER,
ScopeRoles.MEMBER,
ScopeRoles.SUPERVISOR,
]:
for member in self.DEFAULTS[role]:
self.project._update_scope_project_team(ScopeMemberActions.ADD, role, member)
def setUp(self):
super().setUp()
self._reset_members()
def tearDown(self):
self._reset_members()
super().tearDown()
def test_reset_members(self):
"""Test `_reset_members` method of the test class"""
self.assertTrue(True)
def test_members(self):
scope = self.project
# Helper function:
def get_member_names(**kwargs):
return [member["username"] for member in scope.members(**kwargs)]
all_members = set(get_member_names())
managers = set(get_member_names(is_manager=True))
supervisors = set(get_member_names(is_supervisor=True))
non_managers = set(get_member_names(is_manager=False))
leads = set(get_member_names(is_leadmember=True))
non_leads = set(get_member_names(is_leadmember=False))
basic_members = set(get_member_names(is_manager=False, is_leadmember=False))
self.assertEqual(5, len(all_members), msg=",".join(all_members))
self.assertTrue(
basic_members and leads and managers and supervisors,
msg="Test scope must have a member of every type!",
)
all_roles = basic_members | leads | managers | supervisors
remaining_non_leads = all_roles - leads
remaining_non_managers = all_roles - managers
self.assertSetEqual(
all_roles, all_members, msg="The sum of all roles should equal all members."
)
self.assertSetEqual(remaining_non_leads, non_leads)
self.assertSetEqual(remaining_non_managers, non_managers)
def test_add_member(self):
member_to_be_added = "anotheruser"
self.project.add_member(member_to_be_added)
self.project = self.client.scope(pk=self.project.id)
project_members = self.project.members()
# testing
self.assertTrue(member_to_be_added in [member["username"] for member in project_members])
def test_add_member_by_id(self):
member_id = 4
with self.assertRaises(IllegalArgumentError):
# noinspection PyTypeChecker
self.project.add_member(member_id)
def test_add_non_existing_member(self):
member_to_be_added = "Nobody"
with self.assertRaises(NotFoundError):
self.project.add_member(member_to_be_added)
def test_remove_member(self):
member_to_be_removed = "anotheruser"
# setUp
self.project.add_member(member_to_be_removed)
# testing
self.project.remove_member(member_to_be_removed)
self.project = self.client.scope(pk=self.project.id)
project_members = self.project.members()
self.assertTrue(
member_to_be_removed not in [member["username"] for member in project_members]
)
def test_add_manager(self):
manager_to_be_added = "anotheruser"
# testing
self.project.add_manager(manager_to_be_added)
self.project = self.client.scope(pk=self.project.id)
project_managers = self.project.members(is_manager=True)
self.assertTrue(
manager_to_be_added in [manager["username"] for manager in project_managers]
)
def test_remove_manager(self):
manager_to_be_removed = "anotheruser"
# setUp
self.project.add_manager(manager_to_be_removed)
# testing
self.project.remove_manager(manager_to_be_removed)
self.project = self.client.scope(pk=self.project.id)
project_managers = self.project.members(is_manager=True)
self.assertTrue(
manager_to_be_removed not in [manager["username"] for manager in project_managers]
)
project_managers = self.project.members(is_manager=False)
self.assertTrue(
manager_to_be_removed in [manager["username"] for manager in project_managers]
)
def test_add_leadmember(self):
leadmember_to_be_added = "anotheruser"
# testing
self.project.add_leadmember(leadmember_to_be_added)
self.project = self.client.scope(pk=self.project.id)
project_leadmembers = self.project.members(is_leadmember=True)
self.assertTrue(
leadmember_to_be_added
in [leadmember["username"] for leadmember in project_leadmembers]
)
def test_remove_leadmember(self):
leadmember_to_be_removed = "anotheruser"
# setUp
self.project.add_leadmember(leadmember_to_be_removed)
# testing
self.project.remove_leadmember(leadmember_to_be_removed)
self.project = self.client.scope(pk=self.project.id)
project_leadmembers = self.project.members(is_leadmember=True)
self.assertTrue(
leadmember_to_be_removed
not in [leadmember["username"] for leadmember in project_leadmembers]
)
project_leadmembers = self.project.members(is_leadmember=False)
self.assertTrue(
leadmember_to_be_removed
in [leadmember["username"] for leadmember in project_leadmembers]
)
def test_add_supervisor(self):
supervisor_to_be_added = "anotheruser"
# testing
self.project.add_supervisor(supervisor_to_be_added)
self.project = self.client.scope(pk=self.project.id)
project_supervisors = self.project.members(is_supervisor=True)
self.assertTrue(
supervisor_to_be_added
in [supervisor["username"] for supervisor in project_supervisors]
)
def test_remove_supervisor(self):
supervisor_to_be_removed = "anotheruser"
# setUp
self.project.add_supervisor(supervisor_to_be_removed)
# testing
self.project.remove_supervisor(supervisor_to_be_removed)
self.project = self.client.scope(pk=self.project.id)
project_supervisors = self.project.members(is_supervisor=True)
self.assertTrue(
supervisor_to_be_removed
not in [supervisor["username"] for supervisor in project_supervisors]
)
|
class TestScopeMembers(TestBetamax):
'''
Tests user assignment to a scope.
'''
def _reset_members(self):
'''Reset the scope members by removing all members and adding the defaults'''
pass
def setUp(self):
pass
def tearDown(self):
pass
def test_reset_members(self):
'''Test `_reset_members` method of the test class'''
pass
def test_members(self):
pass
def get_member_names(**kwargs):
pass
def test_add_member(self):
pass
def test_add_member_by_id(self):
pass
def test_add_non_existing_member(self):
pass
def test_remove_member(self):
pass
def test_add_manager(self):
pass
def test_remove_manager(self):
pass
def test_add_leadmember(self):
pass
def test_remove_leadmember(self):
pass
def test_add_supervisor(self):
pass
def test_remove_supervisor(self):
pass
| 17 | 3 | 10 | 0 | 8 | 1 | 1 | 0.13 | 1 | 6 | 4 | 0 | 15 | 1 | 15 | 90 | 189 | 23 | 147 | 49 | 130 | 19 | 98 | 49 | 81 | 3 | 3 | 2 | 18 |
140,624 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_scope.py
|
tests.test_scope.TestScopes
|
class TestScopes(TestBetamax):
"""
Test retrieval and scope attributes and methods.
"""
def test_scope_attributes(self):
attributes = [
"_client",
"_json_data",
"id",
"name",
"created_at",
"updated_at",
"ref",
"process",
"workflow_root",
"description",
"status",
"category",
"tags",
"start_date",
"due_date",
]
obj = self.project
for attribute in attributes:
with self.subTest(attribute):
self.assertTrue(
hasattr(obj, attribute),
f"Could not find '{attribute}' in the object: '{obj.__dict__.keys()}'",
)
def test_retrieve_scopes(self):
self.assertTrue(self.client.scopes())
def test_retrieve_scope_with_refs(self):
# setup
scope_ref = "bike-project"
scope_name = "Bike Project"
scope = self.client.scope(ref=scope_ref)
# testing
self.assertIsInstance(scope, Scope)
self.assertTrue(scope.name, scope_name)
def test_retrieve_scope_with_kwargs(self):
retrieve_scopes_with_kwargs = self.client.scopes(name__icontains="Bike")
self.assertTrue(retrieve_scopes_with_kwargs)
self.assertTrue(len(retrieve_scopes_with_kwargs) >= 1)
def test_retrieve_single_unknown(self):
with self.assertRaises(NotFoundError):
self.client.scope("123lladadwd")
def test_retrieve_single_multiple(self):
with self.assertRaises(MultipleFoundError):
self.client.scope()
def test_team_property_of_scope(self):
"""Test for the property 'team' of a scope."""
team = self.project.team
self.assertIsNone(team)
def test_side_bar(self):
side_bar_manager = self.project.side_bar()
self.assertIsInstance(side_bar_manager, SideBarManager)
def test_root_properties(self):
for value in [
self.project.workflow_root_process,
self.project.catalog_root_process,
self.project.app_root_process,
self.project.product_root_model,
self.project.product_root_instance,
self.project.catalog_root_model,
self.project.catalog_root_instance,
]:
with self.subTest(""):
self.assertIsNotNone(value)
|
class TestScopes(TestBetamax):
'''
Test retrieval and scope attributes and methods.
'''
def test_scope_attributes(self):
pass
def test_retrieve_scopes(self):
pass
def test_retrieve_scope_with_refs(self):
pass
def test_retrieve_scope_with_kwargs(self):
pass
def test_retrieve_single_unknown(self):
pass
def test_retrieve_single_multiple(self):
pass
def test_team_property_of_scope(self):
'''Test for the property 'team' of a scope.'''
pass
def test_side_bar(self):
pass
def test_root_properties(self):
pass
| 10 | 2 | 8 | 0 | 7 | 0 | 1 | 0.1 | 1 | 3 | 3 | 0 | 9 | 0 | 9 | 84 | 81 | 13 | 62 | 20 | 52 | 6 | 35 | 20 | 25 | 2 | 3 | 2 | 11 |
140,625 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_services.py
|
tests.test_services.TestServiceSetup
|
class TestServiceSetup(TestBetamax):
"""Only for test setup, will create a service with a debug script
:ivar service: service with a debug.py script
"""
def _create_service(self, name=None):
"""Creates a service with name, and adds a test_upload_script.py (debugging)"""
# setUp
new_service = self.project.create_service(
name=name or "Test upload script to service",
description="Only used for testing - you can safely remove this",
environment_version=ServiceEnvironmentVersion.PYTHON_3_12,
)
upload_path = os.path.join(
self.test_assets_dir,
"tests",
"files",
"test_upload_script_to_service",
"test_upload_script.py",
)
# testing
new_service.upload(pkg_path=upload_path)
self.assertEqual(
new_service._json_data["script_file_name"], "test_upload_script.py"
)
return new_service
def setUp(self):
super().setUp()
self.test_assets_dir = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
)
self.service = self._create_service()
def tearDown(self):
self.service.delete()
super().tearDown()
|
class TestServiceSetup(TestBetamax):
'''Only for test setup, will create a service with a debug script
:ivar service: service with a debug.py script
'''
def _create_service(self, name=None):
'''Creates a service with name, and adds a test_upload_script.py (debugging)'''
pass
def setUp(self):
pass
def tearDown(self):
pass
| 4 | 2 | 10 | 0 | 9 | 1 | 1 | 0.21 | 1 | 2 | 1 | 2 | 3 | 2 | 3 | 78 | 39 | 5 | 28 | 8 | 24 | 6 | 14 | 8 | 10 | 1 | 3 | 0 | 3 |
140,626 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_services.py
|
tests.test_services.TestServicesWithCustomUploadedService
|
class TestServicesWithCustomUploadedService(TestServiceSetup):
def test_update_service_incorrect_name(self):
with self.assertRaises(IllegalArgumentError):
self.service.edit(name=1234)
def test_update_service_incorrect_description(self):
with self.assertRaises(IllegalArgumentError):
self.service.edit(description=True)
def test_update_service_incorrect_version(self):
with self.assertRaises(IllegalArgumentError):
self.service.edit(version=["2.0"])
def test_service_refresh_from_kechain(self):
version_after = "-latest"
self.service.edit(version=version_after)
self.service.refresh()
self.assertEqual(self.service.version, version_after)
def test_get_executions_of_service(self):
self.assertTrue(len(self.service.get_executions()) >= 0)
def test_create_and_delete_service(self):
service_name = "Test service creation"
new_service = self.project.create_service(service_name)
self.assertTrue(new_service.name, service_name)
self.assertTrue(new_service)
# tearDown
new_service.delete()
with self.assertRaisesRegex(NotFoundError, "fit criteria"):
self.project.service(pk=new_service.id)
def test_create_service_with_wrong_service_type(self):
with self.assertRaisesRegex(
IllegalArgumentError, "must be an option from enum"
):
self.project.create_service(
name="This service type does not exist", service_type="RUBY_SCRIPT"
)
def test_create_service_with_wrong_environment_version(self):
with self.assertRaisesRegex(
IllegalArgumentError, "must be an option from enum"
):
self.project.create_service(
name="This env version does not exist", environment_version="0.0"
)
def test_save_service_script(self):
# setUp
with temp_chdir() as target_dir:
self.service.save_as(target_dir=target_dir)
self.assertEqual(len(os.listdir(target_dir)), 1)
def test_upload_script_to_service(self):
# setUp
upload_path = os.path.join(
self.test_assets_dir,
"tests",
"files",
"test_upload_script_to_service",
"test_upload_script.py",
)
# testing
self.service.upload(pkg_path=upload_path)
# second upload modified filename
self.assertRegex(
self.service._json_data["script_file_name"], r"test_upload_\w+.py"
)
def test_upload_script_to_service_with_wrong_path(self):
# setUp
upload_path = os.path.join(
self.test_assets_dir,
"tests",
"files",
"uploaded",
"this_file_does_exists.not",
)
# testing
with self.assertRaisesRegex(
OSError, "Could not locate python package to upload in"
):
self.service.upload(pkg_path=upload_path)
|
class TestServicesWithCustomUploadedService(TestServiceSetup):
def test_update_service_incorrect_name(self):
pass
def test_update_service_incorrect_description(self):
pass
def test_update_service_incorrect_version(self):
pass
def test_service_refresh_from_kechain(self):
pass
def test_get_executions_of_service(self):
pass
def test_create_and_delete_service(self):
pass
def test_create_service_with_wrong_service_type(self):
pass
def test_create_service_with_wrong_environment_version(self):
pass
def test_save_service_script(self):
pass
def test_upload_script_to_service(self):
pass
def test_upload_script_to_service_with_wrong_path(self):
pass
| 12 | 0 | 7 | 0 | 6 | 1 | 1 | 0.1 | 1 | 3 | 2 | 0 | 11 | 0 | 11 | 89 | 88 | 14 | 67 | 18 | 55 | 7 | 43 | 17 | 31 | 1 | 4 | 1 | 11 |
140,627 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_sidebar.py
|
tests.test_sidebar.TestSideBar
|
class TestSideBar(TestBetamax):
def setUp(self):
super().setUp()
self.scope = self.project.clone(asynchronous=False) # type: Scope
del self.project
self.manager = SideBarManager(scope=self.scope)
self.scope_uri = f"#/scopes/{self.scope.id}"
self.scope_activity_uri = f"{self.scope_uri}/{SubprocessDisplayMode.ACTIVITIES}"
self.default_button_config = {
"title": "new button",
"icon": "bookmark",
"uri": f"{self.scope_uri}/{KEChainPages.DATA_MODEL}",
}
def tearDown(self):
self.scope.delete()
super().tearDown()
def test_manager(self):
side_bar_manager = SideBarManager(scope=self.scope)
self.assertIsInstance(side_bar_manager, SideBarManager)
def test_singleton_manager_per_scope(self):
manager_1 = SideBarManager(scope=self.scope)
manager_2 = self.scope.side_bar()
self.assertTrue(
manager_1 is manager_2,
msg="There are 2 different manager objects while the same object is expected.",
)
def test_loading_of_existing_buttons(self):
for scope in self.client.scopes(status=ScopeStatus.ACTIVE):
scope.side_bar()
def test_override_sidebar_property(self):
value = self.manager.override_sidebar
self.assertIsInstance(value, bool)
self.assertFalse(value)
self.manager.override_sidebar = True
self.assertTrue(self.manager.override_sidebar)
def test_create_button(self):
new_button = self.manager.create_button(**self.default_button_config)
self.assertIsInstance(new_button, SideBarButton)
self.assertTrue(new_button is self.manager[-1])
self.assertIsInstance(new_button.__repr__(), str)
# noinspection PyTypeChecker
def test_create_button_incorrect_arguments(self):
with self.assertRaises(IllegalArgumentError):
SideBarButton(self.manager, order="3")
with self.assertRaises(IllegalArgumentError):
SideBarButton(self.manager, order=1, title=False)
with self.assertRaises(IllegalArgumentError):
SideBarButton(self.manager, order=1, title="Button", icon=32)
with self.assertRaises(IllegalArgumentError):
SideBarButton(self.manager, order=1, title="Button", icon="pennant", uri=44)
with self.assertRaises(IllegalArgumentError):
SideBarButton(
self.manager,
order=1,
title="Button",
icon="pennant",
uri="http://www.google.com",
uri_target="any",
)
with self.assertRaises(IllegalArgumentError):
SideBarButton(
self.manager,
order=1,
title="Button",
icon="pennant",
uri="http://www.google.com",
icon_mode="best",
)
with self.assertRaises(IllegalArgumentError):
SideBarButton(
self.manager,
order=1,
title="Button",
icon="pennant",
uri="http://www.google.com",
random="unsupported keyword",
)
def test_edit_button(self):
custom_name = "Custom Dutch name"
new_button = self.manager.create_button(**self.default_button_config)
new_button.edit(
display_icon="pennant",
displayName_nl=custom_name,
)
new_button.refresh()
self.assertEqual("pennant", new_button.display_icon)
self.assertEqual(
custom_name, new_button._other_attributes.get("displayName_nl")
)
def test_delete_button(self):
new_button = self.manager.create_button(**self.default_button_config)
new_button.delete()
self.assertNotIn(new_button, self.manager)
def test_get_button(self):
new_button = self.manager.create_button(**self.default_button_config)
button_from_index = self.manager[0]
button_from_title = self.manager["new button"]
button_from_button = self.manager[new_button]
self.assertIs(new_button, button_from_index)
self.assertIs(new_button, button_from_title)
self.assertIs(new_button, button_from_button)
with self.assertRaises(IndexError):
# noinspection PyStatementEffect
self.manager[3]
with self.assertRaises(NotFoundError):
# noinspection PyStatementEffect
self.manager["unused button title"]
def test_remove_button(self):
new_button = self.manager.create_button(**self.default_button_config)
self.manager.remove(new_button)
self.assertTrue(len(self.manager) == 0)
def test_insert_button(self):
button_1 = self.manager.create_button(order=0, **self.default_button_config)
button_2 = self.manager.create_button(order=1, **self.default_button_config)
button_3 = self.manager.create_button(order=2, **self.default_button_config)
self.manager.insert(0, button_2)
self.assertListEqual(
[button_2, button_1, button_3],
list(self.manager),
)
def test_bulk_add_buttons(self):
buttons = [
{
"displayName": "activity button",
"displayIcon": "bookmark",
"uri": f"{self.scope_activity_uri}/{self.scope.activities()[0].id}",
},
{
"displayName": "ke-chain page",
"displayIcon": "university",
"uri": f"{self.scope_uri}/{KEChainPages.EXPLORER}",
},
{
"displayName": "external button",
"displayIcon": "google",
"uri": "https://www.google.com",
},
]
new_buttons = self.manager.add_buttons(
buttons=buttons,
override_sidebar=True,
)
self.assertIsInstance(new_buttons, list)
self.assertTrue(all(isinstance(b, SideBarButton) for b in new_buttons))
self.assertTrue(len(self.manager) == 3)
def test_context_manager(self):
with SideBarManager(scope=self.scope) as bulk_creation_manager:
bulk_creation_manager.override_sidebar = True
bulk_creation_manager.add_task_button(
activity=self.scope.activities()[0],
icon="bookmark",
)
bulk_creation_manager.add_external_button(
url="https://www.google.com",
icon="google",
title="Google",
)
bulk_creation_manager.add_ke_chain_page(
page_name=KEChainPages.WORK_BREAKDOWN,
icon="sitemap",
)
self.assertEqual(
0,
len(self.scope.options.get("customNavigation", list())),
msg="During bulk creation of buttons, KE-chain should not be updated yet.",
)
self.assertEqual(
3,
len(self.scope.options["customNavigation"]),
msg="After closing the context `with`, update should be performed.",
)
updated_side_bar_buttons = self.scope.options.get("customNavigation")
self.assertTrue(
len(updated_side_bar_buttons) == 3,
msg="At the end of bulk creation, the buttons must have been created.",
)
self.assertTrue(self.scope.options.get("overrideSideBar"))
def test_load_buttons(self):
# setup: create a custom button
with self.scope.side_bar() as sbm:
sbm.override_sidebar = True
sbm.add_ke_chain_page(KEChainPages.WORK_BREAKDOWN)
# Reload side-bar from KE-chain
self.scope.side_bar().refresh()
# testing: delete original button (this tests the "load") and add another one
with self.scope.side_bar() as sbm:
for button in sbm:
sbm.delete_button(button)
sbm.override_sidebar = True
sbm.add_ke_chain_page(KEChainPages.TASKS)
self.assertEqual(1, len(self.scope.options.get("customNavigation")))
def test_attributes_button(self):
display_name_nl = "Het data model"
button_title = "New button"
# Check whether all attributes are retrieved and set
with self.scope.side_bar() as sbm:
sbm.add_ke_chain_page(
page_name=KEChainPages.DATA_MODEL,
title=button_title,
displayName_nl=display_name_nl,
)
# Reload side-bar from KE-chain
self.scope.side_bar().refresh()
sbm = self.scope.side_bar()
found = False
for button in sbm: # type: SideBarButton
if button._other_attributes.get("displayName_nl") == display_name_nl:
found = True
self.assertTrue(found)
def test_attributes_sidebar(self):
sbm = self.scope.side_bar()
# Check starting condition
self.assertFalse(sbm.override_sidebar)
# Set value
sbm.override_sidebar = True
# Reload side-bar from KE-chain
sbm.refresh()
# Test attributes
self.assertTrue(sbm.override_sidebar)
def test_alignment(self):
# Check whether all attributes are retrieved and set
with self.scope.side_bar() as sbm:
sbm.add_ke_chain_page(
page_name=KEChainPages.CONTEXTS,
alignment=SidebarItemAlignment.TOP,
)
sbm.add_ke_chain_page(
page_name=KEChainPages.FORMS,
alignment=SidebarItemAlignment.BOTTOM,
)
# Reload side-bar from KE-chain
self.scope.side_bar().refresh()
found = [False, False]
sbm = self.scope.side_bar()
for button in sbm: # type: SideBarButton
if button.display_name == KEChainPageLabels[KEChainPages.FORMS]:
self.assertEqual(button.alignment, SidebarItemAlignment.BOTTOM)
found[0] = True
if button.display_name == KEChainPageLabels[KEChainPages.CONTEXTS]:
self.assertEqual(button.alignment, SidebarItemAlignment.TOP)
found[1] = True
self.assertTrue(all(found))
def test_side_bar_permissions(self):
# Check whether all attributes are retrieved and set
with self.scope.side_bar() as sbm:
sbm.add_ke_chain_page(
page_name=KEChainPages.FORMS,
minimum_access_level=SidebarAccessLevelOptions.IS_MEMBER,
)
sbm.add_ke_chain_page(
page_name=KEChainPages.CONTEXTS,
minimum_access_level=SidebarAccessLevelOptions.IS_LEAD_MEMBER,
)
sbm.add_ke_chain_page(
page_name=KEChainPages.CATALOG_FORMS,
minimum_access_level=SidebarAccessLevelOptions.IS_SUPERVISOR,
)
sbm.add_ke_chain_page(
page_name=KEChainPages.WORKFLOWS,
minimum_access_level=SidebarAccessLevelOptions.IS_MANAGER,
)
sbm.add_ke_chain_page(
page_name=KEChainPages.DETAIL,
)
# Reload side-bar from KE-chain
self.scope.side_bar().refresh()
found = [False, False, False, False, False]
sbm = self.scope.side_bar()
for button in sbm: # type: SideBarButton
if button.display_name == KEChainPageLabels[KEChainPages.FORMS]:
self.assertTrue(
button.minimum_access_level == SidebarAccessLevelOptions.IS_MEMBER
)
found[0] = True
if button.display_name == KEChainPageLabels[KEChainPages.CONTEXTS]:
self.assertTrue(
button.minimum_access_level
== SidebarAccessLevelOptions.IS_LEAD_MEMBER
)
found[1] = True
if button.display_name == KEChainPageLabels[KEChainPages.CATALOG_FORMS]:
self.assertTrue(
button.minimum_access_level
== SidebarAccessLevelOptions.IS_SUPERVISOR
)
found[2] = True
if button.display_name == KEChainPageLabels[KEChainPages.WORKFLOWS]:
self.assertTrue(
button.minimum_access_level == SidebarAccessLevelOptions.IS_MANAGER
)
found[3] = True
if button.display_name == KEChainPageLabels[KEChainPages.DETAIL]:
self.assertTrue(
button.minimum_access_level == SidebarAccessLevelOptions.IS_MEMBER
)
found[4] = True
self.assertTrue(all(found))
def test_sidebar_card_object(self):
"""Aim to create a sidebard card."""
target_dict = {
"itemType": "CARD",
"align": "top",
"showCloseAction": True,
"showActionButton": True,
"actionButtonUri": "https://changelog.md",
"actionButtonUriTarget": "_new",
"actionButtonName": "Discover more",
"actionButtonName_nl": "Ontdek meer",
"displayText": "This project ...",
"displayText_nl": "Dit project ...",
"displayTextAlign": "left",
"showBackground": True,
"minimumAccessLevel": "is_member",
"maximumAccessLevel": "is_supervisor",
}
sidebar_card = SideBarCard(
side_bar_manager=self.manager,
alignment=SidebarItemAlignment.TOP,
show_close_action=True,
show_action_button=True,
action_button_name="Discover more",
action_button_uri="https://changelog.md",
action_button_uri_target=URITarget.NEW,
display_text="This project ...",
display_text_align=Alignment.LEFT,
show_background=True,
minimum_access_level=SidebarAccessLevelOptions.IS_MEMBER,
maximum_access_level=SidebarAccessLevelOptions.IS_SUPERVISOR,
displayText_nl="Dit project ...",
actionButtonName_nl="Ontdek meer",
)
card_dict = sidebar_card.as_dict()
self.maxDiff = None
self.assertDictEqual(target_dict, card_dict)
def test_sidebar_card_creation_inside_the_manager(self):
with self.scope.side_bar() as sbm:
sbm.create_card(
display_text="Foo Bar",
show_action_button=False,
)
# Reload side-bar from KE-chain
self.scope.side_bar().refresh()
sbm = self.scope.side_bar()
self.assertTrue(len(sbm) == 1)
for item in sbm:
self.assertEqual(item.display_text, "Foo Bar")
self.assertFalse(hasattr(item, "order"))
self.assertFalse(item.show_action_button)
|
class TestSideBar(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_manager(self):
pass
def test_singleton_manager_per_scope(self):
pass
def test_loading_of_existing_buttons(self):
pass
def test_override_sidebar_property(self):
pass
def test_create_button(self):
pass
def test_create_button_incorrect_arguments(self):
pass
def test_edit_button(self):
pass
def test_delete_button(self):
pass
def test_get_button(self):
pass
def test_remove_button(self):
pass
def test_insert_button(self):
pass
def test_bulk_add_buttons(self):
pass
def test_context_manager(self):
pass
def test_load_buttons(self):
pass
def test_attributes_button(self):
pass
def test_attributes_sidebar(self):
pass
def test_alignment(self):
pass
def test_side_bar_permissions(self):
pass
def test_sidebar_card_object(self):
'''Aim to create a sidebard card.'''
pass
def test_sidebar_card_creation_inside_the_manager(self):
pass
| 23 | 1 | 18 | 3 | 15 | 1 | 2 | 0.07 | 1 | 17 | 12 | 0 | 22 | 6 | 22 | 97 | 425 | 77 | 330 | 69 | 307 | 23 | 185 | 63 | 162 | 7 | 3 | 2 | 36 |
140,628 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.Alignment
|
class Alignment(Enum):
"""The alignment options for attachment viewer, navigation bar widgets and service widgets.
:cvar LEFT: Aligned to the left
:cvar CENTER: Aligned to the center
:cvar RIGHT: Aligned to the right
"""
LEFT = "left"
CENTER = "center"
RIGHT = "right"
|
class Alignment(Enum):
'''The alignment options for attachment viewer, navigation bar widgets and service widgets.
:cvar LEFT: Aligned to the left
:cvar CENTER: Aligned to the center
:cvar RIGHT: Aligned to the right
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1.25 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 2 | 11 | 2 | 4 | 4 | 3 | 5 | 4 | 4 | 3 | 0 | 1 | 0 | 0 |
140,629 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_signature.py
|
tests.test_signature.TestPropertySignatureProperty
|
class TestPropertySignatureProperty(TestBetamax):
def setUp(self):
super().setUp()
self.wheel_model = self.project.model("Wheel")
self.bike = self.project.model("Bike")
self.test_files_dir = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
)
self.test_image = create_test_image_file()
self.file_name = "__TEST_SIGNATURE_STORED_FILE"
self.signature_stored_file = self.client.create_stored_file(
name=self.file_name,
scope=self.project,
classification=StoredFileClassification.SCOPED,
filepath=self.test_image,
description="__TEST_STORED_FILE_DESCRIPTION",
)
self.test_signature_property_model: SignatureProperty = self.bike.add_property(
name=f"__Test signature property @ {datetime.now()}",
property_type=PropertyType.SIGNATURE_VALUE,
description="Description of test signature property",
unit="no unit",
default_value=None,
)
def tearDown(self):
self.test_signature_property_model.delete()
self.signature_stored_file.delete()
super().tearDown()
def test_create_signature_property(self):
# implicit inside the setUp
pass
def test_upload_new_signature_to_property(self):
self.test_signature_property_model.value = self.signature_stored_file
self.test_signature_property_model.refresh()
self.assertIsNotNone(self.test_signature_property_model.value)
|
class TestPropertySignatureProperty(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create_signature_property(self):
pass
def test_upload_new_signature_to_property(self):
pass
| 5 | 0 | 10 | 1 | 8 | 0 | 1 | 0.03 | 1 | 5 | 3 | 0 | 4 | 8 | 4 | 79 | 42 | 7 | 34 | 13 | 29 | 1 | 20 | 12 | 15 | 1 | 3 | 0 | 4 |
140,630 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_stored_file.py
|
tests.test_stored_file.TestStoredFilesBaseTestCase
|
class TestStoredFilesBaseTestCase(TestBetamax):
def setUp(self):
super().setUp()
self.test_files_dir = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
)
self.pdf_file_name = "test_upload_pdf.pdf"
self.upload_pdf_path = os.path.join(
self.test_files_dir,
"tests",
"files",
"test_upload_image_to_attachment_property",
self.pdf_file_name,
)
self.image_file_name = "test_upload_image.png"
self.upload_image_path = os.path.join(
self.test_files_dir,
"tests",
"files",
"test_upload_image_to_attachment_property",
self.image_file_name,
)
self.pdf_stored_file_name = "__TEST_TEMPORARY_STORED_PDF_FILE"
self.image_stored_file_name = "__TEST_TEMPORARY_STORED_IMAGE_FILE"
self.stored_pdf_file = self.client.create_stored_file(
name=self.pdf_stored_file_name,
scope=self.project,
classification=StoredFileClassification.SCOPED,
filepath=self.upload_pdf_path,
description="__TEST_STORED_FILE_DESCRIPTION",
)
self.stored_image_file = self.client.create_stored_file(
name=self.image_stored_file_name,
scope=self.project,
classification=StoredFileClassification.SCOPED,
filepath=self.upload_image_path,
description="__TEST_STORED_FILE_DESCRIPTION",
)
self.added_stored_file = None
def tearDown(self):
if self.stored_pdf_file:
self.stored_pdf_file.delete()
if self.stored_image_file:
self.stored_image_file.delete()
if self.added_stored_file:
self.added_stored_file.delete()
super().tearDown()
|
class TestStoredFilesBaseTestCase(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
| 3 | 0 | 24 | 1 | 23 | 0 | 3 | 0 | 1 | 2 | 1 | 2 | 2 | 11 | 2 | 77 | 49 | 2 | 47 | 14 | 44 | 0 | 21 | 13 | 18 | 4 | 3 | 1 | 5 |
140,631 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_stored_file.py
|
tests.test_stored_file.TestStoredFilesDownload
|
class TestStoredFilesDownload(TestStoredFilesBaseTestCase):
def test_download_pdf_from_stored_file(self):
with temp_chdir() as target_dir:
filepath = os.path.join(target_dir, "test_upload_pdf.pdf")
self.stored_pdf_file.save_as(filename=filepath)
def test_download_image_from_stored_file(self):
with temp_chdir() as target_dir:
filepath = os.path.join(target_dir, "test_upload_image.png")
self.stored_image_file.save_as(filename=filepath, size=StoredFileSize.M)
image = Image.open(filepath)
self.assertEqual(image.width, 200)
self.assertEqual(image.height, 105)
self.assertEqual(image.format, "JPEG")
def test_upload_and_download_of_json_file(self):
with temp_chdir() as target_dir:
the_json = {"foo": "bar", "hello": "world"}
self.stored_pdf_file._upload_json(content=the_json)
downloaded_json = self.stored_pdf_file.json_load()
self.assertDictEqual(the_json, downloaded_json)
|
class TestStoredFilesDownload(TestStoredFilesBaseTestCase):
def test_download_pdf_from_stored_file(self):
pass
def test_download_image_from_stored_file(self):
pass
def test_upload_and_download_of_json_file(self):
pass
| 4 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 3 | 0 | 3 | 80 | 21 | 2 | 19 | 12 | 15 | 0 | 19 | 9 | 15 | 1 | 4 | 1 | 3 |
140,632 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_tags.py
|
tests.test_tags.ConcreteTagsBase
|
class ConcreteTagsBase(TagsMixin):
"""
Dummy implementation of the edit method allows for instantiation of the TagsMixin class.
"""
def edit(self, tags=None, *args, **kwargs):
return None
|
class ConcreteTagsBase(TagsMixin):
'''
Dummy implementation of the edit method allows for instantiation of the TagsMixin class.
'''
def edit(self, tags=None, *args, **kwargs):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 7 | 7 | 1 | 3 | 2 | 1 | 3 | 3 | 2 | 1 | 1 | 1 | 0 | 1 |
140,633 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_tags.py
|
tests.test_tags.TestTags
|
class TestTags(TestCase):
tags = ["one", "two", "three"]
def setUp(self):
self.obj = ConcreteTagsBase()
self.obj._tags = self.tags
def tearDown(self):
pass
def test_edit(self):
self.assertIsNone(self.obj.edit(tags=self.tags))
def test_getter(self):
self.assertTrue(len(self.tags) == len(self.obj.tags))
self.assertTrue(sorted(self.tags) == sorted(self.obj.tags))
def test_setter(self):
new_tags = ["1", "2", "3"]
self.obj.tags = new_tags
self.assertTrue(len(new_tags) == len(self.obj.tags))
self.assertTrue(sorted(new_tags) == sorted(self.obj.tags))
def test_setter_duplicate(self):
self.obj.add_tag(tag="one")
self.assertTrue(len(self.obj.tags) == 3)
def test_setter_none(self):
self.obj.tags = None
self.assertIsInstance(self.obj.tags, list)
self.assertTrue(len(self.obj.tags) == 0)
def test_setter_not_an_iterable(self):
with self.assertRaises(IllegalArgumentError):
self.obj.tags = "four"
def test_setter_not_a_string(self):
with self.assertRaises(ValueError):
self.obj.tags = [1, 2, 3]
def test_remove_tag(self):
self.obj.remove_tag(tag="two")
self.assertNotIn("two", self.obj.tags)
def test_remove_tag_failure(self):
with self.assertRaises(IllegalArgumentError):
self.obj.remove_tag(tag="just a flesh wound")
def test_add_tag(self):
self.obj.add_tag(tag="four")
self.assertIn("four", self.obj.tags)
def test_has_tag_true(self):
self.assertTrue(self.obj.has_tag(tag="three"))
def test_has_tag_false(self):
self.assertFalse(self.obj.has_tag(tag="ten"))
|
class TestTags(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_edit(self):
pass
def test_getter(self):
pass
def test_setter(self):
pass
def test_setter_duplicate(self):
pass
def test_setter_none(self):
pass
def test_setter_not_an_iterable(self):
pass
def test_setter_not_a_string(self):
pass
def test_remove_tag(self):
pass
def test_remove_tag_failure(self):
pass
def test_add_tag(self):
pass
def test_has_tag_true(self):
pass
def test_has_tag_false(self):
pass
| 15 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 4 | 2 | 0 | 14 | 1 | 14 | 86 | 61 | 18 | 43 | 18 | 28 | 0 | 43 | 18 | 28 | 1 | 2 | 1 | 14 |
140,634 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_tags.py
|
tests.test_tags.TestTagsActivity
|
class TestTagsActivity(TestBetamax):
tags = ["one", "two", "three"]
def setUp(self):
super().setUp()
self.task = self.project.activity(name="SubTask") # type: Activity
def tearDown(self):
self.task.tags = None
super().tearDown()
def test_activity_tags(self):
# setup
new_tags = ["four", "five", "six"]
self.task.tags = new_tags
reloaded = self.project.activity(pk=self.task.id)
self.assertEqual(len(new_tags), len(reloaded.tags))
self.assertListEqual(sorted(new_tags), sorted(reloaded.tags))
def test_activity_tags_may_be_emptied(self):
# setup
self.task.tags = []
reloaded_task = self.project.activity(pk=self.task.id)
self.assertEqual(0, len(reloaded_task.tags))
|
class TestTagsActivity(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_activity_tags(self):
pass
def test_activity_tags_may_be_emptied(self):
pass
| 5 | 0 | 5 | 1 | 4 | 1 | 1 | 0.17 | 1 | 1 | 0 | 0 | 4 | 1 | 4 | 79 | 26 | 6 | 18 | 10 | 13 | 3 | 18 | 10 | 13 | 1 | 3 | 0 | 4 |
140,635 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_tags.py
|
tests.test_tags.TestTagsScope
|
class TestTagsScope(TestBetamax):
def test_scope_tags(self):
"""test to retrieve the tags for a scope"""
# setup
saved_tags = self.project.tags
# test
scope_tags = ["a", "list", "of-tags"]
self.project.edit(tags=scope_tags)
self.assertListEqual(scope_tags, self.project.tags)
self.assertTrue(len(scope_tags) == len(self.project.tags))
self.assertTrue(sorted(scope_tags) == sorted(self.project.tags))
# teardown
self.project.edit(tags=saved_tags)
def test_scope_tags_may_be_emptied(self):
# setup
saved_tags = self.project.tags
# test
self.project.edit(tags=[])
self.assertListEqual(self.project.tags, [])
# teardown
self.project.edit(tags=saved_tags)
|
class TestTagsScope(TestBetamax):
def test_scope_tags(self):
'''test to retrieve the tags for a scope'''
pass
def test_scope_tags_may_be_emptied(self):
pass
| 3 | 1 | 13 | 3 | 7 | 4 | 1 | 0.5 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 77 | 27 | 6 | 14 | 6 | 11 | 7 | 14 | 6 | 11 | 1 | 3 | 0 | 2 |
140,636 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_teams.py
|
tests.test_teams.TestTeams
|
class TestTeams(TestBetamax):
def setUp(self):
super().setUp()
self.required_kwargs = dict(
name="_test team", user=self.client.user("testuser") # type: User
)
self.team = self.client.create_team(**self.required_kwargs) # type: Team
def tearDown(self):
self.team.delete()
super().tearDown()
def test_create_team(self):
self.assertIsInstance(self.team, Team)
self.assertEqual(len(self.team.members()), 1)
self.assertEqual(self.team.name, "_test team")
def test_create_team_with_inputs(self):
# setUp
landing_page = f"#/scopes/{self.project.id}"
new_team = self.client.create_team(
description="This is the description",
options=dict(
landingPage=landing_page,
),
is_hidden=True,
**self.required_kwargs,
)
# testing
self.assertEqual(new_team.description, "This is the description")
self.assertDictEqual(new_team.options, {"landingPage": landing_page})
self.assertTrue(new_team.is_hidden)
# tearDown
new_team.delete()
def test_create_team_incorrect_inputs(self):
with self.assertRaises(IllegalArgumentError):
self.client.create_team(description=1, **self.required_kwargs)
with self.assertRaises(IllegalArgumentError):
self.client.create_team(options=f"#/scopes/{self.project.id}", **self.required_kwargs)
with self.assertRaises(IllegalArgumentError):
self.client.create_team(is_hidden="False", **self.required_kwargs)
def test_retrieve_teams(self):
self.assertTrue(self.client.teams())
def test_retrieve_single_unknown_team(self):
with self.assertRaises(NotFoundError):
self.client.team("This is not a existing team name for sure")
def test_retrieve_single_multiple_team_raises_error(self):
with self.assertRaises(MultipleFoundError):
self.client.team()
def test_retrieve_single_team_with_known_teamname(self):
self.assertTrue(self.client.team(name="_test team"))
def test_retrieve_members(self):
members = self.team.members()
self.assertTrue(len(members) > 0)
def test_retrieve_managers_members_owners(self):
all_members = self.team.members()
manager = self.team.members(role=TeamRoles.MANAGER)
self.assertTrue(len(manager) >= 0)
owner = self.team.members(role=TeamRoles.OWNER)
self.assertTrue(len(owner) > 0)
members = self.team.members(role=TeamRoles.MEMBER)
self.assertTrue(len(owner) > 0)
self.assertEqual(len(all_members), len(manager) + len(owner) + len(members))
def test_retrieve_member_with_invalid_role(self):
with self.assertRaisesRegex(IllegalArgumentError, "must be an option from enum"):
self.team.members(role="FOOBARROLE")
def test_add_and_remove_member(self):
members = self.team.members()
a_user = self.client.user(username="anotheruser")
self.team.add_members([a_user.id], role=TeamRoles.MEMBER)
self.assertIn(
a_user.id, [member.get("pk") for member in self.team.members(role=TeamRoles.MEMBER)]
)
self.team.remove_members([a_user.id])
self.assertListEqual(members, self.team.members())
def test_add_scope_to_team(self):
# setup
self.project.edit(team=self.team.id)
self.assertEqual(self.project.team, self.team)
# check
team_scopes = self.team.scopes()
self.assertEqual([t.id for t in team_scopes], [self.project.id])
def test_team_attributes(self):
attributes = ["_client", "_json_data", "id", "name", "created_at", "updated_at", "ref"]
obj = self.team
for attribute in attributes:
self.assertTrue(
hasattr(obj, attribute),
f"Could not find '{attribute}' in the object: '{obj.__dict__}'",
)
def test_team_edit(self):
# setUp
options = dict(landingPage=f"#/scopes/{self.project.id}")
self.team.edit(
name="renamed team",
description="My team description",
options=options,
is_hidden=True,
)
# testing
self.assertEqual(self.team.name, "renamed team")
self.assertEqual(self.team.description, "My team description")
self.assertDictEqual(self.team.options, options)
self.assertTrue(self.team.is_hidden)
# noinspection PyTypeChecker
def test_team_edit_wrong_inputs(self):
with self.assertRaises(IllegalArgumentError):
self.team.edit(name=123)
with self.assertRaises(IllegalArgumentError):
self.team.edit(description=False)
with self.assertRaises(IllegalArgumentError):
self.team.edit(options="New scope")
with self.assertRaises(IllegalArgumentError):
self.team.edit(is_hidden=1)
|
class TestTeams(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create_team(self):
pass
def test_create_team_with_inputs(self):
pass
def test_create_team_incorrect_inputs(self):
pass
def test_retrieve_teams(self):
pass
def test_retrieve_single_unknown_team(self):
pass
def test_retrieve_single_multiple_team_raises_error(self):
pass
def test_retrieve_single_team_with_known_teamname(self):
pass
def test_retrieve_members(self):
pass
def test_retrieve_managers_members_owners(self):
pass
def test_retrieve_member_with_invalid_role(self):
pass
def test_add_and_remove_member(self):
pass
def test_add_scope_to_team(self):
pass
def test_team_attributes(self):
pass
def test_team_edit(self):
pass
def test_team_edit_wrong_inputs(self):
pass
| 18 | 0 | 7 | 1 | 6 | 1 | 1 | 0.13 | 1 | 7 | 5 | 0 | 17 | 2 | 17 | 92 | 142 | 31 | 103 | 34 | 85 | 13 | 84 | 34 | 66 | 2 | 3 | 1 | 18 |
140,637 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_users.py
|
tests.test_users.TestCreateUsers
|
class TestCreateUsers(TestBetamax):
def test_create_a_new_user(self):
"""Create a new user.
! You need to delete this one by hand as we cannot yet delete a user
using the API. And basically we also do not want that.
"""
payload = dict(
username="__delete_me",
email="hostmaster+newuser@ke-works.com",
name="__Nieuwe Gebruiker made for a pykechain test - safe to delete",
language_code=LanguageCodes.DUTCH,
timezone=str(pytz.timezone("Europe/Amsterdam")),
)
self.client.create_user(**payload)
def test_create_a_new_user_and_reset_password(self):
"""Create a new user.
! You need to delete this one by hand as we cannot yet delete a user
using the API. And basically we also do not want that.
"""
payload = dict(
username="__delete_me",
email="hostmaster+newuser@ke-works.com",
name="__Nieuwe Gebruiker made for a pykechain test - safe to delete",
language_code=LanguageCodes.DUTCH,
timezone=str(pytz.timezone("Europe/Amsterdam")),
send_passwd_link=True,
)
self.client.create_user(**payload)
|
class TestCreateUsers(TestBetamax):
def test_create_a_new_user(self):
'''Create a new user.
! You need to delete this one by hand as we cannot yet delete a user
using the API. And basically we also do not want that.
'''
pass
def test_create_a_new_user_and_reset_password(self):
'''Create a new user.
! You need to delete this one by hand as we cannot yet delete a user
using the API. And basically we also do not want that.
'''
pass
| 3 | 2 | 15 | 1 | 10 | 4 | 1 | 0.4 | 1 | 3 | 1 | 0 | 2 | 0 | 2 | 77 | 31 | 3 | 20 | 5 | 17 | 8 | 7 | 5 | 4 | 1 | 3 | 0 | 2 |
140,638 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_users.py
|
tests.test_users.TestUsers
|
class TestUsers(TestBetamax):
def test_retrieve_users(self):
self.assertTrue(self.client.users())
def test_retrieve_single_unknown_user(self):
with self.assertRaises(NotFoundError):
self.client.user("123lladadwd")
def test_user_attributes(self):
attributes = [
"_client",
"_json_data",
"id",
"name",
"created_at",
"updated_at",
"username",
"timezone",
"language",
"email",
]
obj = self.client.users()[0]
for attribute in attributes:
with self.subTest(msg=attribute):
self.assertTrue(
hasattr(obj, attribute),
f"Could not find '{attribute}' in the object: '{obj.__dict__}'",
)
def test_retrieve_single_multiple_user_raises_error(self):
with self.assertRaises(MultipleFoundError):
self.client.user()
def test_retrieve_single_user_with_known_id(self):
self.assertTrue(self.client.user(pk=1))
def test_retrieve_single_user_with_known_username(self):
self.assertTrue(self.client.user(username="testuser"))
def test_retrieve_user_timezone(self):
user_retrieved = self.client.user(username="testuser")
timezone_retrieved = user_retrieved.timezone
self.assertIn(timezone_retrieved.zone, ["Atlantic/Cape_Verde", "UTC"])
def test_retrieve_user_name(self):
user_retrieved = self.client.user(username="testuser")
name_retrieved = user_retrieved.name
self.assertIn(name_retrieved, ["User Test", ""])
def test_retrieve_default_name(self):
user_retrieved = self.client.user(username="testuser")
default_name = user_retrieved.default_name
self.assertIsInstance(default_name, str)
self.assertIn(default_name, user_retrieved.username)
def test_retrieve_user_email(self):
user_retrieved = self.client.user(username="testuser")
email_retrieved = user_retrieved.email
self.assertEqual("a@b.nl", email_retrieved)
def test_retrieve_user_language(self):
user_retrieved = self.client.user(username="testuser")
language_retrieved = user_retrieved.language
self.assertIn(language_retrieved, LanguageCodes.values())
def test_now_in_my_timezone(self):
user_retrieved = self.client.user(username="testuser")
now = user_retrieved.now_in_my_timezone()
import datetime
self.assertIsInstance(now, datetime.datetime)
|
class TestUsers(TestBetamax):
def test_retrieve_users(self):
pass
def test_retrieve_single_unknown_user(self):
pass
def test_user_attributes(self):
pass
def test_retrieve_single_multiple_user_raises_error(self):
pass
def test_retrieve_single_user_with_known_id(self):
pass
def test_retrieve_single_user_with_known_username(self):
pass
def test_retrieve_user_timezone(self):
pass
def test_retrieve_user_name(self):
pass
def test_retrieve_default_name(self):
pass
def test_retrieve_user_email(self):
pass
def test_retrieve_user_language(self):
pass
def test_now_in_my_timezone(self):
pass
| 13 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 5 | 3 | 0 | 12 | 0 | 12 | 87 | 72 | 13 | 59 | 29 | 45 | 0 | 45 | 29 | 31 | 2 | 3 | 2 | 13 |
140,639 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_stored_file.py
|
tests.test_stored_file.TestStoredFiles
|
class TestStoredFiles(TestBetamax):
def setUp(self):
super().setUp()
self.test_files_dir = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
)
self.upload_path = os.path.join(
self.test_files_dir,
"tests",
"files",
"test_upload_image_to_attachment_property",
"test_upload_image.png",
)
self.name = "__TEST_STORED_FILE"
self.stored_file = self.client.create_stored_file(
name=self.name,
scope=self.project,
classification=StoredFileClassification.SCOPED,
filepath=self.upload_path,
description="__TEST_STORED_FILE_DESCRIPTION",
)
self.added_stored_file = None
def tearDown(self):
if self.stored_file:
self.stored_file.delete()
if self.added_stored_file:
self.added_stored_file.delete()
super().tearDown()
def test_add_stored_file(self):
name = "__TEST_ADD_STORED_FILE"
self.client.create_stored_file(
name=name,
scope=self.project,
category=StoredFileCategory.REFERENCED,
classification=StoredFileClassification.SCOPED,
filepath=self.upload_path,
)
self.added_stored_file = self.client.stored_file(name=name)
self.assertEqual(self.added_stored_file.category, StoredFileCategory.REFERENCED)
self.assertEqual(
self.added_stored_file.classification, StoredFileClassification.SCOPED
)
self.assertIsInstance(self.added_stored_file, StoredFile)
def test_retrieve_stored_file(self):
existing_file = self.client.stored_file(
classification=StoredFileClassification.SCOPED
)
self.assertEqual(existing_file.category, StoredFileCategory.GLOBAL)
self.assertEqual(existing_file.name, self.name)
self.assertIsInstance(existing_file, StoredFile)
def test_retrieve_stored_files(self):
existing_files = self.client.stored_files(
classification=StoredFileClassification.SCOPED
)
self.assertEqual(len(existing_files), 1)
self.assertEqual(
existing_files[0].classification, StoredFileClassification.SCOPED
)
self.assertEqual(existing_files[0].category, StoredFileCategory.GLOBAL)
self.assertEqual(existing_files[0].name, self.name)
self.assertIsInstance(existing_files[0], StoredFile)
def test_delete_stored_file(self):
self.assertIsInstance(self.client.stored_file(name=self.name), StoredFile)
self.stored_file.delete()
with self.assertRaises(NotFoundError):
self.client.stored_file(name=self.name)
self.stored_file = None
def test_edit_name_stored_file(self):
self.stored_file.edit(name="__TEST_EDIT_NAME")
self.assertEqual(self.stored_file.name, "__TEST_EDIT_NAME")
def test_edit_stored_file_attributes(self):
self.stored_file.edit(
description="__TEST_EDIT_DESCRIPTION",
classification=StoredFileClassification.GLOBAL,
category=StoredFileCategory.REFERENCED,
scope=None,
)
self.assertEqual(
self.stored_file.classification, StoredFileClassification.GLOBAL
)
self.assertEqual(self.stored_file.category, StoredFileCategory.REFERENCED)
self.assertEqual(self.stored_file.scope, None)
|
class TestStoredFiles(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_add_stored_file(self):
pass
def test_retrieve_stored_file(self):
pass
def test_retrieve_stored_files(self):
pass
def test_delete_stored_file(self):
pass
def test_edit_name_stored_file(self):
pass
def test_edit_stored_file_attributes(self):
pass
| 9 | 0 | 11 | 1 | 10 | 0 | 1 | 0 | 1 | 5 | 4 | 0 | 8 | 6 | 8 | 83 | 96 | 14 | 82 | 18 | 73 | 0 | 47 | 17 | 38 | 3 | 3 | 1 | 10 |
140,640 |
KE-works/pykechain
|
KE-works_pykechain/pykechain/enums.py
|
pykechain.enums.CardWidgetImageValue
|
class CardWidgetImageValue(Enum):
"""
Image for the CardWidget.
.. versionadded:: 3.0
:cvar CUSTOM_IMAGE: "Custom image"
:cvar NO_IMAGE: "No image"
"""
CUSTOM_IMAGE = "Custom image"
NO_IMAGE = "No image"
|
class CardWidgetImageValue(Enum):
'''
Image for the CardWidget.
.. versionadded:: 3.0
:cvar CUSTOM_IMAGE: "Custom image"
:cvar NO_IMAGE: "No image"
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 12 | 3 | 3 | 3 | 2 | 6 | 3 | 3 | 2 | 0 | 1 | 0 | 0 |
140,641 |
KE-works/pykechain
|
KE-works_pykechain/tests/test_workflows.py
|
tests.test_workflows.TestWorkflowMethods
|
class TestWorkflowMethods(TestBetamax):
def setUp(self):
super().setUp()
self.catalog_workflow: Workflow = self.client.workflow(
"Simple Workflow", category=WorkflowCategory.CATALOG
)
self.workflow = self.project.import_workflow(
workflow=self.catalog_workflow,
name="__TEST Imported Simple Flow from Catalog",
)
def tearDown(self):
super().tearDown()
try:
self.workflow.delete()
except (NotFoundError, ForbiddenError):
# we pass this silently as workflow delete when the
# cassettes are irrelevant and returns a 404 NotFoundError
pass
def test_edit_workflow_description(self):
new_description = "foo bar"
self.workflow.edit(description=new_description)
self.assertEqual(self.workflow.description, new_description)
def test_workflow_in_and_activate(self):
self.workflow.deactivate()
self.assertFalse(self.workflow.active)
self.workflow.activate()
self.assertTrue(self.workflow.active)
def test_create_delete_status_and_create_delete_workflow_transition(self):
"""Test to create a transition on a workflow.
- tests creation of status on workflow
- tests deletion of status
- tests deletion of transition on workflow
"""
test_status = self.workflow.create_status(
name="__TEST DONE", category=StatusCategory.DONE
)
test_transition = self.workflow.transition(test_status.name)
self.workflow.delete_transition(test_transition)
from_status = self.workflow.create_status(
name="__TEST FROM", category=StatusCategory.TODO
)
from_transition = self.workflow.transition(from_status.name)
self.workflow.delete_transition(from_transition)
new_transition = self.workflow.create_transition(
name="___test transition",
to_status=test_status,
transition_type=TransitionType.DIRECTED,
from_status=[from_status],
)
self.workflow.delete_transition(new_transition)
test_status.delete()
from_status.delete()
def test_workflow_status_order(self):
cloned_wf = self.workflow.clone(
name="___cloned_workflow_status_order", target_scope=self.workflow.scope_id
)
try:
status_ids = [s.id for s in deepcopy(cloned_wf.statuses)]
reversed_status_ids = list(reversed(status_ids))
cloned_wf.status_order = reversed_status_ids
self.assertListEqual(
reversed_status_ids, check_list_of_base(cloned_wf.status_order, Status)
)
finally:
cloned_wf.delete()
def test_workflow_unlink_and_link_transitions(self):
transitions = deepcopy(self.workflow.transitions)
the_transition_to_unlink = transitions[-1]
# unlink
self.workflow.unlink_transitions([the_transition_to_unlink])
self.assertListEqual(self.workflow.transitions, transitions[:-1])
# relink
self.workflow.link_transitions([the_transition_to_unlink])
self.assertListEqual(self.workflow.transitions, transitions)
|
class TestWorkflowMethods(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_edit_workflow_description(self):
pass
def test_workflow_in_and_activate(self):
pass
def test_create_delete_status_and_create_delete_workflow_transition(self):
'''Test to create a transition on a workflow.
- tests creation of status on workflow
- tests deletion of status
- tests deletion of transition on workflow
'''
pass
def test_workflow_status_order(self):
pass
def test_workflow_unlink_and_link_transitions(self):
pass
| 8 | 1 | 12 | 1 | 9 | 1 | 1 | 0.14 | 1 | 10 | 7 | 0 | 7 | 2 | 7 | 82 | 88 | 14 | 65 | 21 | 57 | 9 | 46 | 21 | 38 | 2 | 3 | 1 | 8 |
140,642 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_property_reference.py
|
tests.models.test_property_reference.TestPropertyStatusReferences
|
class TestPropertyStatusReferences(TestBetamax):
def setUp(self):
super().setUp()
root = self.project.model(name="Product")
self.part = self.project.create_model(
name="TEST_STATUS_REFERENCE_PART",
parent=root,
multiplicity=Multiplicity.ONE,
)
self.status_ref_prop_model = self.part.add_property(
name="status ref", property_type=PropertyType.STATUS_REFERENCES_VALUE
)
self.status_ref_prop_instance = self.part.instance().property(
name=self.status_ref_prop_model.name
)
self.status_1: Status = Status.get(client=self.client, name="To Do")
self.status_2: Status = Status.get(client=self.client, name="Done")
def tearDown(self):
if self.part:
self.part.delete()
super().tearDown()
def test_create(self):
self.assertIsInstance(self.status_ref_prop_model, StatusReferencesProperty)
def test_value_model(self):
self.status_ref_prop_model.value = [self.status_1]
self.assertIsNotNone(self.status_ref_prop_model.value)
self.assertEqual(self.status_ref_prop_model.value[0].id, self.status_1.id)
self.assertEqual(len(self.status_ref_prop_model.value), 1)
def test_no_value_model(self):
self.assertIsNone(self.status_ref_prop_model.value)
def test_value_instance(self):
self.status_ref_prop_instance.value = [self.status_1]
self.assertIsNotNone(self.status_ref_prop_instance.value)
self.assertEqual(self.status_ref_prop_instance.value[0].id, self.status_1.id)
self.assertEqual(len(self.status_ref_prop_instance.value), 1)
def test_no_value_instance(self):
self.assertIsNone(self.status_ref_prop_instance.value)
def test_multiple_values(self):
self.status_ref_prop_instance.value = [self.status_1, self.status_2]
self.assertEqual(len(self.status_ref_prop_instance.value), 2)
self.assertIn(
self.status_1.id,
[value.id for value in self.status_ref_prop_instance.value],
)
self.assertIn(
self.status_2.id,
[value.id for value in self.status_ref_prop_instance.value],
)
|
class TestPropertyStatusReferences(TestBetamax):
def setUp(self):
pass
def tearDown(self):
pass
def test_create(self):
pass
def test_value_model(self):
pass
def test_no_value_model(self):
pass
def test_value_instance(self):
pass
def test_no_value_instance(self):
pass
def test_multiple_values(self):
pass
| 9 | 0 | 6 | 1 | 6 | 0 | 1 | 0 | 1 | 5 | 4 | 0 | 8 | 6 | 8 | 83 | 59 | 11 | 48 | 15 | 39 | 0 | 34 | 15 | 25 | 2 | 3 | 1 | 9 |
140,643 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_representations.py
|
tests.models.test_representations.TestUseCameraScannerInputRepresentationForCharProperties
|
class TestUseCameraScannerInputRepresentationForCharProperties(
Bases._TestPropertyRepresentation
):
property_type = PropertyType.CHAR_VALUE
representation_class = CameraScannerInputRepresentation
value = True
new_value = False
|
class TestUseCameraScannerInputRepresentationForCharProperties(
Bases._TestPropertyRepresentation
):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 84 | 7 | 0 | 7 | 7 | 4 | 0 | 5 | 5 | 4 | 0 | 5 | 0 | 0 |
140,644 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_representations.py
|
tests.models.test_representations.TestUseCameraScannerInputRepresentationForFloatAreaProperties
|
class TestUseCameraScannerInputRepresentationForFloatAreaProperties(
Bases._TestPropertyRepresentation
):
property_type = PropertyType.FLOAT_VALUE
representation_class = CameraScannerInputRepresentation
value = True
new_value = False
|
class TestUseCameraScannerInputRepresentationForFloatAreaProperties(
Bases._TestPropertyRepresentation
):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 84 | 7 | 0 | 7 | 7 | 4 | 0 | 5 | 5 | 4 | 0 | 5 | 0 | 0 |
140,645 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_representations.py
|
tests.models.test_representations.TestUseCameraScannerInputRepresentationForIntegerAreaProperties
|
class TestUseCameraScannerInputRepresentationForIntegerAreaProperties(
Bases._TestPropertyRepresentation
):
property_type = PropertyType.INT_VALUE
representation_class = CameraScannerInputRepresentation
value = True
new_value = False
|
class TestUseCameraScannerInputRepresentationForIntegerAreaProperties(
Bases._TestPropertyRepresentation
):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 84 | 7 | 0 | 7 | 7 | 4 | 0 | 5 | 5 | 4 | 0 | 5 | 0 | 0 |
140,646 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_representations.py
|
tests.models.test_representations.TestUseCameraScannerInputRepresentationForTextAreaCharProperties
|
class TestUseCameraScannerInputRepresentationForTextAreaCharProperties(
Bases._TestPropertyRepresentation
):
property_type = PropertyType.TEXT_VALUE
representation_class = CameraScannerInputRepresentation
value = True
new_value = False
|
class TestUseCameraScannerInputRepresentationForTextAreaCharProperties(
Bases._TestPropertyRepresentation
):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 84 | 7 | 0 | 7 | 7 | 4 | 0 | 5 | 5 | 4 | 0 | 5 | 0 | 0 |
140,647 |
KE-works/pykechain
|
KE-works_pykechain/tests/models/test_representations.py
|
tests.models.test_representations.TestUsePropertyNameRepresentationForActivityReferences
|
class TestUsePropertyNameRepresentationForActivityReferences(
Bases._TestPropertyRepresentation
):
property_type = PropertyType.ACTIVITY_REFERENCES_VALUE
representation_class = UsePropertyNameRepresentation
value = True
new_value = False
|
class TestUsePropertyNameRepresentationForActivityReferences(
Bases._TestPropertyRepresentation
):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 84 | 7 | 0 | 7 | 7 | 4 | 0 | 5 | 5 | 4 | 0 | 5 | 0 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.