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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codemie-test-harness
-Version: 0.1.214
+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.214)
+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.214 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/assistant/tools/project_management/test_assistant_pm_tools.py

@@ -16,6 +16,7 @@ from codemie_test_harness.tests.test_data.project_management_test_data import (
 from codemie_test_harness.tests.utils.base_utils import (
     credentials_to_dict,
     assert_tool_triggered,
+    get_random_name,
 )
 from codemie_test_harness.tests.utils.constants import (
     project_management_integrations,
@@ -45,6 +46,9 @@ def test_assistant_with_project_management_tools(
         project_management_integrations[integration_type]
     )
 
+    if "%s" in prompt:
+        prompt = prompt % get_random_name()
+
     assistant = assistant(
         Toolkit.PROJECT_MANAGEMENT,
         tool_name,

{codemie_test_harness-0.1.214 → 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.214 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/test_data/assistant_test_data.py

@@ -803,36 +803,101 @@ DOCX_TOOL_TEST_DATA = [
         id="image_extraction",
     ),
     pytest.param(
-        "From test_extended.docx extract and show the text with OCR from images",
+        "From test_extended.docx extract and show the OCR from images and text from the first page",
         """
-            ### Extracted Text with OCR from Images in *test_extended.docx*
-
-            #### **Image 1: Capability Configuration**
-            The image contains text related to client authentication, authorization settings, and available flows. Below is the OCR-extracted text:
-
+            Here is the extracted content from the first page of the `test_extended.docx` document including text and OCR results from images:
+            
+            ### Text Content
             ```
-            **Capability config**
-
-            - **Client authentication**
-              - 🟦 On
-
-            - **Authorization**
-              - ⚪ Off
-
+            1. Getting Started with AI/RunTM CodeMie
+            
+            This section provides a brief description of what AI/RunTM CodeMie is and describes how to start using the AI/RunTM CodeMie tool as soon as possible.
+            
+            1.1 What is AI/RunTM CodeMie?
+            
+            AI/RunTM CodeMie is a sophisticated AI assistant tool tailored specifically for developers. AI/RunTM CodeMie is an innovative LLM-powered platform designed to help users to address specific challenges and find solutions for their needs. Unlike conventional large language models (LLMs) such as ChatGPT, Bard, and Copilot, AI/RunTM CodeMie is engineered to support development processes more comprehensively. It integrates seamlessly with essential development tools including Git, Jira, Confluence, and various search engines. This integration empowers AI/RunTM CodeMie to go beyond the capabilities of a standard chatbot, enabling it to manage Jira issues, devise appropriate implementations, and generate pull requests. 
+            
+            AI/RunTM CodeMie leverages AI to automate coding tasks, reduce technical debt, streamline code reviews and legacy application migrations, enhance onboarding, improve information access and analysis, optimize call center operations, ensure consistent customer support, maintain data security, and analyze market sentiment, ultimately enhancing productivity and reducing costs. The development of such a powerful assistant necessitates extensive customization and fine-tuning. The following sections will delve into the intricate adjustments and configurations required to harness the full potential of AI/RunTM CodeMie.
+            
+            1.2 What Are AI/RunTM CodeMie Capabilities?
+            
+            AI/RunTM CodeMie efficiently addresses numerous tasks across varying difficulty levels. Below is an overview of AI/RunTM CodeMie’s key capabilities:
+            
+            Comprehensive SDLC Smart Assistance and Assistants Library: AI/RunTM CodeMie offers robust smart assistance across all phases of the SDLC process by leveraging a variety of AI assistant roles, such as Business Analyst (BA), Developer, Quality Assurance (QA), Project Manager (PM), and more. These pre-built AI assistants enhance performance and productivity, and automate routine work, significantly reducing process costs and accelerating the software development cycle. The platform comes with a comprehensive library of pre-built AI assistants tailored to various roles within the SDLC to suit the diverse needs within a project.
+            
+            Assistants Constructor: Provides the flexibility to create personalized assistants equipped with specific tools and abilities tailored to your project's needs.
+            
+            Indexing and Data Management: AI/RunTM CodeMie provides options for data indexing, including the ability to monitor the current progress and status of the indexing process, perform incremental or full reindexing, and manage indexed data sources effectively. Supported data sources include Jira, Confluence, various file formats (PDF, PPT, Excel, etc.), and Git.
+            
+            Support for Multi-Agent Workflows: AI/RunTM аCodeMie supports multi-agent workflows, allowing multiple AI assistants to collaborate seamlessly on complex tasks and workflows. This capability covers use cases where different agents need to interact and share information to achieve a common goal, enhancing coordination and efficiency across various phases of the SDLC.
+            
+            Ease of Use for Beginners: Simple use cases for newcomers include code review, newcomer training, and user story creation. These require minimal setup, such as configuring your Git token for code-related tasks or your Jira token for project management tasks.
+            
+            Extensive Library of Tools: AI/RunTM CodeMie includes a wide array of tools to support various aspects of software development and project management:
+            
+            Version Control Systems (VCS): Tools for managing and tracking changes in the codebase, such as Git.
+            
+            Codebase Tools: Tools for code review, static code analysis, and automated code formatting.
+            
+            Research Tools: Tools to assist in gathering and organizing research data and documentation.
+            
+            Cloud Tools: Integration with major cloud providers for deployment, monitoring, and management of cloud resources.
+            
+            Project Management Tool (Jira: For project management, task tracking, and issue tracking, 
+            
+            Confluence: For documentation, knowledge sharing, and collaboration.)
+            
+            Open API: Integration with various open APIs to extend functionality and connect with other services.
+            
+            Notification Tools: Tools for sending notifications and alerts via email, chat, or other communication channels.
+            
+            Data Management Tools: Tools for querying Elasticsearch indexes.
+            
+            Git
+            
+            Access Management: Keycloak
+            
+            Plugin
+            
+            Open API
+            
+            Notification
+            
+            File Management
+            
+            Data Management
+            
+            Quality Assurance
+            
+            There is no priority or sequential system in place. Everything depends on the given instructions. It is possible to instruct the model to use a specific data source for a particular use case or provide a description for the data source when it is created. Data source descriptions are provided to the model so it can understand better use cases for it.
+            
+            The data source does not have rules, only description. System Instructions(System prompt) extends based on data source description. If contradictions arise, the model will use its creative problem-solving abilities to address them. 
+            
+            The model has a context window, but it is irrelevant to data source size. The model answer will depend on query quality. There is a use case when the model has thousands of data sources, however with queries that are specific and on point there are no problems. If a poor query provided e.g., “tell me about something” answer would be vague.
+            
+            Other than the context window there is no limit, however there is a simple rule: the smaller and clearer the instructions, the better. Also, the instructions must be uncontradictory, as this will reduce the risk of confusing LLM.
+            
+            1.3 Meet the AI/Run FAQ Assistant
+            ```
+            
+            ### OCR from Image Text
+            ```
+            Capability config
+            
+            - **Client authentication** 
+              - On
+            
+            - **Authorization** 
+              - Off
+            
             - **Authentication flow**
-              - ☑️ Standard flow
-              - ☑️ Direct access grants
-              - ☐ Implicit flow
-              - ☑️ Service accounts roles
-              - ☐ OAuth 2.0 Device Authorization Grant
-              - ☐ OIDC CIBA Grant
+              - [x] Standard flow
+              - [x] Direct access grants
+              - [ ] Implicit flow
+              - [x] Service accounts roles
+              - [ ] OAuth 2.0 Device Authorization Grant
+              - [ ] OIDC CIBA Grant
             ```
-
-            This image primarily highlights authentication configurations, flow types, and the enabling/disabling of various features.
-
-            ---
-
-            Let me know if you'd like to perform further analysis or extract more details!
         """,
         id="text_with_images",
     ),

{codemie_test_harness-0.1.214 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/test_data/pm_tools_test_data.py

@@ -1,4 +1,3 @@
-from codemie_test_harness.tests.utils.base_utils import get_random_name
 from codemie_test_harness.tests.utils.confluence_utils import CONFLUENCE_SPACE_KEYS
 from codemie_test_harness.tests.utils.jira_utils import JIRA_PROJECT_KEYS
 
@@ -101,7 +100,7 @@ def get_jira_tool_create_prompt(jira_type: str) -> str:
         "For generic jira tool use exactly the same parameters: "
         "relative_url=/rest/api/2/issue "
         "method=POST "
-        f"params={{'fields': {{'project': {{'key': '{JIRA_PROJECT_KEYS[jira_type]}'}}, 'summary': '{get_random_name()} Test issue created by automation', "
+        f"params={{'fields': {{'project': {{'key': '{JIRA_PROJECT_KEYS[jira_type]}'}}, 'summary': '%s Test issue created by automation', "
         "'description': 'This is a test issue created for testing purposes', 'issuetype': {'name': 'Task'}}}}}"
     )
 
@@ -121,7 +120,7 @@ def get_confluence_tool_create_prompt(confluence_type: str) -> str:
     Create a new page in Confluence with the following details using Generic Confluence Tool with the params:
     relative_url='/rest/api/content'
     method='POST'
-    params={{'type': 'page', 'title': '{get_random_name()} Test Page Created by Automation', 'space': {{'key': '{CONFLUENCE_SPACE_KEYS[confluence_type]}'}},
+    params={{'type': 'page', 'title': '%s Test Page Created by Automation', 'space': {{'key': '{CONFLUENCE_SPACE_KEYS[confluence_type]}'}},
     'body': {{'storage': {{'value': '<p>This is a test page created for testing purposes.</p>', 'representation': 'storage'}}}}}}
 """
 

{codemie_test_harness-0.1.214 → 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.214 → 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.214 → 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.214 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/workflow/assistant_tools/project_management/test_workflow_with_assistant_pm_tools.py

@@ -4,7 +4,10 @@ from codemie_test_harness.tests.enums.tools import Toolkit
 from codemie_test_harness.tests.test_data.project_management_test_data import (
     pm_tools_test_data,
 )
-from codemie_test_harness.tests.utils.base_utils import assert_tool_triggered
+from codemie_test_harness.tests.utils.base_utils import (
+    assert_tool_triggered,
+    get_random_name,
+)
 from codemie_test_harness.tests.utils.constants import (
     project_management_integrations,
 )
@@ -36,6 +39,9 @@ def test_workflow_with_assistant_with_project_management_tools(
         project_management_integrations[integration_type]
     )
 
+    if "%s" in prompt:
+        prompt = prompt % get_random_name()
+
     assistant = assistant(
         Toolkit.PROJECT_MANAGEMENT,
         tool_name,

{codemie_test_harness-0.1.214 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/workflow/test_workflows.py

@@ -3,6 +3,9 @@ import json
 import pytest
 from hamcrest import assert_that, equal_to
 
+from codemie_test_harness.tests.assistant.test_assistants import (
+    system_prompt_for_chatting_with_files,
+)
 from codemie_test_harness.tests.enums.tools import Default
 from codemie_test_harness.tests.test_data.assistant_test_data import (
     EXCEL_TOOL_TEST_DATA,
@@ -84,15 +87,17 @@ def test_workflow_with_user_input_and_file_attachment(
 
     # Create workflow with virtual assistant that has file analysis capabilities
     # Note: File analysis tools are automatically available when files are processed
-    system_prompt = "You are a helpful assistant that can analyze and process files. "
+    task = (
+        f"What is the content/text of the {file_name}. Show information from ALL pages. "
+        "For PDF use 'Text' for query. If provided file is CSV then run python_repl_ast tool and show first 5 rows."
+        "For images explain what you see on it."
+        "For excel show data from the sheet with name 'Sheet1'"
+    )
 
     workflow_instance = workflow_with_virtual_assistant(
         assistant_and_state_name=assistant_and_state_name,
-        system_prompt=system_prompt,
-        task=(
-            "Analyze the uploaded file from the provided file URL and give a detailed summary. "
-            "Use the appropriate file analysis tools based on the file type to extract and process the content."
-        ),
+        system_prompt=system_prompt_for_chatting_with_files,
+        task=task,
     )
 
     # Prepare user input that includes file reference

{codemie_test_harness-0.1.214 → codemie_test_harness-0.1.216}/codemie_test_harness/tests/workflow/virtual_assistant_tools/project_management/test_workflow_with_project_management_tools.py

@@ -36,6 +36,10 @@ def test_workflow_with_virtual_assistant_with_project_management_tools(
         project_management_integrations[integration_type]
     )
     assistant_and_state_name = get_random_name()
+
+    if "%s" in prompt:
+        prompt = prompt % get_random_name()
+
     test_workflow = workflow_with_virtual_assistant(
         assistant_and_state_name, tool_name, integration=integration
     )