pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/cli/commands/test_usage_limits.py

@@ -0,0 +1,412 @@
+import unittest
+from unittest.mock import patch, Mock
+
+from pygeai.cli.commands import Option
+from pygeai.cli.commands.usage_limits import (
+    show_help,
+    set_organization_usage_limit,
+    get_organization_latest_usage_limit,
+    get_all_usage_limits_from_organization,
+    delete_usage_limit_from_organization,
+    update_organization_usage_limit,
+    set_project_usage_limit,
+    get_all_usage_limits_from_project,
+    get_latest_usage_limit_from_project,
+    get_active_usage_limit_from_project,
+    delete_usage_limit_from_project,
+    update_project_usage_limit
+)
+from pygeai.core.common.exceptions import MissingRequirementException
+
+
+class TestUsageLimitsCommands(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_usage_limits.TestUsageLimitsCommands
+    """
+    def setUp(self):
+        # Helper to create Option objects for testing
+        self.mock_option = lambda name, value: (Option(name, [f"--{name}"], f"Description for {name}", True), value)
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.build_help_text')
+    def test_show_help(self, mock_build_help, mock_write_stdout):
+        mock_help_text = "Mocked help text"
+        mock_build_help.return_value = mock_help_text
+
+        show_help()
+
+        mock_build_help.assert_called_once()
+        mock_write_stdout.assert_called_once_with(mock_help_text)
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_set_organization_usage_limit_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.set_organization_usage_limit.return_value = {"status": "set"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("subscription_type", "basic"),
+            self.mock_option("usage_unit", "requests"),
+            self.mock_option("soft_limit", "100"),
+            self.mock_option("hard_limit", "200"),
+            self.mock_option("renewal_status", "monthly")
+        ]
+
+        set_organization_usage_limit(option_list)
+
+        mock_instance.set_organization_usage_limit.assert_called_once_with(
+            organization="org123",
+            usage_limit={
+                "subscriptionType": "basic",
+                "usageUnit": "requests",
+                "softLimit": "100",
+                "hardLimit": "200",
+                "renewalStatus": "monthly"
+            }
+        )
+        mock_write_stdout.assert_called_once_with("Organization usage limit: \n{'status': 'set'}")
+
+    def test_set_organization_usage_limit_missing_organization(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            set_organization_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot set usage limit for organization without organization ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_get_organization_latest_usage_limit_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_organization_latest_usage_limit.return_value = {"limit": "latest"}
+        option_list = [self.mock_option("organization", "org123")]
+
+        get_organization_latest_usage_limit(option_list)
+
+        mock_instance.get_organization_latest_usage_limit.assert_called_once_with(organization="org123")
+        mock_write_stdout.assert_called_once_with("Organization usage limit: \n{'limit': 'latest'}")
+
+    def test_get_organization_latest_usage_limit_missing_organization(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_organization_latest_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot get latest usage limit for organization without organization ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_get_all_usage_limits_from_organization_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_all_usage_limits_from_organization.return_value = {"limits": ["limit1", "limit2"]}
+        option_list = [self.mock_option("organization", "org123")]
+
+        get_all_usage_limits_from_organization(option_list)
+
+        mock_instance.get_all_usage_limits_from_organization.assert_called_once_with(organization="org123")
+        mock_write_stdout.assert_called_once_with("Organization usage limits: \n{'limits': ['limit1', 'limit2']}")
+
+    def test_get_all_usage_limits_from_organization_missing_organization(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_all_usage_limits_from_organization(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot get all usage limits for organization without organization ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_delete_usage_limit_from_organization_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.delete_usage_limit_from_organization.return_value = {"status": "deleted"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("limit_id", "limit456")
+        ]
+
+        delete_usage_limit_from_organization(option_list)
+
+        mock_instance.delete_usage_limit_from_organization.assert_called_once_with(
+            organization="org123",
+            limit_id="limit456"
+        )
+        mock_write_stdout.assert_called_once_with("Deleted usage limit: \n{'status': 'deleted'}")
+
+    def test_delete_usage_limit_from_organization_missing_fields(self):
+        option_list = [self.mock_option("organization", "org123")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            delete_usage_limit_from_organization(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot delete usage limit for organization without organization ID and limit ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_update_organization_usage_limit_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.set_organization_hard_limit.return_value = {"status": "updated_hard"}
+        mock_instance.set_organization_soft_limit.return_value = {"status": "updated_soft"}
+        mock_instance.set_organization_renewal_status.return_value = {"status": "updated_renewal"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("limit_id", "limit456"),
+            self.mock_option("hard_limit", "200"),
+            self.mock_option("soft_limit", "100"),
+            self.mock_option("renewal_status", "monthly")
+        ]
+
+        update_organization_usage_limit(option_list)
+
+        mock_instance.set_organization_hard_limit.assert_called_once_with(
+            organization="org123",
+            limit_id="limit456",
+            hard_limit="200"
+        )
+        mock_instance.set_organization_soft_limit.assert_called_once_with(
+            organization="org123",
+            limit_id="limit456",
+            soft_limit="100"
+        )
+        mock_instance.set_organization_renewal_status.assert_called_once_with(
+            organization="org123",
+            limit_id="limit456",
+            renewal_status="monthly"
+        )
+
+    def test_update_organization_usage_limit_missing_fields(self):
+        option_list = [self.mock_option("organization", "org123")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_organization_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot update usage limit for organization without organization ID and limit ID")
+
+    def test_update_organization_usage_limit_missing_update_values(self):
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("limit_id", "limit456")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_organization_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "At least one of the following parameters must be define to update usage limit: --soft-limit, --hard-limit or --renewal-status")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_set_project_usage_limit_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.set_project_usage_limit.return_value = {"status": "set"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456"),
+            self.mock_option("subscription_type", "premium"),
+            self.mock_option("usage_unit", "tokens"),
+            self.mock_option("soft_limit", "500"),
+            self.mock_option("hard_limit", "1000"),
+            self.mock_option("renewal_status", "yearly")
+        ]
+
+        set_project_usage_limit(option_list)
+
+        mock_instance.set_project_usage_limit.assert_called_once_with(
+            organization="org123",
+            project="proj456",
+            usage_limit={
+                "subscriptionType": "premium",
+                "usageUnit": "tokens",
+                "softLimit": "500",
+                "hardLimit": "1000",
+                "renewalStatus": "yearly"
+            }
+        )
+        mock_write_stdout.assert_called_once_with("Project usage limit: \n{'status': 'set'}")
+
+    def test_set_project_usage_limit_missing_fields(self):
+        option_list = [self.mock_option("organization", "org123")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            set_project_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot set usage limit for project without organization and project ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_get_all_usage_limits_from_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_all_usage_limits_from_project.return_value = {"limits": ["limit1", "limit2"]}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456")
+        ]
+
+        get_all_usage_limits_from_project(option_list)
+
+        mock_instance.get_all_usage_limits_from_project.assert_called_once_with(
+            organization="org123",
+            project="proj456"
+        )
+        mock_write_stdout.assert_called_once_with("Project usage limits: \n{'limits': ['limit1', 'limit2']}")
+
+    def test_get_all_usage_limits_from_project_missing_fields(self):
+        option_list = [self.mock_option("organization", "org123")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_all_usage_limits_from_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot get usage limits for project without organization and project ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_get_latest_usage_limit_from_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_latest_usage_limit_from_project.return_value = {"limit": "latest"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456")
+        ]
+
+        get_latest_usage_limit_from_project(option_list)
+
+        mock_instance.get_latest_usage_limit_from_project.assert_called_once_with(
+            organization="org123",
+            project="proj456"
+        )
+        mock_write_stdout.assert_called_once_with("Project's latest usage limit: \n{'limit': 'latest'}")
+
+    def test_get_latest_usage_limit_from_project_missing_fields(self):
+        option_list = [self.mock_option("organization", "org123")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_latest_usage_limit_from_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot get latest usage limit for project without organization and project ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_get_active_usage_limit_from_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_active_usage_limit_from_project.return_value = {"limit": "active"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456")
+        ]
+
+        get_active_usage_limit_from_project(option_list)
+
+        mock_instance.get_active_usage_limit_from_project.assert_called_once_with(
+            organization="org123",
+            project="proj456"
+        )
+        mock_write_stdout.assert_called_once_with("Project's latest usage limit: \n{'limit': 'active'}")
+
+    def test_get_active_usage_limit_from_project_missing_fields(self):
+        option_list = [self.mock_option("organization", "org123")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_active_usage_limit_from_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot get active usage limit for project without organization and project ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_delete_usage_limit_from_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.delete_usage_limit_from_project.return_value = {"status": "deleted"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456"),
+            self.mock_option("limit_id", "limit789")
+        ]
+
+        delete_usage_limit_from_project(option_list)
+
+        mock_instance.delete_usage_limit_from_project.assert_called_once_with(
+            organization="org123",
+            project="proj456",
+            limit_id="limit789"
+        )
+        mock_write_stdout.assert_called_once_with("Deleted usage limit: \n{'status': 'deleted'}")
+
+    def test_delete_usage_limit_from_project_missing_fields(self):
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            delete_usage_limit_from_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot delete usage limit for project without organization, project and limit ID")
+
+    @patch('pygeai.cli.commands.usage_limits.Console.write_stdout')
+    @patch('pygeai.cli.commands.usage_limits.UsageLimitClient')
+    def test_update_project_usage_limit_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.set_hard_limit_for_active_usage_limit_from_project.return_value = {"status": "updated_hard"}
+        mock_instance.set_soft_limit_for_active_usage_limit_from_project.return_value = {"status": "updated_soft"}
+        mock_instance.set_project_renewal_status.return_value = {"status": "updated_renewal"}
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456"),
+            self.mock_option("limit_id", "limit789"),
+            self.mock_option("hard_limit", "200"),
+            self.mock_option("soft_limit", "100"),
+            self.mock_option("renewal_status", "monthly")
+        ]
+
+        update_project_usage_limit(option_list)
+
+        mock_instance.set_hard_limit_for_active_usage_limit_from_project.assert_called_once_with(
+            organization="org123",
+            project="proj456",
+            limit_id="limit789",
+            hard_limit="200"
+        )
+        mock_instance.set_soft_limit_for_active_usage_limit_from_project.assert_called_once_with(
+            organization="org123",
+            project="proj456",
+            limit_id="limit789",
+            soft_limit="100"
+        )
+        mock_instance.set_project_renewal_status.assert_called_once_with(
+            organization="org123",
+            project="proj456",
+            limit_id="limit789",
+            renewal_status="monthly"
+        )
+
+    def test_update_project_usage_limit_missing_fields(self):
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_project_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot update usage limit for project without organization ID, project ID and limit ID")
+
+    def test_update_project_usage_limit_missing_update_values(self):
+        option_list = [
+            self.mock_option("organization", "org123"),
+            self.mock_option("project", "proj456"),
+            self.mock_option("limit_id", "limit789")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_project_usage_limit(option_list)
+
+        self.assertEqual(str(context.exception), "At least one of the following parameters must be define to update usage limit: --soft-limit, --hard-limit or --renewal-status")
+

pygeai/tests/cli/commands/test_validators.py

@@ -0,0 +1,160 @@
+import unittest
+from pathlib import Path
+import tempfile
+import os
+
+from pygeai.cli.commands.validators import validate_dataset_file, validate_row_structure, validate_system_metric
+from pygeai.core.common.exceptions import WrongArgumentError
+
+
+class TestValidators(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_validators.TestValidators
+    """
+
+    def test_validate_dataset_file_not_found(self):
+        with self.assertRaises(FileNotFoundError) as cm:
+            validate_dataset_file("nonexistent_file.txt")
+        self.assertEqual(str(cm.exception), "Dataset file not found: nonexistent_file.txt")
+
+    def test_validate_dataset_file_not_a_file(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with self.assertRaises(ValueError) as cm:
+                validate_dataset_file(temp_dir)
+            self.assertEqual(str(cm.exception), f"Dataset path is not a file: {temp_dir}")
+
+    def test_validate_dataset_file_valid(self):
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            temp_file.write(b"test content")
+            temp_file_path = temp_file.name
+
+        try:
+            validate_dataset_file(temp_file_path)
+        finally:
+            os.unlink(temp_file_path)
+
+    def test_validate_row_structure_missing_required_field(self):
+        row = {
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input"
+        }
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_row_structure(row)
+        self.assertEqual(str(cm.exception), 'Missing or invalid value for required field "dataSetRowExpectedAnswer". It must be a non-empty string.')
+
+    def test_validate_row_structure_invalid_required_field_type(self):
+        row = {
+            "dataSetRowExpectedAnswer": 123,
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input"
+        }
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_row_structure(row)
+        self.assertEqual(str(cm.exception), 'Missing or invalid value for required field "dataSetRowExpectedAnswer". It must be a non-empty string.')
+
+    def test_validate_row_structure_invalid_expected_sources_type(self):
+        row = {
+            "dataSetRowExpectedAnswer": "answer",
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input",
+            "expectedSources": "not a list"
+        }
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_row_structure(row)
+        self.assertEqual(str(cm.exception), '"expectedSources" must be a list of objects, even if empty.')
+
+    def test_validate_row_structure_invalid_expected_source_structure(self):
+        row = {
+            "dataSetRowExpectedAnswer": "answer",
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input",
+            "expectedSources": [{"invalid_key": "value"}]
+        }
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_row_structure(row)
+        self.assertEqual(str(cm.exception), 'Each item in "expectedSources" must be a dictionary containing the following string fields: "dataSetExpectedSourceId", "dataSetExpectedSourceName", "dataSetExpectedSourceValue", and "dataSetExpectedSourceExtension".')
+
+    def test_validate_row_structure_invalid_filter_variables_type(self):
+        row = {
+            "dataSetRowExpectedAnswer": "answer",
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input",
+            "expectedSources": [],
+            "filterVariables": "not a list"
+        }
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_row_structure(row)
+        self.assertEqual(str(cm.exception), '"filterVariables" must be a list of objects, even if empty.')
+
+    def test_validate_row_structure_invalid_filter_variable_structure(self):
+        row = {
+            "dataSetRowExpectedAnswer": "answer",
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input",
+            "expectedSources": [],
+            "filterVariables": [{"invalid_key": "value"}]
+        }
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_row_structure(row)
+        self.assertEqual(str(cm.exception), 'Each item in "filterVariables" must be a dictionary containing the following string fields: "dataSetMetadataType", "dataSetRowFilterKey", "dataSetRowFilterOperator", "dataSetRowFilterValue", and "dataSetRowFilterVarId".')
+
+    def test_validate_row_structure_valid(self):
+        row = {
+            "dataSetRowExpectedAnswer": "answer",
+            "dataSetRowContextDocument": "context",
+            "dataSetRowInput": "input",
+            "expectedSources": [{
+                "dataSetExpectedSourceId": "id",
+                "dataSetExpectedSourceName": "name",
+                "dataSetExpectedSourceValue": "value",
+                "dataSetExpectedSourceExtension": "ext"
+            }],
+            "filterVariables": [{
+                "dataSetMetadataType": "type",
+                "dataSetRowFilterKey": "key",
+                "dataSetRowFilterOperator": "op",
+                "dataSetRowFilterValue": "val",
+                "dataSetRowFilterVarId": "var_id"
+            }]
+        }
+        validate_row_structure(row)
+
+    def test_validate_system_metric_not_dict(self):
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_system_metric("not a dict")
+        self.assertEqual(str(cm.exception), "Each system metric must be a dictionary.")
+
+    def test_validate_system_metric_missing_required_field(self):
+        metric = {"systemMetricWeight": 0.5}
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_system_metric(metric)
+        self.assertEqual(str(cm.exception), 'Missing required field "systemMetricId" in system metric.')
+
+    def test_validate_system_metric_invalid_id_type(self):
+        metric = {"systemMetricId": 123, "systemMetricWeight": 0.5}
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_system_metric(metric)
+        self.assertEqual(str(cm.exception), '"systemMetricId" must be a non-empty string.')
+
+    def test_validate_system_metric_empty_id(self):
+        metric = {"systemMetricId": "", "systemMetricWeight": 0.5}
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_system_metric(metric)
+        self.assertEqual(str(cm.exception), '"systemMetricId" must be a non-empty string.')
+
+    def test_validate_system_metric_invalid_weight_type(self):
+        metric = {"systemMetricId": "id", "systemMetricWeight": "invalid"}
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_system_metric(metric)
+        self.assertEqual(str(cm.exception), '"systemMetricWeight" must be a number between 0 and 1 (inclusive).')
+
+    def test_validate_system_metric_weight_out_of_range(self):
+        metric = {"systemMetricId": "id", "systemMetricWeight": 1.5}
+        with self.assertRaises(WrongArgumentError) as cm:
+            validate_system_metric(metric)
+        self.assertEqual(str(cm.exception), '"systemMetricWeight" must be a number between 0 and 1 (inclusive).')
+
+    def test_validate_system_metric_valid(self):
+        metric = {"systemMetricId": "valid_id", "systemMetricWeight": 0.75}
+        validate_system_metric(metric)
+

pygeai/tests/cli/commands/test_version.py

@@ -0,0 +1,81 @@
+import unittest
+from unittest.mock import patch, Mock
+import requests
+import importlib.metadata
+
+from pygeai.cli.commands.version import get_latest_version, get_installed_version, check_new_version
+
+
+class TestVersion(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_version.TestVersion
+    """
+    def test_get_latest_version_success(self):
+        package_name = "test-package"
+        mock_response = Mock()
+        mock_response.text = '{"info": {"version": "1.2.3"}}'
+        mock_response.raise_for_status.return_value = None
+
+        with patch('requests.get', return_value=mock_response):
+            result = get_latest_version(package_name)
+            self.assertEqual(result, "1.2.3")
+
+    def test_get_latest_version_request_exception(self):
+        package_name = "test-package"
+        with patch('requests.get', side_effect=requests.RequestException("Connection error")):
+            result = get_latest_version(package_name)
+            self.assertIsNone(result)
+
+    def test_get_installed_version_success(self):
+        package_name = "test-package"
+        with patch('importlib.metadata.version', return_value="1.0.0"):
+            result = get_installed_version(package_name)
+            self.assertEqual(result, "1.0.0")
+
+    def test_get_installed_version_not_installed(self):
+        package_name = "test-package"
+        with patch('importlib.metadata.version', side_effect=importlib.metadata.PackageNotFoundError):
+            result = get_installed_version(package_name)
+            self.assertEqual(result, "Not installed")
+
+    def test_get_installed_version_unknown(self):
+        package_name = "test-package"
+        with patch('importlib.metadata.version', side_effect=ModuleNotFoundError):
+            result = get_installed_version(package_name)
+            self.assertEqual(result, "Unknown")
+
+    def test_check_new_version_latest_greater(self):
+        package_name = "test-package"
+        with patch('pygeai.cli.commands.version.get_latest_version', return_value="2.0.0"):
+            with patch('pygeai.cli.commands.version.get_installed_version', return_value="1.0.0"):
+                result = check_new_version(package_name)
+                self.assertIn("There's a new version available: 2.0.0", result)
+
+    def test_check_new_version_same_version(self):
+        package_name = "test-package"
+        with patch('pygeai.cli.commands.version.get_latest_version', return_value="1.0.0"):
+            with patch('pygeai.cli.commands.version.get_installed_version', return_value="1.0.0"):
+                result = check_new_version(package_name)
+                self.assertIn("You have the latest version 1.0.0", result)
+
+    def test_check_new_version_not_installed(self):
+        package_name = "test-package"
+        with patch('pygeai.cli.commands.version.get_latest_version', return_value="2.0.0"):
+            with patch('pygeai.cli.commands.version.get_installed_version', return_value="Not installed"):
+                result = check_new_version(package_name)
+                self.assertIn("not installed, but the latest version available is 2.0.0", result)
+
+    def test_check_new_version_unknown_version(self):
+        package_name = "test-package"
+        with patch('pygeai.cli.commands.version.get_latest_version', return_value="2.0.0"):
+            with patch('pygeai.cli.commands.version.get_installed_version', return_value="Unknown"):
+                result = check_new_version(package_name)
+                self.assertEqual(result, "Could not determine version information.")
+
+    def test_check_new_version_latest_none(self):
+        package_name = "test-package"
+        with patch('pygeai.cli.commands.version.get_latest_version', return_value=None):
+            with patch('pygeai.cli.commands.version.get_installed_version', return_value="1.0.0"):
+                result = check_new_version(package_name)
+                self.assertEqual(result, "Could not determine version information.")
+