diff --git a/lobster/tools/python/python.py b/lobster/tools/python/python.py index 496bff68..24583057 100755 --- a/lobster/tools/python/python.py +++ b/lobster/tools/python/python.py @@ -500,7 +500,6 @@ def main(): if options.out: with open(options.out, "w", encoding="UTF-8") as fd: lobster_write(fd, schema, "lobster_python", items) - fd.write("\n") print("Written output for %u items to %s" % (len(items), options.out)) else: diff --git a/test-system/lobster-python/multiple_identical_function_names.output b/test-system/lobster-python/multiple_identical_function_names.output index 31c4f397..b738e651 100644 --- a/test-system/lobster-python/multiple_identical_function_names.output +++ b/test-system/lobster-python/multiple_identical_function_names.output @@ -103,4 +103,3 @@ Written output for 6 items to multiple_identical_function_names.lobster "schema": "lobster-imp-trace", "version": 3 } - diff --git a/test-unit/test_items.py b/test-unit/test_items.py index 420701f9..e074ba1a 100644 --- a/test-unit/test_items.py +++ b/test-unit/test_items.py @@ -4,7 +4,7 @@ from hashlib import sha1 from lobster.location import Location -class SetUp(unittest.TestCase): +class SetUp(unittest.TestCase): mock_namespace = "mock_namespace" mock_tag = "mock_tag" mock_framework = "mock_framework" @@ -14,12 +14,12 @@ class SetUp(unittest.TestCase): mock_status = "active" mock_language = "mock_language" mock_location = create_autospec(Location, instance=True) - tracing_tag = Tracing_Tag(mock_namespace, mock_tag) + tracing_tag = Tracing_Tag(mock_namespace, mock_tag) item = Item(tracing_tag, mock_location) requirement = Requirement(tracing_tag, mock_location, mock_framework, mock_kind, mock_name, mock_text, mock_status) implementation = Implementation(tracing_tag, mock_location, mock_language, mock_kind, mock_name) activity = Activity(tracing_tag, mock_location, mock_framework, mock_kind) - + def set_location_data(self, location_type): if location_type == "file": location_data = { @@ -45,18 +45,18 @@ def set_location_data(self, location_type): } elif location_type == "void": location_data = { - "kind": location_type + "kind": location_type } return location_data -class TestTracingTag(unittest.TestCase): +class TestTracingTag(unittest.TestCase): def test_key(self): expected_key = "mock_namespace mock_tag" actual_key = SetUp.tracing_tag.key() self.assertEqual(expected_key, actual_key) def test_to_json(self): - expected_json = "mock_namespace mock_tag" + expected_json = "mock_namespace mock_tag" actual_json = SetUp.tracing_tag.to_json() self.assertEqual(expected_json, actual_json) @@ -66,7 +66,6 @@ def test_from_json(self, mock_from_text): expected_namespace = "namespace" expected_rest_value = "string" expected_result = SetUp.tracing_tag - mock_from_text.return_value = expected_result result = SetUp.tracing_tag.from_json(json_input) @@ -74,26 +73,26 @@ def test_from_json(self, mock_from_text): mock_from_text.assert_called_once_with(expected_namespace, expected_rest_value) self.assertEqual(result, expected_result) - def test_from_text_with_version(self): - text = "mock_tag@version" + def test_from_text_with_version(self): + text = "mock_tag@version" expected_namespace = "mock_namespace" expected_tag = "mock_tag" expected_version = "version" - + result = SetUp.tracing_tag.from_text(SetUp.tracing_tag.namespace, text) - + self.assertEqual(result.namespace, expected_namespace) self.assertEqual(result.tag, expected_tag) self.assertEqual(result.version, expected_version) - + def test_from_text_without_version(self): namespace = "namespace" text = "tag" expected_tag = "tag" expected_version = None - + result = SetUp.tracing_tag.from_text(namespace, text) - + self.assertEqual(result.namespace, namespace) self.assertEqual(result.tag, expected_tag) self.assertEqual(result.version, expected_version) @@ -106,59 +105,59 @@ def test_from_text_invalid_text(self): with self.assertRaises(AssertionError): SetUp.tracing_tag.from_text("namespace", 123) - def test_hash(self): + def test_hash(self): hash_val = SetUp.tracing_tag.hash() hfunc = sha1() hfunc.update(SetUp.tracing_tag.key().encode("UTF-8")) expected_hash = hfunc.hexdigest() self.assertEqual(hash_val, expected_hash) -class TestItem(unittest.TestCase): - def test_set_level_valid_string(self): - mock_level = "mock_level" - +class TestItem(unittest.TestCase): + def test_set_level_valid_string(self): + mock_level = "mock_level" + SetUp.item.set_level(mock_level) self.assertEqual(SetUp.item.level, mock_level) - + def test_set_level_invalid_string(self): invalid_level = 10 - - with self.assertRaises(AssertionError): + + with self.assertRaises(AssertionError): result = SetUp.item.set_level(invalid_level) - def test_error(self): - mock_message = "mock_message" - + def test_error(self): + mock_message = "mock_message" + SetUp.item.error(mock_message) self.assertIn(mock_message, SetUp.item.messages) self.assertTrue(SetUp.item.messages) @patch("lobster.items.Tracing_Tag.key") - def test_add_tracing_target(self, mock_key): - mock_target = SetUp.tracing_tag + def test_add_tracing_target(self, mock_key): + mock_target = SetUp.tracing_tag expected_result = "mock_namespace mock_tag" - + mock_key.return_value = expected_result - + SetUp.item.add_tracing_target(mock_target) self.assertIn(mock_target, SetUp.item.unresolved_references) self.assertIn(expected_result, SetUp.item.unresolved_references_cache) - def test_perform_source_checks(self): - mock_valid_source_info = {"key": "value"} + def test_perform_source_checks(self): + mock_valid_source_info = {"key": "value"} - try: - SetUp.item.perform_source_checks(mock_valid_source_info) + try: + SetUp.item.perform_source_checks(mock_valid_source_info) except AssertionError: self.fail("perform_source_checks() raised AssertionError unexpectedly!") - def test_perform_source_checks_with_invalid_type(self): + def test_perform_source_checks_with_invalid_type(self): mock_invalid_source_info = ["not", "a", "dict"] with self.assertRaises(AssertionError): - SetUp.item.perform_source_checks(mock_invalid_source_info) + SetUp.item.perform_source_checks(mock_invalid_source_info) @patch("lobster.items.Tracing_Tag.key") def test_determine_status_ok(self, mock_key): @@ -168,7 +167,7 @@ def test_determine_status_ok(self, mock_key): SetUp.item.just_down = [] SetUp.item.just_global = [] SetUp.item.messages = [] - SetUp.item.has_error = False + SetUp.item.has_error = False SetUp.item.level = "level1" expected_result = "mock_namespace mock_tag" mock_key.return_value = expected_result @@ -181,18 +180,18 @@ def test_determine_status_ok(self, mock_key): } } stab = { - mock_key() : SetUp.item + mock_key() : SetUp.item } SetUp.item.determine_status(config, stab) self.assertEqual(SetUp.item.tracing_status, Tracing_Status.PARTIAL) - + def test_determine_status_missing_up_reference(self): mock_namespace = "mock_namespace" - mock_tag = "mock_tag" + mock_tag = "mock_tag" SetUp.item.level = "level1" SetUp.item.just_up = [] - SetUp.item.just_global = [] + SetUp.item.just_global = [] SetUp.item.ref_up = [] config = { "level1": { @@ -212,7 +211,7 @@ def test_determine_status_missing_up_reference(self): def test_determine_status_missing_down_reference(self): mock_namespace = "mock_namespace" - mock_tag = "mock_tag" + mock_tag = "mock_tag" SetUp.item.level = "level1" SetUp.item.just_down = [] SetUp.item.just_global = [] @@ -233,10 +232,10 @@ def test_determine_status_missing_down_reference(self): self.assertEqual(SetUp.item.tracing_status, Tracing_Status.MISSING) self.assertIn("missing reference to level1", SetUp.item.messages) - @patch("lobster.items.Item.set_level") - def test_additional_data_from_json_valid_data(self, mock_set_level): + @patch("lobster.items.Item.set_level") + def test_additional_data_from_json_valid_data(self, mock_set_level): mock_level = "mock_level" - mock_set_level.return_value = "mock_level" + mock_set_level.return_value = "mock_level" mock_data = { "refs": ["mock_namespace mock_tag"], "ref_up": ["mock refup"], @@ -259,7 +258,7 @@ def test_additional_data_from_json_valid_data(self, mock_set_level): self.assertEqual(SetUp.item.just_down, ["down1"]) self.assertEqual(SetUp.item.just_global, ["global1"]) self.assertEqual(SetUp.item.tracing_status, Tracing_Status.OK) - + def test_additional_data_from_json_invalid_level(self): level = 123 data = {} @@ -283,7 +282,7 @@ def test_additional_data_from_json_invalid_schema_version(self): with self.assertRaises(AssertionError): SetUp.item.additional_data_from_json(level, data, schema_version) - + @patch("lobster.items.Tracing_Tag.to_json") def test_to_json(self, mock_to_json): mock_to_json.return_value = "mock_value" @@ -296,7 +295,7 @@ def test_to_json(self, mock_to_json): SetUp.item.ref_up = [SetUp.tracing_tag] SetUp.item.ref_down = [SetUp.tracing_tag] SetUp.item.tracing_status = MagicMock() - SetUp.item.tracing_status.name = "mock_status" + SetUp.item.tracing_status.name = "mock_status" expected_json = { "tag": "mock_value", "location": SetUp.mock_location.to_json(), @@ -317,7 +316,7 @@ def test_to_json(self, mock_to_json): class TestRequirement(unittest.TestCase): @patch("lobster.items.Item.to_json") - def test_to_json(self, mock_super_to_json): + def test_to_json(self, mock_super_to_json): mock_super_to_json.return_value = { "item_property": "item_value" } @@ -327,22 +326,22 @@ def test_to_json(self, mock_super_to_json): "kind": "mock_kind", "text": "mock_text", "status": "active" - } + } result = SetUp.requirement.to_json() - + mock_super_to_json.assert_called_once_with() self.assertEqual(result, expected_result) @patch("lobster.items.Item.error") - def test_perform_source_checks_valid_status(self, mock_super_error): + def test_perform_source_checks_valid_status(self, mock_super_error): mock_error_message = None mock_super_error.return_value = mock_error_message source_info = { "valid_status": ["active", "inactive"] - } + } SetUp.requirement.perform_source_checks(source_info) - + self.assertIsNone(mock_super_error()) @patch("lobster.items.Item.error") @@ -351,19 +350,19 @@ def test_perform_source_checks_invalid_status(self, mock_super_error): mock_super_error.return_value = mock_error_message source_info = { "valid_status": ["inactive", "closed"] - } + } SetUp.requirement.perform_source_checks(source_info) - + expected_error_message = "status is active, expected closed or inactive" self.assertEqual(mock_super_error(), expected_error_message) def test_perform_source_checks_invalid_source_info(self): - invalid_source_info = ["invalid", "list"] - + invalid_source_info = ["invalid", "list"] + with self.assertRaises(AssertionError): SetUp.requirement.perform_source_checks(invalid_source_info) - + @patch("lobster.items.Tracing_Tag.from_json") def test_from_json(self, mock_from_json): mock_level = "mock_level" @@ -412,14 +411,14 @@ def test_to_json(self, mock_super_to_json): expected_result = { "item_property": "item_value", "language": "mock_language", - "kind": "mock_kind" + "kind": "mock_kind" } result = SetUp.implementation.to_json() mock_super_to_json.assert_called_once_with() self.assertEqual(result, expected_result) - + @patch("lobster.items.Tracing_Tag.from_json") def test_from_json(self, mock_from_json): mock_level = "mock_level" @@ -427,14 +426,14 @@ def test_from_json(self, mock_from_json): setup = SetUp() mock_from_json.return_value = SetUp.tracing_tag for location_type in ["file", "github", "codebeamer", "void"]: - with self.subTest(location_type): + with self.subTest(location_type): location_data = setup.set_location_data(location_type) mock_data = { "tag": SetUp.tracing_tag, "location": location_data, "language": "Python", "kind": "kind_data", - "name": "name_data", + "name": "name_data", } result = setup.implementation.from_json(mock_level, mock_data, mock_schema_version) self.assertEqual(result.tag, SetUp.tracing_tag) @@ -478,7 +477,7 @@ def test_from_json(self, mock_from_json): mock_level = "mock_level" mock_schema_version = 3 setup = SetUp() - mock_from_json.return_value = setup.tracing_tag + mock_from_json.return_value = setup.tracing_tag for location_type in ["file", "github", "codebeamer", "void"]: with self.subTest(location_type): location_data = setup.set_location_data(location_type)