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

tests/test_api_client.py

@@ -2,20 +2,18 @@
 
    isort:skip_file
 """
-
-import unittest
-import os
+import datetime
+import json
 import sys
+import unittest
 
-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-from mock import MagicMock
+from unittest import mock
 
 from ciocore import api_client
 
+from ciocore.api_client import request_extra_environment
+from ciocore.api_client import _get_compute_usage, get_compute_usage
+from ciocore.api_client import _get_storage_usage, get_storage_usage
 
 class ApiClientTest(unittest.TestCase):
     @staticmethod
@@ -26,7 +24,7 @@ class ApiClientTest(unittest.TestCase):
             return True
 
     def setUp(self):
-        self.env = {"HOME": "/users/joebloggs"}
+        self.env = {"USERPROFILE": "/users/joebloggs", "HOME": "/users/joebloggs"}
 
         self.api_key_dict = {"api_key": {"client_id": "123", "private_key": "secret123"}}
 
@@ -41,11 +39,298 @@ class ApiClientTest(unittest.TestCase):
 
     def test_get_standard_creds_path(self):
         with mock.patch.dict("os.environ", self.env):
-            fn = api_client.get_creds_path(api_key=False)
+            fn = api_client.get_creds_path(api_key=False).replace("\\", "/")
             self.assertEqual(fn, "/users/joebloggs/.config/conductor/credentials")
 
     def test_get_api_key_creds_path(self):
         with mock.patch.dict("os.environ", self.env):
-            fn = api_client.get_creds_path(api_key=True)
+            fn = api_client.get_creds_path(api_key=True).replace("\\", "/")
             self.assertEqual(fn, "/users/joebloggs/.config/conductor/api_key_credentials")
 
+
+class TestTruncateMiddle(unittest.TestCase):
+
+    def test_truncation_not_needed(self):
+        self.assertEqual(api_client.truncate_middle("short", 10), "short")
+
+    def test_truncation_with_even_max_length(self):
+        self.assertEqual(api_client.truncate_middle("1234567890ABCDEF", 8), "1234~DEF")
+
+    def test_truncation_with_odd_max_length(self):
+        self.assertEqual(api_client.truncate_middle("1234567890ABCDEF", 9), "1234~CDEF")
+
+    def test_empty_string(self):
+        self.assertEqual(api_client.truncate_middle("", 5), "")
+
+    def test_non_string_input(self):
+        with self.assertRaises(TypeError):
+            api_client.truncate_middle(12345, 5)
+
+class TestRegisterClient(unittest.TestCase):
+    USER_AGENT_MAX_PATH_LENGTH = 10  # Example max length for testing
+
+    @classmethod
+    def setUpClass(cls):
+        cls.original_executable = sys.executable
+        sys.executable = '/usr/bin/python3'  # Example path for testing
+
+    @classmethod
+    def tearDownClass(cls):
+        sys.executable = cls.original_executable
+
+    def test_register_client_with_version(self):
+        client_name = 'ApiClient'
+        client_version = '1.0'
+
+        with mock.patch('platform.python_version', return_value='3.8.2'), \
+             mock.patch('platform.system', return_value='Linux'), \
+             mock.patch('platform.release', return_value='5.4.0-42-generic'):
+            user_agent = api_client.ApiClient.register_client(client_name, client_version)
+
+        expected_user_agent = (
+            f"ApiClient/1.0 (python 3.8.2; Linux 5.4.0-42-generic; "
+        )
+        self.assertTrue(user_agent.startswith(expected_user_agent))
+
+    def test_register_client_without_version(self):
+        client_name = 'ApiClient'
+
+        with mock.patch('platform.python_version', return_value='3.8.2'), \
+             mock.patch('platform.system', return_value='Linux'), \
+             mock.patch('platform.release', return_value='5.4.0-42-generic'):
+            user_agent =  api_client.ApiClient.register_client(client_name)
+
+
+        expected_user_agent = (
+            f"ApiClient/unknown (python 3.8.2; Linux 5.4.0-42-generic; "
+        )
+
+        self.assertTrue(user_agent.startswith(expected_user_agent))
+
+
+class TestRequestExtraEnvironment(unittest.TestCase):
+
+    def setUp(self):
+        self.api_response_data = {
+            "data": [
+                {"account_id": "123", "env": ["VAR1=value1", "VAR2=value2"]},
+                {"account_id": "456", "env": ["VAR3=value3", "VAR4=value4"]}
+            ]
+        }
+        self.response_ok = mock.MagicMock(status_code=200, text=json.dumps(self.api_response_data))
+        self.response_error = mock.MagicMock(status_code=500, text=json.dumps({"error": "Internal Server Error"}))
+
+    @mock.patch("ciocore.api_client.ApiClient")
+    @mock.patch("ciocore.api_client.read_conductor_credentials")
+    @mock.patch("ciocore.api_client.account_id_from_jwt")
+    def test_request_extra_environment_success(self, mock_account_id_from_jwt, mock_read_conductor_credentials, mock_ApiClient):
+        # Set up mocks for successful execution
+        mock_read_conductor_credentials.return_value = "valid_token"
+        mock_account_id_from_jwt.return_value = "123"
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_ok.text, self.response_ok.status_code)
+
+        result = request_extra_environment()
+
+        self.assertEqual(result, ["VAR1=value1", "VAR2=value2"])
+        mock_ApiClient.assert_called_once()
+        mock_read_conductor_credentials.assert_called_once_with(True)
+        mock_account_id_from_jwt.assert_called_once_with("valid_token")
+
+    @mock.patch("ciocore.api_client.ApiClient")
+    def test_request_extra_environment_api_failure(self, mock_ApiClient):
+        # Set up mock for API failure
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_error.text, self.response_error.status_code)
+
+        # Assert exception raised when the API call fails
+        with self.assertRaises(Exception) as context:
+            request_extra_environment()
+
+        self.assertIn('Failed to get extra environment', str(context.exception))
+        mock_ApiClient.assert_called_once()
+
+    @mock.patch("ciocore.api_client.ApiClient")
+    @mock.patch("ciocore.api_client.read_conductor_credentials")
+    @mock.patch("ciocore.api_client.account_id_from_jwt")
+    def test_request_extra_environment_no_account_env(self, mock_account_id_from_jwt, mock_read_conductor_credentials, mock_ApiClient):
+        # Set up mocks to simulate valid token and account ID but no matching environment
+        mock_read_conductor_credentials.return_value = "valid_token"
+        mock_account_id_from_jwt.return_value = "invalid_id"  # This won't match any 'account_id' in response
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_ok.text, self.response_ok.status_code)
+
+        with self.assertRaises(Exception) as context:
+            request_extra_environment()
+
+        self.assertEqual("Error: Could not get account environment!", str(context.exception))
+        mock_ApiClient.assert_called_once()
+
+class TestGetComputeUsage(unittest.TestCase):
+
+    def setUp(self):
+        
+        # Precison is rounded to 4 places to avoid FP issues.
+        self.compute_response_data = {
+            "data": [
+                {
+                    "cores": 0.5, 
+                    "instance_cost": 0.0200, 
+                    "license_cost": 0.0200, 
+                    "minutes": 6.9700, 
+                    "self_link": 0, 
+                    "start_time": "Tue, 09 Jan 2024 18:00:00 GMT"
+                }, 
+                {
+                    "cores": 0.4, 
+                    "instance_cost": 0.0200, 
+                    "license_cost": 0.0200, 
+                    "minutes": 6.9600, 
+                    "self_link": 1, 
+                    "start_time": "Tue, 09 Jan 2024 19:00:00 GMT"
+                }, 
+                {
+                    "cores": 0.9613, 
+                    "instance_cost": 0.0400, 
+                    "license_cost": 0.0800, 
+                    "minutes": 7.2100, 
+                    "self_link": 2, 
+                    "start_time": "Tue, 16 Jan 2024 17:00:00 GMT"
+                }, 
+            ]
+        }
+     
+        self.response_ok = mock.MagicMock(status_code=200, text=json.dumps(self.compute_response_data))
+        self.response_error = mock.MagicMock(status_code=500, text=json.dumps({"error": "Internal Server Error"}))
+
+    @mock.patch("ciocore.api_client.ApiClient")
+    @mock.patch("ciocore.api_client.read_conductor_credentials")
+    @mock.patch("ciocore.api_client.account_id_from_jwt")
+    def test_query_raw_compute_usage(self, mock_account_id_from_jwt, mock_read_conductor_credentials, mock_ApiClient):
+        # Set up mocks for successful execution
+        mock_read_conductor_credentials.return_value = "valid_token"
+        mock_account_id_from_jwt.return_value = "123"
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_ok.text, self.response_ok.status_code)
+
+        start_time = datetime.datetime(2024, 1, 1)
+        end_time = datetime.datetime(2024, 3, 20)
+
+        result = _get_compute_usage(start_time, end_time)
+
+        self.assertEqual(result, self.compute_response_data['data'])
+        
+    @mock.patch("ciocore.api_client.ApiClient")
+    @mock.patch("ciocore.api_client.read_conductor_credentials")
+    @mock.patch("ciocore.api_client.account_id_from_jwt")
+    def test_compute_usage(self, mock_account_id_from_jwt, mock_read_conductor_credentials, mock_ApiClient):
+        # Set up mocks for successful execution
+        mock_read_conductor_credentials.return_value = "valid_token"
+        mock_account_id_from_jwt.return_value = "123"
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_ok.text, self.response_ok.status_code)
+
+        start_time = datetime.datetime(2024, 1, 1)
+        end_time = datetime.datetime(2024, 3, 20)
+
+        result = get_compute_usage(start_time=start_time, end_time=end_time)
+
+        self.assertEqual(result, {  '2024-01-09': {'cost': 0.08,
+                                                 'corehours': 0.9, 
+                                                 'walltime': 13.93},
+                                    '2024-01-16': { 'cost': 0.12,
+                                                    'corehours': 0.9613, 
+                                                    'walltime': 7.21}})
+        
+    @mock.patch("ciocore.api_client.ApiClient")
+    def test_get_compute_usage_api_failure(self, mock_ApiClient):
+        # Set up mock for API failure
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_error.text, self.response_error.status_code)
+
+        start_time = datetime.datetime(2024, 1, 1)
+        end_time = datetime.datetime(2024, 3, 20)
+        
+        # Assert exception raised when the API call fails
+        with self.assertRaises(Exception) as context:
+            get_compute_usage(start_time, end_time)
+
+        self.assertIn('Failed to query compute usage', str(context.exception))
+        mock_ApiClient.assert_called_once()    
+class TestGetStorageUsage(unittest.TestCase):
+
+    def setUp(self):
+               
+        self.storage_response_data = {
+            "data": [
+                {
+                "cost": "28.96", 
+                "cost_per_day": [
+                    4.022,
+                    4.502, 
+                    4.502, 
+                    5.102, 
+                    5.102, 
+                    5.732
+                ], 
+                "currency": "USD", 
+                "daily_price": "0.006", 
+                "end_date": "2024-01-07", 
+                "gibs_per_day": [
+                    679.714,
+                    750.34, 
+                    750.34, 
+                    850.36, 
+                    850.35, 
+                    955.32
+                ], 
+                "gibs_used": "806.07", 
+                "monthly_price": "0.18", 
+                "start_date": "2024-01-01", 
+                "storage_unit": "GiB"
+                }
+            ]
+            }
+        
+        self.response_ok = mock.MagicMock(status_code=200, text=json.dumps(self.storage_response_data))
+        self.response_error = mock.MagicMock(status_code=500, text=json.dumps({"error": "Internal Server Error"}))
+        
+    @mock.patch("ciocore.api_client.ApiClient")
+    @mock.patch("ciocore.api_client.read_conductor_credentials")
+    @mock.patch("ciocore.api_client.account_id_from_jwt")
+    def test_query_raw_storage_usage(self, mock_account_id_from_jwt, mock_read_conductor_credentials, mock_ApiClient):
+        # Set up mocks for successful execution
+        mock_read_conductor_credentials.return_value = "valid_token"
+        mock_account_id_from_jwt.return_value = "123"
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_ok.text, self.response_ok.status_code)
+
+        start_time = datetime.datetime(2024, 5, 1)
+        end_time = datetime.datetime(2024, 5, 17)
+
+        result = _get_storage_usage(start_time, end_time)
+
+        self.assertEqual(result, self.storage_response_data['data'][0])
+
+    @mock.patch("ciocore.api_client.ApiClient")
+    @mock.patch("ciocore.api_client.read_conductor_credentials")
+    @mock.patch("ciocore.api_client.account_id_from_jwt")
+    def test_storage_usage(self, mock_account_id_from_jwt, mock_read_conductor_credentials, mock_ApiClient):
+        # Set up mocks for successful execution
+        mock_read_conductor_credentials.return_value = "valid_token"
+        mock_account_id_from_jwt.return_value = "123"
+        mock_api_instance = mock_ApiClient.return_value
+        mock_api_instance.make_request.return_value = (self.response_ok.text, self.response_ok.status_code)
+
+        start_time = datetime.datetime(2024, 1, 1)
+        end_time = datetime.datetime(2024, 1, 7)
+
+        result = get_storage_usage(start_time=start_time, end_time=end_time)
+        
+        self.assertEqual(result, {  '2024-01-01': {'cost': 4.022, 'GiB': 679.714},
+                                    '2024-01-02': {'cost': 4.502, 'GiB': 750.34},
+                                    '2024-01-03': {'cost': 4.502, 'GiB': 750.34},
+                                    '2024-01-04': {'cost': 5.102, 'GiB': 850.36},
+                                    '2024-01-05': {'cost': 5.102, 'GiB': 850.35},
+                                    '2024-01-06': {'cost': 5.732, 'GiB': 955.32}
+                                  })

tests/test_base_downloader.py

@@ -0,0 +1,104 @@
+from ciocore.downloader.base_downloader import (
+    BaseDownloader,
+    DEFAULT_NUM_THREADS,
+    DEFAULT_PROGRESS_INTERVAL,
+    DEFAULT_MAX_ATTEMPTS,
+    DEFAULT_DELAY,
+    DEFAULT_JITTER,
+    DEFAULT_PAGE_SIZE,
+)
+import unittest
+from unittest import mock
+
+from ciocore import api_client
+
+from unittest.mock import  patch
+
+from concurrent.futures import ThreadPoolExecutor
+
+
+class TestBaseDownloaderInit(unittest.TestCase):
+    def test_default_values(self):
+        # Create an instance of the class
+        downloader = BaseDownloader()
+
+        # Assertions
+        self.assertIsNone(downloader.output_path)
+        self.assertFalse(downloader.force)
+        self.assertEqual(downloader.num_threads, DEFAULT_NUM_THREADS)
+        self.assertEqual(downloader.max_queue_size, DEFAULT_NUM_THREADS * 2)
+        self.assertEqual(
+            downloader.progress_interval, DEFAULT_PROGRESS_INTERVAL / 1000.0
+        )
+        self.assertEqual(downloader.page_size, DEFAULT_PAGE_SIZE)
+        self.assertIsInstance(downloader.client, api_client.ApiClient)
+        self.assertEqual(downloader.max_attempts, DEFAULT_MAX_ATTEMPTS)
+        self.assertEqual(downloader.delay, DEFAULT_DELAY)
+        self.assertEqual(downloader.jitter, DEFAULT_JITTER)
+        self.assertIsNone(downloader.regex)
+
+
+    def test_custom_values(self):
+        output_path = "/path/to/destination"
+        num_threads = 4
+        progress_interval = 500
+        page_size = 10
+        force = True
+        regex = r"\d+"
+        max_attempts = 3
+        delay = 2
+        jitter = 0.5
+
+        downloader = BaseDownloader(
+            output_path=output_path,
+            num_threads=num_threads,
+            progress_interval=progress_interval,
+            page_size=page_size,
+            force=force,
+            regex=regex,
+            max_attempts=max_attempts,
+            delay=delay,
+            jitter=jitter,
+        )
+
+        # Assertions
+        self.assertEqual(downloader.output_path, output_path)
+        self.assertTrue(downloader.force)
+        self.assertEqual(downloader.num_threads, num_threads)
+        self.assertEqual(downloader.max_queue_size, num_threads * 2)
+        self.assertAlmostEqual(downloader.progress_interval, progress_interval / 1000.0)
+        self.assertEqual(downloader.page_size, page_size)
+        self.assertIsInstance(downloader.client, api_client.ApiClient)
+        self.assertEqual(downloader.max_attempts, max_attempts)
+        self.assertEqual(downloader.delay, delay)
+        self.assertEqual(downloader.jitter, jitter)
+        self.assertIsNotNone(downloader.regex)
+
+
+class TestBaseDownloaderRun(unittest.TestCase):
+    def setUp(self):
+        self.downloader = BaseDownloader()
+
+    def tearDown(self):
+        pass
+
+    def test_run_method(self):
+        with patch(
+            "ciocore.downloader.base_downloader.ThreadPoolExecutor"
+        ) as mock_executor:
+            my_mock_executor = mock.MagicMock(spec=ThreadPoolExecutor)
+
+            mock_executor.return_value.__enter__.return_value = my_mock_executor
+
+            tasks = [{"id": 1, "name": "task1"}, {"id": 2, "name": "task2"}]
+            next_locator = False
+            mock_get_some_tasks = mock.MagicMock(return_value=(tasks, next_locator))
+
+            self.downloader.get_some_tasks = mock_get_some_tasks
+            self.downloader.download_tasks = mock.MagicMock()
+            self.downloader.event_queue = mock.MagicMock()
+
+            self.downloader.run()
+
+            mock_get_some_tasks.assert_called_with(None)
+            self.downloader.download_tasks.assert_called_with(tasks, my_mock_executor)

tests/test_cli.py

@@ -0,0 +1,149 @@
+from click.testing import CliRunner
+from ciocore.cli import upload as cli_upload
+from ciocore.cli import download as cli_download
+import unittest
+import os
+from unittest import mock
+
+
+class CliTestUploaderOptions(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+        self.default_args = {
+            "database_filepath": None,
+            "location": None,
+            "md5_caching": True,
+            "thread_count": mock.ANY,
+        }
+        init_patcher = mock.patch("ciocore.cli.Uploader.__init__", autospec=True)
+        self.mock_init = init_patcher.start()
+        self.addCleanup(init_patcher.stop)
+
+    def test_receives_full_args_dict_with_defaults_when_no_args_given(self):
+        self.runner.invoke(cli_upload, [])
+        self.mock_init.assert_called_once_with(mock.ANY, self.default_args)
+
+    def test_database_filepath_arg(self):
+        self.runner.invoke(cli_upload, ["--database_filepath", "foo"])
+        expected = self.default_args
+        expected.update({"database_filepath": "foo"})
+        self.mock_init.assert_called_once_with(mock.ANY, expected)
+
+    def test_location_arg(self):
+        self.runner.invoke(cli_upload, ["--location", "foo"])
+        expected = self.default_args
+        expected.update({"location": "foo"})
+        self.mock_init.assert_called_once_with(mock.ANY, expected)
+
+    def test_md5_caching_arg(self):
+        self.runner.invoke(cli_upload, ["--md5_caching", False])
+        expected = self.default_args
+        expected.update({"md5_caching": False})
+        self.mock_init.assert_called_once_with(mock.ANY, expected)
+
+    def test_thread_count_arg(self):
+        self.runner.invoke(cli_upload, ["--thread_count", 4])
+        expected = self.default_args
+        expected.update({"thread_count": 4})
+        self.mock_init.assert_called_once_with(mock.ANY, expected)
+
+
+class CliTestUploaderArguments(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+        uploader_patcher = mock.patch("ciocore.cli.Uploader", autospec=True)
+        self.mock_uploader = uploader_patcher.start()
+        self.mock_inst = self.mock_uploader.return_value
+        self.addCleanup(uploader_patcher.stop)
+
+    def test_path_only_branch_if_paths(self):
+        with self.runner.isolated_filesystem():
+            filenames = ["foo.txt", "bar.txt", "baz.txt", "qux.txt"]
+            filenames = [os.path.join(os.getcwd(), filename) for filename in filenames]
+            for filename in filenames:
+                with open(filename, "w") as f:
+                    f.write("hello world")
+            self.runner.invoke(cli_upload, filenames)
+            self.mock_inst.assets_only.assert_called_once_with(
+                mock.ANY, mock.ANY, mock.ANY, mock.ANY
+            )
+            self.mock_inst.main.assert_not_called()
+
+    def test_main_branch_if_no_paths(self):
+        with self.runner.isolated_filesystem():
+            self.runner.invoke(cli_upload)
+            self.mock_inst.main.assert_called_once()
+            self.mock_inst.assets_only.assert_not_called()
+
+
+class CliTestDownloader(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+        dl_patcher_runner = mock.patch(
+            "ciocore.cli.LoggingDownloadRunner.__init__", autospec=True
+        )
+        self.mock_runner = dl_patcher_runner.start()
+        self.addCleanup(dl_patcher_runner.stop)
+
+        start_daemon_patcher = mock.patch(
+            "ciocore.cli.Downloader.start_daemon", autospec=True
+        )
+        self.mock_start_daemon = start_daemon_patcher.start()
+        self.addCleanup(start_daemon_patcher.stop)
+
+ 
+    def test_jobid_branch_if_job_id(self):
+        jid = "00000"
+        # self.assertTrue(True)
+        self.runner.invoke(cli_download, [jid])
+        self.mock_runner.assert_called_once( )
+        self.mock_start_daemon.assert_not_called()
+
+    # def test_job_id_only(self):
+    #     jid = "00000"
+    #     self.runner.invoke(cli_download, [jid])
+    #     self.mock_dljobs.assert_called_once_with(
+    #         (jid,), thread_count=mock.ANY, output_dir=mock.ANY
+        # )
+
+    # def test_several_job_ids(self):
+    #     jid1 = "00000"
+    #     jid2 = "11111"
+    #     self.runner.invoke(cli_download, [jid1, jid2])
+    #     self.mock_dljobs.assert_called_once_with(
+    #         (jid1,jid2),  thread_count=mock.ANY, output_dir=mock.ANY
+    #     )
+
+    # def test_job_ids_and_others(self):
+    #     jid1 = "00000"
+    #     jid2 = "11111"
+    #     tc = 4
+    #     od = "foo"
+    #     self.runner.invoke(
+    #         cli_download,
+    #         ["--thread_count", tc, "--destination", od, jid1, jid2 ],
+    #     )
+    #     self.mock_dljobs.assert_called_once_with(
+    #         (jid1,jid2), thread_count=tc, output_dir=od
+    #     )
+
+    # def test_daemon_branch_if_no_job_id(self):
+    #     self.runner.invoke(cli_download, [])
+    #     self.mock_start_daemon.assert_called_once()
+    #     self.mock_dljobs.assert_not_called()
+
+    # def test_daemon_branch_args_present(self):
+    #     tc = 4
+    #     od = "foo"
+    #     self.runner.invoke(cli_download)
+    #     self.mock_start_daemon.assert_called_once_with(thread_count=mock.ANY, location=mock.ANY, output_dir=mock.ANY)
+ 
+    # def test_daemon_branch_args(self):
+    #     tc = 4
+    #     od = "/foo"
+    #     loc = "bar"
+    #     self.runner.invoke(cli_download, ["--thread_count", tc, "--location", loc])
+    #     self.mock_start_daemon.assert_called_once_with(thread_count=tc, location="bar", output_dir=None)
+ 

tests/test_common.py

@@ -9,13 +9,7 @@ FILES_PATH = os.path.join(os.path.dirname(__file__), "files")
 
 
 class TestMd5(unittest.TestCase):
- 
-    def test_get_base64_md5_is_correct_md5(self):
-        from ciocore import common
-        fn1 = os.path.join(FILES_PATH, "one")
-        md5=common.get_base64_md5(fn1)
-        self.assertEqual(md5, "9iVbsBxkj+lncU1SqJ6OnA==")
-
+  
     def test_get_base64_md5_is_correct_type(self):
         from ciocore import common
         from builtins import str