ciocore 5.1.1__py2.py3-none-any.whl → 10.0.0b3__py2.py3-none-any.whl

tests/test_hardware_set.py

@@ -0,0 +1,139 @@
+""" test data
+
+   isort:skip_file
+"""
+import unittest
+
+
+from ciocore.hardware_set import HardwareSet
+
+PROJECTS = [
+    "Deadpool",
+    "Harry Potter & the chamber of secrets",
+    "Captain Corelli's Mandolin",
+    "Gone with the Wind",
+]
+
+from package_fixtures import *
+from instance_type_fixtures import (
+    CW_INSTANCE_TYPES,
+    AWS_INSTANCE_TYPES,
+    CW_INSTANCE_TYPES_WITH_GPUS,
+    ALL_INSTANCE_TYPES,
+)
+
+
+class TestCategorizedInstanceTypes(unittest.TestCase):
+    def setUp(self):
+        self.hs = HardwareSet(CW_INSTANCE_TYPES)
+
+    def test_number_of_categories(self):
+        self.assertEqual(self.hs.number_of_categories(), 4)
+
+    def test_categories_sorted_on_order(self):
+        labels = [i["label"] for i in self.hs.get_model()]
+        self.assertEqual(labels, ["low", "mid", "high", "extra"])
+
+    def test_content_count(self):
+        low_category_values = [c["value"] for c in self.hs.get_model()[0]["content"]]
+        self.assertEqual(low_category_values, ["cw-a-4-16", "cw-b-8-16"])
+
+    def test_in_several_categories(self):
+        low_category_values = [c["value"] for c in self.hs.get_model()[0]["content"]]
+        extra_category_values = [c["value"] for c in self.hs.get_model()[3]["content"]]
+        self.assertIn("cw-a-4-16", low_category_values)
+        self.assertIn("cw-a-4-16", extra_category_values)
+
+    def test_category_names(self):
+        names = self.hs.labels()
+        self.assertEqual(names, ["low", "mid", "high", "extra"])
+
+
+class TestRecategorizeInstanceTypes(unittest.TestCase):
+    def setUp(self):
+        self.hs = HardwareSet(CW_INSTANCE_TYPES_WITH_GPUS)
+
+    def test_recategorize_cpu_gpu(self):
+        test_func = (
+            lambda x: [{"label": "GPU", "order": 2}]
+            if "gpu" in x and x["gpu"]
+            else [{"label": "CPU", "order": 1}]
+        )
+        self.hs.recategorize(test_func)
+        self.assertEqual(self.hs.number_of_categories(), 2)
+
+    def test_find_all_by_condition(self):
+        test_func = lambda x: "gpu" in x and x["gpu"]
+        result = self.hs.find_all(test_func)
+        self.assertEqual(len(result), 2)
+        print(self.hs)
+
+    def test_find_first_by_condition(self):
+        test_func = lambda x: x["memory"] < 32
+        result = self.hs.find_first(test_func)
+        self.assertTrue(result["memory"] < 32)
+
+    def test_find_category(self):
+        label = "mid"
+        result = self.hs.find_category(label)
+        self.assertEqual(result["label"], label)
+        self.assertEqual(result["order"], 2)
+
+
+class TestFind(unittest.TestCase):
+    def setUp(self):
+        self.hs = HardwareSet(CW_INSTANCE_TYPES_WITH_GPUS)
+
+    def test_find_unspecified_category(self):
+        result = self.hs.find("cw-e-4-32")
+        self.assertIsNotNone(result)
+
+    def test_category_that_exists(self):
+        result = self.hs.find("cw-e-4-32", category="high")
+        self.assertIsNotNone(result)
+
+    def test_returns_none_if_not_in_category(self):
+        result = self.hs.find("cw-e-4-32", category="low")
+        self.assertIsNone(result)
+
+    def test_returns_none_if_non_existent_category(self):
+        result = self.hs.find("cw-e-4-32", category="foo")
+        self.assertIsNone(result)
+
+
+class TestUncategorizedInstanceTypes(unittest.TestCase):
+    def setUp(self):
+        self.hs = HardwareSet(ALL_INSTANCE_TYPES)
+
+    def test_number_of_categories_uncategorized(self):
+        self.assertEqual(self.hs.number_of_categories(), 1)
+
+    def test_model_sorted_on_cores_mem(self):
+        content = self.hs.get_model()[0]["content"]
+        result = [c["label"] for c in content]
+        self.assertEqual(
+            result,
+            [
+                "windows 4 core 26.0GB Mem",
+                "linux 4 core 27.0GB Mem",
+                "linux 8 core 30.0GB Mem",
+                "windows 32 core 208.0GB Mem",
+                "linux 32 core 208.0GB Mem",
+                "windows 64 core 416.0GB Mem",
+                "linux 64 core 416.0GB Mem",
+            ],
+        )
+
+
+class TestProvider(unittest.TestCase):
+    def test_gcp_provider(self):
+        hs = HardwareSet(ALL_INSTANCE_TYPES)
+        self.assertEqual(hs.provider, "gcp")
+
+    def test_cw_provider(self):
+        hs = HardwareSet(CW_INSTANCE_TYPES_WITH_GPUS)
+        self.assertEqual(hs.provider, "cw")
+
+    def test_aws_provider(self):
+        hs = HardwareSet(AWS_INSTANCE_TYPES)
+        self.assertEqual(hs.provider, "aws")

