codemie-test-harness 0.1.166__tar.gz → 0.1.168__tar.gz

{codemie_test_harness-0.1.166 → codemie_test_harness-0.1.168}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codemie-test-harness
-Version: 0.1.166
+Version: 0.1.168
 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.166)
+Requires-Dist: codemie-sdk-python (==0.1.168)
 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.168/codemie_test_harness/tests/assistant/tools/mcp/test_single_assistant_dual_time_plugins.py

@@ -0,0 +1,160 @@
+"""
+This test verifies that a single assistant can have multiple instances of the same
+MCP server plugin running with different configurations under the same plugin-key.
+"""
+
+import json
+import os
+import subprocess
+import uuid
+from pathlib import Path
+from time import sleep
+from typing import Tuple, List
+
+import pytest
+
+from codemie_test_harness.tests.enums.tools import Toolkit
+from codemie_sdk.models.integration import CredentialTypes
+from codemie_test_harness.tests.conftest import cleanup_plugin_process
+from codemie_test_harness.tests.test_data.plugin_tools_test_data import (
+    dual_time_plugin_test_data,
+)
+from codemie_test_harness.tests.utils.credentials_manager import CredentialsManager
+
+
+CACHE_DIR = Path.home() / ".cache" / "uv" / "archive-v0"
+SERVERS_JSON_PATH = "lib/python3.12/site-packages/toolkits/mcp/servers.json"
+CODEMIE_PLUGINS_PATH = "bin/codemie-plugins"
+PLUGIN_INIT_DELAY = 15
+
+TIME_CONFIGS = {
+    "time-kyiv": {"timezone": "Europe/Kiev", "label": "time-kyiv"},
+    "time-tokyo": {"timezone": "Asia/Tokyo", "label": "time-tokyo"},
+}
+
+
+def find_cache_paths() -> Tuple[Path, Path]:
+    """Find required cache paths for servers.json and codemie-plugins."""
+    for cache_subdir in CACHE_DIR.glob("*"):
+        if not cache_subdir.is_dir():
+            continue
+
+        servers_json = cache_subdir / SERVERS_JSON_PATH
+        codemie_plugins = cache_subdir / CODEMIE_PLUGINS_PATH
+
+        if servers_json.exists() and codemie_plugins.exists():
+            return servers_json, codemie_plugins
+
+    raise FileNotFoundError("Required cache files not found")
+
+
+def configure_mcp_servers(servers_json_path: Path) -> None:
+    """Configure MCP servers in servers.json."""
+    with open(servers_json_path, "r+") as f:
+        config = json.load(f)
+        mcp_servers = config.get("mcpServers", {})
+
+        for server_name, server_config in TIME_CONFIGS.items():
+            if server_name not in mcp_servers:
+                mcp_servers[server_name] = {
+                    "command": "uvx",
+                    "args": [
+                        "mcp-server-time",
+                        f"--local-timezone={server_config['timezone']}",
+                    ],
+                }
+
+        f.seek(0)
+        json.dump(config, f, indent=2)
+        f.truncate()
+
+
+def create_plugin_process(
+    server_name: str, plugin_key: str, codemie_plugins_path: Path
+) -> subprocess.Popen:
+    """Create a plugin process for given server configuration."""
+    config = TIME_CONFIGS[server_name]
+
+    env = os.environ.copy()
+    env.update(
+        {"PLUGIN_LABEL": config["label"], "PLUGIN_EXPERIMENTAL_PROTOCOL": "true"}
+    )
+
+    command = [
+        str(codemie_plugins_path),
+        "--plugin-key",
+        plugin_key,
+        "--plugin-engine-uri",
+        CredentialsManager.get_parameter("NATS_URL"),
+        "mcp",
+        "run",
+        "-s",
+        server_name,
+        "-e",
+        f"{server_name}=PLUGIN_LABEL",
+    ]
+
+    return subprocess.Popen(command, env=env)
+
+
+def cleanup_processes(processes: List[subprocess.Popen]) -> None:
+    """Clean up all managed processes."""
+    for process in processes:
+        cleanup_plugin_process(process)
+
+
+@pytest.fixture(scope="module")
+def dual_time_plugins(integration_utils):
+    """Create two time plugin instances with different configurations."""
+    plugin_key = str(uuid.uuid4())
+    processes = []
+
+    # Setup integration
+    credential_values = CredentialsManager.plugin_credentials(plugin_key)
+    settings = integration_utils.create_integration(
+        credential_type=CredentialTypes.PLUGIN, credential_values=credential_values
+    )
+
+    # Download codemie-tools
+    download_process = subprocess.Popen(["uvx", "codemie-tools"])
+    processes.append(download_process)
+
+    # Find paths and configure servers
+    servers_json_path, codemie_plugins_path = find_cache_paths()
+    configure_mcp_servers(servers_json_path)
+
+    # Start plugin processes for each time config
+    for server_name in TIME_CONFIGS.keys():
+        process = create_plugin_process(server_name, plugin_key, codemie_plugins_path)
+        processes.append(process)
+
+    # Wait for plugin initialization
+    sleep(PLUGIN_INIT_DELAY)
+
+    yield settings
+    cleanup_processes(processes)
+
+
+@pytest.mark.assistant
+@pytest.mark.mcp
+@pytest.mark.plugin
+@pytest.mark.regression
+@pytest.mark.parametrize(
+    "prompt,expected_response",
+    dual_time_plugin_test_data,
+    ids=["Get Tools Available", "Get Kyiv time", "Get Tokyo time"],
+)
+def test_single_assistant_dual_time_plugins(
+    dual_time_plugins,
+    assistant_utils,
+    assistant,
+    similarity_check,
+    prompt,
+    expected_response,
+):
+    assistant_instance = assistant(
+        Toolkit.PLUGIN, Toolkit.PLUGIN, settings=dual_time_plugins
+    )
+
+    response = assistant_utils.ask_assistant(assistant_instance, prompt)
+    similarity_check.check_similarity(response, expected_response)

