Warning

This document is for an in-development version of Galaxy. You can alternatively view this page in the latest release if it exists or view the top of the latest release's documentation.

galaxy.selenium package

Top-level of library designed to ease use of Selenium targetting Galaxy.

galaxy_selenium is purposes being designed to depend on Python selenium, six, pyyaml, and optional pyvirtualdisplay but not galaxy-lib (or any of Galaxy or Galaxy’s test stuff) currently.

Subpackages

• galaxy.selenium.scripts package
  • Submodules
  • galaxy.selenium.scripts.dump_tour module
    • main()
    • DumpTourCallback
      • DumpTourCallback.__init__()
      • DumpTourCallback.driver_wrapper
      • DumpTourCallback.handle_step()
• galaxy.selenium.toolbox package
  • Submodules
  • galaxy.selenium.toolbox.filters module
    • restrict_test()

Submodules

galaxy.selenium.cli module

galaxy.selenium.cli.add_selenium_arguments(parser)

Add common selenium arguments for argparse driver utility.

class galaxy.selenium.cli.DriverWrapper(args)

Bases: NavigatesGalaxy

Adapt argparse command-line options to a browser automation driver.

__init__(args)

build_url(url='', for_selenium: bool = True)

Build URL to the target Galaxy.

screenshot(label: str) → None

No-op in this context, not saving debugging/testing screenshots.

Consider a verbose or debug option for saving these.

property default_timeout

finish()

Clean up driver and display resources.

galaxy.selenium.components module

galaxy.selenium.context module

class galaxy.selenium.context.GalaxySeleniumContext

Bases: NavigatesGalaxy

url: str

target_url_from_selenium: str

configured_driver: ConfiguredDriver

build_url(url: str, for_selenium: bool = True) → str

Build URL to the target Galaxy.

screenshot(label: str)

If GALAXY_TEST_SCREENSHOTS_DIRECTORY is set create a screenshot there named <label>.png.

Unlike the above “snapshot” feature, this will be written out regardless and not in a per-test directory. The above method is used for debugging failures within a specific test. This method if more for creating a set of images to augment automated testing with manual human inspection after a test or test suite has executed.

class galaxy.selenium.context.GalaxySeleniumContextImpl(from_dict: dict | None = None)

Bases: GalaxySeleniumContext

Minimal, simplified GalaxySeleniumContext useful outside the context of test cases.

A variant of this concept that can also populate content via the API to then interact with via the Selenium is galaxy_test.selenium.framework.GalaxySeleniumContextImpl.

__init__(from_dict: dict | None = None) → None

galaxy.selenium.context.init(config=None, clazz=<class 'galaxy.selenium.context.GalaxySeleniumContextImpl'>) → GalaxySeleniumContext

galaxy.selenium.data module

galaxy.selenium.driver_factory module

class galaxy.selenium.driver_factory.ConfiguredDriver(timeout_handler: Callable[[WaitTypeT | None], float], browser: str = 'auto', remote: bool = False, remote_host: str = '127.0.0.1', remote_port: str = '4444', headless: bool = False, backend_type: Literal['selenium', 'playwright'] = 'selenium')

Bases: object

Configured driver factory supporting both Selenium and Playwright backends.

This class creates and manages either a Selenium WebDriver or Playwright driver based on the backend_type parameter. It provides a unified interface via HasDriverProtocol for both implementations.

Attributes:

driver_impl: The HasDriverProtocol implementation (HasDriver or HasPlaywrightDriver) config: Configuration dictionary for serialization backend_type: Which backend is being used (“selenium” or “playwright”)

__init__(timeout_handler: Callable[[WaitTypeT | None], float], browser: str = 'auto', remote: bool = False, remote_host: str = '127.0.0.1', remote_port: str = '4444', headless: bool = False, backend_type: Literal['selenium', 'playwright'] = 'selenium')

Initialize a configured driver with the specified backend.

Args:

timeout_handler: Callback function that returns timeout value for wait operations browser: Browser name (“auto”, “CHROME”, “FIREFOX”, etc.) remote: Whether to use remote Selenium Grid (Selenium only) remote_host: Remote Selenium Grid host remote_port: Remote Selenium Grid port headless: Whether to run browser in headless mode backend_type: Which backend to use (“selenium” or “playwright”)

Raises:

Exception: If Playwright backend is requested with remote=True Exception: If Playwright is not installed when backend_type=”playwright”

backend_type: Literal['selenium', 'playwright']

config: dict[str, Any]

driver_impl: HasDriverProtocol[Any]

to_dict() → dict[str, Any]

Serialize configuration to dictionary.

static from_dict(timeout_handler: Callable[[WaitTypeT | None], float], as_dict: dict[str, Any]) → ConfiguredDriver

