codemie-test-harness 0.1.205__py3-none-any.whl → 0.1.207__py3-none-any.whl

codemie_test_harness/tests/ui/pageobject/assistants/assistant_mcp_server.py

@@ -0,0 +1,171 @@
+from playwright.sync_api import Page, Locator, expect
+from reportportal_client import step
+from tests.ui.test_data.assistant_test_data import get_minimal_assistant_mcp_config_data
+
+
+class AssistantMCPIntegrationModal:
+    def __init__(self, page: Page):
+        self.page = page
+
+    @property
+    def mcp_pop_up(self):
+        """Main dialog container using p-dialog class"""
+        return self.page.locator("div.p-dialog[role='dialog']").filter(
+            has_text="Add new MCP server"
+        )
+
+    def mcp_pop_up_header(self):
+        """Dialog header with 'Add new MCP server' text"""
+        return self.mcp_pop_up.locator(
+            "h4.text-base.font-semibold:has-text('Add new MCP server')"
+        )
+
+    # --- Name input ---
+    @property
+    def name_input(self) -> Locator:
+        return self.mcp_pop_up.locator("input[name='name'][placeholder='Name*']")
+
+    # --- Description textarea ---
+    @property
+    def description_textarea(self) -> Locator:
+        return self.mcp_pop_up.locator(
+            "textarea[name='description'][placeholder='Description*']"
+        )
+
+    # --- Tools Tokens Size Limit input ---
+    @property
+    def tokens_size_limit_input(self) -> Locator:
+        return self.mcp_pop_up.locator("input[name='tokensSizeLimit'][type='number']")
+
+    # --- Configuration mode select (JSON/Form) ---
+    @property
+    def config_mode_switch(self) -> Locator:
+        return self.mcp_pop_up.locator("div.p-selectbutton.p-button-group")
+
+    @property
+    def config_mode_json_radio(self) -> Locator:
+        return self.config_mode_switch.locator(
+            "div.p-button[role='button']:has(span:has-text('JSON'))"
+        )
+
+    @property
+    def config_mode_form_radio(self) -> Locator:
+        return self.config_mode_switch.locator(
+            "div.p-button[role='button']:has(span:has-text('Form'))"
+        )
+
+    # --- Configuration (JSON) textarea ---
+    @property
+    def configuration_json_textarea(self) -> Locator:
+        return self.mcp_pop_up.locator("textarea[name='configJson']#json-config")
+
+    # --- Environment Variables dropdown ---
+    @property
+    def env_vars_dropdown(self) -> Locator:
+        return self.mcp_pop_up.locator(
+            "div.p-dropdown:has(span.p-dropdown-label:text('Environment Variables'))"
+        )
+
+    # --- MCP-Connect URL input ---
+    @property
+    def mcp_connect_url_input(self) -> Locator:
+        return self.mcp_pop_up.locator(
+            "input[name='connectUrl'][placeholder='https://']"
+        )
+
+    # --- Buttons ---
+    @property
+    def cancel_button(self) -> Locator:
+        return self.mcp_pop_up.locator(
+            "button.bg-button-secondary-bg:has-text('Cancel')"
+        )
+
+    @property
+    def test_integration_button(self) -> Locator:
+        return self.mcp_pop_up.locator(
+            "button.bg-button-secondary-bg:has-text('Test Integration')"
+        )
+
+    @property
+    def add_button(self) -> Locator:
+        return self.mcp_pop_up.locator("button.bg-button-primary-bg:has-text('Add')")
+
+    # ---- Action Methods ----
+
+    @step
+    def fill_name(self, value: str):
+        self.name_input.fill(value)
+
+    @step
+    def fill_description(self, value: str):
+        self.description_textarea.fill(value)
+
+    @step
+    def fill_tokens_size_limit(self, value: int):
+        self.tokens_size_limit_input.fill(str(value))
+
+    @step
+    def select_config_mode(self, mode: str):
+        if mode.lower() == "json":
+            self.config_mode_json_radio.click()
+        elif mode.lower() == "form":
+            self.config_mode_form_radio.click()
+        else:
+            raise ValueError("Mode must be 'json' or 'form'")
+
+    @step
+    def fill_configuration_json(self, value: str):
+        self.configuration_json_textarea.fill(value)
+
+    @step
+    def open_env_vars_dropdown(self):
+        self.env_vars_dropdown.click()
+
+    @step
+    def fill_mcp_connect_url(self, value: str):
+        self.mcp_connect_url_input.fill(value)
+
+    @step
+    def click_cancel(self):
+        self.cancel_button.click()
+
+    @step
+    def click_test_integration(self):
+        self.test_integration_button.click()
+
+    @step
+    def click_add(self):
+        self.add_button.click()
+
+    @step
+    def fill_mcp_server_base_form(self):
+        test_data = get_minimal_assistant_mcp_config_data()
+        self.fill_name(test_data.name)
+        self.fill_description(test_data.description)
+        self.fill_configuration_json(test_data.configuration)
+        self.click_add()
+
+    # --- Assertions (optional helpers) ---
+
+    def is_pop_visible(self):
+        return self.mcp_pop_up_header().count() > 0
+
+    @step
+    def should_see_name(self, name: str):
+        expect(self.name_input).to_have_value(name)
+
+    @step
+    def should_see_description(self, description: str):
+        expect(self.description_textarea).to_have_value(description)
+
+    @step
+    def should_see_tokens_size_limit(self, token_size: str):
+        expect(self.tokens_size_limit_input).to_have_value(token_size)
+
+    @step
+    def should_see_configuration_json(self, config: str):
+        expect(self.configuration_json_textarea).to_have_value(config)
+
+    @step
+    def should_see_mcp_connect_url(self, url: str):
+        expect(self.mcp_connect_url_input).to_have_value(url)