{codemie_test_harness-0.1.166 → codemie_test_harness-0.1.168}/codemie_test_harness/tests/test_data/plugin_tools_test_data.py

@@ -73,3 +73,36 @@ CREATE_READ_DELETE_FILE_TEST_DATA = {
     "remove_file_prompt": "execute command: git rm -f {}.properties",
     "remove_file_response": "The file `{}.properties` has been removed from the git repository.",
 }
+
+"""Test data for dual time plugin MCP server tests."""
+
+dual_time_plugin_test_data = [
+    (
+        "Show tools with their name and description",
+        """
+            Sure, here are the tools available with their name and description:
+
+            1. **functions._get_current_time_2f90**: 
+               - **Description**: Get current time in a specific timezone. If no timezone is provided by the user, it uses 'Asia/Tokyo' as the local timezone.
+
+            2. **functions._convert_time_2f90**: 
+               - **Description**: Convert time between timezones. If no source timezone is provided by the user, it uses 'Asia/Tokyo' as the local timezone. Similarly, if no target timezone is provided, it uses 'Asia/Tokyo' as the local timezone.
+
+            3. **functions._get_current_time_5cba**: 
+               - **Description**: Similar to `_get_current_time_2f90`, this gets the current time in a specific timezone, defaulting to 'Asia/Tokyo' if no timezone is provided.
+
+            4. **functions._convert_time_5cba**: 
+               - **Description**: Similar to `_convert_time_2f90`, this converts time between timezones, defaulting to 'Asia/Tokyo' if no source or target timezone is provided. 
+
+            These tools are designed to help manage and convert timezone-related data efficiently.
+        """,
+    ),
+    (
+        "What is the current time in Kyiv? Return in format: The current time in Kyiv (Europe/Kiev timezone) is: $time_here",
+        "The current time in Kyiv (Europe/Kiev timezone) is",
+    ),
+    (
+        "What is the current time in Tokyo? Return in format: The current time in Tokyo (Asia/Tokyo timezone) is: $time_here",
+        "The current time in Tokyo (Asia/Tokyo timezone) is",
+    ),
+]

{codemie_test_harness-0.1.166 → codemie_test_harness-0.1.168}/codemie_test_harness/tests/ui/pageobject/base_page.py

@@ -4,7 +4,7 @@ from playwright.sync_api import expect
 from reportportal_client import step
 
 from codemie_test_harness.tests.ui.pageobject.components.pop_up import PopUp