tests/test_job_downloader.py

@@ -0,0 +1,213 @@
+from ciocore.downloader.job_downloader import JobDownloader, flatten
+import unittest
+from unittest import mock
+import re
+import json
+
+DOWNLOAD_BATCHES = {
+    "00000": [
+        {
+            "next_cursor": "00000_1",
+            "downloads": [
+                {
+                    "download_id": 1,
+                    "files": [
+                        {"url": "https://example.com/file1", "size": 100},
+                        {"url": "https://example.com/file2", "size": 200},
+                    ],
+                },
+                {
+                    "download_id": 2,
+                    "files": [
+                        {"url": "https://example.com/file3", "size": 100},
+                        {"url": "https://example.com/file4", "size": 200},
+                    ],
+                },
+            ],
+        },
+        {
+            "next_cursor": "00000_2",
+            "downloads": [
+                {
+                    "download_id": 3,
+                    "files": [
+                        {"url": "https://example.com/file5", "size": 100},
+                        {"url": "https://example.com/file6", "size": 200},
+                    ],
+                },
+                {
+                    "download_id": 4,
+                    "files": [
+                        {"url": "https://example.com/file7", "size": 100},
+                        {"url": "https://example.com/file8", "size": 200},
+                    ],
+                },
+            ],
+        },
+        {
+            "next_cursor": None,
+            "downloads": [
+                {
+                    "download_id": 5,
+                    "files": [
+                        {"url": "https://example.com/file9", "size": 100},
+                        {"url": "https://example.com/file10", "size": 200},
+                    ],
+                }
+            ],
+        },
+    ],
+    "00001": [
+        {
+            "next_cursor": "00001_1",
+            "downloads": [
+                {
+                    "download_id": 101,
+                    "files": [
+                        {"url": "https://example.com/file101", "size": 100},
+                        {"url": "https://example.com/file102", "size": 200},
+                    ],
+                },
+                {
+                    "download_id": 102,
+                    "files": [
+                        {"url": "https://example.com/file103", "size": 100},
+                        {"url": "https://example.com/file104", "size": 200},
+                    ],
+                },
+            ],
+        },
+        {
+            "next_cursor": "00001_2",
+            "downloads": [
+                {
+                    "download_id": 103,
+                    "files": [
+                        {"url": "https://example.com/file105", "size": 100},
+                        {"url": "https://example.com/file106", "size": 200},
+                    ],
+                },
+                {
+                    "download_id": 104,
+                    "files": [
+                        {"url": "https://example.com/file107", "size": 100},
+                        {"url": "https://example.com/file108", "size": 200},
+                    ],
+                },
+            ],
+        },
+        {
+            "next_cursor": None,
+            "downloads": [
+                {
+                    "download_id": 105,
+                    "files": [
+                        {"url": "https://example.com/file109", "size": 100},
+                        {"url": "https://example.com/file110", "size": 200},
+                    ],
+                }
+            ],
+        },
+    ],
+}
+
+class MockedApiClient:
+    def _get_batch(self, cursor):
+        if not cursor:
+            return json.dumps(DOWNLOAD_BATCHES["00000"][0])
+        
+        job_id, index = cursor.split("_")
+        index = int(index)
+        batch = json.dumps(DOWNLOAD_BATCHES[job_id][index])
+        return batch
+
+    def make_request(self, url, verb="POST", params=None, data=None, use_api_key=True):
+        m = re.match("/jobs/(\d{5})/downloads", url)
+        if m:
+            job_id = m.group(1)
+            # This is a request for a download batch
+            if not job_id in DOWNLOAD_BATCHES:
+                print(f"Job {job_id} not found")
+                return None, 204
+            else:
+                print(f"Job {job_id} found")
+            
+            cursor = params.get("start_cursor", None)
+            batch = self._get_batch(cursor)
+            return batch, 201
+        else:
+            # This is not a request for a download batch
+            raise NotImplementedError("This is not a request for a download batch")
+
+
+class TestJobDownloader(unittest.TestCase):
+    
+    
+    def setUp(self):
+        download_tasks_patcher = mock.patch.object(JobDownloader,"download_tasks")
+        self.mock_download_tasks = download_tasks_patcher.start()
+        self.addCleanup(download_tasks_patcher.stop)
+    
+
+    def test_batch_all_batches(self):
+        mocked_jobs = DOWNLOAD_BATCHES.keys()
+
+        # instantiate
+        jdl = JobDownloader(mocked_jobs)
+
+        # set the mocked api client
+        jdl.client = MockedApiClient()
+
+        jdl.run()
+        self.assertEqual(self.mock_download_tasks.call_count, 6)
+        
+#     def test_no_calls_if_non_existent_job(self):
+#         mocked_jobs = ["00002"]
+# ``
+#         # instantiate
+#         jdl = JobDownloader(mocked_jobs)
+
+#         # set the mocked api client
+#         jdl.client = MockedApiClient()
+
+#         jdl.run()
+#         self.assertEqual(self.mock_download_tasks.call_count, 0)
+
+
+        # mock_get_some_tasks.side_effect = get_some_tasks_side_effect
+
+        # tasks, locator = jdl.get_some_tasks(None)
+        # self.assertEqual(tasks, ["t1,t2,t3"])
+        # self.assertEqual(locator, {"job_index": 0, "cursor": "a"})
+
+        # print(jdl.get_some_tasks(2))
+        # print(jdl.get_some_tasks(3))
+
+        #  with mock.patch('requests.get') as mock_get:
+        #     # Construct the expected JSON response
+        #     json_response = {
+        #         "next_cursor": "AA",
+        #         "downloads": [
+        #             {
+        #                 "download_id": 1,
+        #                 "files": [
+        #                     {
+        #                         "url": "https://example.com/file1",
+        #                         "size": 100
+        #                     },
+        #                     {
+        #                         "url": "https://example.com/file2",
+        #                         "size": 200
+        #                     }
+        #                 ]
+        #             }
+        #         ],
+        #         "job_id": "00000",
+        #         "output_dir": "/some/path",
+        #         "size": 300,
+        #         "task_id": "001"
+        #     }
+        #     # Create a mock response object
+        #     mock_response = mock_get.return_value
+        #     # Set the JSON content of the response
+        #     mock_response.json.return_value = json_response