codemie_test_harness/tests/ui/pageobject/assistants/assistant_sidebar.py

@@ -0,0 +1,140 @@
+from playwright.sync_api import Page, Locator
+from reportportal_client import step
+
+
+class AssistantSidebar:
+    """Page Object Model for the Assistants Page Sidebar."""
+
+    def __init__(self, page: Page):
+        self.page = page
+
+    # --- Locators ---
+
+    @property
+    def main_sidebar(self) -> Locator:
+        """The sidebar <aside>."""
+        return self.page.locator("aside.flex.flex-col.border-r.bg-sidebar-gradient")
+
+    @property
+    def title(self) -> Locator:
+        """Sidebar title: 'Assistants'."""
+        return self.main_sidebar.locator("h2:text-is('Assistants')")
+
+    @property
+    def subtitle(self) -> Locator:
+        """Sidebar subtitle paragraph."""
+        return self.main_sidebar.locator("p.text-sm.text-text-secondary")
+
+    @property
+    def categories_label(self) -> Locator:
+        """The 'Categories' label/heading."""
+        return self.main_sidebar.locator("span:text-is('Categories')")
+
+    @property
+    def categories_list(self) -> Locator:
+        """<ul> under 'Categories'."""
+        return self.categories_label.locator("xpath=../../ul")
+
+    @property
+    def category_items(self) -> Locator:
+        """All category <li> elements."""
+        return self.categories_list.locator("li")
+
+    def category_button(self, name: str) -> Locator:
+        """Button for a category by visible text."""
+        return self.categories_list.locator(f"button:has-text('{name}')")
+
+    @property
+    def filters_label(self) -> Locator:
+        """'Filters' span above filters section."""
+        return self.main_sidebar.locator("span:text-is('Filters')")
+
+    @property
+    def clear_all_filters_button(self) -> Locator:
+        """'Clear all' filter reset button."""
+        return self.main_sidebar.locator("button:has-text('Clear all')")
+
+    @property
+    def search_input(self) -> Locator:
+        """Filter/search input."""
+        return self.main_sidebar.locator("input[placeholder='Search']")
+
+    # Accordion and filter options are unique/complex:
+    def accordion_tab(self, tab_title: str) -> Locator:
+        """Accordion tab by title, e.g. 'PROJECT', 'CREATED BY', ..."""
+        return self.main_sidebar.locator(
+            f".p-accordion-header-text span:has-text('{tab_title.upper()}')"
+        ).locator("xpath=../../..")
+
+    def multiselect_filter(self, label: str) -> Locator:
+        """Filter dropdown by its label in filter accordion, e.g. 'Project'."""
+        return self.main_sidebar.locator(f".p-multiselect-label:has-text('{label}')")
+
+    def created_by_input(self) -> Locator:
+        """Input for 'Created By' filter."""
+        return self.main_sidebar.locator("input[placeholder='Created By']")
+
+    def radio_filter_option(self, label: str) -> Locator:
+        """Radio 'Shared' filter options like All/With Project/Not Shared."""
+        return (
+            self.main_sidebar.locator(f"label.flex.items-center span:text('{label}')")
+            .locator("xpath=..")
+            .locator("input[type='radio']")
+        )
+
+    # --- Methods ---
+
+    @step
+    def click_category(self, name: str):
+        """Clicks on a category item by label."""
+        self.category_button(name).click()
+
+    @step
+    def select_filter_tab(self, tab_title: str):
+        """Expands a filter accordion tab by label."""
+        tab = self.accordion_tab(tab_title)
+        tab.locator("a.p-accordion-header-link").click()
+
+    @step
+    def clear_filters(self):
+        """Clicks the 'Clear all' button in filters."""
+        self.clear_all_filters_button.click()
+
+    @step
+    def search(self, text: str):
+        """Sets sidebar search/filter."""
+        self.search_input.fill(text)
+
+    @step
+    def select_multiselect_option(self, label: str):
+        """Clicks on a filter dropdown and selects the label (if supported)."""
+        ms = self.multiselect_filter(label)
+        ms.click()
+        ms.locator(f"..//li[.='{label}']").click()
+
+    @step
+    def set_created_by(self, author: str):
+        """Sets the 'Created By' filter text."""
+        input_field = self.created_by_input()
+        input_field.fill(author)
+
+    @step
+    def select_radio_option(self, option_label: str):
+        """Selects a radio option for shared status."""
+        self.radio_filter_option(option_label).check(force=True)
+
+    @step
+    def visible_categories(self):
+        """Returns the names of all visible categories."""
+        return [
+            self.category_items.nth(i).inner_text().strip()
+            for i in range(self.category_items.count())
+        ]
+
+    @step
+    def visible_filter_radios(self):
+        """Returns the text values of radio options in Shared filter."""
+        # Find all labels within the 'Shared' tab
+        tab = self.accordion_tab("SHARED")
+        radios = tab.locator("label.flex.items-center")
+        return [radios.nth(i).inner_text().strip() for i in range(radios.count())]

