codemie-test-harness 0.1.215__tar.gz → 0.1.216__tar.gz

{codemie_test_harness-0.1.215 → codemie_test_harness-0.1.216}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codemie-test-harness
-Version: 0.1.215
+Version: 0.1.216
 Summary: Autotest for CodeMie backend and UI
 Author: Anton Yeromin
 Author-email: anton_yeromin@epam.com
@@ -13,7 +13,7 @@ Requires-Dist: aws-assume-role-lib (>=2.10.0,<3.0.0)
 Requires-Dist: boto3 (>=1.39.8,<2.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: codemie-plugins (>=0.1.123,<0.2.0)
-Requires-Dist: codemie-sdk-python (==0.1.215)
+Requires-Dist: codemie-sdk-python (==0.1.216)
 Requires-Dist: pytest (>=8.4.1,<9.0.0)
 Requires-Dist: pytest-playwright (>=0.7.0,<0.8.0)
 Requires-Dist: pytest-repeat (>=0.9.3,<0.10.0)

{codemie_test_harness-0.1.215 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/conftest.py

@@ -439,6 +439,41 @@ def webhook_integration(integration_utils):
             pass
 
 
+@pytest.fixture(scope="module")
+def scheduler_integration(integration_utils):
+    created_integrations = []
+
+    def _create(
+        alias,
+        resource_type,
+        resource_id,
+        prompt: str = None,
+        schedule: str = "* * * * *",  # every minute
+        is_enabled: bool = True,
+    ):
+        credential_values = [
+            CredentialValues(key="url", value=CredentialsManager.AUTO_GENERATED),
+            CredentialValues(key="is_enabled", value=is_enabled),
+            CredentialValues(key="schedule", value=schedule),
+            CredentialValues(key="resource_type", value=resource_type),
+            CredentialValues(key="resource_id", value=resource_id),
+            CredentialValues(key="prompt", value=prompt),
+        ]
+        integration = integration_utils.create_integration(
+            CredentialTypes.SCHEDULER, credential_values, integration_alias=alias
+        )
+        created_integrations.append(integration)
+        return integration
+
+    yield _create
+
+    for integration in created_integrations:
+        try:
+            integration_utils.delete_integration(integration)
+        except HTTPError:
+            pass
+
+
 @pytest.fixture(scope="function")
 def general_integration(integration_utils):
     created_integration: Optional[Integration] = None

codemie_test_harness-0.1.216/codemie_test_harness/tests/scheduler/test_scheduler_service.py

@@ -0,0 +1,264 @@
+"""Scheduler integration tests for CodeMie.
+
+This module contains tests for scheduler functionality including:
+- Basic scheduler operations with different resource types (assistant, workflow, datasource)
+- Error handling and validation for invalid cron expressions
+- Error handling for invalid resource IDs
+- Disabled scheduler verification
+"""
+
+import pytest
+
+from hamcrest import (
+    assert_that,
+    equal_to,
+    has_item,
+    any_of,
+)
+from requests import HTTPError
+from codemie_test_harness.tests.utils.base_utils import get_random_name, wait_for_entity
+from codemie_sdk.models.datasource import DataSourceStatus
+
+
+@pytest.mark.scheduler
+@pytest.mark.api
+class TestSchedulerValidIntegrations:
+    """Tests for valid scheduler integrations - verify scheduler creation with different resource types."""
+
+    def test_scheduler_with_assistant(
+        self, assistant, scheduler_integration, conversation_utils
+    ):
+        """Test scheduler can be created with assistant resource type.
+
+        This test verifies:
+        1. Scheduler integration can be created with an assistant
+        2. Integration stores correct configuration (schedule, resource type, resource ID)
+        3. Assistant can be triggered manually to verify the resource is valid
+        """
+        scheduler_alias = get_random_name()
+        message = f"Test message for scheduler {scheduler_alias}"
+
+        # Create assistant
+        assistant = assistant()
+
+        # Create scheduler integration with assistant
+        scheduler_integration(
+            alias=scheduler_alias,
+            resource_type="assistant",
+            resource_id=assistant.id,
+            prompt=message,
+            is_enabled=True,
+        )
+
+        # Wait for conversation
+        conversation = wait_for_entity(
+            lambda: conversation_utils.list_conversations(),
+            entity_name=message,
+            timeout=80,
+        )
+
+        # Verify conversation details
+        assert_that(conversation.name, equal_to(message))
+        assert_that(conversation.initial_assistant_id, equal_to(assistant.id))
+        assert_that(conversation.assistant_ids, has_item(assistant.id))
+
+    def test_scheduler_with_workflow(
+        self,
+        workflow_with_virtual_assistant,
+        scheduler_integration,
+        workflow_utils,
+    ):
+        """Test scheduler can be created with workflow resource type.
+
+        This test verifies:
+        1. Scheduler integration can be created with a workflow
+        2. Integration stores correct configuration
+        3. Workflow can be executed manually to verify the resource is valid
+        """
+        scheduler_alias = get_random_name()
+        message = f"Test message for scheduler {scheduler_alias}"
+
+        # Create a simple workflow
+        workflow = workflow_with_virtual_assistant(scheduler_alias)
+
+        # Create scheduler integration with workflow
+        scheduler_integration(
+            alias=scheduler_alias,
+            resource_type="workflow",
+            resource_id=workflow.id,
+            prompt=message,
+            is_enabled=True,
+        )
+
+        # Wait for execution with specific prompt
+        execution = wait_for_entity(
+            lambda: workflow_utils.get_executions(workflow),
+            entity_name=message,
+            timeout=80,
+        )
+
+        # Verify execution details
+        assert_that(execution.prompt.strip('""'), equal_to(message))
+        assert_that(execution.workflow_id, equal_to(workflow.id))
+
+    @pytest.mark.parametrize(
+        "datasource_fixture",
+        [
+            "jira_datasource",
+            "confluence_datasource",
+            "code_datasource",
+        ],
+    )
+    def test_scheduler_with_datasource(
+        self,
+        request,
+        datasource_fixture,
+        scheduler_integration,
+        datasource_utils,
+    ):
+        """Test scheduler can be created with datasource resource type.
+
+        This test verifies:
+        1. Scheduler integration can be created with different datasource types
+        2. Integration stores correct configuration
+        3. Datasource indexing can be triggered manually to verify the resource is valid
+
+        Test is parametrized to work with different datasource types:
+        - jira_datasource
+        - confluence_datasource
+        - code_datasource
+        """
+        # Get the datasource from the fixture
+        datasource = request.getfixturevalue(datasource_fixture)
+        scheduler_alias = get_random_name()
+
+        # Create scheduler integration with datasource
+        scheduler_integration(
+            alias=scheduler_alias,
+            resource_type="datasource",
+            resource_id=datasource.id,
+            is_enabled=True,
+        )
+
+        triggered_datasource = datasource_utils.wait_for_update_date_change(
+            datasource_id=datasource.id, timeout=80
+        )
+
+        # Verify datasource exists and check its status (indexing should be in progress)
+        assert_that(triggered_datasource.id, equal_to(datasource.id))
+        assert_that(triggered_datasource.name, equal_to(datasource.name))
+        assert_that(triggered_datasource.status, DataSourceStatus.FETCHING)
+
+
+@pytest.mark.scheduler
+@pytest.mark.api
+class TestSchedulerInvalidIntegrations:
+    """Tests for invalid scheduler integrations - verify proper error handling."""
+
+    @pytest.mark.parametrize(
+        "invalid_cron",
+        [
+            ("invalid_cron_expression"),
+            ("* * * *"),
+            ("60 0 * * *"),
+            ("0 25 * * *"),
+            ("0 0 32 * *"),
+            ("0 0 * 13 *"),
+            ("0 0 * * 8"),
+            (""),
+        ],
+    )
+    def test_scheduler_with_invalid_cron(
+        self, assistant, scheduler_integration, invalid_cron
+    ):
+        """Test scheduler creation fails with invalid cron expressions.
+
+        This test verifies that the system properly validates cron expressions
+        and rejects invalid formats.
+
+        Parametrized with various invalid cron expressions:
+        - Completely invalid format
+        - Incomplete expressions
+        - Out-of-range values for each field
+        - Empty expressions
+        """
+        scheduler_alias = get_random_name()
+        created_assistant = assistant()
+
+        with pytest.raises(HTTPError) as exc_info:
+            scheduler_integration(
+                alias=scheduler_alias,
+                resource_type="assistant",
+                resource_id=created_assistant.id,
+                schedule=invalid_cron,
+                prompt=scheduler_alias,
+                is_enabled=True,
+            )
+
+        assert_that(exc_info.value.response.status_code, equal_to(422))
+        assert_that(
+            exc_info.value.response.json()["error"]["message"],
+            any_of(
+                equal_to("Invalid cron expression"), equal_to("Invalid schedule format")
+            ),
+        )
+
+    @pytest.mark.parametrize(
+        "resource_type, error",
+        [
+            ("assistant", "Assistant not found"),
+            ("workflow", "Workflow not found"),
+            ("datasource", "Datasource not found"),
+        ],
+    )
+    def test_scheduler_with_invalid_resource_id(
+        self, scheduler_integration, resource_type, error
+    ):
+        """Test scheduler creation with non-existent resource ID.
+
+        This test verifies that the system handles invalid resource IDs properly,
+        either by rejecting them during creation or handling them gracefully during execution.
+        """
+        scheduler_alias = get_random_name()
+        invalid_resource_id = "invalid_resource_" + get_random_name()
+
+        with pytest.raises(HTTPError) as exc_info:
+            scheduler_integration(
+                alias=scheduler_alias,
+                resource_type=resource_type,
+                resource_id=invalid_resource_id,
+                prompt=scheduler_alias,
+                is_enabled=True,
+            )
+
+        assert_that(exc_info.value.response.status_code, equal_to(404))
+        assert_that(
+            exc_info.value.response.json()["error"]["message"],
+            equal_to(error),
+        )
+
+    def test_scheduler_with_invalid_resource_type(
+        self, assistant, scheduler_integration
+    ):
+        """Test scheduler creation with invalid resource type.
+
+        This test verifies that the system properly validates resource types.
+        """
+        scheduler_alias = get_random_name()
+        created_assistant = assistant()
+
+        with pytest.raises(HTTPError) as exc_info:
+            scheduler_integration(
+                alias=scheduler_alias,
+                resource_type="invalid_resource_type",
+                resource_id=created_assistant.id,
+                prompt=scheduler_alias,
+                is_enabled=True,
+            )
+
+        # Verify error has 422 status code (Unprocessable Entity)
+        assert_that(exc_info.value.response.status_code, equal_to(422))
+        assert_that(
+            exc_info.value.response.json()["error"]["message"],
+            equal_to("Invalid resource type"),
+        )

{codemie_test_harness-0.1.215 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/utils/base_utils.py

@@ -104,12 +104,14 @@ def wait_for_entity(get_entity_callable, entity_name, timeout=10, poll_interval=
     start_time = time.time()
 
     while time.time() - start_time < timeout:
-        try:
-            entities = [raw for raw in get_entity_callable() if raw.name == entity_name]
-        except AttributeError:
-            entities = [
-                raw for raw in get_entity_callable() if raw.alias == entity_name
-            ]
+        entities = [
+            raw
+            for raw in get_entity_callable()
+            if (hasattr(raw, "name") and entity_name == raw.name)
+            or (hasattr(raw, "alias") and entity_name == raw.alias)
+            or (hasattr(raw, "prompt") and entity_name == raw.prompt)
+        ]
+
         if len(entities) > 0:
             return entities[0]
         time.sleep(poll_interval)

{codemie_test_harness-0.1.215 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/utils/datasource_utils.py

@@ -208,6 +208,47 @@ class DataSourceUtils(BaseUtils):
                 raise ApiError(f"Datasource {datasource_id} indexing failed")
         raise TimeoutError("Datasource was not indexed within the timeout period.")
 
+    def wait_for_update_date_change(
+        self,
+        datasource_id: str,
+        timeout: int = 80,
+        pool_interval: int = 3,
+    ) -> DataSource:
+        """Wait for datasource update_date to become greater than created_date.
+
+        This method polls the datasource and waits until the update_date is greater
+        than the created_date, indicating that the datasource has been updated/re-indexed.
+
+        Args:
+            datasource_id: The ID of the datasource to monitor
+            timeout: Maximum time to wait in seconds (default from DEFAULT_TIMEOUT)
+            pool_interval: Time between polling attempts in seconds (default 3)
+
+        Returns:
+            DataSource: The updated datasource object with update_date > created_date
+
+        Raises:
+            TimeoutError: If update_date doesn't change within the timeout period
+        """
+        start_time = time.time()
+
+        # Get initial datasource state
+        datasource = self.client.datasources.get(datasource_id)
+        created_date = datasource.created_date
+
+        while time.time() - start_time < timeout:
+            sleep(pool_interval)
+            datasource = self.client.datasources.get(datasource_id)
+
+            # Check if update_date is greater than created_date
+            if datasource.update_date and datasource.update_date > created_date:
+                return datasource
+
+        raise TimeoutError(
+            f"Datasource {datasource_id} update_date did not change within the timeout period. "
+            f"Created: {created_date}, Last checked update: {datasource.update_date}"
+        )
+
     def get_datasource(self, datasource_id):
         return self.client.datasources.get(datasource_id)
 

{codemie_test_harness-0.1.215 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/utils/workflow_utils.py

@@ -123,11 +123,15 @@ class WorkflowUtils(BaseUtils):
     ):
         self.client.workflows.run(workflow, user_input=user_input, file_name=file_name)
         executions_service = self.client.workflows.executions(workflow)
-        execution_id = next(
-            row.execution_id
-            for row in executions_service.list()
-            if row.prompt == user_input
+
+        # Wait for execution to appear (returns execution object with prompt attribute)
+        execution = wait_for_entity(
+            lambda: executions_service.list(),
+            entity_name=user_input,
         )
+        execution_id = execution.execution_id
+
+        # Wait for state to appear
         states_service = executions_service.states(execution_id)
         state = wait_for_entity(
             lambda: states_service.list(),

{codemie_test_harness-0.1.215 → codemie_test_harness-0.1.216}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codemie-test-harness"
-version = "0.1.215"
+version = "0.1.216"
 description = "Autotest for CodeMie backend and UI"
 authors = [
     "Anton Yeromin <anton_yeromin@epam.com>",
@@ -12,7 +12,7 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "^3.12"
-codemie-sdk-python = "0.1.215"
+codemie-sdk-python = "0.1.216"
 pytest = "^8.4.1"
 python-dotenv = "^1.1.0"
 PyHamcrest = "^2.1.0"