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

tests/test_config.py

@@ -6,12 +6,20 @@ import sys
 import os
 import logging
 
-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-APIKEY = '{"auth_provider_x509_cert_url": "https://www.exampleapis.com/oauth2/v1/certs", "auth_uri": "https://accounts.example.com/o/oauth2/auth", "client_email": "account-5641301770895360@eloquent-vector-104019.iam.gserviceaccount.com", "client_id": "106815243682887997903", "client_x509_cert_url": "https://www.exampleapis.com/robot/v1/metadata/x509/account-5641301770895360%40eloquent-vector-104019.iam.gserviceaccount.com", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDcadqRWyd7VpYN\n804fEn07qlqNXU0ihz6g2dfbj9gzZDhHGVCI5QvPFskAQcV91k8cDdFu380m+sh1\nz9wlcdaM/lksRV/DRJiV76qrqyrNi0gSekZUuYhSsyMWUGvG4aSbf5BzVf1j8W4I\nUArH+ht5pgdSjowNc4zQIqmMH2XY+Ntr+NysBBfIv1PI6GoHFgDYOTSzsvz0qFYS\nWuonYGTjzNz4CY9Yh5ki8iq0/ijKzpUWeRUkpK9uF7WBoxrj3EyFFHejtfhVX2l0\n2KxrIF0kkmy5nmxVUck76FqdQ6vyvaHudREd3z/08hgdYogemQUTKFE/0LQmKuBV\nIJipPvORAgMBAAECggEAZvPMozN8LBikC00XstzMgRePp1MqydN5NeG6+TPlrQ+F\nV/RjkSXHT8oZRdTy3dXB6t0rc4n2xdvC0YCvGBBlwkK1vT+EPO2oBfTF99yCKDME\nDZlui3mDyvkgjPYweVuBKx65Bp5mNo4ZMqnMd18EAVxDM9UgZtIPtlJSdoBd7qtk\nyCGr03l+SV0krmvPV+KS9vyDOg/7Km5gMhTMaIveNyS1pG6AmZ0ggQA5djg/P2iF\nxGwYdvfADY5cBzg0OG5ELv9hvyA4CKN6RLfYv3JJS2gbNaMknjmsjaM/p0LtE2HL\n+uFPL0ZjoMwV3BlEFQIHwhNWS63H43ISBa1/2XvGPwKBgQDw4a4kQ9+Ce3edWonz\n3Fm/3no+HrMSVjbv28qphAHMFrSUdbMejQm4QSbNeOW1pEcVvW21u8tYagrJEsaU\ns4DulFXRep36teVDWpc1FrNowWEPPVeC8CO74VfssK1h2Itqis8JPbzXOcNtSH9+\nAg1EvrB9XnyEvJuM6GOGo3juTwKBgQDqP058+H3iSZe6al4P6Ib3g/82nr2dHeN5\n4xxGu1fzTMNX5lopbNji6tQcsMoMVPdOvCQy5c0PEUbvo7mxfZ8fOZwgBjIcXbYg\nzIJkPTSv7nxSE5M5lW5juzLkdq2k5k0qt9ByWuWEA3PSn/DEANa5888phSCoJSw/\nPjpwHhZoHwKBgQDCoQbMxI6e5lYCrToT8PIPhpptAO8dnM2sxoGcsE2ncp0b63H7\n+GdnGjVZBhtMxdyt4y33DjLCUIRAbUxIsDU4EGC67oEhJsGEx3iva5Uwyjc7UgwY\nfyHQV8ZsN2EQUyBqyJd6VwjzOff+n/prfQrthcoisiqYMbDZjJeGHSXEHwKBgAo4\nBsmG4Z78jOTx/PZ+s1ya4ohUdnsjMahAkxw20ghoIeF0yBwkhnWnvucdg0L0dfF2\nXbHmuoJcw5ZyswgeLdHj5n6zJn58TBS0Nz/+N40xPzUpa3PIpA8vvHGhB8Q408b4\nS9yhQH/40pWuqocybiugijoKd7k+HecIZO49MccLAoGBAPDScJHSxKPW6wJKjxDC\nXXWWQ2flbwv4Sja487QV/trWMSRnHJHnCVHqv/F7ThPaoHM+MJSzrJ7wr/CJhk0H\noEt+0Rn6qPd/A36bSjTfXMFLXWi75ovek+IJGKxr7B46jrcS/oe1XIIOlV1+OvOY\nVoO6vgYkPhpMkth2hyZ/luea\n-----END PRIVATE KEY-----\n", "private_key_id": "3dfe3bdc40d4dc431d283bf22feb113c9b622dd3", "project_id": "eloquent-vector-104019", "token_uri": "https://oauth2.exampleapis.com/token", "type": "service_account"}'
+from unittest import mock
+
+MOCK_API_KEY = '''{
+    "type": "service_account",
+    "project_id": "mock-project",
+    "private_key_id": "mock-key-id",
+    "private_key": "-----BEGIN PRIVATE KEY-----\\nMOCKKEY\\n-----END PRIVATE KEY-----\\n",
+    "client_email": "mock@example.com",
+    "client_id": "123456789",
+    "auth_uri": "https://accounts.example.com/oauth2/auth",
+    "token_uri": "https://oauth2.example.com/token",
+    "auth_provider_x509_cert_url": "https://www.example.com/oauth2/v1/certs",
+    "client_x509_cert_url": "https://www.example.com/robot/v1/metadata/x509/mock%40example.com"
+}'''
 
 PY3 = sys.version_info >= (3, 0)
 BUILTIN_OPEN = "builtins.open" if PY3 else "__builtin__.open"