Deserialize configuration from dictionary.

quit() → None

Clean up and close the driver.

galaxy.selenium.driver_factory.get_local_driver(browser='auto', headless=False) → WebDriver

galaxy.selenium.driver_factory.get_remote_driver(host, port, browser='auto') → WebDriver

galaxy.selenium.driver_factory.get_playwright_browser_type(browser: str = 'auto') → Literal['chromium', 'firefox', 'webkit']

Map Selenium browser names to Playwright browser types.

Args:

browser: Browser name (CHROME, FIREFOX, auto, etc.)

Returns:

Playwright browser type: ‘chromium’, ‘firefox’, or ‘webkit’ This matches the BrowserType.name property values.

Raises:

NotImplementedError: If browser type has no direct Playwright mapping

galaxy.selenium.driver_factory.is_virtual_display_available()

galaxy.selenium.driver_factory.virtual_display_if_enabled(enabled)

galaxy.selenium.has_driver module

A mixin to extend a class that has self.driver with higher-level constructs.

This should be mixed into classes with a self.driver and self.default_timeout attribute.

galaxy.selenium.has_driver.exception_indicates_click_intercepted(exception)

galaxy.selenium.has_driver.exception_indicates_not_clickable(exception)

galaxy.selenium.has_driver.exception_indicates_stale_element(exception)

class galaxy.selenium.has_driver.HasDriver

Bases: TimeoutMessageMixin, WaitMethodsMixin, Generic[WaitTypeT]

by

alias of By

keys

alias of Keys

driver: WebDriver

axe_script_url: str = 'https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.7.1/axe.min.js'

axe_skip: bool = False

property backend_type: Literal['selenium', 'playwright']

Identify this as the Selenium backend implementation.

property current_url: str

Get the current page URL.

Returns:

The current URL

property page_source: str

Get the HTML source of the current page.

Returns:

The page HTML as a string

property page_title: str

Get the title of the current page.

Returns:

The page title as a string

navigate_to(url: str) → None

Navigate to a URL.

Args:

url: The URL to navigate to

re_get_with_query_params(params_str: str)

assert_xpath(xpath: str)

assert_selector(selector: str)

assert_selector_absent_or_hidden(selector: str)

assert_absent_or_hidden(selector_template: Target)

assert_disabled(selector_template: Target)

selector_is_displayed(selector: str)

is_displayed(selector_template: Target) → bool

assert_selector_absent(selector: str)

find_elements(selector_template: Target) → list[WebElementProtocol]

find_element(selector_template: Target | tuple[str, str]) → WebElementProtocol

Find first element matching selector template (no waiting).

Args:

selector_template: Either a Target or a (locator_type, value) tuple

assert_absent(selector_template: Target) → None

element_absent(selector_template: Target) → bool

switch_to_frame(frame_reference: str | int | WebElement = 'frame')

Switch to an iframe or frame.

Args:

frame_reference: Can be:

• str: frame name or id (will wait for frame to be available)

• int: frame index

• WebElement: frame element

Returns:

The result of the switch operation

switch_to_default_content()

Switch back to the default content (main page context).

This exits any iframe/frame context and returns to the top-level page.

get_cookies() → list[Cookie]

Get all cookies for the current domain.

Returns:

List of cookie dictionaries with keys like ‘name’, ‘value’, ‘domain’, ‘path’, etc.

click(selector_template: Target)

action_chains()

drag_and_drop(source: WebElementProtocol, target: WebElementProtocol) → None

Drag and drop from source element to target element.

Uses JavaScript-based drag and drop implementation for reliability.

Args:

source: The element to drag target: The element to drop onto

move_to_and_click(element: WebElementProtocol) → None

Move to an element and click it using ActionChains.

This is useful when a simple click doesn’t work due to element positioning.

Args:

element: The element to move to and click

hover(element: WebElement) → None

Hover over an element (move mouse to element without clicking).

Args:

element: The element to hover over

send_enter(element: WebElement | None = None)

send_escape(element: WebElement | None = None)

send_backspace(element: WebElement | None = None)

aggressive_clear(element: WebElement) → None

abstract property timeout_handler: Callable[[WaitTypeT | None], float]

Get timeout handler for application specific wait types.

wait(timeout=<object object>, wait_type: ~galaxy.selenium.has_driver_protocol.WaitTypeT | None = None, **kwds)

click_xpath(xpath: str)

click_label(text: str)

click_selector(selector: str)

fill(form: WebElement, info: dict)

click_submit(form: WebElement)

prepend_timeout_message(timeout_exception: TimeoutException, message: str) → TimeoutException

accept_alert()

Return a context manager for accepting alerts.

