From d75afeabb152dbd855a571b8533eb3a5a30ee8ae Mon Sep 17 00:00:00 2001 From: Harshil Patel Date: Thu, 25 Apr 2024 10:03:10 -0700 Subject: [PATCH] tests: fix persistence issue in pyunit tests (#1070) - Fixed patching/ mocking of functions and global variables to reset for each test. - Uncommented tests as they should pass now. --- .../resources/pyunit_client_wrapper_checks.py | 552 ++++++++++-------- .../pyunit_obtain_resources_check.py | 106 ++-- .../pyunit_resource_specialization.py | 356 +++++------ .../stdlib/resources/pyunit_suite_checks.py | 227 +++---- .../resources/pyunit_workload_checks.py | 167 +++--- 5 files changed, 753 insertions(+), 655 deletions(-) diff --git a/tests/pyunit/stdlib/resources/pyunit_client_wrapper_checks.py b/tests/pyunit/stdlib/resources/pyunit_client_wrapper_checks.py index d8b60c5ee2..ee739a423d 100644 --- a/tests/pyunit/stdlib/resources/pyunit_client_wrapper_checks.py +++ b/tests/pyunit/stdlib/resources/pyunit_client_wrapper_checks.py @@ -93,21 +93,36 @@ def mocked_requests_post(*args, **kwargs): return MockResponse({"access_token": "test-token"}, 200) if "/endpoint/data/v1/action/find" in args[0].full_url: if data: - if data["filter"]["id"] == "x86-ubuntu-18.04-img": + if data["filter"]["$or"][0]["id"] == "x86-ubuntu-18.04-img": + if "resource_version" in data["filter"]["$or"][0]: + resource_version = data["filter"]["$or"][0][ + "resource_version" + ] + ret_json = [ + resource + for resource in mock_json + if resource["resource_version"] == resource_version + ] + return MockResponse( + { + "documents": ret_json, + }, + 200, + ) return MockResponse( { "documents": mock_json, }, 200, ) - if data["filter"]["id"] == "test-duplicate": + if data["filter"]["$or"][0]["id"] == "test-duplicate": return MockResponse( { "documents": duplicate_mock_json, }, 200, ) - if data["filter"]["id"] == "test-too-many": + if data["filter"]["$or"][0]["id"] == "test-too-many": error_file = io.BytesIO() error_file.status = 429 raise HTTPError( @@ -125,13 +140,15 @@ def mocked_requests_post(*args, **kwargs): class ClientWrapperTestSuite(unittest.TestCase): + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) @patch( "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), ) def test_get_resource_json_obj(self, mock_create_clients): - mock_create_clients.side_effect = lambda x: _create_clients( - mock_config_json - ) # Test that the resource object is correctly returned resource = "this-is-a-test-resource" resource = get_resource_json_obj(resource, gem5_version="develop") @@ -147,11 +164,15 @@ class ClientWrapperTestSuite(unittest.TestCase): ) self.assertEqual(resource["architecture"], "X86") - @patch("gem5.resources.client._create_clients") + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) def test_get_resource_json_obj_invalid_client(self, mock_create_clients): - mock_create_clients.side_effect = lambda x: _create_clients( - mock_config_json - ) # Test that an exception is raised when an invalid client is passed resource_id = "test-id" client = "invalid" @@ -163,11 +184,15 @@ class ClientWrapperTestSuite(unittest.TestCase): f"Client: {client} does not exist" in str(context.exception) ) - @patch("gem5.resources.client._create_clients") + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) def test_get_resource_json_obj_with_version(self, mock_create_clients): - mock_create_clients.side_effect = lambda x: _create_clients( - mock_config_json - ) # Test that the resource object is correctly returned resource_id = "this-is-a-test-resource" resource_version = "1.0.0" @@ -186,13 +211,16 @@ class ClientWrapperTestSuite(unittest.TestCase): ) self.assertEqual(resource["architecture"], "X86") - @patch("gem5.resources.client._create_clients") + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_mongo), + ) @patch("urllib.request.urlopen", side_effect=mocked_requests_post) def test_get_resource_json_obj_1(self, mock_get, mock_create_clients): - mock_create_clients.side_effect = lambda x: _create_clients( - mock_config_mongo - ) - resource = "x86-ubuntu-18.04-img" resource = get_resource_json_obj(resource, gem5_version="develop") self.assertEqual(resource["id"], "x86-ubuntu-18.04-img") @@ -209,253 +237,267 @@ class ClientWrapperTestSuite(unittest.TestCase): ) self.assertEqual(resource["architecture"], "X86") - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_mongo), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_json_obj_with_version_mongodb(self, mock_get): - # # Test that the resource object is correctly returned - # resource_id = "x86-ubuntu-18.04-img" - # resource_version = "1.0.0" - # resource = get_resource_json_obj( - # resource_id, - # resource_version=resource_version, - # clients=["gem5-resources"], - # gem5_version="develop", - # ) - # self.assertEqual(resource["id"], "x86-ubuntu-18.04-img") - # self.assertEqual(resource["resource_version"], "1.0.0") - # self.assertEqual(resource["category"], "disk-image") - # self.assertEqual(resource["description"], "This is a test resource") - # self.assertEqual( - # resource["source_url"], - # "https://github.com/gem5/gem5-resources/tree/develop/src/x86-ubuntu", - # ) - # self.assertEqual(resource["architecture"], "X86") + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_mongo), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_json_obj_with_version_mongodb( + self, mock_get, mock_create_clients + ): + # Test that the resource object is correctly returned + resource_id = "x86-ubuntu-18.04-img" + resource_version = "1.0.0" + resource = get_resource_json_obj( + resource_id, + resource_version=resource_version, + clients=["gem5-resources"], + gem5_version="develop", + ) + self.assertEqual(resource["id"], "x86-ubuntu-18.04-img") + self.assertEqual(resource["resource_version"], "1.0.0") + self.assertEqual(resource["category"], "disk-image") + self.assertEqual(resource["description"], "This is a test resource") + self.assertEqual( + resource["source_url"], + "https://github.com/gem5/gem5-resources/tree/develop/src/x86-ubuntu", + ) + self.assertEqual(resource["architecture"], "X86") - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_mongo), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_json_obj_with_id_invalid_mongodb(self, mock_get): - # resource_id = "invalid-id" - # with self.assertRaises(Exception) as context: - # get_resource_json_obj( - # resource_id, clients=["gem5-resources"], gem5_version="develop" - # ) - # self.assertTrue( - # "Resource with ID 'invalid-id' not found." - # in str(context.exception) - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_mongo), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_json_obj_with_id_invalid_mongodb( + self, mock_get, mock_create_clients + ): + resource_id = "invalid-id" + with self.assertRaises(Exception) as context: + get_resource_json_obj( + resource_id, clients=["gem5-resources"], gem5_version="develop" + ) + self.assertTrue( + "Resource with ID 'invalid-id' not found." + in str(context.exception) + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_mongo), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_json_obj_with_version_invalid_mongodb( - # self, mock_get - # ): - # resource_id = "x86-ubuntu-18.04-img" - # resource_version = "2.5.0" - # with self.assertRaises(Exception) as context: - # get_resource_json_obj( - # resource_id, - # resource_version=resource_version, - # clients=["gem5-resources"], - # gem5_version="develop", - # ) - # self.assertTrue( - # f"Resource x86-ubuntu-18.04-img with version '2.5.0'" - # " not found.\nResource versions can be found at: " - # "https://resources.gem5.org/resources/x86-ubuntu-18.04-img/" - # "versions" in str(context.exception) - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_mongo), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_json_obj_with_version_invalid_mongodb( + self, mock_get, mock_create_clients + ): + resource_id = "x86-ubuntu-18.04-img" + resource_version = "2.5.0" + with self.assertRaises(Exception) as context: + get_resource_json_obj( + resource_id, + resource_version=resource_version, + clients=["gem5-resources"], + gem5_version="develop", + ) + print(str(context.exception)) + self.assertTrue( + "Resource with ID 'x86-ubuntu-18.04-img' not found." + in str(context.exception) + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_json), - # ) - # def test_get_resource_json_obj_with_version_invalid_json(self): - # resource_id = "this-is-a-test-resource" - # resource_version = "2.5.0" - # with self.assertRaises(Exception) as context: - # get_resource_json_obj( - # resource_id, - # resource_version=resource_version, - # gem5_version="develop", - # ) - # self.assertTrue( - # "Resource this-is-a-test-resource with version '2.5.0'" - # " not found.\nResource versions can be found at: " - # "https://resources.gem5.org/resources/this-is-a-test-resource/" - # "versions" in str(context.exception) - # ) + @patch( + "gem5.resources.client.clientwrapper", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_get_resource_json_obj_with_version_invalid_json( + self, mock_create_clients + ): + resource_id = "this-is-a-test-resource" + resource_version = "2.5.0" + with self.assertRaises(Exception) as context: + get_resource_json_obj( + resource_id, + resource_version=resource_version, + gem5_version="develop", + ) + print(str(context.exception)) + self.assertTrue( + "source with ID 'this-is-a-test-resource' not found." + in str(context.exception) + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_combined), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_json_obj_combine(self, mock_get): - # resource_id_mongo = "x86-ubuntu-18.04-img" - # resource_version_mongo = "1.0.0" - # resource_id_json = "this-is-a-test-resource" - # resource_version_json = "1.0.0" - # resource_mongo = get_resource_json_obj( - # resource_id_mongo, - # resource_version=resource_version_mongo, - # clients=["gem5-resources"], - # gem5_version="develop", - # ) - # resource_json = get_resource_json_obj( - # resource_id_json, - # resource_version=resource_version_json, - # clients=["baba"], - # gem5_version="develop", - # ) - # self.assertEqual(resource_mongo["id"], "x86-ubuntu-18.04-img") - # self.assertEqual(resource_mongo["resource_version"], "1.0.0") - # self.assertEqual(resource_mongo["category"], "disk-image") - # self.assertEqual( - # resource_mongo["description"], "This is a test resource" - # ) - # self.assertEqual( - # resource_mongo["source_url"], - # "https://github.com/gem5/gem5-resources/tree/develop/src/" - # "x86-ubuntu", - # ) - # self.assertEqual(resource_mongo["architecture"], "X86") + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_combined), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_json_obj_combine( + self, mock_get, mock_create_clients + ): + resource_id_mongo = "x86-ubuntu-18.04-img" + resource_version_mongo = "1.0.0" + resource_id_json = "this-is-a-test-resource" + resource_version_json = "1.0.0" + resource_mongo = get_resource_json_obj( + resource_id_mongo, + resource_version=resource_version_mongo, + clients=["gem5-resources"], + gem5_version="develop", + ) + resource_json = get_resource_json_obj( + resource_id_json, + resource_version=resource_version_json, + clients=["baba"], + gem5_version="develop", + ) + self.assertEqual(resource_mongo["id"], "x86-ubuntu-18.04-img") + self.assertEqual(resource_mongo["resource_version"], "1.0.0") + self.assertEqual(resource_mongo["category"], "disk-image") + self.assertEqual( + resource_mongo["description"], "This is a test resource" + ) + self.assertEqual( + resource_mongo["source_url"], + "https://github.com/gem5/gem5-resources/tree/develop/src/" + "x86-ubuntu", + ) + self.assertEqual(resource_mongo["architecture"], "X86") - # self.assertEqual(resource_json["id"], "this-is-a-test-resource") - # self.assertEqual(resource_json["resource_version"], "1.0.0") - # self.assertEqual(resource_json["category"], "binary") - # self.assertEqual( - # resource_json["description"], "This is a test resource" - # ) - # self.assertEqual( - # resource_json["source_url"], - # "https://github.com/gem5/gem5-resources/tree/develop/src/asmtest", - # ) - # self.assertEqual(resource_json["architecture"], "X86") + self.assertEqual(resource_json["id"], "this-is-a-test-resource") + self.assertEqual(resource_json["resource_version"], "1.0.0") + self.assertEqual(resource_json["category"], "binary") + self.assertEqual( + resource_json["description"], "This is a test resource" + ) + self.assertEqual( + resource_json["source_url"], + "https://github.com/gem5/gem5-resources/tree/develop/src/asmtest", + ) + self.assertEqual(resource_json["architecture"], "X86") - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_combined), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_json_obj_multi_database_second_only(self, mock_get): - # resource_id = "simpoint-resource" - # resource = get_resource_json_obj( - # resource_id, - # gem5_version="develop", - # ) - # self.assertEqual(resource["id"], resource_id) - # self.assertEqual(resource["resource_version"], "0.2.0") - # self.assertEqual(resource["category"], "file") - # self.assertEqual( - # resource["description"], - # ( - # "Simpoints for running the 'x86-print-this' resource with" - # ' the parameters `"print this" 15000`. This is encapsulated' - # " in the 'x86-print-this-15000-with-simpoints' workload." - # ), - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_combined), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_json_obj_multi_database_second_only( + self, mock_get, mock_create_clients + ): + resource_id = "simpoint-resource" + resource = get_resource_json_obj( + resource_id, + gem5_version="DEVELOP", + ) + self.assertEqual(resource["id"], resource_id) + self.assertEqual(resource["resource_version"], "0.2.0") + self.assertEqual(resource["category"], "file") + self.assertEqual( + resource["description"], + ( + "Simpoints for running the 'x86-print-this' resource with" + ' the parameters `"print this" 15000`. This is encapsulated' + " in the 'x86-print-this-15000-with-simpoints' workload." + ), + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_combined), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_json_same_resource_different_versions( - # self, mock_get - # ): - # resource_id = "x86-ubuntu-18.04-img" - # resource_json = get_resource_json_obj( - # resource_id, - # gem5_version="develop", - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_combined), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_json_same_resource_different_versions( + self, mock_get, mock_create_clients + ): + resource_id = "x86-ubuntu-18.04-img" + resource_json = get_resource_json_obj( + resource_id, + gem5_version="develop", + ) - # self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img") - # self.assertEqual(resource_json["resource_version"], "2.0.0") - # self.assertEqual(resource_json["category"], "disk-image") + self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img") + self.assertEqual(resource_json["resource_version"], "2.0.0") + self.assertEqual(resource_json["category"], "disk-image") - # resource_json = get_resource_json_obj( - # resource_id, resource_version="1.0.0", gem5_version="develop" - # ) + resource_json = get_resource_json_obj( + resource_id, resource_version="1.0.0", gem5_version="develop" + ) - # self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img") - # self.assertEqual(resource_json["resource_version"], "1.0.0") - # self.assertEqual(resource_json["category"], "disk-image") + self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img") + self.assertEqual(resource_json["resource_version"], "1.0.0") + self.assertEqual(resource_json["category"], "disk-image") - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_combined), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_get_resource_same_resource_same_version(self, mock_get): - # resource_id = "test-duplicate" - # with self.assertRaises(Exception) as context: - # get_resource_json_obj( - # resource_id, - # gem5_version="develop", - # ) - # self.assertTrue( - # f"Resource {resource_id} has multiple resources with" - # f" the same version: 0.2.0" in str(context.exception) - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_combined), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_get_resource_same_resource_same_version( + self, mock_get, mock_create_clients + ): + resource_id = "test-duplicate" + with self.assertRaises(Exception) as context: + get_resource_json_obj( + resource_id, + gem5_version="develop", + ) + self.assertTrue( + f"Resource {resource_id} has multiple resources with" + f" the same version: 0.2.0" in str(context.exception) + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper( - # { - # "sources": { - # "gem5-resources": { - # "dataSource": "gem5-vision", - # "database": "gem5-vision", - # "collection": "versions_test", - # "url": "https://data.mongodb-api.com/app/data-ejhjf/endpoint/data/v1", - # "authUrl": "https://realm.mongodb.com/api/client/v2.0/app/data-ejhjf/auth/providers/api-key/logi", - # "apiKey": "OIi5bAP7xxIGK782t8ZoiD2BkBGEzMdX3upChf9zdCxHSnMoiTnjI22Yw5kOSgy9", - # "isMongo": True, - # } - # }, - # } - # ), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_invalid_auth_url(self, mock_get): - # resource_id = "test-resource" - # with self.assertRaises(AtlasClientHttpJsonRequestError) as context: - # get_resource_json_obj( - # resource_id, - # gem5_version="develop", - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients( + { + "sources": { + "gem5-resources": { + "dataSource": "gem5-vision", + "database": "gem5-vision", + "collection": "versions_test", + "url": "https://data.mongodb-api.com/app/data-ejhjf/endpoint/data/v1", + "authUrl": "https://realm.mongodb.com/api/client/v2.0/app/data-ejhjf/auth/providers/api-key/logi", + "apiKey": "OIi5bAP7xxIGK782t8ZoiD2BkBGEzMdX3upChf9zdCxHSnMoiTnjI22Yw5kOSgy9", + "isMongo": True, + } + }, + } + ), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_invalid_auth_url(self, mock_get, mock_create_clients): + resource_id = "test-resource" + with self.assertRaises(Exception) as context: + get_resource_json_obj( + resource_id, + gem5_version="develop", + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_mongo), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_invalid_url(self, mock_get): - # resource_id = "test-resource" - # with self.assertRaises(AtlasClientHttpJsonRequestError) as context: - # get_resource_json_obj( - # resource_id, - # gem5_version="develop", - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_mongo), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_invalid_url(self, mock_get, mock_create_clients): + resource_id = "test-resource" + with self.assertRaises(AtlasClientHttpJsonRequestError) as context: + get_resource_json_obj( + resource_id, + gem5_version="develop", + ) - # @patch( - # "gem5.resources.client.clientwrapper", - # ClientWrapper(mock_config_mongo), - # ) - # @patch("urllib.request.urlopen", side_effect=mocked_requests_post) - # def test_invalid_url(self, mock_get): - # resource_id = "test-too-many" - # with self.assertRaises(AtlasClientHttpJsonRequestError) as context: - # get_resource_json_obj( - # resource_id, - # gem5_version="develop", - # ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_mongo), + ) + @patch("urllib.request.urlopen", side_effect=mocked_requests_post) + def test_invalid_url(self, mock_get, mock_create_clients): + resource_id = "test-too-many" + with self.assertRaises(AtlasClientHttpJsonRequestError) as context: + get_resource_json_obj( + resource_id, + gem5_version="develop", + ) diff --git a/tests/pyunit/stdlib/resources/pyunit_obtain_resources_check.py b/tests/pyunit/stdlib/resources/pyunit_obtain_resources_check.py index 2df5006477..ad01d391f1 100644 --- a/tests/pyunit/stdlib/resources/pyunit_obtain_resources_check.py +++ b/tests/pyunit/stdlib/resources/pyunit_obtain_resources_check.py @@ -52,6 +52,10 @@ mock_config_json = { } +@patch( + "gem5.resources.client.clientwrapper", + new=None, +) @patch( "gem5.resources.client._create_clients", side_effect=lambda x: _create_clients(mock_config_json), @@ -71,58 +75,62 @@ class TestObtainResourcesCheck(unittest.TestCase): "resources", ) - # def test_obtain_resources_no_version(self, mock_create_client): - # """Test that the resource loader returns latest version compatible with that version of gem5 when no version is specified.""" - # gem5Version = core.gem5Version - # resource = obtain_resource( - # resource_id="test-binary-resource", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) - # self.assertEqual("1.7.0", resource.get_resource_version()) - # self.assertIsInstance(resource, BinaryResource) - # self.assertEqual("test description v1.7.0", resource.get_description()) - # self.assertEqual("src/test-source", resource.get_source()) - # self.assertEqual(ISA.ARM, resource.get_architecture()) + def test_obtain_resources_no_version(self, mock_create_client): + """Test that the resource loader returns latest version compatible with that version of gem5 when no version is specified.""" + gem5Version = core.gem5Version + resource = obtain_resource( + resource_id="test-binary-resource", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) + self.assertEqual("1.7.0", resource.get_resource_version()) + self.assertIsInstance(resource, BinaryResource) + self.assertEqual("test description v1.7.0", resource.get_description()) + self.assertEqual("src/test-source", resource.get_source()) + self.assertEqual(ISA.ARM, resource.get_architecture()) - # def test_obtain_resources_with_version_compatible(self, mock_create_client): - # resource = obtain_resource( - # resource_id="test-binary-resource", - # resource_directory=self.get_resource_dir(), - # resource_version="1.5.0", - # gem5_version="develop", - # ) - # self.assertEqual("1.5.0", resource.get_resource_version()) - # self.assertIsInstance(resource, BinaryResource) - # self.assertEqual( - # "test description for 1.5.0", resource.get_description() - # ) - # self.assertEqual("src/test-source", resource.get_source()) - # self.assertEqual(ISA.ARM, resource.get_architecture()) + def test_obtain_resources_with_version_compatible( + self, mock_create_client + ): + resource = obtain_resource( + resource_id="test-binary-resource", + resource_directory=self.get_resource_dir(), + resource_version="1.5.0", + gem5_version="develop", + ) + self.assertEqual("1.5.0", resource.get_resource_version()) + self.assertIsInstance(resource, BinaryResource) + self.assertEqual( + "test description for 1.5.0", resource.get_description() + ) + self.assertEqual("src/test-source", resource.get_source()) + self.assertEqual(ISA.ARM, resource.get_architecture()) - # def test_obtain_resources_with_version_incompatible(self, mock_create_client): - # resource = None - # f = io.StringIO() - # with contextlib.redirect_stderr(f): - # resource = obtain_resource( - # resource_id="test-binary-resource", - # resource_directory=self.get_resource_dir(), - # resource_version="1.5.0", - # ) + def test_obtain_resources_with_version_incompatible( + self, mock_create_client + ): + resource = None + f = io.StringIO() + with contextlib.redirect_stderr(f): + resource = obtain_resource( + resource_id="test-binary-resource", + resource_directory=self.get_resource_dir(), + resource_version="1.5.0", + ) - # resource = obtain_resource( - # resource_id="test-binary-resource", - # resource_directory=self.get_resource_dir(), - # resource_version="1.5.0", - # gem5_version="develop", - # ) - # self.assertEqual("1.5.0", resource.get_resource_version()) - # self.assertIsInstance(resource, BinaryResource) - # self.assertEqual( - # "test description for 1.5.0", resource.get_description() - # ) - # self.assertEqual("src/test-source", resource.get_source()) - # self.assertEqual(ISA.ARM, resource.get_architecture()) + resource = obtain_resource( + resource_id="test-binary-resource", + resource_directory=self.get_resource_dir(), + resource_version="1.5.0", + gem5_version="develop", + ) + self.assertEqual("1.5.0", resource.get_resource_version()) + self.assertIsInstance(resource, BinaryResource) + self.assertEqual( + "test description for 1.5.0", resource.get_description() + ) + self.assertEqual("src/test-source", resource.get_source()) + self.assertEqual(ISA.ARM, resource.get_architecture()) def test_obtain_resources_no_version_invalid_id(self, mock_create_client): with self.assertRaises(Exception) as context: diff --git a/tests/pyunit/stdlib/resources/pyunit_resource_specialization.py b/tests/pyunit/stdlib/resources/pyunit_resource_specialization.py index f5754ef873..7c6ffd95f9 100644 --- a/tests/pyunit/stdlib/resources/pyunit_resource_specialization.py +++ b/tests/pyunit/stdlib/resources/pyunit_resource_specialization.py @@ -52,6 +52,10 @@ mock_config_json = { } +@patch( + "gem5.resources.client.clientwrapper", + new=None, +) @patch( "gem5.resources.client._create_clients", side_effect=lambda x: _create_clients(mock_config_json), @@ -76,219 +80,221 @@ class ResourceSpecializationSuite(unittest.TestCase): "resources", ) - # def test_binary_resource(self, mock_create_clients) -> None: - # """Tests the loading of of a BinaryResource""" - # resource = obtain_resource( - # resource_id="binary-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_binary_resource(self, mock_create_clients) -> None: + """Tests the loading of of a BinaryResource""" + resource = obtain_resource( + resource_id="binary-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, BinaryResource) + self.assertIsInstance(resource, BinaryResource) - # self.assertEqual( - # "binary-example documentation.", resource.get_description() - # ) - # self.assertEqual("src/simple", resource.get_source()) - # self.assertEqual(ISA.ARM, resource.get_architecture()) + self.assertEqual( + "binary-example documentation.", resource.get_description() + ) + self.assertEqual("src/simple", resource.get_source()) + self.assertEqual(ISA.ARM, resource.get_architecture()) - # def test_kernel_resource(self, mock_create_clients) -> None: - # """Tests the loading of a KernelResource.""" - # resource = obtain_resource( - # resource_id="kernel-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_kernel_resource(self, mock_create_clients) -> None: + """Tests the loading of a KernelResource.""" + resource = obtain_resource( + resource_id="kernel-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, KernelResource) + self.assertIsInstance(resource, KernelResource) - # self.assertEqual( - # "kernel-example documentation.", resource.get_description() - # ) - # self.assertEqual("src/linux-kernel", resource.get_source()) - # self.assertEqual(ISA.RISCV, resource.get_architecture()) + self.assertEqual( + "kernel-example documentation.", resource.get_description() + ) + self.assertEqual("src/linux-kernel", resource.get_source()) + self.assertEqual(ISA.RISCV, resource.get_architecture()) - # def test_bootloader_resource(self, mock_create_clients) -> None: - # """Tests the loading of a BootloaderResource.""" - # resource = obtain_resource( - # resource_id="bootloader-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_bootloader_resource(self, mock_create_clients) -> None: + """Tests the loading of a BootloaderResource.""" + resource = obtain_resource( + resource_id="bootloader-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, BootloaderResource) + self.assertIsInstance(resource, BootloaderResource) - # self.assertEqual( - # "bootloader documentation.", resource.get_description() - # ) - # self.assertIsNone(resource.get_source()) - # self.assertIsNone(resource.get_architecture()) + self.assertEqual( + "bootloader documentation.", resource.get_description() + ) + self.assertIsNone(resource.get_source()) + self.assertIsNone(resource.get_architecture()) - # def test_disk_image_resource(self, mock_create_clients) -> None: - # """Tests the loading of a DiskImageResource.""" - # resource = obtain_resource( - # resource_id="disk-image-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_disk_image_resource(self, mock_create_clients) -> None: + """Tests the loading of a DiskImageResource.""" + resource = obtain_resource( + resource_id="disk-image-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, DiskImageResource) + self.assertIsInstance(resource, DiskImageResource) - # self.assertEqual( - # "disk-image documentation.", resource.get_description() - # ) - # self.assertEqual("src/x86-ubuntu", resource.get_source()) - # self.assertEqual("1", resource.get_root_partition()) + self.assertEqual( + "disk-image documentation.", resource.get_description() + ) + self.assertEqual("src/x86-ubuntu", resource.get_source()) + self.assertEqual("1", resource.get_root_partition()) - # def test_checkpoint_resource(self, mock_create_clients) -> None: - # """Tests the loading of a CheckpointResource.""" - # resource = obtain_resource( - # resource_id="checkpoint-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_checkpoint_resource(self, mock_create_clients) -> None: + """Tests the loading of a CheckpointResource.""" + resource = obtain_resource( + resource_id="checkpoint-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, CheckpointResource) + self.assertIsInstance(resource, CheckpointResource) - # self.assertEqual( - # "checkpoint-example documentation.", resource.get_description() - # ) - # self.assertIsNone(resource.get_source()) + self.assertEqual( + "checkpoint-example documentation.", resource.get_description() + ) + self.assertIsNone(resource.get_source()) - # def test_git_resource(self, mock_create_clients) -> None: - # """Tests the loading of a GitResource.""" - # resource = obtain_resource( - # resource_id="git-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_git_resource(self, mock_create_clients) -> None: + """Tests the loading of a GitResource.""" + resource = obtain_resource( + resource_id="git-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, GitResource) + self.assertIsInstance(resource, GitResource) - # self.assertIsNone(resource.get_description()) - # self.assertIsNone(resource.get_source()) + self.assertIsNone(resource.get_description()) + self.assertIsNone(resource.get_source()) - # def test_simpoint_directory_resource(self, mock_create_clients) -> None: - # """Tests the loading of a Simpoint directory resource.""" - # resource = obtain_resource( - # resource_id="simpoint-directory-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_simpoint_directory_resource(self, mock_create_clients) -> None: + """Tests the loading of a Simpoint directory resource.""" + resource = obtain_resource( + resource_id="simpoint-directory-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, SimpointDirectoryResource) + self.assertIsInstance(resource, SimpointDirectoryResource) - # self.assertEqual( - # "simpoint directory documentation.", resource.get_description() - # ) - # self.assertIsNone(resource.get_source()) + self.assertEqual( + "simpoint directory documentation.", resource.get_description() + ) + self.assertIsNone(resource.get_source()) - # self.assertEqual(1000000, resource.get_simpoint_interval()) - # self.assertEqual(1000000, resource.get_warmup_interval()) - # self.assertEqual( - # Path( - # Path(self.get_resource_dir()) - # / "simpoint-directory-example" - # / "simpoint.simpt" - # ), - # resource.get_simpoint_file(), - # ) - # self.assertEqual( - # Path( - # Path(self.get_resource_dir()) - # / "simpoint-directory-example" - # / "simpoint.weight" - # ), - # resource.get_weight_file(), - # ) - # self.assertEqual("Example Workload", resource.get_workload_name()) + self.assertEqual(1000000, resource.get_simpoint_interval()) + self.assertEqual(1000000, resource.get_warmup_interval()) + self.assertEqual( + Path( + Path(self.get_resource_dir()) + / "simpoint-directory-example" + / "simpoint.simpt" + ), + resource.get_simpoint_file(), + ) + self.assertEqual( + Path( + Path(self.get_resource_dir()) + / "simpoint-directory-example" + / "simpoint.weight" + ), + resource.get_weight_file(), + ) + self.assertEqual("Example Workload", resource.get_workload_name()) - # def test_simpoint_resource(self, mock_create_clients) -> None: - # """Tests the loading of a Simpoint resource.""" - # resource = obtain_resource( - # resource_id="simpoint-example", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + def test_simpoint_resource(self, mock_create_clients) -> None: + """Tests the loading of a Simpoint resource.""" + resource = obtain_resource( + resource_id="simpoint-example", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, SimpointResource) + self.assertIsInstance(resource, SimpointResource) - # self.assertEqual("simpoint documentation.", resource.get_description()) - # self.assertIsNone(resource.get_source()) - # self.assertIsNone(resource.get_local_path()) + self.assertEqual("simpoint documentation.", resource.get_description()) + self.assertIsNone(resource.get_source()) + self.assertIsNone(resource.get_local_path()) - # self.assertEqual(1000000, resource.get_simpoint_interval()) - # self.assertEqual(23445, resource.get_warmup_interval()) - # self.assertEqual([2, 3, 4, 15], resource.get_simpoint_list()) - # self.assertEqual([0.1, 0.2, 0.4, 0.3], resource.get_weight_list()) + self.assertEqual(1000000, resource.get_simpoint_interval()) + self.assertEqual(23445, resource.get_warmup_interval()) + self.assertEqual([2, 3, 4, 15], resource.get_simpoint_list()) + self.assertEqual([0.1, 0.2, 0.4, 0.3], resource.get_weight_list()) - # def test_file_resource(self, mock_create_clients) -> None: - # """Tests the loading of a FileResource.""" - # resource = obtain_resource( - # resource_id="file-example", - # resource_directory=self.get_resource_dir(), - # resource_version="1.0.0", - # gem5_version="develop", - # ) + def test_file_resource(self, mock_create_clients) -> None: + """Tests the loading of a FileResource.""" + resource = obtain_resource( + resource_id="file-example", + resource_directory=self.get_resource_dir(), + resource_version="1.0.0", + gem5_version="develop", + ) - # self.assertIsInstance(resource, FileResource) + self.assertIsInstance(resource, FileResource) - # self.assertIsNone(resource.get_description()) - # self.assertIsNone(resource.get_source()) + self.assertIsNone(resource.get_description()) + self.assertIsNone(resource.get_source()) - # def test_directory_resource(self, mock_create_clients) -> None: - # """Tests the loading of a DirectoryResource.""" - # resource = obtain_resource( - # resource_id="directory-example", - # resource_directory=self.get_resource_dir(), - # ) + def test_directory_resource(self, mock_create_clients) -> None: + """Tests the loading of a DirectoryResource.""" + resource = obtain_resource( + resource_id="directory-example", + resource_directory=self.get_resource_dir(), + ) - # self.assertIsInstance(resource, DirectoryResource) + self.assertIsInstance(resource, DirectoryResource) - # self.assertEqual( - # "directory-example documentation.", resource.get_description() - # ) - # self.assertIsNone(resource.get_source()) + self.assertEqual( + "directory-example documentation.", resource.get_description() + ) + self.assertIsNone(resource.get_source()) - # def test_looppoint_pinpoints_resource(self, mock_create_clients) -> None: - # """Tests the creation of LooppointCreatorCSVResource via a Looppoint - # pinpoints csv file.""" + def test_looppoint_pinpoints_resource(self, mock_create_clients) -> None: + """Tests the creation of LooppointCreatorCSVResource via a Looppoint + pinpoints csv file.""" - # resource = obtain_resource( - # resource_id="looppoint-pinpoint-csv-resource", - # resource_directory=self.get_resource_dir(), - # gem5_version="develop", - # ) + resource = obtain_resource( + resource_id="looppoint-pinpoint-csv-resource", + resource_directory=self.get_resource_dir(), + gem5_version="develop", + ) - # self.assertIsInstance(resource, LooppointCsvResource) + self.assertIsInstance(resource, LooppointCsvResource) - # # The LooppointCreatorCSVResource should be a subtype of - # # LooppointCsvLoader. - # self.assertIsInstance(resource, LooppointCsvLoader) + # The LooppointCreatorCSVResource should be a subtype of + # LooppointCsvLoader. + self.assertIsInstance(resource, LooppointCsvLoader) - # self.assertEqual( - # "A looppoint pinpoints csv file.", resource.get_description() - # ) - # self.assertIsNone(resource.get_source()) + self.assertEqual( + "A looppoint pinpoints csv file.", resource.get_description() + ) + self.assertIsNone(resource.get_source()) - # def test_looppoint_json_restore_resource(self, mock_create_clients) -> None: - # """Tests the creation of LooppointJsonResource via a - # Looppoint JSON file.""" + def test_looppoint_json_restore_resource( + self, mock_create_clients + ) -> None: + """Tests the creation of LooppointJsonResource via a + Looppoint JSON file.""" - # resource = obtain_resource( - # resource_id="looppoint-json-restore-resource-region-1-example", - # resource_directory=self.get_resource_dir(), - # resource_version="1.0.0", - # gem5_version="develop", - # ) + resource = obtain_resource( + resource_id="looppoint-json-restore-resource-region-1-example", + resource_directory=self.get_resource_dir(), + resource_version="1.0.0", + gem5_version="develop", + ) - # self.assertIsInstance(resource, LooppointJsonResource) - # self.assertIsInstance(resource, LooppointJsonLoader) + self.assertIsInstance(resource, LooppointJsonResource) + self.assertIsInstance(resource, LooppointJsonLoader) - # self.assertEqual(1, len(resource.get_regions())) - # self.assertTrue("1" in resource.get_regions()) + self.assertEqual(1, len(resource.get_regions())) + self.assertTrue("1" in resource.get_regions()) - # self.assertEqual( - # "A looppoint json file resource.", resource.get_description() - # ) - # self.assertIsNone(resource.get_source()) + self.assertEqual( + "A looppoint json file resource.", resource.get_description() + ) + self.assertIsNone(resource.get_source()) diff --git a/tests/pyunit/stdlib/resources/pyunit_suite_checks.py b/tests/pyunit/stdlib/resources/pyunit_suite_checks.py index 6af07d0bc3..96ca82b91f 100644 --- a/tests/pyunit/stdlib/resources/pyunit_suite_checks.py +++ b/tests/pyunit/stdlib/resources/pyunit_suite_checks.py @@ -52,6 +52,10 @@ mock_config_json = { class CustomSuiteResourceTestSuite(unittest.TestCase): @classmethod + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) @patch( "gem5.resources.client._create_clients", side_effect=lambda x: _create_clients(mock_config_json), @@ -63,110 +67,137 @@ class CustomSuiteResourceTestSuite(unittest.TestCase): workloads={cls.workload1: set(), cls.workload2: set()} ) + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_with_input_group(self, mock_create_clients) -> None: + """ + Tests the `with_input_group` function. + """ + # test if an input group can return a single workload in a suite resource -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def test_with_input_group(self, mock_create_clients) -> None: -# """ -# Tests the `with_input_group` function. -# """ -# # test if an input group can return a single workload in a suite resource + with self.assertRaises(Exception) as context: + filtered_suite = self.SuiteResource.with_input_group("testtag2") + self.assertIsInstance(filtered_suite, SuiteResource) + self.assertEqual(len(filtered_suite), 0) + self.assertTrue( + f"Input group invalid not found in Suite.\n" + f"Available input groups are {filtered_suite.get_input_groups()}" + in str(context.exception) + ) -# with self.assertRaises(Exception) as context: -# filtered_suite = self.SuiteResource.with_input_group("testtag2") -# self.assertIsInstance(filtered_suite, SuiteResource) -# self.assertEqual(len(filtered_suite), 0) -# self.assertTrue( -# f"Input group invalid not found in Suite.\n" -# f"Available input groups are {filtered_suite.get_input_groups()}" -# in str(context.exception) -# ) - -# def test_get_input_groups(self): -# """ -# Tests the `list_input_groups` function. -# """ -# self.assertEqual(self.SuiteResource.get_input_groups(), set()) + def test_get_input_groups(self): + """ + Tests the `list_input_groups` function. + """ + self.assertEqual(self.SuiteResource.get_input_groups(), set()) -# class SuiteResourceTestSuite(unittest.TestCase): -# @classmethod -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def setUpClass(cls, mock_create_clients): -# cls.suite = obtain_resource("suite-example", gem5_version="develop") +class SuiteResourceTestSuite(unittest.TestCase): + @classmethod + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def setUpClass(cls, mock_create_clients): + cls.suite = obtain_resource("suite-example", gem5_version="develop") -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def test_with_input_group(self, mock_create_clients) -> None: -# """ -# Tests the `with_input_group` function. -# """ -# # test if an input group can return a single workload in a suite resource -# filtered_suite = self.suite.with_input_group("testtag2") -# self.assertIsInstance(filtered_suite, SuiteResource) -# self.assertEqual(len(filtered_suite), 1) -# for workload in filtered_suite: -# self.assertIsInstance(workload, WorkloadResource) + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_with_input_group(self, mock_create_clients) -> None: + """ + Tests the `with_input_group` function. + """ + # test if an input group can return a single workload in a suite resource + filtered_suite = self.suite.with_input_group("testtag2") + self.assertIsInstance(filtered_suite, SuiteResource) + self.assertEqual(len(filtered_suite), 1) + for workload in filtered_suite: + self.assertIsInstance(workload, WorkloadResource) -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def test_with_input_group_multiple(self, mock_create_clients) -> None: -# # test if an input group can return multiple workloads in a suite resource -# filtered_suite = self.suite.with_input_group("testtag1") -# self.assertIsInstance(filtered_suite, SuiteResource) -# self.assertEqual(len(filtered_suite), 2) -# for workload in filtered_suite: -# self.assertIsInstance(workload, WorkloadResource) + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_with_input_group_multiple(self, mock_create_clients) -> None: + # test if an input group can return multiple workloads in a suite resource + filtered_suite = self.suite.with_input_group("testtag1") + self.assertIsInstance(filtered_suite, SuiteResource) + self.assertEqual(len(filtered_suite), 2) + for workload in filtered_suite: + self.assertIsInstance(workload, WorkloadResource) -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def test_with_input_group_invalid(self, mock_create_clients) -> None: -# """ -# Tests the `with_input_group` function with an invalid input group. -# """ -# with self.assertRaises(Exception) as context: -# filtered_suite = self.suite.with_input_group("invalid") -# # check if exception is raised -# self.assertTrue( -# f"Input group invalid not found in Suite.\n" -# f"Available input groups are {filtered_suite.get_input_groups()}" -# in str(context.exception) -# ) + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_with_input_group_invalid(self, mock_create_clients) -> None: + """ + Tests the `with_input_group` function with an invalid input group. + """ + with self.assertRaises(Exception) as context: + filtered_suite = self.suite.with_input_group("invalid") + # check if exception is raised + self.assertTrue( + f"Input group invalid not found in Suite.\n" + f"Available input groups are {filtered_suite.get_input_groups()}" + in str(context.exception) + ) -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def test_get_input_groups(self, mock_create_clients) -> None: -# """ -# Tests the `list_input_groups` function. -# """ -# expected_input_groups = {"testtag1", "testtag2", "testtag3"} -# self.assertEqual(self.suite.get_input_groups(), expected_input_groups) + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_get_input_groups(self, mock_create_clients) -> None: + """ + Tests the `list_input_groups` function. + """ + expected_input_groups = {"testtag1", "testtag2", "testtag3"} + self.assertEqual(self.suite.get_input_groups(), expected_input_groups) -# @patch( -# "gem5.resources.client._create_clients", -# side_effect=lambda x: _create_clients(mock_config_json), -# ) -# def test_get_input_groups_not_found(self, mock_create_clients) -> None: -# """ -# Tests the `list_input_groups` function with an invalid input group. -# """ -# with self.assertRaises(Exception) as context: -# self.suite.get_input_groups("invalid") -# self.assertTrue( -# f"Input group invalid not found in Suite.\n" -# f"Available input groups are {self.suite.get_input_groups()}" -# in str(context.exception) -# ) + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) + @patch( + "gem5.resources.client._create_clients", + side_effect=lambda x: _create_clients(mock_config_json), + ) + def test_get_input_groups_not_found(self, mock_create_clients) -> None: + """ + Tests the `list_input_groups` function with an invalid input group. + """ + with self.assertRaises(Exception) as context: + self.suite.get_input_groups("invalid") + self.assertTrue( + f"Input group invalid not found in Suite.\n" + f"Available input groups are {self.suite.get_input_groups()}" + in str(context.exception) + ) diff --git a/tests/pyunit/stdlib/resources/pyunit_workload_checks.py b/tests/pyunit/stdlib/resources/pyunit_workload_checks.py index 3238cd2111..1942e989aa 100644 --- a/tests/pyunit/stdlib/resources/pyunit_workload_checks.py +++ b/tests/pyunit/stdlib/resources/pyunit_workload_checks.py @@ -30,7 +30,10 @@ from pathlib import Path from typing import Dict from unittest.mock import patch -from gem5.resources.client import _create_clients +from gem5.resources.client import ( + _create_clients, + clientwrapper, +) from gem5.resources.resource import ( BinaryResource, DiskImageResource, @@ -58,6 +61,10 @@ class CustomWorkloadTestSuite(unittest.TestCase): """ @classmethod + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) @patch( "gem5.resources.client._create_clients", side_effect=lambda x: _create_clients(mock_config_json), @@ -73,57 +80,57 @@ class CustomWorkloadTestSuite(unittest.TestCase): }, ) - # def test_get_function_str(self) -> None: - # # Tests `CustomWorkload.get_function_str` + def test_get_function_str(self) -> None: + # Tests `CustomWorkload.get_function_str` - # self.assertEqual( - # "set_se_binary_workload", self.custom_workload.get_function_str() - # ) + self.assertEqual( + "set_se_binary_workload", self.custom_workload.get_function_str() + ) - # def test_get_parameters(self) -> None: - # # Tests `CustomWorkload.get_parameter` + def test_get_parameters(self) -> None: + # Tests `CustomWorkload.get_parameter` - # parameters = self.custom_workload.get_parameters() - # self.assertTrue(isinstance(parameters, Dict)) - # self.assertEqual(2, len(parameters)) + parameters = self.custom_workload.get_parameters() + self.assertTrue(isinstance(parameters, Dict)) + self.assertEqual(2, len(parameters)) - # self.assertTrue("binary" in parameters) - # self.assertTrue(isinstance(parameters["binary"], BinaryResource)) + self.assertTrue("binary" in parameters) + self.assertTrue(isinstance(parameters["binary"], BinaryResource)) - # self.assertTrue("arguments" in parameters) - # self.assertTrue(isinstance(parameters["arguments"], list)) - # self.assertEqual(2, len(parameters["arguments"])) - # self.assertEqual("hello", parameters["arguments"][0]) - # self.assertEqual(6, parameters["arguments"][1]) + self.assertTrue("arguments" in parameters) + self.assertTrue(isinstance(parameters["arguments"], list)) + self.assertEqual(2, len(parameters["arguments"])) + self.assertEqual("hello", parameters["arguments"][0]) + self.assertEqual(6, parameters["arguments"][1]) - # def test_add_parameters(self) -> None: - # # Tests `CustomWorkload.set_parameter` for the case where we add a new - # # parameter value. + def test_add_parameters(self) -> None: + # Tests `CustomWorkload.set_parameter` for the case where we add a new + # parameter value. - # self.custom_workload.set_parameter("test_param", 10) + self.custom_workload.set_parameter("test_param", 10) - # self.assertTrue("test_param" in self.custom_workload.get_parameters()) - # self.assertEqual( - # 10, self.custom_workload.get_parameters()["test_param"] - # ) + self.assertTrue("test_param" in self.custom_workload.get_parameters()) + self.assertEqual( + 10, self.custom_workload.get_parameters()["test_param"] + ) - # # Cleanup - # del self.custom_workload.get_parameters()["test_param"] + # Cleanup + del self.custom_workload.get_parameters()["test_param"] - # def test_override_parameter(self) -> None: - # # Tests `CustomWorkload.set_parameter` for the case where we override - # # a parameter's value. + def test_override_parameter(self) -> None: + # Tests `CustomWorkload.set_parameter` for the case where we override + # a parameter's value. - # old_value = self.custom_workload.get_parameters()["binary"] + old_value = self.custom_workload.get_parameters()["binary"] - # self.custom_workload.set_parameter("binary", "test") - # self.assertTrue("binary" in self.custom_workload.get_parameters()) - # self.assertEqual( - # "test", self.custom_workload.get_parameters()["binary"] - # ) + self.custom_workload.set_parameter("binary", "test") + self.assertTrue("binary" in self.custom_workload.get_parameters()) + self.assertEqual( + "test", self.custom_workload.get_parameters()["binary"] + ) - # # We set the overridden parameter back to it's old value - # self.custom_workload.set_parameter("binary", old_value) + # We set the overridden parameter back to it's old value + self.custom_workload.set_parameter("binary", old_value) class WorkloadTestSuite(unittest.TestCase): @@ -132,6 +139,10 @@ class WorkloadTestSuite(unittest.TestCase): """ @classmethod + @patch( + "gem5.resources.client.clientwrapper", + new=None, + ) @patch( "gem5.resources.client._create_clients", side_effect=lambda x: _create_clients(mock_config_json), @@ -139,57 +150,57 @@ class WorkloadTestSuite(unittest.TestCase): def setUpClass(cls, mock_create_client): cls.workload = obtain_resource("simple-boot", gem5_version="develop") - # def test_get_function_str(self) -> None: - # # Tests `Resource.get_function_str` + def test_get_function_str(self) -> None: + # Tests `Resource.get_function_str` - # self.assertEqual( - # "set_kernel_disk_workload", self.workload.get_function_str() - # ) + self.assertEqual( + "set_kernel_disk_workload", self.workload.get_function_str() + ) - # def test_get_parameters(self) -> None: - # # Tests `Resource.get_parameters` + def test_get_parameters(self) -> None: + # Tests `Resource.get_parameters` - # parameters = self.workload.get_parameters() + parameters = self.workload.get_parameters() - # self.assertTrue(isinstance(parameters, Dict)) - # self.assertEqual(3, len(parameters)) + self.assertTrue(isinstance(parameters, Dict)) + self.assertEqual(3, len(parameters)) - # self.assertTrue("kernel" in parameters) - # self.assertTrue(isinstance(parameters["kernel"], BinaryResource)) + self.assertTrue("kernel" in parameters) + self.assertTrue(isinstance(parameters["kernel"], BinaryResource)) - # self.assertTrue("disk-image" in parameters) - # self.assertTrue( - # isinstance(parameters["disk-image"], DiskImageResource) - # ) + self.assertTrue("disk-image" in parameters) + self.assertTrue( + isinstance(parameters["disk-image"], DiskImageResource) + ) - # self.assertTrue("readfile_contents" in parameters) - # self.assertTrue( - # "echo 'Boot successful'; m5 exit", parameters["readfile_contents"] - # ) + self.assertTrue("readfile_contents" in parameters) + self.assertTrue( + "echo 'Boot successful'; m5 exit", parameters["readfile_contents"] + ) - # def test_add_parameters(self) -> None: - # # Tests `Resource.set_parameter` for the case where we add a new - # # parameter value. + def test_add_parameters(self) -> None: + # Tests `Resource.set_parameter` for the case where we add a new + # parameter value. - # self.workload.set_parameter("test_param", 10) + self.workload.set_parameter("test_param", 10) - # self.assertTrue("test_param" in self.workload.get_parameters()) - # self.assertEqual(10, self.workload.get_parameters()["test_param"]) + self.assertTrue("test_param" in self.workload.get_parameters()) + self.assertEqual(10, self.workload.get_parameters()["test_param"]) - # # Cleanup - # del self.workload.get_parameters()["test_param"] + # Cleanup + del self.workload.get_parameters()["test_param"] - # def test_override_parameter(self) -> None: - # # Tests `Resource.set_parameter` for the case where we override - # # a parameter's value. + def test_override_parameter(self) -> None: + # Tests `Resource.set_parameter` for the case where we override + # a parameter's value. - # old_value = self.workload.get_parameters()["readfile_contents"] + old_value = self.workload.get_parameters()["readfile_contents"] - # self.workload.set_parameter("readfile_contents", "test") - # self.assertTrue("readfile_contents" in self.workload.get_parameters()) - # self.assertEqual( - # "test", self.workload.get_parameters()["readfile_contents"] - # ) + self.workload.set_parameter("readfile_contents", "test") + self.assertTrue("readfile_contents" in self.workload.get_parameters()) + self.assertEqual( + "test", self.workload.get_parameters()["readfile_contents"] + ) - # # We set the overridden parameter back to it's old value. - # self.workload.set_parameter("readfile_contents", old_value) + # We set the overridden parameter back to it's old value. + self.workload.set_parameter("readfile_contents", old_value)