-from codemie_test_harness.tests.ui.pageobject.components.header import Header
+from codemie_test_harness.tests.ui.pageobject.components.menu import Menu
 
 
 class BasePage:
@@ -16,7 +16,7 @@ class BasePage:
     # Component properties using @property decorator
     @property
     def back_button(self):
-        """Back button in the header."""
+        """Back button in the menu."""
         return self.page.locator(
             '//div[not(contains(@class,"justify-end"))]/button[contains(@class,"secondary medium")]'
         ).first
@@ -27,9 +27,9 @@ class BasePage:
         return PopUp(self.page)
 
     @property
-    def header(self):
-        """Header component instance."""
-        return Header(self.page)
+    def menu(self):
+        """Menu component instance."""
+        return Menu(self.page)
 
     # Common page elements
     @property
@@ -55,44 +55,44 @@ class BasePage:
     # Navigation methods
     @step
     def go_to_workflows_page(self):
-        """Navigate to workflows page using header navigation."""
-        self.header.navigate_to_workflows()
+        """Navigate to workflows page using menu navigation."""
+        self.menu.navigate_to_workflows()
         return self
 
     @step
     def go_to_assistants_page(self):
-        """Navigate to assistants page using header navigation."""
-        self.header.navigate_to_assistants()
+        """Navigate to assistants page using menu navigation."""
+        self.menu.navigate_to_assistants()
         return self
 
     @step
     def go_to_chats_page(self):
-        """Navigate to chats page using header navigation."""
-        self.header.navigate_to_chats()
+        """Navigate to chats page using menu navigation."""
+        self.menu.navigate_to_chats()
         return self
 
     @step
     def go_to_applications_page(self):
-        """Navigate to applications page using header navigation."""
-        self.header.navigate_to_applications()
+        """Navigate to applications page using menu navigation."""
+        self.menu.navigate_to_applications()
         return self
 
     @step
     def go_to_integrations_page(self):
-        """Navigate to integrations page using header navigation."""
-        self.header.navigate_to_integrations()
+        """Navigate to integrations page using menu navigation."""
+        self.menu.navigate_to_integrations()
         return self
 
     @step
     def go_to_data_sources_page(self):
-        """Navigate to data sources page using header navigation."""
-        self.header.navigate_to_data_sources()
+        """Navigate to data sources page using menu navigation."""
+        self.menu.navigate_to_data_sources()
         return self
 
     @step
     def go_to_help_page(self):
-        """Navigate to help page using header navigation."""
-        self.header.navigate_to_help()
+        """Navigate to help page using menu navigation."""
+        self.menu.navigate_to_help()
         return self
 
     # Pop-up interaction methods
@@ -164,10 +164,10 @@ class BasePage:
         """Verify that the new release popup is visible with expected content."""
         expect(self.pop_up.cancel).to_have_text("Got It, Thanks!")
         expect(self.pop_up.submit).to_have_text("Tell Me More")
-        expect(self.pop_up.header).to_have_text("New CodeMie Release")
+        expect(self.pop_up.menu).to_have_text("New CodeMie Release")
         expect(self.pop_up.body).to_have_text(
             re.compile(
-                r"Great news! We've rolled out new CodeMie version 1.\d.\d+ to enhance your experience. Take a moment to "
+                r"Great news! We've rolled out new CodeMie version 2.\d.\d+ to enhance your experience. Take a moment to "
                 "explore what's new and discover how these changes can benefit you! Please review Release Notes!"
             )
         )
@@ -182,9 +182,9 @@ class BasePage:
 
     # Common verification methods
     @step
-    def should_have_header_visible(self):
-        """Verify that the header is visible."""
-        self.header.should_be_visible()
+    def should_have_menu_visible(self):
+        """Verify that the menu is visible."""
+        self.menu.should_be_visible()
         return self
 
     @step

{codemie_test_harness-0.1.166 → codemie_test_harness-0.1.168}/codemie_test_harness/tests/ui/pageobject/components/__init__.py

@@ -1,6 +1,6 @@
 from .workflow_card import WorkflowCard
 from .pop_up import PopUp