tests/test_package_query.py

@@ -0,0 +1,38 @@
+""" test package_query
+"""
+import unittest
+import os
+import sys
+import copy
+from ciocore import package_tree
+from ciocore import package_query
+from package_fixtures import *
+
+class HostnameSortByVersionTest(unittest.TestCase):
+    def setUp(self):
+        self.packages = copy.deepcopy(SOFTWARE_DATA)
+        self.pt = package_tree.PackageTree(self.packages)
+        self.hostname_list = self.pt.supported_host_names()
+    
+    def test_sort_hostnames_by_version(self):
+        sorted_hostnames = package_query.sort_hostnames_by_version(self.hostname_list)
+        sorted_data = {}
+        for item in sorted_hostnames:
+            product, version, platform = item.split()
+            data = {
+                'version': version,
+                'platform': platform
+            }
+            if product in sorted_data.keys():
+                sorted_data[product].append(data)
+            else:
+                sorted_data[product] = [data]
+        self.assertTrue(sorted(list(sorted_data.keys())) == list(sorted_data.keys()))
+        for product in sorted_data.keys():
+            platform_list = [pkg['platform'] for pkg in sorted_data[product]]
+            self.assertTrue(sorted(platform_list) == platform_list)
+            version_list = [pkg['version'] for pkg in sorted_data[product] if pkg['platform'] == 'linux']
+            self.assertTrue(sorted(version_list, reverse=True) == version_list)
+
+if __name__ == "__main__":
+    unittest.main()