codemie-test-harness 0.1.172__tar.gz → 0.1.173__tar.gz

{codemie_test_harness-0.1.172 → codemie_test_harness-0.1.173}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codemie-test-harness
-Version: 0.1.172
+Version: 0.1.173
 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.172)
+Requires-Dist: codemie-sdk-python (==0.1.173)
 Requires-Dist: pytest (>=8.4.1,<9.0.0)
 Requires-Dist: pytest-playwright (>=0.7.0,<0.8.0)
 Requires-Dist: pytest-reportportal (>=5.5.2,<6.0.0)

codemie_test_harness-0.1.173/codemie_test_harness/tests/ui/_test_data/integration_test_data.py

@@ -0,0 +1,121 @@
+"""
+Helper utilities for integration UI tests.
+Contains reusable functions and data generators for integration testing.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Any
+
+from codemie_sdk.models.integration import CredentialTypes
+
+from codemie_test_harness.tests import PROJECT
+from codemie_test_harness.tests.utils.base_utils import get_random_name
+
+
+@dataclass
+class IntegrationTestData:
+    """Data class for integration form fields."""
+
+    project: str
+    alias: str
+    description: str
+    credential_type: CredentialTypes
+    is_global: bool = False
+    fields: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.fields is None:
+            self.fields = {}
+
+
+class IntegrationTestDataFactory:
+    @staticmethod
+    def jira_integration() -> IntegrationTestData:
+        return IntegrationTestData(
+            project=PROJECT,
+            alias=f"JIRA Server Integration {get_random_name()}",
+            description="JIRA Server integration for project management",
+            credential_type=CredentialTypes.JIRA,
+            fields={
+                "url": "https://jira.company.com",
+                "username": "test.user@company.com",
+                "token": "secure_password",
+            },
+        )
+
+    @staticmethod
+    def jira_cloud_integration() -> IntegrationTestData:
+        return IntegrationTestData(
+            project=PROJECT,
+            alias=f"JIRA Cloud Integration {get_random_name()}",
+            description="JIRA Cloud integration with API token",
+            credential_type=CredentialTypes.JIRA,
+            fields={
+                "url": "https://jiraeu.epam.com",
+                "username": "test.user@company.com",
+                "token": "ATATT3xFfGF0...",
+                "is_cloud": True,
+            },
+        )
+
+    @staticmethod
+    def git_integration() -> IntegrationTestData:
+        return IntegrationTestData(
+            project=PROJECT,
+            alias=f"GitLab Integration {get_random_name()}",
+            description="GitLab integration for code repository access",
+            credential_type=CredentialTypes.GIT,
+            fields={
+                "url": "https://gitlab.company.com",
+                "token": "glpat-1234567890abcdef",
+            },
+        )
+
+    @staticmethod
+    def confluence_integration() -> IntegrationTestData:
+        return IntegrationTestData(
+            project=PROJECT,
+            alias=f"Confluence Integration {get_random_name()}",
+            description="Confluence integration for project management",
+            credential_type=CredentialTypes.CONFLUENCE,
+            fields={
+                "url": "https://kb.epam.com",
+                "username": "test.user@company.com",
+                "token": "secure_password",
+                "is_cloud": False,
+            },
+        )
+
+    @staticmethod
+    def confluence_cloud_integration() -> IntegrationTestData:
+        return IntegrationTestData(
+            project=PROJECT,
+            alias=f"Confluence Cloud Integration {get_random_name()}",
+            description="Confluence Cloud integration for project management",
+            credential_type=CredentialTypes.CONFLUENCE,
+            fields={
+                "url": "https://company.atlassian.net",
+                "username": "test.user@company.com",
+                "token": "ATATT3xFfGF0...",
+                "is_cloud": True,
+            },
+        )
+
+    # Expected validation messages
+    validation_messages = {
+        "invalid_email": "Please enter a valid email address",
+        "invalid_url": "Please enter a valid URL",
+        "duplicate_name": "An integration with this name already exists",
+        "connection_failed": "Connection test failed",
+        "connection_timeout": "Connection timeout",
+        "cannot_create_setting": "Cannot create specified setting",
+        "alias_required": "Alias is required",
+    }
+
+    # Success messages
+    success_messages = {
+        "integration_created": "Integration created successfully",
+        "integration_updated": "Integration updated successfully",
+        "connection_test_passed": "Connection test passed",
+        "integration_deleted": "Integration deleted successfully",
+    }

{codemie_test_harness-0.1.172 → codemie_test_harness-0.1.173}/codemie_test_harness/tests/ui/assistants/test_create_assistant.py

@@ -26,7 +26,7 @@ Architecture:
 
 import pytest
 
-from codemie_test_harness.tests.test_data.assistant_test_data import (
+from codemie_test_harness.tests.ui._test_data.assistant_test_data import (
     get_minimal_assistant_data,
 )
 from codemie_test_harness.tests.ui.pageobject.assistants.assistants_page import (

{codemie_test_harness-0.1.172 → codemie_test_harness-0.1.173}/codemie_test_harness/tests/ui/conftest.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from time import sleep
 
 import pytest
+from codemie_sdk.models.integration import IntegrationType
 from reportportal_client import RPLogger, RPLogHandler
 
 from codemie_test_harness.tests import autotest_entity_prefix
@@ -96,6 +97,7 @@ def pytest_sessionfinish(session):
     clean_up_timeout = 1 if EnvironmentResolver.is_production() else 0
     client = get_client()
     prefix = autotest_entity_prefix
+    # Assistants
     assistants = client.assistants.list(filters={"search": prefix}, per_page=200)
     for assistant in assistants:
         if prefix in assistant.name:
@@ -105,3 +107,26 @@ def pytest_sessionfinish(session):
             for conversation in conversations:
                 client.conversations.delete(conversation.id)
                 sleep(clean_up_timeout)
+    # Integrations
+    integrations = client.integrations.list(
+        setting_type=IntegrationType.PROJECT,
+        filters={"search": autotest_entity_prefix},
+        per_page=200,
+    )
+    for integration in integrations:
+        if prefix in integration.alias:
+            client.integrations.delete(
+                setting_id=integration.id, setting_type=IntegrationType.PROJECT
+            )
+            sleep(clean_up_timeout)
+    integrations = client.integrations.list(
+        setting_type=IntegrationType.USER,
+        filters={"search": autotest_entity_prefix},
+        per_page=200,
+    )
+    for integration in integrations:
+        if prefix in integration.alias:
+            client.integrations.delete(
+                setting_id=integration.id, setting_type=IntegrationType.USER
+            )
+            sleep(clean_up_timeout)

codemie_test_harness-0.1.173/codemie_test_harness/tests/ui/integrations/test_create_integration.py

@@ -0,0 +1,320 @@
+"""
+UI tests for Create Integration feature - critical paths with best practices.
+
+This test suite covers the essential "Create Integration" workflow focusing on happy path scenarios.
+All tests follow the Page Object Model pattern with reusable components abstracted in standalone classes.
+"""
+
+import pytest
+from codemie_sdk.models.integration import CredentialTypes
+
+from codemie_test_harness.tests.ui._test_data.integration_test_data import (
+    IntegrationTestDataFactory,
+)
+from codemie_test_harness.tests.ui.pageobject.integrations.create_integration_page import (
+    CreateIntegrationPage,
+)
+from codemie_test_harness.tests.ui.pageobject.integrations.integrations_page import (
+    IntegrationsPage,
+)
+
+
+# noinspection PyArgumentList
+class TestCreateIntegrationNavigation:
+    """Test class for integration creation navigation and page access."""
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_navigate_to_integrations_via_menu(self, page):
+        """
+        Test navigation to create integration page via menu.
+
+        Verifies:
+        - User can navigate to integrations page from menu
+        - Main UI elements are visible on Integrations page
+        """
+        # Arrange
+        integrations_page = IntegrationsPage(page)
+
+        # Act
+        integrations_page.navigate_to_via_menu()
+
+        # Assert
+        integrations_page.should_be_on_integrations_page()
+        integrations_page.should_see_create_integration_button()
+        integrations_page.should_see_integration_type_switcher()
+        integrations_page.should_see_integrations_table()
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_navigate_to_create_integration_via_direct_url(self, page):
+        """
+        Test direct navigation to create integration page via URL.
+
+        Verifies:
+        - Direct URL access works correctly
+        - Page Title matches integration type
+        """
+
+        create_integration_page = CreateIntegrationPage(page)
+
+        # Act
+        create_integration_page.navigate_to_user_integration_creation()
+
+        # Assert
+        create_integration_page.should_be_on_create_user_integration_page()
+
+        # Act
+        create_integration_page.navigate_to_project_integration_creation()
+
+        # Assert
+        create_integration_page.should_be_on_create_project_integration_page()
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_navigate_to_create_integration_from_integrations_page(self, page):
+        """
+        Test navigation to create integration page from integrations page ui elements.
+
+        Verifies:
+        - Navigation via UI elements works correctly
+        - Page Title matches integration type
+        """
+
+        integrations_page = IntegrationsPage(page)
+
+        # Navigate to User Integration creation
+        integrations_page.navigate_to().navigate_to_user_integration_creation()
+
+        create_integration_page = CreateIntegrationPage(page)
+
+        # Assert
+        create_integration_page.should_be_on_create_user_integration_page()
+
+        # Navigate to Project Integration creation
+        integrations_page.navigate_to().navigate_to_project_integration_creation()
+
+        # Assert
+        create_integration_page.should_be_on_create_project_integration_page()
+
+
+# noinspection PyArgumentList
+class TestIntegrationCreationPageElements:
+    """Test class for integration creation page elements display."""
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    @pytest.mark.parametrize(
+        "credential_type",
+        [CredentialTypes.GIT, CredentialTypes.JIRA, CredentialTypes.CONFLUENCE],
+    )
+    def test_create_integration_type_form_fields(self, page, credential_type):
+        """
+        Test that all required form fields are displayed for Git credential type.
+
+        Verifies:
+        - Page navigation and structure validation
+        - Action buttons visibility (Back, Cancel, Create)
+        - Project selector element presence
+        - Global Integration toggle visibility
+        - Credential Type field with "Git" value
+        - Alias field with required indicator
+        - Authentication section with all fields (URL, Token name, Token)
+        - Help text and information tooltips
+        - Form field interactivity validation
+        - Create button initial disabled state
+        """
+
+        create_integration_page = CreateIntegrationPage(page)
+
+        # Act
+        create_integration_page.navigate_to_user_integration_creation()
+        create_integration_page.select_credential_type(credential_type)
+
+        # Assert - Verify page structure (includes title validation)
+        create_integration_page.should_be_on_create_user_integration_page()
+
+        # Assert - Verify UI elements visibility
+        (
+            create_integration_page.should_have_action_buttons_visible(credential_type)
+            .should_have_project_selector_visible()
+            .should_have_global_integration_toggle_visible()
+            .should_have_credential_type_field_visible()
+            .should_have_alias_field_visible()
+            .should_have_authentication_section_visible(credential_type)
+            .should_have_help_texts_visible()
+        )
+
+        # Assert - Verify credential type value
+        create_integration_page.should_have_credential_type_selected(credential_type)
+
+        # Assert - Verify form elements are interactive
+        create_integration_page.should_have_input_fields_editable()
+
+        # Assert - Verify Create button initial state
+        create_integration_page.should_have_create_button_enabled()
+
+
+# noinspection PyArgumentList
+class TestIntegrationCreationWorkflow:
+    """Test class for the complete integration creation workflow."""
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_create_git_integration_complete_workflow(self, page):
+        """
+        Test the complete Git integration creation workflow (happy path).
+
+        Verifies the end-to-end workflow for Git integration creation.
+        """
+        # Arrange
+        integrations_page = IntegrationsPage(page)
+        create_integration_page = CreateIntegrationPage(page)
+        integration_test_data = IntegrationTestDataFactory.git_integration()
+
+        # Act - Navigate and create
+        create_integration_page.navigate_to_user_integration_creation()
+        create_integration_page.fill_git_integration_form(integration_test_data)
+        create_integration_page.create_integration()
+
+        # Assert
+        (
+            integrations_page.navigate_to()
+            .should_see_message(
+                IntegrationTestDataFactory.success_messages["integration_created"]
+            )
+            .should_see_specific_integration(integration_test_data.alias)
+        )
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_create_jira_integration_complete_workflow(self, page):
+        """
+        Test the complete Jira integration creation workflow (happy path).
+
+        Verifies the end-to-end workflow for Jira integration creation including:
+        - Navigation to user integration creation page
+        - Credential type selection (Jira)
+        - Form filling with valid Jira integration data
+        - Integration creation and success validation
+        - Verification of created integration in integrations list
+        """
+        # Arrange
+        integrations_page = IntegrationsPage(page)
+        create_integration_page = CreateIntegrationPage(page)
+        integration_test_data = IntegrationTestDataFactory.jira_integration()
+
+        # Act - Navigate and create
+        create_integration_page.navigate_to_user_integration_creation()
+        create_integration_page.fill_jira_integration_form(integration_test_data)
+        create_integration_page.create_integration()
+
+        # Assert
+        (
+            integrations_page.navigate_to()
+            .should_see_message(
+                IntegrationTestDataFactory.success_messages["integration_created"]
+            )
+            .should_see_specific_integration(integration_test_data.alias)
+        )
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_create_confluence_integration_complete_workflow(self, page):
+        """
+        Test the complete Confluence integration creation workflow (happy path).
+
+        Verifies the end-to-end workflow for Confluence integration creation including:
+        - Navigation to user integration creation page
+        - Credential type selection (Confluence)
+        - Form filling with valid Confluence integration data
+        - Integration creation and success validation
+        - Verification of created integration in integrations list
+        """
+        # Arrange
+        integrations_page = IntegrationsPage(page)
+        create_integration_page = CreateIntegrationPage(page)
+        integration_test_data = IntegrationTestDataFactory.confluence_integration()
+
+        # Act - Navigate and create
+        create_integration_page.navigate_to_user_integration_creation()
+        create_integration_page.fill_confluence_integration_form(integration_test_data)
+        create_integration_page.create_integration()
+
+        # Assert
+        (
+            integrations_page.navigate_to()
+            .should_see_message(
+                IntegrationTestDataFactory.success_messages["integration_created"]
+            )
+            .should_see_specific_integration(integration_test_data.alias)
+        )
+
+
+# noinspection PyArgumentList
+class TestIntegrationFormUserExperience:
+    """Test class for integration form user experience and usability."""
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_form_reset_and_cancel_functionality(self, page):
+        """
+        Test form reset and cancel functionality.
+
+        Verifies:
+        - Cancel button navigates away from form
+        - Form data is not saved when cancelled
+        - User can safely exit creation process
+        """
+        # Arrange
+        create_integration_page = CreateIntegrationPage(page)
+        integrations_page = IntegrationsPage(page)
+
+        # Act
+        cancelled_integration_alias = "Test Integration to Cancel"
+        create_integration_page.navigate_to_user_integration_creation()
+        create_integration_page.fill_alias(cancelled_integration_alias)
+        create_integration_page.cancel_creation()
+
+        # Assert - Should navigate back to integrations page
+        integrations_page.should_have_page_title("Integrations")
+
+        # Verify the cancelled integration was not created
+        integrations_page.should_not_see_integration(cancelled_integration_alias)
+
+    @pytest.mark.integration_ui
+    @pytest.mark.ui
+    @pytest.mark.smoke
+    def test_alias_field_validation_message(self, page):
+        """
+        Test validation message when alias field is empty and form is submitted.
+
+        Verifies:
+        - Error toast notification appears with correct header
+        - Error message contains "Alias is required" text
+        - Toast notification is visible and readable
+        """
+        # Arrange
+        create_integration_page = CreateIntegrationPage(page)
+
+        # Act - Navigate to integration creation and try to submit without alias
+        create_integration_page.navigate_to_user_integration_creation()
+        create_integration_page.select_credential_type(CredentialTypes.GIT)
+        # Leave alias field empty intentionally
+        create_integration_page.create_integration()
+
+        # Assert - Verify error toast notification appears
+        create_integration_page.should_see_error_toast_message(
+            header=IntegrationTestDataFactory.validation_messages[
+                "cannot_create_setting"
+            ],
+            content=IntegrationTestDataFactory.validation_messages["alias_required"],
+        )

{codemie_test_harness-0.1.172 → codemie_test_harness-0.1.173}/codemie_test_harness/tests/ui/pageobject/assistants/create_assistant_page.py

@@ -47,17 +47,6 @@ class CreateAssistantPage(BasePage):
             or self.page.locator('h1:has-text("Create Assistant")')
         )
 
-    @property
-    def back_button(self) -> Locator:
-        """Back button in header with arrow icon"""
-        return (
-            self.page.locator("button.button.secondary.medium").first
-            or self.page.locator(
-                'button:has(svg[xmlns="http://www.w3.org/2000/svg"])'
-            ).first
-            or self.page.locator(".mr-6 button")
-        )
-
     @property
     def generate_with_ai_button(self) -> Locator:
         """Generate with AI button in header with magical styling"""
@@ -71,15 +60,6 @@ class CreateAssistantPage(BasePage):
             )
         )
 
-    @property
-    def cancel_button(self) -> Locator:
-        """Cancel button in header"""
-        return (
-            self.page.locator('button.button.secondary.medium:has-text("Cancel")')
-            or self.page.locator('button:has-text("Cancel")')
-            or self.page.locator('.ml-auto button:has-text("Cancel")')
-        )
-
     @property
     def create_button(self) -> Locator:
         """Create button with plus icon (primary button)"""

{codemie_test_harness-0.1.172 → codemie_test_harness-0.1.173}/codemie_test_harness/tests/ui/pageobject/base_page.py

@@ -1,6 +1,6 @@
 import re
 
-from playwright.sync_api import expect
+from playwright.sync_api import expect, Locator
 from reportportal_client import step
 
 from codemie_test_harness.tests.ui.pageobject.components.menu import Menu
@@ -15,11 +15,24 @@ class BasePage:
 
     # Component properties using @property decorator
     @property
-    def back_button(self):
-        """Back button in the menu."""
-        return self.page.locator(
-            '//div[not(contains(@class,"justify-end"))]/button[contains(@class,"secondary medium")]'
-        ).first
+    def back_button(self) -> Locator:
+        """Back button in header with arrow icon"""
+        return (
+            self.page.locator("button.button.secondary.medium").first
+            or self.page.locator(
+                'button:has(svg[xmlns="http://www.w3.org/2000/svg"])'
+            ).first
+            or self.page.locator(".mr-6 button")
+        )
+
+    @property
+    def cancel_button(self) -> Locator:
+        """Cancel button in header"""
+        return (
+            self.page.locator('button.button.secondary.medium:has-text("Cancel")')
+            or self.page.locator('button:has-text("Cancel")')
+            or self.page.locator('.ml-auto button:has-text("Cancel")')
+        )
 
     @property
     def pop_up(self):