codemie-test-harness 0.1.136__py3-none-any.whl → 0.1.137__py3-none-any.whl

codemie_test_harness/tests/service/test_user_service.py

@@ -1,24 +1,41 @@
-"""Integration tests for UserService."""
-
-from codemie_sdk import CodeMieClient
+import os
 from codemie_sdk.models.user import User, UserData
+from hamcrest import (
+    assert_that,
+    instance_of,
+    is_not,
+    all_of,
+    has_property,
+)
+
+
+def test_about_me(user_utils):
+    user = user_utils.get_about_me()
 
+    assert_that(
+        user,
+        all_of(
+            instance_of(User),
+            has_property("user_id", is_not(None)),
+            has_property("name", os.getenv("AUTH_USERNAME")),
+            has_property("username", os.getenv("AUTH_USERNAME")),
+            has_property("is_admin", is_not(None)),
+            has_property("applications", instance_of(list)),
+            has_property("applications_admin", instance_of(list)),
+            has_property("knowledge_bases", instance_of(list)),
+        ),
+        "User profile should have all required properties with correct types",
+    )
 
-def test_about_me(client: CodeMieClient):
-    """Test successful retrieval of user profile."""
-    user = client.users.about_me()
-    assert isinstance(user, User)
-    assert user.user_id is not None
-    assert user.name is not None
-    assert user.username is not None
-    assert isinstance(user.is_admin, bool)
-    assert isinstance(user.applications, list)
-    assert isinstance(user.applications_admin, list)
-    assert isinstance(user.knowledge_bases, list)
 
+def test_get_user_data(user_utils):
+    user_data = user_utils.get_user_data()
 
-def test_get_data(client: CodeMieClient):
-    """Test successful retrieval of user data."""
-    user_data = client.users.get_data()
-    assert isinstance(user_data, UserData)
-    assert user_data.user_id is not None
+    assert_that(
+        user_data,
+        all_of(
+            instance_of(UserData),
+            has_property("user_id", is_not(None)),
+        ),
+        "User data should be valid UserData instance with user_id",
+    )

codemie_test_harness/tests/service/test_workflow_execution_service.py

@@ -1,183 +1,156 @@
-"""Integration tests for WorkflowExecutionService."""
-
 from time import sleep
 
 import pytest