codemie_test_harness/tests/ui/pageobject/assistants/assistant_view_page.py

@@ -0,0 +1,256 @@
+from hamcrest import assert_that, contains_string
+from playwright.sync_api import Page, expect
+from reportportal_client import step
+
+
+class AssistantViewPage:
+    def __init__(self, page: Page):
+        self.page = page
+
+    # ----------------
+    # --- LOCATORS ---
+    # ----------------
+
+    @property
+    def assistant_name(self):
+        return self.page.locator("h4.name-target")
+
+    @property
+    def assistant_author(self):
+        return self.page.locator(".text-xs.text-text-secondary > p")
+
+    @property
+    def about_heading(self):
+        return self.page.locator("h5.font-bold.text-sm:text('About Assistant:')")
+
+    @property
+    def about_content(self):
+        # Paragraph under "About Assistant:"
+        return self.about_heading.locator("xpath=../p")
+
+    @property
+    def system_instructions_heading(self):
+        return self.page.locator(
+            "div.flex.bg-new-panel.border.rounded-lg [class*='text-xs']:text('System Instructions')"
+        )
+
+    @property
+    def system_instructions_content(self):
+        return self.page.locator("div.flex.bg-new-panel.border.rounded-lg > p.text-sm")
+
+    # --- Overview Block ---
+    @property
+    def overview_block(self):
+        return self.page.locator("p:text-is('OVERVIEW')").locator("xpath=..")
+
+    @property
+    def overview_project(self):
+        return self.overview_block.locator(
+            "div.flex:has(p.text-text-tertiary:text('Project:')) > p:not(.text-text-tertiary)"
+        )
+
+    @property
+    def overview_shared_status(self):
+        return self.overview_block.locator(
+            "div.flex:has(p.text-text-tertiary:text('Shared status:')) > p:not(.text-text-tertiary)"
+        )
+
+    @property
+    def overview_assistant_id(self):
+        return self.overview_block.locator(
+            "div.flex.flex-col.gap-2.mt-2.font-semibold input[readonly]"
+        )
+
+    # --- Links Block ---
+    @property
+    def access_links_block(self):
+        return self.page.locator(
+            "p.text-xs.text-text-main.font-semibold:text('ACCESS LINKS')"
+        ).locator("xpath=..")
+
+    @property
+    def details_link_input(self):
+        return self.access_links_block.locator(
+            "div.flex.flex-col.gap-2:has(p:text('Link to assistant details:')) input[readonly]"
+        )
+
+    @property
+    def chat_link_input(self):
+        return self.access_links_block.locator(
+            "div.flex.flex-col.gap-2:has(p:text('Link to start a chat')) input[readonly]"
+        )
+
+    # --- Configuration ---
+    @property
+    def configuration_block(self):
+        return self.page.locator(
+            "p.text-xs.text-text-main.font-semibold:text('CONFIGURATION')"
+        ).locator("xpath=..")
+
+    @property
+    def config_llm_model(self):
+        return self.configuration_block.locator("p:text('LLM model:')").locator(
+            "xpath=../div"
+        )
+
+    @property
+    def config_temperature(self):
+        return self.configuration_block.locator("p:text('Temperature:')").locator(
+            "xpath=../div"
+        )
+
+    @property
+    def config_top_p(self):
+        return self.configuration_block.locator("p:text('Top P:')").locator(
+            "xpath=../div"
+        )
+
+    @property
+    def config_additional_datasource_context(self):
+        return self.configuration_block.locator(
+            "div:has(p:text('Additional datasource context')) div.bg-new-panel.py-1\\.5.px-2"
+        )
+
+    # --- Tools & Capabilities ---
+
+    @property
+    def tools_block(self):
+        """Block containing all toolkits under 'TOOLS & CAPABILITIES'."""
+        return self.page.locator(
+            "p.text-xs.text-text-main.font-semibold:text('TOOLS & CAPABILITIES')"
+        ).locator("xpath=..")
+
+    def toolkit_block(self, toolkit_name: str):
+        """Returns the block for the toolkit (e.g., 'Git', 'VCS', etc.)."""
+        return self.tools_block.locator(
+            f"div.text-xs.flex.flex-col.gap-2:has(p.text-sm:has-text('{toolkit_name}'))"
+        )
+
+    def toolkit_tool_labels(self, toolkit_name: str):
+        """Returns elements for all tool labels under a given toolkit block."""
+        return self.toolkit_block(toolkit_name).locator(
+            "div.flex.flex-wrap.gap-2 > div"
+        )
+
+    def toolkit_tool_label(self, toolkit_name: str, tool_label: str):
+        """Returns the div for a specific tool label (exact match, trimmed)."""
+        return self.toolkit_block(toolkit_name).locator(
+            f"div.flex.flex-wrap.gap-2 > div:text-is('{tool_label}')"
+        )
+
+    # --------------------------
+    # --- EXPECT/VERIFY ---
+    # --------------------------
+
+    @step
+    def should_have_all_form_fields_visible(
+        self, name: str, author: str, description: str
+    ):
+        expect(self.assistant_name).to_be_visible()
+        expect(self.assistant_name).to_have_text(name)
+        expect(self.assistant_author).to_be_visible()
+        expect(self.assistant_author).to_have_text(f"by {author}")
+        expect(self.about_content).to_be_visible()
+        expect(self.about_content).to_have_text(description)
+        expect(self.system_instructions_content).to_be_visible()
+        return self
+
+    @step
+    def should_have_overview_form_fields_visible(
+        self, project: str, status: str, assistant_id: str
+    ):
+        expect(self.overview_project).to_be_visible()
+        expect(self.overview_project).to_have_text(project)
+        expect(self.overview_shared_status).to_be_visible()
+        expect(self.overview_shared_status).to_have_text(status)
+        expect(self.overview_assistant_id).to_be_visible()
+        expect(self.overview_assistant_id).to_have_value(assistant_id)
+        return self
+
+    @step
+    def should_have_access_links_form_fields_visible(
+        self, assistant_id: str, assistant_name: str
+    ):
+        expect(self.details_link_input).to_be_visible()
+        assert_that(
+            self.details_link_input.input_value(), contains_string(assistant_id)
+        )
+        expect(self.chat_link_input).to_be_visible()
+        assert_that(self.chat_link_input.input_value(), contains_string(assistant_name))
+        return self
+
+    @step
+    def should_have_configuration_form_fields_visible(
+        self, temperature: str, top_p: str
+    ):
+        expect(self.config_temperature).to_be_visible()
+        expect(self.config_temperature).to_have_text(temperature)
+        expect(self.config_top_p).to_be_visible()
+        expect(self.config_top_p).to_have_text(top_p)
+        return self
+
+    @step
+    def should_see_assistant_name(self, expected):
+        expect(self.assistant_name).to_have_text(expected)
+
+    @step
+    def should_see_assistant_author(self, expected):
+        expect(self.assistant_author).to_have_text(expected)
+
+    @step
+    def should_see_about_content(self, expected):
+        expect(self.about_content).to_have_text(expected)
+
+    @step
+    def should_see_system_instructions(self, expected):
+        expect(self.system_instructions_content).to_have_text(expected)
+
+    @step
+    def should_see_overview_project(self, expected):
+        expect(self.overview_project()).to_have_text(expected)
+
+    @step
+    def should_see_overview_shared_status(self, expected):
+        expect(self.overview_shared_status()).to_have_text(expected)
+
+    @step
+    def should_see_assistant_id(self, expected):
+        expect(self.assistant_id_value).to_have_value(expected)
+
+    @step
+    def should_see_links(self, details_link, chat_link):
+        expect(self.details_link_input()).to_have_value(details_link)
+        expect(self.chat_link_input()).to_have_value(chat_link)
+
+    @step
+    def should_see_config_llm_model(self, expected):
+        expect(self.config_llm_model()).to_have_text(expected)
+
+    @step
+    def should_see_config_temperature(self, expected):
+        expect(self.config_temperature()).to_have_text(expected)
+
+    @step
+    def should_see_config_top_p(self, expected):
+        expect(self.config_top_p()).to_have_text(expected)
+
+    @step
+    def should_see_toolkit_visible(self, toolkit_name: str):
+        """Assert that the toolkit with the given name is visible."""
+        expect(self.toolkit_block(toolkit_name)).to_be_visible()
+
+    @step
+    def should_see_toolkit_contains(self, toolkit_name: str, tool_label: str):
+        """Assert a toolkit contains a tool label (visible)."""
+        expect(self.toolkit_tool_label(toolkit_name, tool_label)).to_be_visible()
+
+    @step
+    def should_see_tool_not_present(self, toolkit_name: str, tool_label: str):
+        """Assert a toolkit does NOT contain a tool label."""
+        expect(self.toolkit_tool_label(toolkit_name, tool_label)).not_to_be_visible()
+
+    @step
+    def should_see_toolkit_tools(self, toolkit_name: str, expected_tools: list):
+        """Assert all expected tool labels are present in a toolkit."""
+        for tool in expected_tools:
+            self.expect_toolkit_contains(toolkit_name, tool)