-from .header import Header
+from .menu import Menu
 from .workflow_sidebar import WorkflowSidebar
 from .execution_history_row import ExecutionHistoryRow
 from .workflow_state_card import WorkflowStateCard
@@ -10,7 +10,7 @@ from .workflow_execution_state import WorkflowExecutionState
 __all__ = [
     "WorkflowCard",
     "PopUp",
-    "Header",
+    "Menu",
     "WorkflowSidebar",
     "ExecutionHistoryRow",
     "WorkflowStateCard",

{codemie_test_harness-0.1.166 → codemie_test_harness-0.1.168}/codemie_test_harness/tests/ui/pageobject/components/execution_history_row.py

@@ -122,7 +122,7 @@ class ExecutionHistoryRow:
         self.should_have_status("In Progress")
         expect(self.status_badge).to_have_class("bg-in-progress-secondary")
         expect(self.status_badge).to_have_class("text-in-progress-main")
-        expect(self.status_badge).to_have_class("border-in-progress-main")
+        expect(self.status_badge).to_have_class("border-in-progress-border")
         expect(self.status_dot).to_have_class("animate-pulse")
 
     @step
@@ -131,7 +131,7 @@ class ExecutionHistoryRow:
         self.should_have_status("Succeeded")
         expect(self.status_badge).to_contain_class("bg-success-secondary")
         expect(self.status_badge).to_contain_class("text-success-main")
-        expect(self.status_badge).to_contain_class("border-success-main")
+        expect(self.status_badge).to_contain_class("border-success-border")
 
     @step
     def should_have_failed_status(self):
@@ -139,7 +139,7 @@ class ExecutionHistoryRow:
         self.should_have_status("Failed")
         expect(self.status_badge).to_contain_class("bg-error-secondary")
         expect(self.status_badge).to_contain_class("text-error-main")
-        expect(self.status_badge).to_contain_class("border-error-main")
+        expect(self.status_badge).to_contain_class("border-error-border")
 
     @step
     def should_have_prompt(self, expected_prompt: str):

codemie_test_harness-0.1.166/codemie_test_harness/tests/ui/pageobject/components/header.py → codemie_test_harness-0.1.168/codemie_test_harness/tests/ui/pageobject/components/menu.py

@@ -1,5 +1,5 @@
 """
-Header component page object for the main navigation header.
+Menu component page object for the main navigation menu.
 Contains methods for interacting with navigation links, logo, and user profile.
 """
 
@@ -7,23 +7,23 @@ from reportportal_client import step
 from playwright.sync_api import expect
 
 
-class Header:
-    """Header component with property-based element locators."""
+class Menu:
+    """Menu component with property-based element locators."""
 
     def __init__(self, page):
         self.page = page
 
-    # Header elements using @property decorator
+    # Menu elements using @property decorator
     @property
-    def header_container(self):
-        """Main header container."""
+    def menu_container(self):
+        """Main menu container."""
         return self.page.locator("//body//header")
 
     @property
     def logo_link(self):
         """Logo link element."""
-        return self.header_container.locator(
-            '//a[@href="#/assistants"][span[text()="EPAM AI/Run"]]'
+        return self.menu_container.locator(
+            "a.h-12.flex.grow.gap-4.items-center.relative.select-none.text-nowrap.cursor-pointer.group"
         )
 
     @property
@@ -33,13 +33,13 @@ class Header:
 
     @property
     def logo_tooltip(self):
-        """Logo tooltip text."""
-        return self.page.locator('span:has-text("EPAM AI/Run")')
+        """Logo tooltip text whn menu is expanded."""
+        return self.page.locator('a:has-text("EPAM AI/RUN"):has-text("CodeMie")')
 
     @property
     def top_nav(self):
         """Top navigation container."""
-        return self.header_container.locator('nav[aria-label="top-nav-links"]')
+        return self.menu_container.locator('nav[aria-label="top-nav-links"]')
 
     @property
     def chats_link(self):
@@ -64,7 +64,7 @@ class Header:
     @property
     def secondary_nav(self):
         """Secondary navigation container."""
-        return self.header_container.locator('nav[aria-label="secondary-nav-links"]')
+        return self.menu_container.locator('nav[aria-label="secondary-nav-links"]')
 
     @property
     def integrations_link(self):
@@ -79,73 +79,51 @@ class Header:
     @property
     def bottom_nav(self):
         """Bottom navigation container."""
-        return self.header_container.locator('nav[aria-label="bottom-nav-links"]')
+        return self.menu_container.locator('nav[aria-label="bottom-nav-links"]')
 
     @property
-    def help_link(self):
-        """Help navigation link."""
-        return self.bottom_nav.locator('a[href="#/help"]')
-
-    @property
-    def user_profile_container(self):
-        """User profile container."""
-        return self.header_container.locator("//span[text()='User Profile']/..")
-
-    @property
-    def user_profile_button(self):
-        """User profile button."""
-        return self.user_profile_container.locator("button")
-
-    @property
-    def user_avatar(self):
-        """User avatar image."""
-        return self.user_profile_button.locator('img[alt="User profile"]')
-
-    @property
-    def user_profile_tooltip(self):
-        """User profile tooltip text."""
-        return self.page.locator('span:has-text("User Profile")')
-
-    # Navigation link tooltips
-    @property
-    def chats_tooltip(self):
-        """Chats tooltip text."""
-        return self.page.locator('span:has-text("Chats")')
+    def faq_assistant_link(self):
+        """FAQ assistant navigation link."""
+        return self.bottom_nav.locator(
+            'a[href="#/assistants/codemie-onboarding/start"]'
+        )
 
     @property
-    def assistants_tooltip(self):
-        """Assistants tooltip text."""
-        return self.page.locator('span:has-text("Assistants")')
+    def prompt_assistant_link(self):
+        """Prompt Engineer assistant navigation link."""
+        return self.bottom_nav.locator('a[href="#/assistants/prompt-engineer/start"]')
 
     @property
-    def workflows_tooltip(self):
-        """Workflows tooltip text."""
-        return self.page.locator('span:has-text("Workflows")')
+    def switch_new_codemie(self):
+        """Switch to new CodeMie."""
+        return self.menu_container.locator(".switch")
 
     @property
-    def applications_tooltip(self):
-        """Applications tooltip text."""
-        return self.page.locator('span:has-text("Applications")')
+    def hide_expand_menu_button(self):
+        """Hide/Expand menu button."""
+        return self.menu_container.locator(
+            'button[type="button"].rounded-lg.flex.items-center'
+        )
 
     @property
-    def integrations_tooltip(self):
-        """Integrations tooltip text."""
-        return self.page.locator('span:has-text("Integrations")')
+    def help_link(self):
+        """Help navigation link."""
+        return self.bottom_nav.locator('a[href="#/help"]')
 
     @property
-    def data_sources_tooltip(self):
-        """Data Sources tooltip text."""
-        return self.page.locator('span:has-text("Data Sources")')
+    def user_profile_button(self):
+        """User profile button."""
+        return self.menu_container.locator("button.cursor-pointer.group")
 
     @property
-    def help_tooltip(self):
-        """Help tooltip text."""
-        return self.page.locator('span:has-text("Help")')
+    def user_avatar(self):
+        """User avatar image."""
+        return self.user_profile_button.locator("img")
 
     # Action methods
     @step
     def click_logo(self):
-        """Click on the EPAM AI/Run logo to navigate to assistants page."""
+        """Click on the EPAM AI/Run logo to navigate to new chat."""
         self.logo_link.click()
         return self
 
@@ -197,46 +175,6 @@ class Header:
         self.user_profile_button.click()
         return self
 
-    @step
-    def hover_over_navigation_item(self, navigation_item: str):
-        """
-        Hover over a navigation item to display its tooltip.
-
-        Args:
-            navigation_item (str): The navigation item to hover over
-                                 ('chats', 'assistants', 'workflows', 'applications',
-                                  'integrations', 'data_sources', 'help', 'logo', 'user_profile')
-        """
-        navigation_items = {
-            "chats": self.chats_link,
-            "assistants": self.assistants_link,
-            "workflows": self.workflows_link,
-            "applications": self.applications_link,
-            "integrations": self.integrations_link,
-            "data_sources": self.data_sources_link,
-            "help": self.help_link,
-            "logo": self.logo_link,
-            "user_profile": self.user_profile_button,
-        }
-
-        if navigation_item in navigation_items:
-            navigation_items[navigation_item].hover()
-        else:
-            raise ValueError(f"Unknown navigation item: {navigation_item}")
-        return self
-
-    @step
-    def wait_for_tooltip_to_appear(self, tooltip_text: str):
-        """
-        Wait for a specific tooltip to appear.
-
-        Args:
-            tooltip_text (str): The text of the tooltip to wait for
-        """
-        tooltip = self.page.locator(f'span:has-text("{tooltip_text}")')
-        tooltip.wait_for(state="visible")
-        return self
-
     # Utility methods
     @step
     def get_active_navigation_item(self):
@@ -244,7 +182,7 @@ class Header:
         Get the currently active navigation item.
         Returns the href of the active navigation link.
         """
-        active_link = self.header_container.locator("a.bg-new-panel-secondary")
+        active_link = self.menu_container.locator("a.bg-new-panel-secondary")
         if active_link.is_visible():
             return active_link.get_attribute("href")
         return None
@@ -257,8 +195,8 @@ class Header:
     # Verification methods
     @step
     def should_be_visible(self):
-        """Verify that the header is visible."""
-        expect(self.header_container).to_be_visible()
+        """Verify that the menu is visible."""
+        expect(self.menu_container).to_be_visible()
         return self
 
     @step
@@ -293,12 +231,12 @@ class Header:
         Verify that all main navigation elements are present and visible.
         """
         navigation_structure = {
-            "header": self.header_container,
+            "menu": self.menu_container,
             "logo": self.logo_link,
             "top_nav": self.top_nav,
             "secondary_nav": self.secondary_nav,
             "bottom_nav": self.bottom_nav,
-            "user_profile": self.user_profile_container,
+            "user_profile": self.user_profile_button,
             "chats_link": self.chats_link,
             "assistants_link": self.assistants_link,
             "workflows_link": self.workflows_link,
@@ -306,6 +244,10 @@ class Header:
             "integrations_link": self.integrations_link,
             "data_sources_link": self.data_sources_link,
             "help_link": self.help_link,
+            "faq_assistant_link": self.faq_assistant_link,
+            "prompt_assistant_link": self.prompt_assistant_link,
+            "switch_to_new_codemie": self.switch_new_codemie,
+            "hide_expand_menu": self.hide_expand_menu_button,
         }
 
         for element_name, element in navigation_structure.items():
@@ -322,9 +264,9 @@ class Header:
 
     # Legacy methods for backward compatibility
     @step
-    def is_header_visible(self):
-        """Check if the header is visible on the page."""
-        return self.header_container.is_visible()
+    def is_menu_visible(self):
+        """Check if the menu is visible on the page."""
+        return self.menu_container.is_visible()
 
     @step
     def is_logo_visible(self):
@@ -359,12 +301,12 @@ class Header:
             dict: A dictionary with the visibility status of each navigation section
         """
         return {
-            "header_visible": self.header_container.is_visible(),
+            "menu_visible": self.menu_container.is_visible(),
             "logo_visible": self.logo_link.is_visible(),
             "top_nav_visible": self.top_nav.is_visible(),
             "secondary_nav_visible": self.secondary_nav.is_visible(),
             "bottom_nav_visible": self.bottom_nav.is_visible(),
-            "user_profile_visible": self.user_profile_container.is_visible(),
+            "user_profile_visible": self.user_profile_button.is_visible(),
             "chats_link_visible": self.chats_link.is_visible(),
             "assistants_link_visible": self.assistants_link.is_visible(),
             "workflows_link_visible": self.workflows_link.is_visible(),
@@ -372,4 +314,8 @@ class Header:
             "integrations_link_visible": self.integrations_link.is_visible(),
             "data_sources_link_visible": self.data_sources_link.is_visible(),
             "help_link_visible": self.help_link.is_visible(),
+            "faq_assistant_link_visible": self.faq_assistant_link.is_visible(),
+            "prompt_assistant_link_visible": self.prompt_assistant_link.is_visible(),
+            "switch_to_new_codemie_visible": self.switch_new_codemie.is_visible(),
+            "hide_expand_menu_visible": self.hide_expand_menu_button.is_visible(),
         }