gmicloud 0.1.0__py3-none-any.whl

gmicloud/tests/test_artifacts.py

@@ -0,0 +1,274 @@
+import unittest
+from unittest.mock import patch
+from gmicloud._internal._manager._artifact_manager import ArtifactManager
+from gmicloud._internal._client._iam_client import IAMClient
+from gmicloud._internal._models import *
+from gmicloud._internal._enums import BuildStatus
+
+
+class TestArtifactManager(unittest.TestCase):
+
+    def setUp(self):
+        self.mock_user_id = "test_user_id"
+        self.mock_token = "test_token"
+
+        self.iam_client = IAMClient(client_id="test_client_id", email="test_email", password="test_password")
+        self.iam_client._user_id = self.mock_user_id
+        self.iam_client._access_token = self.mock_token
+
+        self.artifact_manager = ArtifactManager(self.iam_client)
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact')
+    def test_get_artifact_returns_artifact(self, mock_get_artifact):
+        mock_get_artifact.return_value = Artifact(artifact_id="1")
+        artifact = self.artifact_manager.get_artifact("1")
+        self.assertEqual(artifact.artifact_id, "1")
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact')
+    def test_get_artifact_raises_error_for_invalid_artifact_id(self, mock_get_artifact):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.get_artifact("")
+        self.assertTrue("Artifact ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact')
+    def test_get_artifact_raises_error_for_nonexistent_artifact(self, mock_get_artifact):
+        mock_get_artifact.side_effect = Exception("Artifact not found")
+        with self.assertRaises(Exception) as context:
+            self.artifact_manager.get_artifact("nonexistent_id")
+        self.assertTrue("Artifact not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_all_artifacts')
+    def test_get_all_artifacts(self, mock_get_all_artifacts):
+        mock_dict = {
+            'artifact_id': 'test',
+            'artifact_data': {
+                'artifact_type': 'DockerImage',
+                'artifact_link': 'link',
+                'build_status': 'SUCCESS',
+                'build_error': '',
+                'build_id': 'test',
+                'build_file_name': '',
+                'create_at': '2024-12-25T03:20:39.820623326Z',
+                'update_at': '2024-12-25T03:36:25.483679194Z',
+                'status': ''
+            },
+            'artifact_metadata': {
+                'user_id': 'test',
+                'artifact_name': 'name',
+                'artifact_description': 'description',
+                'artifact_tags': ['tags', 'test']
+            },
+            'big_files_metadata': None
+        }
+        mock_get_all_artifacts.return_value = [Artifact(**mock_dict)]
+
+        artifacts = self.artifact_manager.get_all_artifacts()
+        self.assertEqual(len(artifacts), 1)
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact')
+    def test_create_artifact(self, mock_create_artifact):
+        mock_response = CreateArtifactResponse(artifact_id="test_artifact_id", upload_link="mock_link")
+        mock_create_artifact.return_value = mock_response
+
+        response = self.artifact_manager.create_artifact("artifact_name")
+        self.assertEqual(response.artifact_id, "test_artifact_id")
+
+    @patch("gmicloud._internal._client._file_upload_client.FileUploadClient.upload_small_file")
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact')
+    def test_create_artifact_with_file(self, mock_create_artifact, mock_upload_small_file):
+        upload_link = "http://upload-link"
+        artifact_file_path = "./testdata/test.zip"
+
+        mock_response = CreateArtifactResponse(artifact_id="test_artifact_id", upload_link=upload_link)
+        mock_create_artifact.return_value = mock_response
+
+        artifact_id = self.artifact_manager.create_artifact_with_file(
+            artifact_name="artifact_name",
+            artifact_file_path=artifact_file_path,
+        )
+        self.assertEqual(artifact_id, "test_artifact_id")
+        mock_upload_small_file.assert_called_once_with(upload_link, artifact_file_path, "application/zip")
+
+    def test_create_artifact_with_file_raises_error_for_invalid_file_type(self):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.create_artifact_with_file("artifact_name", "./testdata/test.txt")
+        self.assertTrue("File type must be application/zip." in str(context.exception))
+
+    def test_create_artifact_with_file_raises_file_not_found_error(self):
+        with self.assertRaises(FileNotFoundError) as context:
+            self.artifact_manager.create_artifact_with_file("artifact_name", "./testdata/nonexistent.zip")
+        self.assertTrue("File not found: ./testdata/nonexistent.zip" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact_from_template')
+    def test_create_artifact_from_template_creates_artifact(self, mock_create_artifact_from_template):
+        mock_create_artifact_from_template.return_value = CreateArtifactFromTemplateResponse(artifact_id="1",
+                                                                                             status="success")
+        artifact_template_id = "template123"
+        response = self.artifact_manager.create_artifact_from_template(artifact_template_id)
+        self.assertEqual(response.artifact_id, "1")
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact_from_template')
+    def test_create_artifact_from_template_raises_error_for_invalid_template_id(self,
+                                                                                mock_create_artifact_from_template):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.create_artifact_from_template("")
+        self.assertTrue("Artifact template ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact_from_template')
+    def test_create_artifact_from_template_raises_error_for_nonexistent_template(self,
+                                                                                 mock_create_artifact_from_template):
+        mock_create_artifact_from_template.side_effect = Exception("Template not found")
+        with self.assertRaises(Exception) as context:
+            self.artifact_manager.create_artifact_from_template("nonexistent_template_id")
+        self.assertTrue("Template not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact')
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_bigfile_upload_url')
+    @patch('gmicloud._internal._client._file_upload_client.FileUploadClient.upload_small_file')
+    @patch('gmicloud._internal._client._file_upload_client.FileUploadClient.upload_large_file')
+    def test_create_artifact_with_model_files(self, mock_upload_large_file, mock_upload_small_file,
+                                              mock_get_bigfile_upload_url, mock_create_artifact):
+        upload_link = "http://upload-link"
+        bigfile_upload_link = "http://bigfile-upload-link"
+        artifact_file_path = "./testdata/test.zip"
+        model_file_path = "./testdata/model.zip"
+
+        mock_create_artifact.return_value = CreateArtifactResponse(artifact_id="1", upload_link=upload_link)
+        mock_get_bigfile_upload_url.return_value = GetBigFileUploadUrlResponse(artifact_id="1",
+                                                                               upload_link=bigfile_upload_link)
+
+        artifact_id = self.artifact_manager.create_artifact_with_model_files(artifact_name="artifact_name",
+                                                                             artifact_file_path=artifact_file_path,
+                                                                             model_file_paths=[model_file_path])
+        self.assertEqual(artifact_id, "1")
+        mock_upload_small_file.assert_called_once_with(upload_link, artifact_file_path, "application/zip")
+        mock_upload_large_file.assert_called_once_with(bigfile_upload_link, model_file_path)
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact')
+    @patch('gmicloud._internal._client._file_upload_client.FileUploadClient.upload_small_file')
+    def test_create_artifact_with_model_files_raises_file_not_found_error_for_model_file(self, mock_create_artifact,
+                                                                                         mock_upload_small_file):
+        upload_link = "http://upload-link"
+        artifact_file_path = "./testdata/test.zip"
+        model_file_path = "./testdata/nonexistent.zip"
+
+        mock_create_artifact.return_value = CreateArtifactResponse(artifact_id="1", upload_link=upload_link)
+
+        with self.assertRaises(FileNotFoundError) as context:
+            self.artifact_manager.create_artifact_with_model_files(artifact_name="artifact_name",
+                                                                   artifact_file_path=artifact_file_path,
+                                                                   model_file_paths=[model_file_path])
+        self.assertTrue(f"File not found: {model_file_path}" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.rebuild_artifact')
+    def test_rebuild_artifact_rebuilds_successfully(self, mock_rebuild_artifact):
+        mock_rebuild_artifact.return_value = RebuildArtifactResponse(artifact_id="1", build_status=BuildStatus.SUCCESS)
+        response = self.artifact_manager.rebuild_artifact("1")
+        self.assertEqual(response.artifact_id, "1")
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.rebuild_artifact')
+    def test_rebuild_artifact_raises_error_for_invalid_artifact_id(self, mock_rebuild_artifact):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.rebuild_artifact("")
+        self.assertTrue("Artifact ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.rebuild_artifact')
+    def test_rebuild_artifact_raises_error_for_nonexistent_artifact(self, mock_rebuild_artifact):
+        mock_rebuild_artifact.side_effect = Exception("Artifact not found")
+        with self.assertRaises(Exception) as context:
+            self.artifact_manager.rebuild_artifact("nonexistent_id")
+        self.assertTrue("Artifact not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_artifact')
+    def test_delete_artifact_deletes_successfully(self, mock_delete_artifact):
+        mock_delete_artifact.return_value = DeleteArtifactResponse(artifact_id="1")
+        response = self.artifact_manager.delete_artifact("1")
+        self.assertEqual(response.artifact_id, "1")
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_artifact')
+    def test_delete_artifact_raises_error_for_invalid_artifact_id(self, mock_delete_artifact):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.delete_artifact("")
+        self.assertTrue("Artifact ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_artifact')
+    def test_delete_artifact_raises_error_for_nonexistent_artifact(self, mock_delete_artifact):
+        mock_delete_artifact.side_effect = Exception("Artifact not found")
+        with self.assertRaises(Exception) as context:
+            self.artifact_manager.delete_artifact("nonexistent_id")
+        self.assertTrue("Artifact not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_bigfile_upload_url')
+    def test_get_bigfile_upload_url_returns_upload_link(self, mock_get_bigfile_upload_url):
+        upload_link = "http://upload-link"
+        model_file_path = "./testdata/model.zip"
+
+        mock_get_bigfile_upload_url.return_value = GetBigFileUploadUrlResponse(artifact_id="1", upload_link=upload_link)
+        upload_link = self.artifact_manager.get_bigfile_upload_url("1", model_file_path)
+        self.assertEqual(upload_link, upload_link)
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_bigfile_upload_url')
+    def test_get_bigfile_upload_url_raises_error_for_invalid_artifact_id(self, mock_get_bigfile_upload_url):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.get_bigfile_upload_url("", "./testdata/test.zip")
+        self.assertTrue("Artifact ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_bigfile_upload_url')
+    def test_get_bigfile_upload_url_raises_error_for_invalid_file_path(self, mock_get_bigfile_upload_url):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.get_bigfile_upload_url("1", "")
+        self.assertTrue("File path is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_bigfile_upload_url')
+    def test_get_bigfile_upload_url_raises_error_for_nonexistent_file(self, mock_get_bigfile_upload_url):
+        with self.assertRaises(FileNotFoundError) as context:
+            self.artifact_manager.get_bigfile_upload_url("1", "./testdata/nonexistent.zip")
+        self.assertTrue("File not found: ./testdata/nonexistent.zip" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_bigfile')
+    def test_delete_bigfile_deletes_successfully(self, mock_delete_bigfile):
+        mock_delete_bigfile.return_value = DeleteBigfileResponse(artifact_id="1", file_name="file.txt",
+                                                                 status="success")
+        response = self.artifact_manager.delete_bigfile("1", "file.txt")
+        self.assertEqual(response, "success")
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_bigfile')
+    def test_delete_bigfile_raises_error_for_invalid_artifact_id(self, mock_delete_bigfile):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.delete_bigfile("", "file.txt")
+        self.assertTrue("Artifact ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_bigfile')
+    def test_delete_bigfile_raises_error_for_invalid_file_name(self, mock_delete_bigfile):
+        with self.assertRaises(ValueError) as context:
+            self.artifact_manager.delete_bigfile("1", "")
+        self.assertTrue("File name is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.delete_bigfile')
+    def test_delete_bigfile_raises_error_for_nonexistent_artifact(self, mock_delete_bigfile):
+        mock_delete_bigfile.side_effect = Exception("Artifact not found")
+        with self.assertRaises(Exception) as context:
+            self.artifact_manager.delete_bigfile("nonexistent_id", "file.txt")
+        self.assertTrue("Artifact not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact_templates')
+    def test_get_artifact_templates_returns_templates(self, mock_get_artifact_templates):
+        mock_get_artifact_templates.return_value = GetArtifactTemplatesResponse(
+            artifact_templates=[ArtifactTemplate(artifact_template_id="1", artifact_name="Template1")])
+        templates = self.artifact_manager.get_artifact_templates()
+        self.assertEqual(len(templates), 1)
+        self.assertEqual(templates[0].artifact_template_id, "1")
+        self.assertEqual(templates[0].artifact_name, "Template1")
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact_templates')
+    def test_get_artifact_templates_returns_empty_list_when_no_templates(self, mock_get_artifact_templates):
+        mock_get_artifact_templates.return_value = GetArtifactTemplatesResponse(artifact_templates=[])
+        templates = self.artifact_manager.get_artifact_templates()
+        self.assertEqual(len(templates), 0)
+
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact_templates')
+    def test_get_artifact_templates_raises_error_on_failure(self, mock_get_artifact_templates):
+        mock_get_artifact_templates.side_effect = Exception("Failed to fetch templates")
+        with self.assertRaises(Exception) as context:
+            self.artifact_manager.get_artifact_templates()
+        self.assertTrue("Failed to fetch templates" in str(context.exception))

gmicloud/tests/test_tasks.py

@@ -0,0 +1,207 @@
+import unittest
+from unittest.mock import MagicMock, patch, Mock
+from gmicloud._internal._manager._task_manager import TaskManager
+from gmicloud._internal._client._iam_client import IAMClient
+from gmicloud._internal._models import *
+
+
+class TestTaskManager(unittest.TestCase):
+
+    def setUp(self):
+        self.mock_user_id = "test_user_id"
+        self.mock_token = "test_token"
+
+        self.iam_client = IAMClient(client_id="test_client_id", email="test_email", password="test_password")
+        self.iam_client._user_id = self.mock_user_id
+        self.iam_client._access_token = self.mock_token
+        self.task_manager = TaskManager(self.iam_client)
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_task')
+    def test_get_task_returns_task_successfully(self, mock_get_task):
+        mock_get_task.return_value = Task(task_id="1")
+        task = self.task_manager.get_task("1")
+        self.assertEqual(task.task_id, "1")
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_task')
+    def test_get_task_raises_error_for_invalid_task_id(self, mock_get_task):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.get_task("")
+        self.assertTrue("Task ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_task')
+    def test_get_task_raises_error_for_nonexistent_task(self, mock_get_task):
+        mock_get_task.side_effect = Exception("Task not found")
+        with self.assertRaises(Exception) as context:
+            self.task_manager.get_task("nonexistent_id")
+        self.assertTrue("Task not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_all_tasks')
+    def test_get_all_tasks_returns_list_of_tasks(self, mock_get_all_tasks):
+        mock_dict = {
+            'task_id': 'test',
+            'owner': {
+                'user_id': 'test',
+                'group_id': 'current_group_id',
+                'service_account_id': 'current_sa_id'
+            },
+            'config': {
+                'ray_task_config': {
+                    'ray_version': 'latest-py311-gpu',
+                    'ray_cluster_image': '',
+                    'file_path': 'serve',
+                    'deployment_name': 'app',
+                    'artifact_id': 'test',
+                    'replica_resource': {
+                        'cpu': 6,
+                        'ram_gb': 64,
+                        'gpu': 2,
+                        'gpu_name': ''
+                    },
+                    'volume_mounts': None
+                },
+                'task_scheduling': {
+                    'scheduling_oneoff': {
+                        'trigger_timestamp': 0,
+                        'min_replicas': 0,
+                        'max_replicas': 0
+                    },
+                    'scheduling_daily': {
+                        'triggers': None
+                    }
+                },
+                'create_timestamp': 1734951094,
+                'last_update_timestamp': 1734975798
+            },
+            'task_status': '',
+            'readiness_status': '',
+            'info': {
+                'endpoint_status': 'ready',
+                'endpoint': 'api.GMICOULD.ai/INFERENCEENGINE/c49bfbc9-3'
+            }
+        }
+        mock_get_all_tasks.return_value = MagicMock(tasks=[Task(**mock_dict)])
+        tasks = self.task_manager.get_all_tasks()
+        self.assertEqual(len(tasks), 1)
+        self.assertEqual(tasks[0].task_id, "test")
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_all_tasks')
+    def test_get_all_tasks_handles_empty_list(self, mock_get_all_tasks):
+        mock_get_all_tasks.return_value = MagicMock(tasks=[])
+        tasks = self.task_manager.get_all_tasks()
+        self.assertEqual(len(tasks), 0)
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.create_task')
+    def test_create_task_raises_error_for_none_task(self, mock_create_task):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.create_task(None)
+        self.assertTrue("Task object is required and cannot be None." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.create_task')
+    def test_create_task_from_file_creates_task(self, mock_create_task):
+        self.task_manager.create_task_from_file("1", "./testdata/one-off_task.json", int(datetime.now().timestamp()))
+        mock_create_task.assert_called_once()
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.create_task')
+    def test_create_task_from_file_raises_error_for_invalid_file(self, mock_create_task):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.create_task_from_file("1", "./testdata/one-off_task_err.json")
+        self.assertTrue("Failed to parse Task from file" in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.update_task_schedule')
+    def test_update_task_schedule_raises_error_for_none_task(self, mock_update_task_schedule):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.update_task_schedule(None)
+        self.assertTrue("Task object is required and cannot be None." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.update_task_schedule')
+    def test_update_task_schedule_from_file_updates_schedule(self, mock_update_task_schedule):
+        self.task_manager.update_task_schedule_from_file("1", "1", "./testdata/daily_task.json")
+        mock_update_task_schedule.assert_called_once()
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.update_task_schedule')
+    def test_update_task_schedule_from_file_raises_error_for_invalid_file(self, mock_update_task_schedule):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.update_task_schedule_from_file("1", "1", "./testdata/one-off_task_err.json")
+        self.assertTrue("Failed to parse Task from file" in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.start_task')
+    def test_start_task_starts_successfully(self, mock_start_task):
+        mock_start_task.return_value = None
+        self.task_manager.start_task("1")
+        mock_start_task.assert_called_once_with("1")
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.start_task')
+    def test_start_task_raises_error_for_invalid_task_id(self, mock_start_task):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.start_task("")
+        self.assertTrue("Task ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.start_task')
+    def test_start_task_raises_error_for_nonexistent_task(self, mock_start_task):
+        mock_start_task.side_effect = Exception("Task not found")
+        with self.assertRaises(Exception) as context:
+            self.task_manager.start_task("nonexistent_id")
+        self.assertTrue("Task not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.stop_task')
+    def test_stop_task_stops_successfully(self, mock_stop_task):
+        mock_stop_task.return_value = None
+        self.task_manager.stop_task("1")
+        mock_stop_task.assert_called_once_with("1")
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.stop_task')
+    def test_stop_task_raises_error_for_invalid_task_id(self, mock_stop_task):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.stop_task("")
+        self.assertTrue("Task ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.stop_task')
+    def test_stop_task_raises_error_for_nonexistent_task(self, mock_stop_task):
+        mock_stop_task.side_effect = Exception("Task not found")
+        with self.assertRaises(Exception) as context:
+            self.task_manager.stop_task("nonexistent_id")
+        self.assertTrue("Task not found" in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_usage_data')
+    def test_get_usage_data_returns_data_successfully(self, mock_get_usage_data):
+        mock_get_usage_data.return_value = GetUsageDataResponse(usage_data=[Usage(replica_count=1)])
+        response = self.task_manager.get_usage_data("2023-01-01T00:00:00Z", "2023-01-31T23:59:59Z")
+        self.assertEqual(response.usage_data[0].replica_count, 1)
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_usage_data')
+    def test_get_usage_data_raises_error_for_invalid_start_timestamp(self, mock_get_usage_data):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.get_usage_data("", "2023-01-31T23:59:59Z")
+        self.assertTrue("Start timestamp is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_usage_data')
+    def test_get_usage_data_raises_error_for_invalid_end_timestamp(self, mock_get_usage_data):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.get_usage_data("2023-01-01T00:00:00Z", "")
+        self.assertTrue("End timestamp is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.get_usage_data')
+    def test_get_usage_data_raises_error_on_failure(self, mock_get_usage_data):
+        mock_get_usage_data.side_effect = Exception("Failed to fetch usage data")
+        with self.assertRaises(Exception) as context:
+            self.task_manager.get_usage_data("2023-01-01T00:00:00Z", "2023-01-31T23:59:59Z")
+        self.assertTrue("Failed to fetch usage data" in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.archive_task')
+    def test_archive_task_archives_successfully(self, mock_archive_task):
+        mock_archive_task.return_value = None
+        self.task_manager.archive_task("1")
+        mock_archive_task.assert_called_once_with("1")
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.archive_task')
+    def test_archive_task_raises_error_for_invalid_task_id(self, mock_archive_task):
+        with self.assertRaises(ValueError) as context:
+            self.task_manager.archive_task("")
+        self.assertTrue("Task ID is required and cannot be empty." in str(context.exception))
+
+    @patch('gmicloud._internal._client._task_client.TaskClient.archive_task')
+    def test_archive_task_raises_error_for_nonexistent_task(self, mock_archive_task):
+        mock_archive_task.side_effect = Exception("Task not found")
+        with self.assertRaises(Exception) as context:
+            self.task_manager.archive_task("nonexistent_id")
+        self.assertTrue("Task not found" in str(context.exception))