-import requests
-
-from codemie_sdk import CodeMieClient
-from codemie_sdk.models.workflow import (
-    WorkflowCreateRequest,
-    WorkflowMode,
-    ExecutionStatus,
+from hamcrest import (
+    assert_that,
+    equal_to,
+    has_length,
+    contains_string,
+    all_of,
+    less_than_or_equal_to,
+    has_property,
+    is_not,
 )
+
+from codemie_sdk.models.workflow import ExecutionStatus, WorkflowMode
 from codemie_test_harness.tests import PROJECT
 from codemie_test_harness.tests.utils.base_utils import get_random_name
 
+from codemie_test_harness.tests.utils.yaml_utils import (
+    AssistantModel,
+    StateModel,
+    WorkflowYamlModel,
+    prepare_yaml_content,
+)
 
-@pytest.fixture
-def valid_workflow_yaml(default_llm) -> str:
-    """Return a valid workflow YAML configuration for testing."""
-    return f"""
-assistants:
-  - id: asst
-    name: Simple assistant
-    model: {default_llm.base_name}
-    system_prompt: |
-      You are simple chatbot. 
-      Generate a simple response.
-
-states:
-  - id: simple
-    assistant_id: asst
-    task: |
-      Say "Hello, World!"
-    next:
-      state_id: end
-"""
-
-
-@pytest.fixture
-def test_workflow(client: CodeMieClient, valid_workflow_yaml: str):
-    """Create a test workflow and clean it up after the test."""
-    workflow_name = get_random_name()
-    workflow_id = None
-
-    try:
-        # Create workflow
-        create_request = WorkflowCreateRequest(
-            name=workflow_name,
-            description="Test workflow for executions",
-            project=PROJECT,
-            yaml_config=valid_workflow_yaml,
-            mode=WorkflowMode.SEQUENTIAL,
-            shared=False,
-        )
 
-        created = client.workflows.create_workflow(create_request)
-        assert created is not None
-
-        sleep(5)  # Wait for workflow to be fully created
-
-        workflows = client.workflows.list(projects=PROJECT, per_page=10)
-        workflow = next((wf for wf in workflows if wf.name == workflow_name), None)
-        assert workflow is not None
-        workflow_id = workflow.id
-
-        yield workflow_id
-
-    finally:
-        # Clean up
-        if workflow_id:
-            try:
-                client.workflows.delete(workflow_id)
-            except Exception as e:
-                pytest.fail(f"Failed to clean up workflow: {str(e)}")
-
-
-def test_run_workflow(client: CodeMieClient, test_workflow: str):
-    """Test workflow execution with state verification."""
-
-    execution_id = None
-    try:
-        # Create a new execution
-        execution = client.workflows.run(test_workflow, "Test")
-        assert execution is not None
-        sleep(5)
-
-        # Test listing all executions
-        executions = client.workflows.executions(test_workflow).list()
-        assert executions is not None
-        assert len(executions) == 1
-        found_execution = executions[0]
-        execution_id = executions[0].execution_id
-        assert found_execution.workflow_id == test_workflow
-        assert found_execution.status is not None
-        assert found_execution.created_date is not None
-        assert found_execution.created_by is not None
-
-        # Test pagination
-        paginated = client.workflows.executions(test_workflow).list(page=0, per_page=1)
-        assert len(paginated) <= 1
-
-        max_attempts = 30  # 30 * 2 seconds = 60 seconds total wait time
-        attempts = 0
-        while attempts < max_attempts:
-            execution = client.workflows.executions(test_workflow).get(execution_id)
-            if execution.status == ExecutionStatus.SUCCEEDED:
-                # Only verify states and outputs on successful execution
-                # Verify execution states
-                states = (
-                    client.workflows.executions(test_workflow)
-                    .states(execution_id)
-                    .list()
-                )
-                assert states is not None
-                assert len(states) == 2
-
-                first_state = states[0]
-                second_state = states[1]
-                assert first_state.completed_at is not None
-                assert second_state.completed_at is not None
-                assert first_state.completed_at < second_state.completed_at
-
-                # Verify the state outputs
-                for state in states:
-                    state_output = (
-                        client.workflows.executions(test_workflow)
-                        .states(execution_id)
-                        .get_output(state.id)
-                    )
-                    assert state_output is not None
-                    assert state_output.output is not None
-                    # For our test workflow, the first state should contain "Hello, World!"
-                    if state.id == "simple":
-                        assert "Hello, World!" in state_output.output
-                break
-            elif execution.status == ExecutionStatus.FAILED:
-                pytest.fail(f"Workflow execution failed: {execution.error_message}")
-
-            sleep(2)
-            attempts += 1
-        else:
-            raise TimeoutError(
-                f"Workflow execution did not complete within {attempts * 2} seconds"
+@pytest.fixture(scope="session")
+def test_workflow(default_llm, search_utils, workflow_utils):
+    assistant_and_state_name = get_random_name()
+
+    assistant = AssistantModel(
+        id=assistant_and_state_name,
+        model=default_llm.base_name,
+        system_prompt="You are simple chatbot. Generate a simple response.",
+    )
+
+    state = StateModel(
+        id=assistant_and_state_name,
+        assistant_id=assistant_and_state_name,
+        task='Say "Hello, World!"',
+    )
+
+    workflow_yaml = WorkflowYamlModel(
+        enable_summarization_node=True,
+        assistants=[assistant],
+        states=[state],
+    )
+
+    yaml_content = prepare_yaml_content(workflow_yaml.model_dump(exclude_none=True))
+    created = workflow_utils.create_workflow(
+        workflow_yaml=yaml_content,
+        workflow_type=WorkflowMode.SEQUENTIAL,
+        project_name=PROJECT,
+        description="Test workflow for executions",
+    )
+    assert_that(created, is_not(None))
+
+    workflows = search_utils.list_workflows(projects=PROJECT, per_page=10)
+    workflow = next((wf for wf in workflows if wf.name == created.name), None)
+    assert_that(workflow, is_not(None))
+
+    return workflow.id
+
+
+def test_run_workflow(workflow_utils, search_utils, test_workflow: str):
+    execution = workflow_utils.run_workflow(test_workflow, "Test")
+
+    assert_that(execution, is_not(None))
+
+    # Test listing all executions
+    executions = search_utils.list_workflow_executions(test_workflow_id=test_workflow)
+    assert_that(executions, has_length(equal_to(1)))
+    found_execution = executions[0]
+    execution_id = executions[0].execution_id
+    assert_that(
+        found_execution,
+        all_of(
+            has_property("workflow_id", equal_to(test_workflow)),
+            has_property("status", is_not(None)),
+            has_property("created_date", is_not(None)),
+            has_property("created_by", is_not(None)),
+        ),
+    )
+
+    # Test pagination
+    paginated = search_utils.list_workflow_executions(
+        test_workflow_id=test_workflow,
+        page=0,
+        per_page=1,
+    )
+    assert_that(paginated, has_length(less_than_or_equal_to(1)))
+
+    max_attempts = 30  # 30 * 2 seconds = 60 seconds total wait time
+    attempts = 0
+    while attempts < max_attempts:
+        execution = workflow_utils.get_workflow_execution(
+            test_workflow_id=test_workflow, execution_id=execution_id
+        )
+        if execution.status == ExecutionStatus.SUCCEEDED:
+            # Only verify states and outputs on successful execution
+            # Verify execution states
+            states = workflow_utils.get_workflow_executions_states(
+                test_workflow, execution_id
+            ).list()
+            assert_that(states, has_length(equal_to(2)))
+
+            first_state = states[0]
+            second_state = states[1]
+            assert_that(first_state.completed_at, is_not(None))
+            assert_that(second_state.completed_at, is_not(None))
+            assert_that(
+                first_state.completed_at,
+                less_than_or_equal_to(second_state.completed_at),
             )
 
-    finally:
-        if execution_id:
-            try:
-                client.workflows.executions(test_workflow).delete_all()
-                sleep(5)
-                try:
-                    client.workflows.executions(test_workflow).get(execution_id)
-                    pytest.fail(
-                        f"Workflow execution {execution_id} still exists after deletion"
-                    )
-                except requests.exceptions.HTTPError as e:
-                    if e.response.status_code != 404:
-                        pytest.fail(
-                            f"Unexpected error during cleanup verification: {str(e)}"
-                        )
-            except Exception as e:
-                pytest.fail(f"Failed to clean up workflow execution: {str(e)}")
-
-
-def test_list_executions_nonexistent_workflow(client: CodeMieClient):
-    """Test listing executions for non-existent workflow."""
-    workflows = client.workflows.executions("non-existent-id").list()
-    print(workflows)
-    assert len(workflows) == 0
-
-
-def test_list_executions_invalid_parameters(client: CodeMieClient, test_workflow: str):
-    """Test listing executions with invalid parameters."""
-    # Test invalid page number
+            # Verify the state outputs
+            for state in states:
+                state_output = workflow_utils.get_workflow_executions_states(
+                    test_workflow, execution_id
+                ).get_output(state.id)
+                # For our test workflow, the first state should contain "Hello, World!"
+                if state.id == "simple":
+                    assert_that(state_output.output, contains_string("Hello, World!"))
+            break
+        elif execution.status == ExecutionStatus.FAILED:
+            pytest.fail(f"Workflow execution failed: {execution.error_message}")
+
+        sleep(2)
+        attempts += 1
+    else:
+        raise TimeoutError(
+            f"Workflow execution did not complete within {attempts * 2} seconds"
+        )
+
+
+@pytest.mark.skip(reason="Bug: https://jiraeu.epam.com/browse/EPMCDME-7883")
+def test_list_executions_nonexistent_workflow(search_utils):
     with pytest.raises(Exception) as exc_info:
-        client.workflows.executions(test_workflow).list(page=-1)
-    assert "page" in str(exc_info.value).lower()
+        search_utils.list_workflow_executions("non-existent-id")
+
+    assert_that(
+        str(exc_info.value).lower(),
+        contains_string("No workflows found with id non-existent-id"),
+    )
+
+
+def test_list_executions_with_invalid_page_number(search_utils):
+    with pytest.raises(Exception) as exc_info:
+        search_utils.list_workflow_executions(test_workflow_id=None, page=-1)
+    assert_that(str(exc_info.value).lower(), contains_string("page"))
+
 
-    # Test invalid per_page value
+def test_list_executions_with_invalid_per_page_value(search_utils):
     with pytest.raises(Exception) as exc_info:
-        client.workflows.executions(test_workflow).list(per_page=0)
-    assert "per_page" in str(exc_info.value).lower()
+        search_utils.list_workflow_executions(test_workflow_id=None, per_page=0)
+    assert_that(str(exc_info.value).lower(), contains_string("per_page"))