diff --git a/test/galaxy_selenium/has_driver.py b/test/galaxy_selenium/has_driver.py index c9826296fa7..021de2eac0a 100644 --- a/test/galaxy_selenium/has_driver.py +++ b/test/galaxy_selenium/has_driver.py @@ -28,6 +28,10 @@ class HasDriver: for element in elements: assert not element.is_displayed() + def selector_is_displayed(self, selector): + element = self.driver.find_element_by_css_selector(selector) + return element.is_displayed() + def assert_selector_absent(self, selector): assert len(self.driver.find_elements_by_css_selector(selector)) == 0 diff --git a/test/galaxy_selenium/navigates_galaxy.py b/test/galaxy_selenium/navigates_galaxy.py index 565c33cda22..56e8c72a99f 100644 --- a/test/galaxy_selenium/navigates_galaxy.py +++ b/test/galaxy_selenium/navigates_galaxy.py @@ -99,9 +99,12 @@ class NavigatesGalaxy(HasDriver): 'galaxysession': self.get_galaxy_session() } - def history_panel_name_element(self): + def history_panel_name_selector(self): name_selector = self.test_data["historyPanel"]["selectors"]["history"]["name"] - return self.wait_for_selector(name_selector) + return name_selector + + def history_panel_name_element(self): + return self.wait_for_selector(self.history_panel_name_selector()) def current_history(self): history = self.api_get("histories")[0] @@ -563,6 +566,33 @@ class NavigatesGalaxy(HasDriver): menu_selector = self.test_data["historyOptions"]["selectors"]["menu"] return menu_selector + def history_panel_add_tags(self, tags): + tag_icon_selector = self.test_data['historyPanel']['selectors']['history']['tagIcon'] + tag_area_selector = self.test_data['historyPanel']['selectors']['history']['tagArea'] + + if not self.selector_is_displayed(tag_area_selector): + self.wait_for_and_click_selector(tag_icon_selector) + + tag_area_selector += ' .tags-input input' + tag_area = self.wait_for_and_click_selector(tag_area_selector) + + for tag in tags: + tag_area.send_keys(tag) + self.send_enter(tag_area) + time.sleep(.5) + + def history_panel_rename(self, new_name): + editable_text_input_element = self.history_panel_click_to_rename() + editable_text_input_element.send_keys(new_name) + self.send_enter(editable_text_input_element) + + def history_panel_click_to_rename(self): + self.wait_for_and_click_selector(self.history_panel_name_selector()) + return self.wait_for_selector(self.history_panel_edit_title_input_selector()) + + def history_panel_edit_title_input_selector(self): + return self.test_data["historyPanel"]["selectors"]["history"]["nameEditableTextInput"] + def history_panel_refresh_click(self): self.wait_for_and_click_selector("#history-refresh-button") diff --git a/test/selenium_tests/test_history_panel.py b/test/selenium_tests/test_history_panel.py index 6fa33c6912d..12c514b7306 100644 --- a/test/selenium_tests/test_history_panel.py +++ b/test/selenium_tests/test_history_panel.py @@ -22,7 +22,7 @@ class HistoryPanelTestCase(SeleniumTestCase): @selenium_test def test_history_panel_rename(self): self.register() - editable_text_input_element = self.click_to_rename_history() + editable_text_input_element = self.history_panel_click_to_rename() editable_text_input_element.send_keys("New History Name") self.send_enter(editable_text_input_element) @@ -32,20 +32,20 @@ class HistoryPanelTestCase(SeleniumTestCase): @selenium_test def test_history_rename_cancel_with_click(self): self.register() - editable_text_input_element = self.click_to_rename_history() + editable_text_input_element = self.history_panel_click_to_rename() editable_text_input_element.send_keys("New History Name") self.click_center() - self.assert_selector_absent(self.edit_title_input_selector()) + self.assert_selector_absent(self.history_panel_edit_title_input_selector()) name_element = self.history_panel_name_element() assert "New History Name" not in name_element.text @selenium_test def test_history_rename_cancel_with_escape(self): self.register() - editable_text_input_element = self.click_to_rename_history() + editable_text_input_element = self.history_panel_click_to_rename() editable_text_input_element.send_keys("New History Name") self.send_escape(editable_text_input_element) - self.assert_selector_absent(self.edit_title_input_selector()) + self.assert_selector_absent(self.history_panel_edit_title_input_selector()) name_element = self.history_panel_name_element() assert "New History Name" not in name_element.text @@ -96,23 +96,13 @@ class HistoryPanelTestCase(SeleniumTestCase): self.click_hda_title(hda_id, wait=True) self.wait_for_selector_visible(hda_body_selector) - self.click_history_refresh() + self.history_panel_refresh_click() title_selector = self.hda_div_selector(hda_id) self.wait_for_selector_visible(hda_body_selector) self.click_hda_title(hda_id, wait=True) - self.click_history_refresh() + self.history_panel_refresh_click() self.wait_for_selector(title_selector) self.assert_selector_absent_or_hidden(hda_body_selector) - - def click_history_refresh(self): - self.wait_for_and_click_selector('a#history-refresh-button') - - def click_to_rename_history(self): - self.history_panel_name_element().click() - return self.wait_for_selector(self.edit_title_input_selector()) - - def edit_title_input_selector(self): - return self.test_data["historyPanel"]["selectors"]["history"]["nameEditableTextInput"] diff --git a/test/selenium_tests/test_published_histories_grid.py b/test/selenium_tests/test_published_histories_grid.py index 188a68b6eee..56f7411696a 100644 --- a/test/selenium_tests/test_published_histories_grid.py +++ b/test/selenium_tests/test_published_histories_grid.py @@ -6,16 +6,6 @@ from .framework import ( SeleniumTestCase, ) -# Test case data -HISTORY1_NAME = 'First' -HISTORY2_NAME = 'Second' -HISTORY3_NAME = 'Third' -HISTORY4_NAME = 'Four' -HISTORY1_TAGS = ['tag1', 'tag2'] -HISTORY2_TAGS = ['tag3'] -HISTORY3_TAGS = ['tag1'] -HISTORY3_ANNOT = 'some description' - class HistoryGridTestCase(SeleniumTestCase): @@ -26,7 +16,7 @@ class HistoryGridTestCase(SeleniumTestCase): @selenium_test def test_history_grid_histories(self): self.navigate_to_published_histories_page() - self.assert_grid_histories_are([HISTORY2_NAME, HISTORY3_NAME, HISTORY1_NAME]) + self.assert_histories_in_grid(self.all_histories) @selenium_test def test_history_grid_search_standard(self): @@ -34,23 +24,23 @@ class HistoryGridTestCase(SeleniumTestCase): input_selector = '#input-free-text-search-filter' search_input = self.wait_for_selector(input_selector) - search_input.send_keys(HISTORY1_NAME) + search_input.send_keys(self.history1_name) self.send_enter(search_input) - self.assert_grid_histories_are([HISTORY1_NAME]) - self.unset_filter('free-text-search', HISTORY1_NAME) + self.assert_grid_histories_are([self.history1_name]) + + self.unset_filter('free-text-search', self.history1_name) search_input = self.wait_for_selector(input_selector) - search_input.send_keys(HISTORY4_NAME) + search_input.send_keys(self.history4_name) self.send_enter(search_input) + self.assert_grid_histories_are(['No Items']) @selenium_test def test_history_grid_search_advanced(self): self.navigate_to_published_histories_page() - advanced_search_selector = '#standard-search .advanced-search-toggle' - advanced_search_link = self.wait_for_selector(advanced_search_selector) - advanced_search_link.click() + self.wait_for_and_click_selector('#standard-search .advanced-search-toggle') name_filter_selector = '#input-name-filter' annot_filter_selector = '#input-annotation-filter' @@ -58,32 +48,35 @@ class HistoryGridTestCase(SeleniumTestCase): tags_filter_selector = '#input-tags-filter' # Search by name - self.set_filter(name_filter_selector, HISTORY1_NAME) - self.assert_grid_histories_are([HISTORY1_NAME]) - self.unset_filter('name', HISTORY1_NAME) + self.set_filter(name_filter_selector, self.history1_name) + self.assert_grid_histories_are([self.history1_name]) + self.unset_filter('name', self.history1_name) + + self.set_filter(name_filter_selector, self.history4_name) + self.assert_grid_histories_are(['No Items']) + self.unset_filter('name', self.history4_name) # Search by annotation - annotation = HISTORY3_ANNOT.split(' ')[0] - self.set_filter(annot_filter_selector, annotation) - self.assert_grid_histories_are([HISTORY3_NAME]) - self.unset_filter('annotation', annotation) + self.set_filter(annot_filter_selector, self.history3_annot) + self.assert_grid_histories_are([self.history3_name]) + self.unset_filter('annotation', self.history3_annot) # Search by owner owner = self.user2_email.split('@')[0] self.set_filter(owner_filter_selector, owner) - self.assert_grid_histories_are([HISTORY2_NAME]) + self.assert_grid_histories_are([self.history2_name]) self.unset_filter('username', owner) # Search by tags - self.set_filter(tags_filter_selector, HISTORY1_TAGS[0]) - self.assert_grid_histories_are([HISTORY3_NAME, HISTORY1_NAME]) - self.unset_filter('tags', HISTORY1_TAGS[0]) + self.set_filter(tags_filter_selector, self.history1_tags[0]) + self.assert_grid_histories_are([self.history1_name, self.history3_name], False) + self.unset_filter('tags', self.history1_tags[0]) @selenium_test def test_history_grid_sort_by_name(self): self.navigate_to_published_histories_page() self.wait_for_and_click_selector('th#name-header > a') - self.assert_grid_histories_are([HISTORY1_NAME, HISTORY2_NAME, HISTORY3_NAME]) + self.assert_grid_histories_are(sorted(self.all_histories)) @selenium_test def test_history_grid_sort_by_owner(self): @@ -98,35 +91,35 @@ class HistoryGridTestCase(SeleniumTestCase): tags = None grid = self.wait_for_selector('#grid-table-body') for row in grid.find_elements_by_tag_name('tr'): - cell = row.find_elements_by_tag_name('td')[0] # Name - if cell.text == HISTORY1_NAME: - tags = row.find_elements_by_tag_name('td')[4] # Tags + td = row.find_elements_by_tag_name('td') + name = td[0].text + if name == self.history1_name: + tags = td[4] break - assert tags is not None + + if tags is None: + raise AssertionError('Failed to find history with name [%s]' % self.history1_name) tag_button_selector = '.tag-area > .tag-button:first-child > .tag-name' tag_button = tags.find_element_by_css_selector(tag_button_selector) - assert tag_button.text == HISTORY1_TAGS[0] - + self.assertEqual(tag_button.text, self.history1_tags[0]) tag_button.click() - self.assert_grid_histories_are([HISTORY3_NAME, HISTORY1_NAME]) + self.assert_grid_histories_are([self.history1_name, self.history3_name], False) def get_histories(self, sleep=False): time.sleep(1.5) - names = [] grid = self.wait_for_selector('#grid-table-body') for row in grid.find_elements_by_tag_name('tr'): cell = row.find_elements_by_tag_name('td')[0] # Name names.append(cell.text) - return names @retry_assertion_during_transitions def assert_grid_histories_sorted_by_owner(self): histories = self.get_histories() - index_1, index_2, index_3 = [histories.index(n) for n in [HISTORY1_NAME, HISTORY2_NAME, HISTORY3_NAME]] + index_1, index_2, index_3 = [histories.index(n) for n in self.all_histories] # 1 and 3 are owned by a owner whose username lexicographically # precedes 2. So verify 1 and 3 come before 2. assert index_1 < index_2 @@ -135,11 +128,24 @@ class HistoryGridTestCase(SeleniumTestCase): @retry_assertion_during_transitions def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() - if not sort_matters: - expected_histories = set(expected_histories) - actual_histories = set(actual_histories) - self.assertEqual(expected_histories, actual_histories) + # Filter out histories created by other tests + all_histories = self.all_histories + ['No Items'] + actual_histories = [x for x in actual_histories if x in all_histories] + + if not sort_matters: + actual_histories = set(actual_histories) + expected_histories = set(expected_histories) + self.assertEqual(actual_histories, expected_histories) + + @retry_assertion_during_transitions + def assert_histories_in_grid(self, expected_histories, present=True): + actual_histories = self.get_histories() + intersection = set(actual_histories).intersection(expected_histories) + if present: + self.assertEqual(intersection, set(expected_histories)) + else: + self.assertEqual(intersection, set()) def set_filter(self, selector, value): filter_input = self.wait_for_selector_clickable(selector) @@ -153,34 +159,15 @@ class HistoryGridTestCase(SeleniumTestCase): close_link.click() time.sleep(.5) - def set_tags(self, tags): - tag_icon_selector = self.test_data['historyPanel']['selectors']['history']['tagIcon'] - tag_area_selector = self.test_data['historyPanel']['selectors']['history']['tagArea'] - - if not self.is_displayed(tag_area_selector): - tag_icon = self.wait_for_selector_clickable(tag_icon_selector) - tag_icon.click() - - tag_area_selector += ' .tags-input input' - tag_area = self.wait_for_selector_clickable(tag_area_selector) - tag_area.click() - - for tag in tags: - tag_area.send_keys(tag) - self.send_enter(tag_area) - time.sleep(.5) - def set_annotation(self, annotation): anno_icon_selector = self.test_data['historyPanel']['selectors']['history']['annoIcon'] anno_area_selector = self.test_data['historyPanel']['selectors']['history']['annoArea'] - if not self.is_displayed(anno_area_selector): - annon_icon = self.wait_for_selector_clickable(anno_icon_selector) - annon_icon.click() + if not self.selector_is_displayed(anno_area_selector): + self.wait_for_and_click_selector(anno_icon_selector) anno_area_selector += ' .annotation' - annon_area = self.wait_for_selector_clickable(anno_area_selector) - annon_area.click() + self.wait_for_and_click_selector(anno_area_selector) area_editable_selector = anno_area_selector + ' textarea' done_button_selector = anno_area_selector + ' button' @@ -192,34 +179,46 @@ class HistoryGridTestCase(SeleniumTestCase): anno_done_button.click() def ensure_users_and_histories(self): - if getattr(HistoryGridTestCase, "user1_email", None): + if getattr(HistoryGridTestCase, 'user1_email', None): + self.home() # ensure Galaxy is loaded return - HistoryGridTestCase.user1_email = self._get_random_email("test1") - HistoryGridTestCase.user2_email = self._get_random_email("test2") + tag1 = self._get_random_name(len=5) + tag2 = self._get_random_name(len=5) + tag3 = self._get_random_name(len=5) + + HistoryGridTestCase.user1_email = self._get_random_email('test1') + HistoryGridTestCase.user2_email = self._get_random_email('test2') + HistoryGridTestCase.history1_name = self._get_random_name() + HistoryGridTestCase.history2_name = self._get_random_name() + HistoryGridTestCase.history3_name = self._get_random_name() + HistoryGridTestCase.history4_name = self._get_random_name() + HistoryGridTestCase.history1_tags = [tag1, tag2] + HistoryGridTestCase.history2_tags = [tag3] + HistoryGridTestCase.history3_tags = [tag1] + HistoryGridTestCase.history3_annot = self._get_random_name() + HistoryGridTestCase.all_histories = [self.history1_name, self.history2_name, self.history3_name] + self.register(self.user1_email) - self.create_history(HISTORY1_NAME) - self.set_tags(HISTORY1_TAGS) + self.create_history(self.history1_name) + self.history_panel_add_tags(self.history1_tags) self.publish_current_history() - self.create_history(HISTORY3_NAME) - self.set_tags(HISTORY3_TAGS) - self.set_annotation(HISTORY3_ANNOT) + self.create_history(self.history3_name) + self.history_panel_add_tags(self.history3_tags) + self.set_annotation(self.history3_annot) self.publish_current_history() self.logout_if_needed() self.register(self.user2_email) - self.create_history(HISTORY2_NAME) - self.set_tags(HISTORY2_TAGS) + self.create_history(self.history2_name) + self.history_panel_add_tags(self.history2_tags) self.publish_current_history() def create_history(self, name): + self.home() self.click_history_option('Create New') - - # Rename the history - editable_text_input_element = self.click_to_rename_history() - editable_text_input_element.send_keys(name) - self.send_enter(editable_text_input_element) + self.history_panel_rename(name) def publish_current_history(self): self.click_history_option('Share or Publish') @@ -236,22 +235,4 @@ class HistoryGridTestCase(SeleniumTestCase): self.click_label( self.navigation_data['labels']['masthead']['menus']['libraries']) selector = 'a[href="/histories/list_published"]' - histories_link = self.wait_for_selector_clickable(selector) - histories_link.click() - - def click_history_option(self, option_label): - self.home() - self.click_history_options() # Open history menu - - # Click labelled option - menu_option = self.driver.find_element_by_link_text(option_label) - menu_option.click() - - def click_to_rename_history(self): - self.history_panel_name_element().click() - edit_title_input_selector = self.test_data['historyPanel']['selectors']['history']['nameEditableTextInput'] - return self.wait_for_selector(edit_title_input_selector) - - def is_displayed(self, selector): - element = self.driver.find_element_by_css_selector(selector) - return element.is_displayed() + self.wait_for_and_click_selector(selector) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py new file mode 100644 index 00000000000..c1b7feec624 --- /dev/null +++ b/test/selenium_tests/test_saved_histories.py @@ -0,0 +1,342 @@ +import time + +from .framework import ( + retry_assertion_during_transitions, + selenium_test, + SeleniumTestCase, +) + + +class SavedHistoriesTestCase(SeleniumTestCase): + + def setUp(self): + super(SavedHistoriesTestCase, self).setUp() + self.ensure_user_and_histories() + + @selenium_test + def test_saved_histories_list(self): + self.navigate_to_saved_histories_page() + self.assert_histories_in_grid([self.history2_name, self.history3_name]) + + @selenium_test + def test_history_switch(self): + self.navigate_to_saved_histories_page() + self.click_popup_option(self.history2_name, 'Switch') + time.sleep(1) + history_name = self.history_panel_name_element() + self.assertEqual(history_name.text, self.history2_name) + + @selenium_test + def test_history_view(self): + self.navigate_to_saved_histories_page() + self.click_popup_option(self.history2_name, 'View') + history_name = self.wait_for_selector('.name.editable-text') + self.assertEqual(history_name.text, self.history2_name) + + @selenium_test + def test_history_publish(self): + self.navigate_to_saved_histories_page() + + # Publish the history + self.click_popup_option(self.history2_name, 'Share or Publish') + self.wait_for_and_click_selector('input[name="make_accessible_and_publish"]') + + self.navigate_to_saved_histories_page() + + self.show_advanced_search() + self.select_filter('sharing', 'published') + time.sleep(1) + + self.assert_histories_in_grid([self.history2_name]) + + @selenium_test + def test_rename_history(self): + self.navigate_to_saved_histories_page() + + self.click_popup_option('Unnamed history', 'Rename') + + # Rename the history + history_name_input = self.wait_for_selector('input[name="name"]') + history_name_input.clear() + history_name_input.send_keys(self.history1_name) + self.send_enter(history_name_input) + + message = self.wait_for_selector_visible('.infomessagelarge') + expected_message = 'History: Unnamed history renamed to: %s' % self.history1_name + self.assertEqual(expected_message, message.text) + + self.navigate_to_saved_histories_page() + + self.assert_histories_in_grid([self.history1_name, self.history2_name, self.history3_name]) + + @selenium_test + def test_delete_and_undelete_history(self): + self.navigate_to_saved_histories_page() + + # Delete the history + self.click_popup_option(self.history2_name, 'Delete') + + self.assert_histories_in_grid([self.history2_name], False) + + self.show_advanced_search() + self.select_filter('deleted', 'True') + time.sleep(1) + + # Restore the history + self.click_popup_option(self.history2_name, 'Undelete') + + self.wait_for_selector_visible('.donemessage') + self.select_filter('deleted', 'False') + + self.assert_histories_in_grid([self.history2_name]) + + @selenium_test + def test_permanently_delete_history(self): + self.create_history(self.history4_name) + + self.navigate_to_saved_histories_page() + self.assert_histories_in_grid([self.history4_name]) + + self.click_popup_option(self.history4_name, 'Delete Permanently') + alert = self.driver.switch_to.alert + alert.accept() + + self.assert_histories_in_grid([self.history4_name], False) + + self.show_advanced_search() + self.select_filter('deleted', 'True') + + self.assert_histories_in_grid([self.history4_name]) + + @selenium_test + def test_delete_and_undelete_multiple_histories(self): + self.navigate_to_saved_histories_page() + + delete_button_selector = 'input[type="button"][value="Delete"]' + undelete_button_selector = 'input[type="button"][value="Undelete"]' + + # Delete multiple histories + self.check_histories([self.history2_name, self.history3_name]) + self.wait_for_and_click_selector(delete_button_selector) + + self.assert_histories_in_grid([self.history2_name, self.history3_name], False) + + self.show_advanced_search() + self.select_filter('deleted', 'True') + time.sleep(1) + + # Restore multiple histories + self.check_histories([self.history2_name, self.history3_name]) + self.wait_for_and_click_selector(undelete_button_selector) + + self.wait_for_selector_visible('.donemessage') + self.select_filter('deleted', 'False') + + self.assert_histories_in_grid([self.history2_name, self.history3_name]) + + @selenium_test + def test_sort_by_name(self): + self.navigate_to_saved_histories_page() + + self.wait_for_and_click_selector('.sort-link[sort_key="name"]') + actual_histories = self.get_histories() + + expected_histories = [self.history2_name, self.history3_name] + if self.history1_name in actual_histories: + expected_histories.append(self.history1_name) + expected_histories = sorted(expected_histories) + + # Filter out histories created by other tests + actual_histories = [x for x in actual_histories if x in self.all_histories] + + self.assertEqual(actual_histories, expected_histories) + + @selenium_test + def test_standard_search(self): + self.navigate_to_saved_histories_page() + + input_selector = '#input-free-text-search-filter' + search_input = self.wait_for_selector(input_selector) + search_input.send_keys(self.history2_name) + self.send_enter(search_input) + + self.assert_grid_histories_are([self.history2_name]) + + self.unset_filter('free-text-search', self.history2_name) + search_input = self.wait_for_selector(input_selector) + search_input.send_keys(self.history4_name) + self.send_enter(search_input) + + self.assert_grid_histories_are(['No Items']) + + @selenium_test + def test_advanced_search(self): + self.navigate_to_saved_histories_page() + + self.show_advanced_search() + + name_filter_selector = '#input-name-filter' + tags_filter_selector = '#input-tags-filter' + + # Search by name + self.set_filter(name_filter_selector, self.history2_name) + self.assert_grid_histories_are([self.history2_name]) + self.unset_filter('name', self.history2_name) + + self.set_filter(name_filter_selector, self.history4_name) + self.assert_grid_histories_are(['No Items']) + self.unset_filter('name', self.history4_name) + + # Search by tags + self.set_filter(tags_filter_selector, self.history3_tags[0]) + self.assert_grid_histories_are([self.history3_name]) + self.unset_filter('tags', self.history3_tags[0]) + + self.set_filter(tags_filter_selector, self.history4_tags[0]) + self.assert_grid_histories_are(['No Items']) + self.unset_filter('tags', self.history4_tags[0]) + + @selenium_test + def test_tags(self): + self.navigate_to_saved_histories_page() + + # Click the add tag button + tags_cell = self.get_history_tags_cell(self.history2_name) + add_tag_button = tags_cell.find_element_by_css_selector('.add-tag-button') + add_tag_button.click() + + # Insert a tag + tags_cell = self.get_history_tags_cell(self.history2_name) + tag_area = tags_cell.find_element_by_tag_name('textarea') + tag_area.send_keys(self.history2_tags[0]) + self.send_enter(tag_area) + + # Search by tag + tags_cell = self.get_history_tags_cell(self.history2_name) + tag = tags_cell.find_element_by_css_selector('span.tag-name') + tag.click() + + self.assert_grid_histories_are([self.history2_name], False) + + @retry_assertion_during_transitions + def assert_grid_histories_are(self, expected_histories, sort_matters=True): + actual_histories = self.get_histories() + if not sort_matters: + actual_histories = set(actual_histories) + expected_histories = set(expected_histories) + self.assertEqual(actual_histories, expected_histories) + + @retry_assertion_during_transitions + def assert_histories_in_grid(self, expected_histories, present=True): + actual_histories = self.get_histories() + intersection = set(actual_histories).intersection(expected_histories) + if present: + self.assertEqual(intersection, set(expected_histories)) + else: + self.assertEqual(intersection, set()) + + def get_histories(self): + time.sleep(1.5) + names = [] + grid = self.wait_for_selector('#grid-table-body') + for row in grid.find_elements_by_tag_name('tr'): + td = row.find_elements_by_tag_name('td') + name = td[1].text if td[0].text == '' else td[0].text + names.append(name) + return names + + def set_filter(self, selector, value): + filter_input = self.wait_for_selector_clickable(selector) + filter_input.send_keys(value) + self.send_enter(filter_input) + + def unset_filter(self, filter_key, filter_value): + close_button_selector = 'a[filter_key="%s"][filter_val="%s"]' % \ + (filter_key, filter_value) + self.wait_for_and_click_selector(close_button_selector) + time.sleep(.5) + + def navigate_to_saved_histories_page(self): + self.home() + self.click_masthead_user() # Open masthead menu + label = self.navigation_data['labels']['masthead']['menus']['user'] + self.click_label(label) + self.wait_for_and_click_selector('a[href="/histories/list"]') + + def ensure_user_and_histories(self): + if getattr(SavedHistoriesTestCase, 'user_email', None): + self.home() # ensure Galaxy is loaded + self.submit_login(self.user_email) + return + + SavedHistoriesTestCase.user_email = self._get_random_email() + SavedHistoriesTestCase.history1_name = self._get_random_name() + SavedHistoriesTestCase.history2_name = self._get_random_name() + SavedHistoriesTestCase.history3_name = self._get_random_name() + SavedHistoriesTestCase.history4_name = self._get_random_name() + SavedHistoriesTestCase.history2_tags = [self._get_random_name(len=5)] + SavedHistoriesTestCase.history3_tags = [self._get_random_name(len=5)] + SavedHistoriesTestCase.history4_tags = [self._get_random_name(len=5)] + SavedHistoriesTestCase.all_histories = [self.history1_name, self.history2_name, self.history3_name] + + self.register(self.user_email) + self.create_history(self.history2_name) + self.create_history(self.history3_name) + self.history_panel_add_tags(self.history3_tags) + + def create_history(self, name): + self.home() + self.click_history_option('Create New') + self.history_panel_rename(name) + + def show_advanced_search(self): + search_selector = '#standard-search .advanced-search-toggle' + self.wait_for_and_click_selector(search_selector) + + def select_filter(self, filter_key, filter_value): + filter_selector = 'a[filter_key="%s"][filter_val="%s"]' % \ + (filter_key, filter_value) + self.wait_for_and_click_selector(filter_selector) + + def click_popup_option(self, history_name, option_label): + history_menu_button = None + grid = self.wait_for_selector('#grid-table-body') + for row in grid.find_elements_by_tag_name('tr'): + name_cell = row.find_elements_by_tag_name('td')[1] + if name_cell.text == history_name: + history_menu_button = name_cell + break + + if history_menu_button is None: + raise AssertionError('Failed to find history with name [%s]' % history_name) + + popup_menu_button = history_menu_button.find_element_by_css_selector('.popup') + x_offset = popup_menu_button.size['width'] - 5 + y_offset = popup_menu_button.size['height'] - 5 + self.action_chains().move_to_element_with_offset(popup_menu_button, x_offset, y_offset).click().perform() + + popup_option = self.driver.find_element_by_link_text(option_label) + popup_option.click() + + def get_history_tags_cell(self, history_name): + tags_cell = None + grid = self.wait_for_selector('#grid-table-body') + for row in grid.find_elements_by_tag_name('tr'): + td = row.find_elements_by_tag_name('td') + if td[1].text == history_name: + tags_cell = td[3] + break + + if tags_cell is None: + raise AssertionError('Failed to find history with name [%s]' % history_name) + + return tags_cell + + def check_histories(self, histories): + grid = self.wait_for_selector('#grid-table-body') + for row in grid.find_elements_by_tag_name('tr'): + td = row.find_elements_by_tag_name('td') + history_name = td[1].text + if history_name in histories: + checkbox = td[0].find_element_by_tag_name('input') + checkbox.click()