codemie_test_harness/tests/ui/pageobject/assistants/assistants_page.py

@@ -78,6 +78,41 @@ class AssistantsPage(BasePage):
         """Clear all filters button."""
         return self.page.locator('button:has-text("Clear all")')
 
+    @property
+    def action_view_details(self):
+        """Dropdown 'View Details' button."""
+        return self.page.locator("button").filter(has_text="View Details")
+
+    @property
+    def action_copy_link(self):
+        """Dropdown 'Copy Link' button."""
+        return self.page.locator("button").filter(has_text="Copy Link")
+
+    @property
+    def action_edit(self):
+        """Dropdown 'Edit' button."""
+        return self.page.locator("button").filter(has_text="Edit")
+
+    @property
+    def action_clone(self):
+        """Dropdown 'Clone' button."""
+        return self.page.locator("button").filter(has_text="Clone")
+
+    @property
+    def action_delete(self):
+        """Dropdown 'Delete' button."""
+        return self.page.locator("button").filter(has_text="Delete")
+
+    @property
+    def action_publish_to_marketplace(self):
+        """Dropdown 'Publish to Marketplace' button."""
+        return self.page.locator("button").filter(has_text="Publish to Marketplace")
+
+    @property
+    def updating_succesful_popup(self):
+        """Updating succesful popup."""
+        return self.page.locator(".codemie-toast .codemie-toast-header")
+
     # Navigation methods
     @step
     def navigate_to(self):
@@ -139,6 +174,27 @@ class AssistantsPage(BasePage):
         self.get_assistant_card_by_name(name).click()
         return self
 
+    @step
+    def action_dropdown_panel(self, name: str):
+        """Three dot menu."""
+        return self.get_assistant_card_by_name(name).locator(
+            "div.flex.items-center.relative"
+        )
+
+    @step
+    def click_assistant_view(self, name: str):
+        """Click on an assistant view by name."""
+        self.action_dropdown_panel(name).click()
+        self.action_view_details.click()
+        return self
+
+    @step
+    def click_assistant_edit(self, name: str):
+        """Click on an assistant edit by name."""
+        self.action_dropdown_panel(name).click()
+        self.action_edit.click()
+        return self
+
     # Verification methods
     @step
     def should_be_on_assistants_page(self):
@@ -195,3 +251,10 @@ class AssistantsPage(BasePage):
         """Verify that an assistant with specific name is not visible."""
         expect(self.get_assistant_card_by_name(name)).to_be_hidden()
         return self
+
+    @step
+    def should_see_updating_popup(self, text: str):
+        """Verify that an update popup is visible."""
+        expect(self.updating_succesful_popup).to_be_visible()
+        expect(self.updating_succesful_popup).to_have_text(text)
+        return self