@@ -29,7 +37,7 @@ class ConfigInitTest(unittest.TestCase):
         It Mocks the 2 api_key functions, the multiprocessing package, and the os environment.
         """
         self.cpu_count_patcher = mock.patch(
-            "multiprocessing.cpu_count", return_value=overrides.get("cpu_count", 4)
+            "os.cpu_count", return_value=overrides.get("cpu_count", 4)
         )
         self.mock_cpu_count = self.cpu_count_patcher.start()
         if overrides.get("cpu_count_raise", False):
@@ -64,23 +72,37 @@ class ConfigInitTest(unittest.TestCase):
         cfg = config.Config()
         self.assertEqual(cfg.__class__.__name__, "Config")
 
+    # DOWNLOADER PAGE SIZE
+    def test_downloader_page_size_default_to_50(self):
+        self.up()
+        cfg = config.Config()
+        self.assertEqual(cfg.config["downloader_page_size"], 50)
+        self.down()
+        
+    def test_downloader_page_size_variable_overrides_default(self):
+        self.up(env={"CONDUCTOR_DOWNLOADER_PAGE_SIZE": "10"})
+        cfg = config.Config()
+        self.assertEqual(cfg.config["downloader_page_size"], 10)
+        self.down()
+        
+        
     # THREAD COUNT
-    def test_thread_count_is_double_cpu_count(self):
-        self.up(cpu_count=2)
+    def test_thread_count_is_cpu_count_minus_one(self):
+        self.up(cpu_count=4)
         cfg = config.Config()
-        self.assertEqual(cfg.config["thread_count"], 4)
+        self.assertEqual(cfg.config["thread_count"], 3)
         self.down()
 
-    def test_thread_count_is_max_16(self):
-        self.up(cpu_count=12)
+    def test_thread_count_is_max_15(self):
+        self.up(cpu_count=20)
         cfg = config.Config()
-        self.assertEqual(cfg.config["thread_count"], 16)
+        self.assertEqual(cfg.config["thread_count"], 15)
         self.down()
 
-    def test_thread_count_is_16_if_an_exception_is_thrown(self):
+    def test_thread_count_is_15_if_an_exception_is_thrown(self):
         self.up(cpu_count_raise=True)
         cfg = config.Config()
-        self.assertEqual(cfg.config["thread_count"], 16)
+        self.assertEqual(cfg.config["thread_count"], 15)
         self.down()
 
     def test_thread_count_variable_overrides_default(self):
@@ -253,7 +275,7 @@ class ApiKeyFromVariableTest(unittest.TestCase):
         self.down()
 
     def test_returns_dict_if_key_is_b64encoded(self):
-        key = APIKEY
+        key = MOCK_API_KEY
         if sys.version_info < (3, 0):
             self.up(env={"CONDUCTOR_API_KEY": base64.b64encode(key)})
         else:
@@ -288,7 +310,7 @@ class ApiKeyFromFileTest(unittest.TestCase):
         self.assertEqual(result, None)
         self.down()
 
-    @mock.patch(BUILTIN_OPEN, new_callable=mock.mock_open, read_data=APIKEY, create=True)
+    @mock.patch(BUILTIN_OPEN, new_callable=mock.mock_open, read_data=MOCK_API_KEY, create=True)
     def test_open_called_with_api_key_path(self, mock_file_open):
         self.up(env={"CONDUCTOR_API_KEY_PATH": "path/to/api_key"})
         config.Config.get_api_key_from_file()
@@ -302,7 +324,7 @@ class ApiKeyFromFileTest(unittest.TestCase):
             config.Config.get_api_key_from_file()
         self.down()
 
-    @mock.patch(BUILTIN_OPEN, new_callable=mock.mock_open, read_data=APIKEY, create=True)
+    @mock.patch(BUILTIN_OPEN, new_callable=mock.mock_open, read_data=MOCK_API_KEY, create=True)
     def test_returns_dict_if_key_is_valid_json(self, mock_file_open):
         self.up(env={"CONDUCTOR_API_KEY_PATH": "path/to/api_key"})
         result = config.Config.get_api_key_from_file()

tests/test_data.py

@@ -1,184 +1,173 @@
-""" test data
-
-   isort:skip_file
-"""
-import json
-import os
-import sys
 import unittest
-from mock import patch
-from ciocore import data
-
-PROJECTS = [
-    "Deadpool",
-    "Harry Potter & the chamber of secrets",
-    "Captain Corelli's Mandolin",
-    "Gone with the Wind"
-]
-
-LIN_INSTANCE_TYPES = [
-    {
-        "cores": 8,
-        "memory": 30.0,
-        "description": "8 core, 30GB Mem",
-        "name": "n1-standard-8",
-        "operating_system": "linux"
-    },
-    {
-        "cores": 64,
-        "memory": 416.0,
-        "description": "64 core, 416GB Mem",
-        "name": "n1-highmem-64",
-        "operating_system": "linux"
-    },
-    {
-        "cores": 4,
-        "memory": 26.0,
-        "description": "4 core, 26GB Mem",
-        "name": "n1-highmem-4",
-        "operating_system": "linux"
-    },
-    {
-        "cores": 32,
-        "memory": 208.0,
-        "description": "32 core, 208GB Mem",
-        "name": "n1-highmem-32",
-        "operating_system": "linux"
-    }
-]
-
-WIN_INSTANCE_TYPES = [
-    {
-        "cores": 64,
-        "memory": 416.0,
-        "description": "64 core, 416GB Mem",
-        "name": "n1-highmem-64-w",
-        "operating_system": "windows"
-    },
-    {
-        "cores": 4,
-        "memory": 26.0,
-        "description": "4 core, 26GB Mem",
-        "name": "n1-highmem-4-w",
-        "operating_system": "windows"
-    },
-    {
-        "cores": 32,
-        "memory": 208.0,
-        "description": "32 core, 208GB Mem",
-        "name": "n1-highmem-32-w",
-        "operating_system": "windows"
-    }
-]
-
-ALL_INSTANCE_TYPES = WIN_INSTANCE_TYPES+LIN_INSTANCE_TYPES
-
-with open(os.path.join(os.path.dirname(__file__), "fixtures", "sw_packages.json"), 'r') as content:
-    SOFTWARE = json.load(content)["data"]
-
-
-class TestDataSingleton(unittest.TestCase):
- 
-    def setUp(self):
-        projects_patcher = patch('ciocore.api_client.request_projects', return_value=PROJECTS)
-        software_packages_patcher = patch('ciocore.api_client.request_software_packages', return_value=SOFTWARE)
-        
-        self.mock_projects = projects_patcher.start()
-        self.mock_software_packages = software_packages_patcher.start()
-
-        self.addCleanup(projects_patcher.stop)
-        self.addCleanup(software_packages_patcher.stop)
-        data.__data__ = {}
-        data.__product__ = None
-
-class TestDataAllInstanceTypes(TestDataSingleton):
+from unittest.mock import patch
+from ciocore import data as coredata
 
+class TestCoreData(unittest.TestCase):
     def setUp(self):
-        super(TestDataAllInstanceTypes, self).setUp()
-        instance_types_patcher = patch('ciocore.api_client.request_instance_types', return_value=ALL_INSTANCE_TYPES)
-        self.mock_instance_types = instance_types_patcher.start()
-        self.addCleanup(instance_types_patcher.stop)
-
-    def test_init_sets_project_global(self):
-        data.init("all")
-        self.assertEqual(data.product(), "all") 
-
-    def test_init_raises_if_product_falsy(self):
-        with self.assertRaises(ValueError):
-            data.init()
+        """Set up test fixtures before each test method."""
+        self.mock_api_responses = {
+            'projects': ['ProjectA', 'ProjectB'],
+            'instance_types': [
+                {'operating_system': 'windows', 'name': 'win_machine', 'cores': 1, 'memory': '1024'},
+                {'operating_system': 'linux', 'name': 'linux_machine', 'cores': 1, 'memory': '1024'}
+            ],
+            'software': [  # Added package_id to each package
+                {
+                    'name': 'maya-io',
+                    'version': '2022',
+                    'platform': 'windows',
+                    'product': 'maya-io',
+                    'package_id': '123456789'
+                },
+                {
+                    'name': 'maya-io',
+                    'version': '2022',
+                    'platform': 'linux',
+                    'product': 'maya-io',
+                    'package_id': '123456780'
+                },
+                {
+                    'name': 'nuke',
+                    'version': '13.0',
+                    'platform': 'linux',
+                    'product': 'nuke',
+                    'package_id': '123456781'
+                }
+            ],
+            'extra_env': ['PATH=/custom/path', 'LICENSE_SERVER=1234']
+        }
+        # Clear data before each test
+        coredata.clear()
+
+    def tearDown(self):
+        """Clean up after each test method."""
+        coredata.clear()
+
+    def test_init_with_single_product(self):
+        """Test initializing with a single product"""
+        coredata.init("maya-io")
+        self.assertEqual(coredata.products(), ["maya-io"])
+        self.assertEqual(coredata.platforms(), set(["windows", "linux"]))
+
+    def test_init_with_multiple_products(self):
+        """Test initializing with multiple products"""
+        coredata.init("maya-io", "nuke")
+        self.assertEqual(coredata.products(), ["maya-io", "nuke"])
+
+    def test_init_with_deprecated_product(self):
+        """Test initializing with deprecated product kwarg"""
+        coredata.init(product="maya-io")
+        self.assertEqual(coredata.products(), ["maya-io"])
+
+    def test_init_with_all_products(self):
+        """Test initializing with 'all' products"""
+        coredata.init(product="all")
+        self.assertEqual(coredata.products(), [])
+
+    def test_init_conflict_raises_error(self):
+        """Test that using both products arg and product kwarg raises error"""
         with self.assertRaises(ValueError):
-            data.init("")
+            coredata.init("maya-io", product="nuke")
 
-    def test_data_raises_if_not_initialized(self):
+    def test_data_requires_init(self):
+        """Test that data() raises error if not initialized"""
         with self.assertRaises(ValueError):
-            data.data()
-
-    def test_valid(self):
-        self.assertEqual(data.valid(), False) 
-        data.init("all")
-        data.data()
-        self.assertEqual(data.valid(), True) 
-
-    def test_clear(self):
-        data.init("all")
-        data.data()
-        self.assertEqual(data.valid(), True) 
-        data.clear()
-        self.assertEqual(data.valid(), False) 
-
-    def test_does_not_refresh_if_not_force(self):
-        data.init("all")
-        p1 = data.data()["projects"]
-        self.assertEqual(len(p1), 4) 
-        self.mock_projects.return_value =  ["a", "b"]
-        p2 = data.data()["projects"]
-        self.assertEqual(p2, p1) 
-
-    def test_does_refresh_if_force_all(self):
-        data.init("all")
-        p1 = data.data()["projects"]
-        self.assertEqual(len(p1), 4) 
-        self.mock_projects.return_value =  ["a", "b"]
-        p2 = data.data(force=True)["projects"]
-        self.assertNotEqual(p2, p1) 
-        self.assertEqual(len(p2), 2) 
+            coredata.data()
+
+    @patch('ciocore.data.api_client')
+    def test_data_fetching(self, mock_client):
+        """Test fetching data through the data() function"""
+        # Setup mock responses
+        mock_client.request_projects.return_value = self.mock_api_responses['projects']
+        mock_client.request_instance_types.return_value = self.mock_api_responses['instance_types']
+        mock_client.request_software_packages.return_value = self.mock_api_responses['software']
+        mock_client.request_extra_environment.return_value = self.mock_api_responses['extra_env']
+
+        coredata.init("maya-io")
+        result = coredata.data()
         
-    def test_get_data_for_one_product(self):
-        data.init(product="cinema4d")
-        inst = data.data()["instance_types"]
-        sw = data.data()["software"]
-        self.assertEqual(len(sw.supported_host_names()), 2) 
-
-    def test_auto_filter_instance_types_based_on_software_plaforms(self):
-        data.init(product="maya-io")
-        inst = data.data()["instance_types"]
-        self.assertEqual(len(inst), 4) 
-
-
-
-class TestDataHomogenousInstanceTypes(TestDataSingleton):
+        self.assertIn("projects", result)
+        self.assertIn("instance_types", result)
+        self.assertIn("software", result)
+        self.assertIn("extra_environment", result)
+        
+        self.assertEqual(result["projects"], self.mock_api_responses["projects"])
+        self.assertIsInstance(result["instance_types"], coredata.HardwareSet)
+        self.assertIsInstance(result["software"], coredata.PackageTree)
+
+    @patch('ciocore.data.api_client')
+    def test_force_refresh(self, mock_client):
+        """Test forcing data refresh"""
+        # Setup mock responses
+        mock_client.request_projects.return_value = self.mock_api_responses['projects']
+        mock_client.request_instance_types.return_value = self.mock_api_responses['instance_types']
+        mock_client.request_software_packages.return_value = self.mock_api_responses['software']
+        mock_client.request_extra_environment.return_value = self.mock_api_responses['extra_env']
+
+        coredata.init("maya-io")
+        first_data = coredata.data()
+        
+        # Second call without force should not make new API calls
+        mock_client.request_projects.reset_mock()
+        second_data = coredata.data()
+        mock_client.request_projects.assert_not_called()
+        
+        # Call with force=True should make new API calls
+        third_data = coredata.data(force=True)
+        mock_client.request_projects.assert_called_once()
 
-    def setUp(self):
-        super(TestDataHomogenousInstanceTypes, self).setUp()
-        instance_types_patcher = patch('ciocore.api_client.request_instance_types', return_value=LIN_INSTANCE_TYPES)
-        self.mock_instance_types = instance_types_patcher.start()
-        self.addCleanup(instance_types_patcher.stop)
-
-    def test_linux_only_instance_types(self):
-        data.init(product="all")
-        it = data.data()["instance_types"]
-        self.assertEqual(len(it), 4) 
-
-    def test_linux_only_packages_when_linux_only_instance_types(self):
-        data.init(product="cinema4d")
-        sw = data.data()["software"]
-        print(sw.supported_host_names())
-        self.assertEqual(len(sw.supported_host_names()), 1)
-
-    def test_platforms_method_only_linux(self):
-        data.init(product="cinema4d")
-        data.data()
-        self.assertEqual({"linux"}, data.platforms()) 
+    def test_valid_state(self):
+        """Test valid() function behavior"""
+        self.assertFalse(coredata.valid())  # Should be invalid before initialization
+        
+        coredata.init("maya-io")
+        self.assertFalse(coredata.valid())  # Should be invalid before data is fetched
+        
+        with patch('ciocore.data.api_client') as mock_client:
+            # Setup mock responses
+            mock_client.request_projects.return_value = self.mock_api_responses['projects']
+            mock_client.request_instance_types.return_value = self.mock_api_responses['instance_types']
+            mock_client.request_software_packages.return_value = self.mock_api_responses['software']
+            mock_client.request_extra_environment.return_value = self.mock_api_responses['extra_env']
+            
+            coredata.data()  # Fetch data
+            self.assertTrue(coredata.valid())  # Should be valid after data is fetched
+        
+        coredata.clear()
+        self.assertFalse(coredata.valid())  # Should be invalid after clear
+
+    @patch('ciocore.data.api_client')
+    def test_platforms_filtering(self, mock_client):
+        """Test platform filtering based on instance types and software"""
+        # Setup mock responses
+        mock_client.request_projects.return_value = self.mock_api_responses['projects']
+        mock_client.request_instance_types.return_value = self.mock_api_responses['instance_types']
+        mock_client.request_software_packages.return_value = self.mock_api_responses['software']
+        mock_client.request_extra_environment.return_value = self.mock_api_responses['extra_env']
+
+        coredata.init("nuke")  # nuke only supports linux
+        coredata.data()
+        
+        # Should only have linux instance types since nuke only supports linux
+        self.assertEqual(coredata.platforms(), {"linux"})
+
+    @patch('ciocore.data.api_client')
+    def test_instances_filter(self, mock_client):
+        """Testing that instance_types is passed correctly to api_client"""
+        # Set up mock response
+        mock_client.request_instance_types.return_value = self.mock_api_responses['instance_types']
+        coredata.init("maya-io")
+
+        # Test with no filter
+        coredata.data()
+        mock_client.request_instance_types.assert_called_with(filter_param="")
         
+        # Test with filter and force=True
+        mock_client.request_instance_types.reset_mock()
 
+        instances_filter = "gpu.gpu_count=gte:1:int"
+        coredata.data(force=True, instances_filter=instances_filter)
+        mock_client.request_instance_types.assert_called_with(filter_param=instances_filter)
 
+if __name__ == '__main__':
+    unittest.main()

tests/test_downloader.py

@@ -0,0 +1,118 @@
+
+from ciocore.downloader.job_downloader import JobDownloader, flatten
+import unittest
+from unittest import mock
+from ciocore.downloader.base_downloader import temp_file
+import tempfile
+import shutil
+import os
+import stat
+import contextlib
+
+class TempFileTests(unittest.TestCase):
+
+    def test_temp_file_creation(self):
+        # Create a temporary file and test if it exists
+        with temp_file("tests/files/file.txt") as temp_path:
+            self.assertTrue(os.path.exists(temp_path))
+            self.assertTrue(os.access(temp_path, os.W_OK & os.R_OK))
+
+    def test_temp_file_overwrite_existing(self):
+        # Test if existing file is overwritten by the temporary file
+        # Create a dummy file at the specified path
+        os.makedirs("tests/files", exist_ok=True)
+        with open("tests/files/file.txt", "w") as f:
+            f.write("dummy content")
+
+        # Replace the file with a temporary file and check the content
+        with temp_file("tests/files/file.txt") as temp_path:
+            with open(temp_path, "r") as tf:
+                content = tf.read()
+            self.assertEqual(content, "")
+
+    def test_temp_file_cleanup(self):
+        with temp_file("tests/files/file.txt") as temp_path:
+            pass  # Do nothing
+        self.assertFalse(os.path.exists(temp_path))
+        
+class TestJobDownloaderFlatten(unittest.TestCase):
+
+    def test_pad_job_id(self):
+        input = ("1234",)
+        result = flatten(input)
+        self.assertEqual(result, [{"job_id": "01234", "task_ids":None}])
+
+    def test_several_job_ids(self):
+        input = ("1234","1235","1236")
+        result = flatten(input)
+        self.assertEqual(result, [
+            {"job_id": "01234", "task_ids":None},
+            {"job_id": "01235", "task_ids":None},
+            {"job_id": "01236", "task_ids":None}
+            ])
+
+    def test_job_and_tasks(self):
+        input = ("1234:1-7x2,10",)
+        result = flatten(input)
+        self.assertEqual(result, [{"job_id": "01234", "task_ids":["001","003","005","007","010"]}])
+
+    def test_several_job_and_tasks(self):
+        input = ("1234:1-7x2,10","1235:12-15")
+        result = flatten(input)
+        self.assertEqual(result, [
+            {"job_id": "01234", "task_ids":["001","003","005","007","010"]},
+            {"job_id": "01235", "task_ids":["012","013","014","015"]}
+            ])
+
+    def test_mix_job_and_job_with_tasks(self):
+        input = ("1234","1235:12-15")
+        result = flatten(input)
+        self.assertEqual(result, [
+            {"job_id": "01234", "task_ids":None},
+            {"job_id": "01235", "task_ids":["012","013","014","015"]}
+            ])
+
+    def test_invalid_range_downloads_whole_job(self):
+        # Someone might have a bunch of stuff queued up and made a mistake and left for the night.
+        # We should download the whole job in this case so they don't have to restart the dl in the
+        # morning.
+        input = ("1234:badrange",)
+        result = flatten(input)
+        self.assertEqual(result, [
+            {"job_id": "01234", "task_ids":None}
+            ])
+
+class TestJobDownloaderGetSomeTasks(unittest.TestCase):
+    def setUp(self):
+        # Create a mock instance of JobDownloader
+        self.obj = JobDownloader(jobs=["00000"])
+
+    @mock.patch("ciocore.downloader.job_downloader.logger.error")
+    def test_get_some_tasks_error(self, mock_error):
+        # Mock the api client to return an error
+        mock_api_client = mock.Mock()
+        response = '{"error": "some error message"}'
+        code = 404
+        mock_api_client.make_request.return_value = (response, code)
+        self.obj.client = mock_api_client
+        # call get_some_tasks
+        tasks, locator = self.obj.get_some_tasks({})
+
+        self.assertEqual(tasks, [])
+        self.assertIsNone(locator)
+        mock_error.assert_called_with(
+            'Error fetching download info for job ID: %s : %s : %s', '00000', '/jobs/00000/downloads', mock.ANY)
+
+    def test_get_some_tasks_success(self):
+        mock_api_client = mock.Mock()
+        # Mock the api client to return a batch of tasks and a next cursor
+        response = '{"downloads": [{"id": 1, "name": "task1"}, {"id": 2, "name": "task2"}], "next_cursor": "1234"}'
+        code = 201
+        mock_api_client.make_request.return_value = (response, code)
+        self.obj.client = mock_api_client
+        self.obj.jobs = [{"job_id": "00000", "task_ids": [1, 2]}]
+        # call get_some_tasks with a locator
+        tasks, locator = self.obj.get_some_tasks({"job_index": 0, "cursor": None})
+
+        self.assertEqual(tasks, [{"id": 1, "name": "task1"}, {"id": 2, "name": "task2"}])
+        self.assertEqual(locator, {"job_index": 0, "cursor": "1234"})