For Selenium, the alert must exist before it can be accepted, so we wait until the context exits to accept it.

Usage:

with driver.accept_alert():

driver.click_selector(“#button-that-shows-alert”)

# Alert is automatically accepted here

execute_script(script: str, *args)

Execute JavaScript in the current browser context.

Args:

script: JavaScript code to execute *args: Optional arguments to pass to the script (accessible as arguments[0], arguments[1], etc.)

Returns:

The return value of the script execution

set_local_storage(key: str, value: str | float) → None

Set a value in the browser’s localStorage.

Args:

key: The localStorage key value: The value to store (will be JSON-stringified if not a string)

remove_local_storage(key: str) → None

Remove a key from the browser’s localStorage.

Args:

key: The localStorage key to remove

scroll_into_view(element: WebElement) → None

Scroll an element into view using JavaScript.

Args:

element: The element to scroll into view

set_element_value(element: WebElement, value: str) → None

Set an element’s value property directly using JavaScript.

This is useful for contenteditable elements or when .clear() doesn’t work.

Args:

element: The element to modify value: The value to set

execute_script_click(element: WebElement) → None

Click an element using JavaScript instead of Selenium’s native click.

This is useful when Selenium’s click is intercepted or the element is not clickable.

Args:

element: The element to click

find_element_by_link_text(text: str, element: WebElement | None = None) → WebElementProtocol

find_element_by_xpath(xpath: str, element: WebElement | None = None) → WebElementProtocol

find_element_by_id(id: str, element: WebElement | None = None) → WebElementProtocol

find_element_by_selector(selector: str, element: WebElement | None = None) → WebElementProtocol

find_elements_by_selector(selector: str, element: WebElement | None = None) → list[WebElementProtocol]

Find multiple elements by CSS selector.

Args:

selector: CSS selector string element: Optional parent element to search within

Returns:

List of WebElementProtocol elements

get_input_value(element: WebElementProtocol) → str

Get the value of an input element.

This provides a unified interface for getting input values across both Selenium and Playwright backends. For Selenium, this uses get_attribute(“value”).

Args:

element: The input element to get the value from

Returns:

The current value of the input element, or empty string if no value

select_by_value(selector_template: Target | tuple[str, str], value: str) → None

Select an option from a <select> element by its value attribute.

Args:

selector_template: Either a Target or a (locator_type, value) tuple for the select element value: The value attribute of the option to select

axe_eval(context: str | None = None, write_to: str | None = None) → AxeResults

save_screenshot(path: str) → None

Save a screenshot to the specified path.

Args:

path: File path where the screenshot should be saved

get_screenshot_as_png() → bytes

Capture a screenshot and return it as PNG bytes.

Returns:

PNG image data as bytes

close() → None

Cleanup the current browser tab/page.

quit() → None

Clean up and close the driver/browser.

This closes all windows/tabs and releases all system resources. The driver cannot be used after calling this method.

double_click(element: WebElement) → None

Double-click an element using ActionChains.

Args:

element: The element to double-click

assert_absent_or_hidden_after_transitions(selector_template: Target, **kwds) → None

Assert element is absent or hidden (convenience method for subclasses to override with retry logic).

This is a basic implementation that calls assert_absent_or_hidden. Subclasses may decorate or override this method with retry logic for handling transitions where elements may become stale.

Args:

selector_template: Target selector for the element **kwds: Additional keyword arguments

galaxy.selenium.has_driver.SeleniumTimeoutException

alias of TimeoutException

class galaxy.selenium.has_driver.TimeoutMessageMixin

Bases: object

Mixin providing timeout message formatting for driver abstractions.

galaxy.selenium.jupyter_context module

galaxy.selenium.jupyter_context.init(config=None)

class galaxy.selenium.jupyter_context.JupyterContextImpl(from_dict: dict | None = None)

Bases: GalaxySeleniumContextImpl

screenshot(label)

If GALAXY_TEST_SCREENSHOTS_DIRECTORY is set create a screenshot there named <label>.png.

Unlike the above “snapshot” feature, this will be written out regardless and not in a per-test directory. The above method is used for debugging failures within a specific test. This method if more for creating a set of images to augment automated testing with manual human inspection after a test or test suite has executed.

galaxy.selenium.navigates_galaxy module

A mixin that extends a HasDriver class with Galaxy-specific utilities.

Implementer must provide a self.build_url method to target Galaxy.

class galaxy.selenium.navigates_galaxy.WaitType(name, default_length)

Bases: tuple

default_length

Alias for field number 1

name

Alias for field number 0

class galaxy.selenium.navigates_galaxy.HistoryEntry(id, hid, history_content_type)

Bases: NamedTuple

id: str

Alias for field number 0

hid: str

Alias for field number 1

history_content_type: str

Alias for field number 2

class galaxy.selenium.navigates_galaxy.WAIT_TYPES

Bases: object

UX_RENDER = ('ux_render', 1)

UX_TRANSITION = ('ux_transition', 5)

UX_POPUP = ('ux_popup', 15)

DATABASE_OPERATION = ('database_operation', 10)

JOB_COMPLETION = ('job_completion', 45)

GIE_SPAWN = ('gie_spawn', 30)

SHED_SEARCH = ('shed_search', 30)

REPO_INSTALL = ('repo_install', 60)

HISTORY_POLL = ('history_poll', 3)

galaxy.selenium.navigates_galaxy.galaxy_timeout_handler(timeout_multiplier: float = 1)

class galaxy.selenium.navigates_galaxy.NullTourCallback

Bases: object

handle_step(step, step_index: int)

galaxy.selenium.navigates_galaxy.exception_seems_to_indicate_transition(e)

True if exception seems to indicate the page state is transitioning.

Galaxy features many different transition effects that change the page state over time. These transitions make it slightly more difficult to test Galaxy because atomic input actions take an indeterminate amount of time to be reflected on the screen. This method takes a Selenium assertion and tries to infer if such a transition could be the root cause of the exception. The methods that follow use it to allow retrying actions during transitions.

Currently the two kinds of exceptions that we say may indicate a transition are StaleElement exceptions (a DOM element grabbed at one step is no longer available) and “not clickable” exceptions (so perhaps a popup modal is blocking a click).

galaxy.selenium.navigates_galaxy.retry_call_during_transitions(f, attempts=10, sleep=0.1, exception_check=<function exception_seems_to_indicate_transition>)

galaxy.selenium.navigates_galaxy.retry_during_transitions(f, attempts=10, sleep=0.1, exception_check=<function exception_seems_to_indicate_transition>)

galaxy.selenium.navigates_galaxy.retry_index_during_transitions()

galaxy.selenium.navigates_galaxy.edit_details(f, scope='.history-index')

Open the editor, run the edits, hit the save button

class galaxy.selenium.navigates_galaxy.ConfigTemplateParameter(form_element_type: Literal['string', 'boolean', 'integer'], name: str, value: Any)

Bases: object

form_element_type: Literal['string', 'boolean', 'integer']

name: str

value: Any

__init__(form_element_type: Literal['string', 'boolean', 'integer'], name: str, value: Any) → None

class galaxy.selenium.navigates_galaxy.FileSourceInstance(template_id: str, name: str, description: Optional[str], parameters: list[galaxy.selenium.navigates_galaxy.ConfigTemplateParameter] = <factory>)

Bases: object

template_id: str

name: str

description: str | None

parameters: list[ConfigTemplateParameter]

__init__(template_id: str, name: str, description: str | None, parameters: list[~galaxy.selenium.navigates_galaxy.ConfigTemplateParameter] = <factory>) → None

class galaxy.selenium.navigates_galaxy.ObjectStoreInstance(template_id: str, name: str, description: Optional[str], parameters: list[galaxy.selenium.navigates_galaxy.ConfigTemplateParameter] = <factory>)

Bases: object

template_id: str

name: str

description: str | None

parameters: list[ConfigTemplateParameter]

__init__(template_id: str, name: str, description: str | None, parameters: list[~galaxy.selenium.navigates_galaxy.ConfigTemplateParameter] = <factory>) → None

class galaxy.selenium.navigates_galaxy.ColumnDefinition(name: str, description: str, type: Literal['Text', 'Integer', 'Element Identifier'] = 'Text', optional: bool = False, default_value: str | None = None)

Bases: object

name: str

description: str

type: Literal['Text', 'Integer', 'Element Identifier'] = 'Text'

optional: bool = False

default_value: str | None = None

__init__(name: str, description: str, type: Literal['Text', 'Integer', 'Element Identifier'] = 'Text', optional: bool = False, default_value: str | None = None) → None

class galaxy.selenium.navigates_galaxy.NavigatesGalaxy

Bases: HasDriverProxy[WaitType]

Class with helpers methods for driving components of the Galaxy interface.

In most cases, methods for interacting with Galaxy components that appear in multiple tests or applications should be refactored into this class for now. Keep in mind that this class is used outside the context of TestCase s as well - so some methods more explicitly related to test data or assertion checking may make more sense in SeleniumTestCase for instance.

Some day this class will likely be split up into smaller mixins for particular components of Galaxy, but until that day the best practice is to prefix methods for driving or querying the interface with the name of the component or page the method operates on. These serve as pseudo-namespaces until we decompose this class. For instance, the method for clicking an option in the workflow editor is workflow_editor_click_option instead of click_workflow_editor_option.

property driver: WebDriver

Access the underlying Selenium WebDriver.

This property provides direct access to the Selenium driver when using the Selenium backend. For Playwright backend, this raises NotImplementedError.

Returns:

WebDriver: The Selenium WebDriver instance

Raises:

NotImplementedError: If using Playwright backend

property page

Access the underlying Playwright Page.

This property provides direct access to the Playwright page when using the Playwright backend. For Selenium backend, this raises NotImplementedError.

Returns:

Page: The Playwright Page instance

Raises:

NotImplementedError: If using Selenium backend

abstract build_url(url: str, for_selenium: bool = True) → str

Build URL to the target Galaxy.

abstract screenshot(label: str) → None

Take a screenshot of the current browser with the specified label.

screenshot_if(label: str | None) → str | None

default_password = '123456'

wait_types

alias of WAIT_TYPES

get(url: str = '')

Expand supplied relative URL and navigate to page using Selenium driver.

property navigation: Component

property components: SmartComponent

Fetch root component describing the Galaxy DOM.

wait_length(wait_type: WaitType) → float

Return the wait time specified by wait_type after applying timeout_multipler.

timeout_multiplier is used in production CI tests to reduce transient failures in a uniform way across test suites to expand waiting.

sleep_for(wait_type: WaitType) → None

Sleep on the Python client side for the specified wait_type.

This method uses wait_length to apply any timeout_multiplier.

sleep_for_seconds(duration: float) → None

Sleep in the local thread for specified number of seconds.

Ideally, we would be sleeping on the Selenium server instead of in the local client (e.g. test) thread.

home() → None

Return to root Galaxy page and wait for some basic widgets to appear.

wait_for_masthead()

go_to_workflow_landing(uuid: str, public: Literal['false', 'true'], client_secret: str | None)

go_to_trs_search() → None

go_to_trs_by_id() → None

go_to_workflow_sharing(workflow_id: str) → None

go_to_workflow_export(workflow_id: str) → None

go_to_history_sharing(history_id: str) → None

make_history_private()

go_to_import_zip() → None

switch_to_main_panel()

local_storage(key: str, value: float | str)

Method decorator to modify localStorage for the scope of the supplied context.

main_panel()

Decorator to operate within the context of Galaxy’s main frame.

visualization_panel()

Decorator to operate within the context of Galaxy’s visualization frame.

api_get(endpoint, data=None, raw=False)

api_post(endpoint, data=None)

api_delete(endpoint, raw=False)

get_galaxy_session()

selenium_to_requests_cookies()

history_panel_name_element()

history_panel_name()

history_panel_collection_rename(hid: int, new_name: str, assert_old_name: str | None = None)

history_panel_expand_collection(collection_hid: int) → SmartComponent

history_panel_collection_name_element()

make_accessible_and_publishable()

history_contents(history_id=None, view='summary', datasets_only=True)

current_history() → dict[str, Any]

current_history_id() → str

current_history_publish()

latest_history_entry()

latest_history_item() → dict[str, Any]

wait_for_history(assert_ok=True)

history_panel_create_new_with_name(name)

history_panel_create_new()

Click create new and pause a bit for the history to begin to refresh.

history_panel_wait_for_hid_ok(hid, allowed_force_refreshes=0)

history_panel_wait_for_hid_deferred(hid, allowed_force_refreshes=0)

wait_for_hid_ok_and_open_details(hid)

history_panel_item_component(history_item=None, hid=None, multi_history_panel=False)

wait_for_history_to_have_hid(history_id, hid)

history_panel_wait_for_hid_visible(hid, allowed_force_refreshes=0, multi_history_panel=False)

hid_to_history_item(hid, current_history_id=None)

history_item_wait_for(history_item_selector, allowed_force_refreshes)

history_panel_wait_for_history_loaded()

history_panel_wait_for_hid_hidden(hid, multi_history_panel=False)

history_panel_wait_for_hid_state(hid, state, allowed_force_refreshes=0, multi_history_panel=False)

history_panel_wait_for_and_select(hids: list[int])

Waits for uploads to pass through queued, running, ok. Not all the states are not guaranteed depending on how fast the upload goes compared to the history polling updates, it might just skip to the end for a really fast upload

get_grid_entry_names(selector)

select_grid_operation(item_name, option_label)

select_history_card_operation(card_name, action_selector, is_in_extra=False)

edit_dataset_dbkey(dbkey_text)

get_history_card(card_name)

get_history_titles(n_expected_histories)

select_grid_cell(grid_name, item_name, column_index=3)

toggle_card_selection_in_list(list_selector, item_names)

check_advanced_search_filter(filter_name)

published_grid_search_for(search_term=None)

get_logged_in_user() → dict[str, Any] | None

get_api_key(force=False) → str | None

get_user_id() → str | None

get_user_email() → str

is_logged_in() → bool

submit_login(email, password=None, assert_valid=True, retries=0)

fill_login_and_submit(email, password=None)

register(email=None, password=None, username=None, confirm=None, assert_valid=True)

Register a virtual subclass of an ABC.

Returns the subclass, to allow usage as a class decorator.

wait_for_logged_in()

click_center()

hover_over(target)

perform_single_upload(test_path, **kwd) → HistoryEntry

perform_upload(test_path, **kwd)

perform_upload_of_pasted_content(paste_data, **kwd)

perform_upload_of_composite_dataset_pasted_data(ext, paste_content)

upload_list(test_paths, name='test', ext=None, genome=None, hide_source_items=True)

upload_pair(test_paths, name='test', ext=None, genome=None, hide_source_items=True)

upload_paired_list(test_paths, name='test', ext=None, genome=None, hide_source_items=True)

collection_builder_pair_rows(row_forward: int, row_reverse: int)

upload_tab_click(tab)

upload_start_click()

upload_set_footer_extension(ext, tab_id='regular')

upload_set_footer_genome(genome, tab_id='regular')

upload_set_collection_type(collection_type)

upload_start(tab_id='regular')

upload_build(tab='collection')

upload_queue_local_file(test_path, tab_id='regular')

upload_paste_data(pasted_content, tab_id='regular')

upload_uri(uri, wait=False)

upload_rule_start()

upload_rule_build()

upload_rule_dataset_dialog()

upload_rule_set_data_type(type_description)

upload_rule_set_dataset(row=1)

rule_builder_set_collection_name(name)

rule_builder_set_extension(extension)

rule_builder_filter_count(count=1)

rule_builder_sort(column_label, screenshot_name=None)

rule_builder_add_regex_groups(column_label, group_count, regex, screenshot_name)

rule_builder_add_regex_replacement(column_label, regex, replacement, screenshot_name=None)

rule_builder_add_value(value, screenshot_name=None)

rule_builder_remove_columns(column_labels, screenshot_name=None)

rule_builder_concatenate_columns(column_label_1, column_label_2, screenshot_name=None)

rule_builder_split_columns(column_labels_1, column_labels_2, screenshot_name=None)

rule_builder_swap_columns(column_label_1, column_label_2, screenshot_name)

rule_builder_rule_editor(rule_type)

rule_builder_set_mapping(mapping_type, column_label, screenshot_name=None)

rule_builder_set_source(json)

rule_builder_enter_source_text(json)

workflow_editor_add_input(item_name='data_input')

workflow_editor_connect(source, sink, screenshot_partial=None)

workflow_editor_source_sink_terminal_ids(source, sink)

workflow_editor_set_license(license: str) → None

workflow_editor_license_text() → str

workflow_editor_add_tool_step(tool_id: str)

workflow_editor_set_tool_vesrion(version: str, node: int | str | None = None) → None

workflow_editor_set_node_label(label: str, node: int | str | None = None)

workflow_editor_set_node_annotation(annotation: str, node: int | str | None = None)

workflow_editor_ensure_tool_form_open(node: int | str | None = None)

workflow_editor_click_option(option_label)

workflow_editor_click_options()

workflow_editor_options_menu_element()

workflow_editor_click_run()

workflow_editor_click_save()

workflow_editor_search_for_workflow(name: str)

workflow_editor_add_steps(name: str)

workflow_editor_add_subworkflow(name: str)

workflow_editor_enter_column_definitions(column_definitions: list[ColumnDefinition])

workflow_editor_enter_column_definition(column_definition: ColumnDefinition, index: int)

navigate_to_histories_page()

navigate_to_saved_visualizations()

navigate_to_histories_shared_with_me_page()

navigate_to_user_preferences()

navigate_to_invocations_grid()

navigate_to_pages()

navigate_to_published_workflows()

navigate_to_published_histories()

navigate_to_tools()

admin_open()

create_quota(name: str | None = None, description: str | None = None, amount: str | None = None, quota_source_label: str | None = None, user: str | None = None)

select_dataset_from_lib_import_modal(filenames)

create_new_library()

libraries_open()

libraries_open_with_name(name)

page_open_and_screenshot(page_name, screenshot_name)

libraries_index_table_elements()

libraries_index_create(name)

libraries_index_click_search()

libraries_index_sort_selector()

libraries_index_sort_click()

libraries_index_search_for(text)

libraries_folder_create(name)

libraries_click_dataset_import()

libraries_dataset_import(btn)

libraries_dataset_import_from_history_search_for(search_term=None)

libraries_dataset_import_from_history_select(to_select_items)

libraries_dataset_import_from_history_click_ok(wait=True)

libraries_table_elements()

populate_library_folder_from_import_dir(library_name, filenames)

navigate_to_new_library()

wait_for_overlays_cleared()

Wait for modals and Toast notifications to disappear.

clear_tooltips(selector_to_move='#center')

pages_index_table_elements()

workflow_index_open()

workflow_index_open_with_name(name: str)

workflow_shared_with_me_open()

workflow_card_elements()

workflow_card_element(workflow_index=0)

workflow_index_column_text(column_index, workflow_index=0)

workflow_index_click_search()

workflow_index_get_current_filter()

workflow_index_search_for(search_term=None)

workflow_index_click_import()

workflow_rename(new_name, workflow_index=0)

workflow_delete_by_name(name)

workflow_bookmark_by_name(name)

workflow_index_name(workflow_index=0)

select_dropdown_item(option_title)

workflow_share_click()

workflow_index_view_external_link(workflow_index=0)

workflow_index_click_tag_display(workflow_index=0)

workflow_index_add_tag(tag: str, workflow_index: int = 0)

workflow_index_tags(workflow_index=0)

workflow_index_tag_elements(workflow_index=0)

workflow_index_click_tag(tag, workflow_index=0)

workflow_import_submit_url(url)

workflow_sharing_click_publish()

tagging_add(tags, auto_closes=True, parent_selector='')

workflow_run_with_name(name: str)

workflow_run_specify_inputs(inputs: dict[str, Any])

workflow_run_submit()

workflow_run_ensure_expanded()

workflow_create_new(annotation: str | None = None, clear_placeholder: bool = False, save_workflow: bool = True)

workflow_editor_set_annotation(annotation: str)

invocation_index_table_elements()

open_toolbox()

swap_to_tool_panel(panel_id: str) → None

swap_to_tool_panel_edam_operations() → None

tool_open(tool_id, outer=False)

datasource_tool_open(tool_id)

run_environment_test_tool(inttest_value='42', select_storage: str | None = None)

select_storage(storage_id: str) → None

select_history_storage(storage_id: str) → None

create_page_and_edit(name=None, slug=None, screenshot_name=None)

create_page(name=None, slug=None, screenshot_name=None)

tool_parameter_div(expanded_parameter_id)

tool_parameter_edit_rules()

tool_set_value(expanded_parameter_id, value, expected_type=None)

tool_form_generate_tour()

tool_form_execute()

click_activity_workflow()

click_button_new_workflow()

click_history_options()

click_history_option_export_to_file()

click_history_option_sharing()

click_history_option(option_label_or_component)

history_element(attribute_value, attribute_name='data-description', scope='.history-index')

content_item_by_attributes(multi_history_panel=False, **attrs)

history_click_create_new()

history_click_editor_save()

history_panel_click_copy_elements()

use_bootstrap_dropdown(option=None, menu=None)

uses bootstrap dropdown by data-description attributes

histories_click_advanced_search()

history_panel_add_tags(tags)

history_panel_rename(new_name)

history_panel_name_input()

history_panel_refresh_click()

history_panel_multi_operations_show()

history_panel_muli_operation_select_hid(hid)

history_panel_multi_operation_action_click(action)

open_history_multi_view()

history_multi_view_display_collection_contents(collection_hid, collection_type='list')

history_panel_item_edit(hid)

display_dataset(hid)

show_dataset_details(hid)

show_dataset_visualizations(hid)

show_dataset_visualization(hid: int, visualization_id: str, screenshot_name: str | None = None)

history_panel_item_view_dataset_details(hid)

history_panel_item_click_visualization_menu(hid)

history_panel_item_available_visualizations_elements(hid)

history_panel_item_get_tags(hid)

history_panel_item_available_visualizations(hid)

history_panel_item_click_visualization(hid, visualization_name)

history_panel_item_selector(hid, wait=False)

modal_body_selector()

history_panel_item_body_component(hid, wait=False)

hda_click_primary_action_button(hid: int, button_key: str)

hda_click_details(hid: int)

history_panel_click_item_title(hid, **kwds)

history_panel_ensure_showing_item_details(hid)

history_panel_item_showing_details(hid)

history_panel_build_list_auto()

history_panel_build_list_advanced()

history_panel_build_list_of_pairs()

history_panel_build_list_of_paired_or_unpaireds()

history_panel_build_list_of_lists()

history_panel_build_list_advanced_and_select_builder(builder: str)

history_panel_build_rule_builder_for_selection()

list_wizard_click_cell_and_send_keys(column_identifier: str, row_index: int, text: str)

collection_builder_set_name(name)

collection_builder_hide_originals()

collection_builder_create()

collection_builder_clear_filters()

collection_builder_click_paired_item(forward_or_reverse, item)

logout_if_needed()

logout()

run_tour(path, skip_steps=None, sleep_on_steps=None, tour_callback=None)

tour_wait_for_clickable_element(selector)

tour_wait_for_element_present(selector)

get_tooltip_text(element, sleep=0, click_away=True)

assert_selector_absent_or_hidden_after_transitions(selector)

Variant of assert_selector_absent_or_hidden that retries during transitions.

In the parent method - the element is found and then it is checked to see if it is visible. It may disappear from the page in the middle there and cause a StaleElement error. For checks where we care about the final resting state after transitions - this method can be used to retry during those transitions.

assert_absent_or_hidden_after_transitions(selector)

Variant of assert_absent_or_hidden that retries during transitions.

See details above for more information about this.

assert_tooltip_text(element, expected: str | Label | Text, sleep: int = 0, click_away: bool = True)

assert_tooltip_text_contains(element, expected: str | Label | Text, sleep: int = 0, click_away: bool = True)

assert_error_message(contains=None)

assert_warning_message(contains=None)

assert_success_message(contains=None)

assert_message(element, contains=None)

assert_no_error_message()

run_tour_step(step, step_index: int, tour_callback)

wait_for_and_click_selector(selector)

wait_for_and_click(selector_template)

Wait for element to be clickable and click it.

wait_for_and_double_click(selector_template)

Wait for element to be clickable and double-click it.

set_history_annotation(annotation, clear_text=False)

ensure_history_annotation_area_displayed()

select_set_value(container_selector_or_elem, value, multiple=False, clear_value=False)

snapshot(description)

Test case subclass overrides this to provide detailed logging.

open_history_editor(scope='.history-index')

close_history_editor(scope='.history-index')

share_ensure_by_user_available(sharing_component)

share_unshare_with_user(sharing_component, email)

share_with_user(sharing_component, user_id=None, user_email=None, screenshot_before_submit=None, screenshot_after_submit=None, assert_valid=False)

create_file_source_template(instance: FileSourceInstance) → str

create_object_store_template(instance: ObjectStoreInstance) → str

tutorial_mode_activate()

mouse_drag(from_element: WebElementProtocol, to_element: WebElementProtocol | None = None, from_offset=(0, 0), to_offset=(0, 0), via_offsets: list[tuple[int, int]] | None = None)

exception galaxy.selenium.navigates_galaxy.NotLoggedInException(timeout_exception, user_info, dom_message)

Bases: TimeoutException

__init__(timeout_exception, user_info, dom_message)

exception galaxy.selenium.navigates_galaxy.ClientBuildException(timeout_exception: TimeoutException)

Bases: TimeoutException

__init__(timeout_exception: TimeoutException)

galaxy.selenium.sizzle module

galaxy.selenium.smart_components module

class galaxy.selenium.smart_components.SmartComponent(component, has_driver: HasDriverProtocol)

Bases: object

Wrap a Component with driver aware methods.

Adapts Galaxy’s component locators more tightly to Selenium - including a Selenium runtime. Allows smarter selectors that know how to wait for themselves, test themselves, click themselves, etc…. More “magic”, but much cleaner usage.

__init__(component, has_driver: HasDriverProtocol)

class galaxy.selenium.smart_components.SmartTarget(target, has_driver: HasDriverProtocol)

Bases: object

Wrap a Target with driver aware methods.

__init__(target, has_driver: HasDriverProtocol)

all()

wait_for_element_count_of_at_least(n: int, **kwds)

wait_for_and_click(**kwds)

wait_for_and_double_click(**kwds)

wait_for_visible(**kwds)

wait_for_clickable(**kwds)

wait_for_text(**kwds)

wait_for_value(**kwds)

property is_displayed

property is_absent

wait_for_absent_or_hidden(**kwds)

wait_for_absent(**kwds)

wait_for_present(**kwds)

assert_absent(**kwds)

assert_absent_or_hidden(**kwds)

assert_absent_or_hidden_after_transitions(**kwds)

assert_disabled(**kwds)

data_value(attribute: str)

assert_data_value(attribute: str, expected_value: str)

has_class(class_name)

wait_for_and_send_keys(*text)

wait_for_and_send_enter()

wait_for_and_clear_and_send_keys(*text)

wait_for_and_clear_aggressive_and_send_keys(*text)

axe_eval() → AxeResults

assert_no_axe_violations_with_impact_of_at_least(impact: typing_extensions.Literal[minor, moderate, serious, critical], excludes: list[str] | None = None) → None