From 108e683f8c011963009d5ecbb964e228a39896e8 Mon Sep 17 00:00:00 2001 From: mugdhadhole1 Date: Fri, 11 Oct 2024 18:38:40 +0530 Subject: [PATCH] Removed the code which added an extra new line at the end of output files Previously make test-ci command added two empty lines at the end of the content in output files now you will see only see one empty line at the end of the content in those output files I have also done some linting changes --- lobster/tools/python/python.py | 1 - .../multiple_identical_function_names.output | 1 - test-unit/test_items.py | 125 +++++++++--------- 3 files changed, 62 insertions(+), 65 deletions(-) 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)