From a1e79b13e1471f73a9ef192c0b7762ec6322fa93 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Sun, 3 Sep 2017 19:04:07 +0200 Subject: [PATCH 01/18] add the first test --- test/selenium_tests/test_saved_histories.py | 72 +++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 test/selenium_tests/test_saved_histories.py diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py new file mode 100644 index 00000000000..80fcd502339 --- /dev/null +++ b/test/selenium_tests/test_saved_histories.py @@ -0,0 +1,72 @@ +import time + +from .framework import SeleniumTestCase, selenium_test + +# Test case data +HISTORY_NAME = 'History 2' + + +class SavedHistoriesTestCase(SeleniumTestCase): + + def setUp(self): + super(SavedHistoriesTestCase, self).setUp() + self.ensure_users_and_histories() + + @selenium_test + def test_saved_histories_list(self): + self.navigate_to_saved_histories_page() + self.assert_grid_histories_are(['History 2', 'Unnamed history']) + + 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) + + 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'): + cell = row.find_elements_by_tag_name('td')[1] # Name + names.append(cell.text) + return names + + 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) + selector = 'a[href="/histories/list"]' + histories_link = self.wait_for_selector_clickable(selector) + histories_link.click() + + def ensure_users_and_histories(self): + if getattr(SavedHistoriesTestCase, 'user_email', None): + return + SavedHistoriesTestCase.user_email = self._get_random_email() + self.register(self.user_email) + self.create_history(HISTORY_NAME) + + def create_history(self, name): + 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) + + 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) From 29622bba69422389f7bae7dfa2b6f7c9a6542acb Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Tue, 5 Sep 2017 23:12:38 +0200 Subject: [PATCH 02/18] add history rename test --- test/selenium_tests/test_saved_histories.py | 54 +++++++++++++++++++-- 1 file changed, 49 insertions(+), 5 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 80fcd502339..df6a9f65762 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -3,19 +3,41 @@ import time from .framework import SeleniumTestCase, selenium_test # Test case data -HISTORY_NAME = 'History 2' +HISTORY1_NAME = 'First' +HISTORY2_NAME = 'Second' class SavedHistoriesTestCase(SeleniumTestCase): def setUp(self): super(SavedHistoriesTestCase, self).setUp() - self.ensure_users_and_histories() + self.ensure_user_and_histories() @selenium_test def test_saved_histories_list(self): self.navigate_to_saved_histories_page() - self.assert_grid_histories_are(['History 2', 'Unnamed history']) + # self.assert_grid_histories_are([HISTORY2_NAME, 'Unnamed history']) + histories = self.get_histories() + assert HISTORY2_NAME in histories + + @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(HISTORY1_NAME) + self.send_enter(history_name_input) + + message = self.wait_for_selector_visible('.infomessagelarge') + expected_message = 'History: Unnamed history renamed to: %s' % HISTORY1_NAME + self.assertEqual(expected_message, message.text) + + self.navigate_to_saved_histories_page() + self.assert_grid_histories_are([HISTORY1_NAME, HISTORY2_NAME], False) def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() @@ -39,16 +61,19 @@ class SavedHistoriesTestCase(SeleniumTestCase): label = self.navigation_data['labels']['masthead']['menus']['user'] self.click_label(label) + selector = 'a[href="/histories/list"]' histories_link = self.wait_for_selector_clickable(selector) histories_link.click() - def ensure_users_and_histories(self): + def ensure_user_and_histories(self): if getattr(SavedHistoriesTestCase, 'user_email', None): + self.submit_login(self.user_email) return + SavedHistoriesTestCase.user_email = self._get_random_email() self.register(self.user_email) - self.create_history(HISTORY_NAME) + self.create_history(HISTORY2_NAME) def create_history(self, name): self.click_history_option('Create New') @@ -66,6 +91,25 @@ class SavedHistoriesTestCase(SeleniumTestCase): menu_option = self.driver.find_element_by_link_text(option_label) menu_option.click() + def click_popup_option(self, history_name, option_label): + # Find history with a given name + history = 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 = name_cell + break + self.assertIsNotNone(history) + + menu_button = name_cell.find_element_by_css_selector('.popup') + x_offset = menu_button.size['width'] - 5 + y_offset = menu_button.size['height'] - 5 + self.action_chains().move_to_element_with_offset(menu_button, x_offset, y_offset).click().perform() + + popup_option = self.driver.find_element_by_link_text(option_label) + popup_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'] From c57b993b456d226da3896633a576013b977eab1b Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Wed, 6 Sep 2017 16:06:38 +0200 Subject: [PATCH 03/18] quick fix --- test/selenium_tests/test_saved_histories.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index df6a9f65762..0a0ec9a7792 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -68,6 +68,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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 From 7824fdab6b0001570001b60bc76e3a77da402877 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Wed, 6 Sep 2017 17:25:20 +0200 Subject: [PATCH 04/18] add delete/undelete test --- test/selenium_tests/test_saved_histories.py | 55 +++++++++++++++++---- 1 file changed, 46 insertions(+), 9 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 0a0ec9a7792..a3baecba4d6 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -17,8 +17,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): def test_saved_histories_list(self): self.navigate_to_saved_histories_page() # self.assert_grid_histories_are([HISTORY2_NAME, 'Unnamed history']) - histories = self.get_histories() - assert HISTORY2_NAME in histories + self.assert_history_in_grid(HISTORY2_NAME) @selenium_test def test_rename_history(self): @@ -39,6 +38,26 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.navigate_to_saved_histories_page() self.assert_grid_histories_are([HISTORY1_NAME, HISTORY2_NAME], False) + @selenium_test + def test_delete_and_undelete_history(self): + self.navigate_to_saved_histories_page() + + # Delete the history + self.click_popup_option(HISTORY2_NAME, 'Delete') + + self.assert_history_in_grid(HISTORY2_NAME, False) + + self.show_advanced_search() + self.select_filter('deleted', 'True') + time.sleep(1) + + # Restore the history + self.click_popup_option(HISTORY2_NAME, 'Undelete') + self.wait_for_selector_visible('.donemessage') + self.select_filter('deleted', 'False') + + self.assert_history_in_grid(HISTORY2_NAME) + def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() if not sort_matters: @@ -46,13 +65,20 @@ class SavedHistoriesTestCase(SeleniumTestCase): actual_histories = set(actual_histories) self.assertEqual(expected_histories, actual_histories) + def assert_history_in_grid(self, history, present=True): + histories = self.get_histories() + if present: + assert history in histories + else: + assert history not in histories + 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'): - cell = row.find_elements_by_tag_name('td')[1] # Name - names.append(cell.text) + name_cell = row.find_elements_by_tag_name('td')[1] + names.append(name_cell.text) return names def navigate_to_saved_histories_page(self): @@ -62,9 +88,8 @@ class SavedHistoriesTestCase(SeleniumTestCase): label = self.navigation_data['labels']['masthead']['menus']['user'] self.click_label(label) - selector = 'a[href="/histories/list"]' - histories_link = self.wait_for_selector_clickable(selector) - histories_link.click() + saved_histories_link = self.wait_for_selector_clickable('a[href="/histories/list"]') + saved_histories_link.click() def ensure_user_and_histories(self): if getattr(SavedHistoriesTestCase, 'user_email', None): @@ -84,6 +109,17 @@ class SavedHistoriesTestCase(SeleniumTestCase): editable_text_input_element.send_keys(name) self.send_enter(editable_text_input_element) + def show_advanced_search(self): + search_selector = '#standard-search .advanced-search-toggle' + search_link = self.wait_for_selector_clickable(search_selector) + search_link.click() + + def select_filter(self, filter_key, filter_value): + filter_selector = 'a[filter_key="%s"][filter_val="%s"]' % \ + (filter_key, filter_value) + filter_link = self.wait_for_selector_clickable(filter_selector) + filter_link.click() + def click_history_option(self, option_label): self.home() self.click_history_options() # Open history menu @@ -93,7 +129,6 @@ class SavedHistoriesTestCase(SeleniumTestCase): menu_option.click() def click_popup_option(self, history_name, option_label): - # Find history with a given name history = None grid = self.wait_for_selector('#grid-table-body') for row in grid.find_elements_by_tag_name('tr'): @@ -101,7 +136,9 @@ class SavedHistoriesTestCase(SeleniumTestCase): if name_cell.text == history_name: history = name_cell break - self.assertIsNotNone(history) + + if history is None: + raise AssertionError('Failed to find history with name [%s]' % history_name) menu_button = name_cell.find_element_by_css_selector('.popup') x_offset = menu_button.size['width'] - 5 From bca6dfefb6946aa5497819a5d80c74f3d2a7210f Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 13:41:02 +0200 Subject: [PATCH 05/18] add history switch test --- test/selenium_tests/test_saved_histories.py | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index a3baecba4d6..2baffb0cbe3 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -5,6 +5,7 @@ from .framework import SeleniumTestCase, selenium_test # Test case data HISTORY1_NAME = 'First' HISTORY2_NAME = 'Second' +HISTORY3_NAME = 'Third' class SavedHistoriesTestCase(SeleniumTestCase): @@ -16,7 +17,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): @selenium_test def test_saved_histories_list(self): self.navigate_to_saved_histories_page() - # self.assert_grid_histories_are([HISTORY2_NAME, 'Unnamed history']) + # self.assert_grid_histories_are([HISTORY3_NAME, HISTORY2_NAME, 'Unnamed history']) self.assert_history_in_grid(HISTORY2_NAME) @selenium_test @@ -36,7 +37,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.assertEqual(expected_message, message.text) self.navigate_to_saved_histories_page() - self.assert_grid_histories_are([HISTORY1_NAME, HISTORY2_NAME], False) + self.assert_grid_histories_are([HISTORY1_NAME, HISTORY2_NAME, HISTORY3_NAME], False) @selenium_test def test_delete_and_undelete_history(self): @@ -58,6 +59,18 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.assert_history_in_grid(HISTORY2_NAME) + @selenium_test + def test_history_switch(self): + self.navigate_to_saved_histories_page() + + self.click_popup_option(HISTORY2_NAME, 'Switch') + time.sleep(1) + + selector = '#current-history-panel .name.editable-text' + history_name = self.wait_for_selector(selector) + + self.assertEqual(history_name.text, HISTORY2_NAME) + def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() if not sort_matters: @@ -100,6 +113,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): SavedHistoriesTestCase.user_email = self._get_random_email() self.register(self.user_email) self.create_history(HISTORY2_NAME) + self.create_history(HISTORY3_NAME) def create_history(self, name): self.click_history_option('Create New') From da42c16ae7014723012dccdc17c0d39a32ab5713 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 13:47:40 +0200 Subject: [PATCH 06/18] add history view test --- test/selenium_tests/test_saved_histories.py | 31 +++++++++++++-------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 2baffb0cbe3..8c8f8317b70 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -20,6 +20,25 @@ class SavedHistoriesTestCase(SeleniumTestCase): # self.assert_grid_histories_are([HISTORY3_NAME, HISTORY2_NAME, 'Unnamed history']) self.assert_history_in_grid(HISTORY2_NAME) + @selenium_test + def test_history_switch(self): + self.navigate_to_saved_histories_page() + + self.click_popup_option(HISTORY2_NAME, 'Switch') + time.sleep(1) + + selector = '#current-history-panel .name.editable-text' + history_name = self.wait_for_selector(selector) + + self.assertEqual(history_name.text, HISTORY2_NAME) + + @selenium_test + def test_history_view(self): + self.navigate_to_saved_histories_page() + self.click_popup_option(HISTORY2_NAME, 'View') + history_name = self.wait_for_selector('.name.editable-text') + self.assertEqual(history_name.text, HISTORY2_NAME) + @selenium_test def test_rename_history(self): self.navigate_to_saved_histories_page() @@ -59,18 +78,6 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.assert_history_in_grid(HISTORY2_NAME) - @selenium_test - def test_history_switch(self): - self.navigate_to_saved_histories_page() - - self.click_popup_option(HISTORY2_NAME, 'Switch') - time.sleep(1) - - selector = '#current-history-panel .name.editable-text' - history_name = self.wait_for_selector(selector) - - self.assertEqual(history_name.text, HISTORY2_NAME) - def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() if not sort_matters: From ff769da9287ddc7f6ad598799a9773d6a2d77c30 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 14:30:24 +0200 Subject: [PATCH 07/18] add history publish test --- test/selenium_tests/test_saved_histories.py | 36 +++++++++++++++------ 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 8c8f8317b70..321fa4aba56 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -26,9 +26,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.click_popup_option(HISTORY2_NAME, 'Switch') time.sleep(1) - - selector = '#current-history-panel .name.editable-text' - history_name = self.wait_for_selector(selector) + history_name = self.history_panel_name_element() self.assertEqual(history_name.text, HISTORY2_NAME) @@ -39,6 +37,24 @@ class SavedHistoriesTestCase(SeleniumTestCase): history_name = self.wait_for_selector('.name.editable-text') self.assertEqual(history_name.text, HISTORY2_NAME) + @selenium_test + def test_history_publish(self): + self.navigate_to_saved_histories_page() + + # Publish the history + self.click_popup_option(HISTORY2_NAME, 'Share or Publish') + selector = 'input[name="make_accessible_and_publish"]' + publish_button = self.wait_for_selector_clickable(selector) + publish_button.click() + + self.navigate_to_saved_histories_page() + + self.show_advanced_search() + self.select_filter('sharing', 'published') + time.sleep(1) + + self.assert_grid_histories_are([HISTORY2_NAME]) + @selenium_test def test_rename_history(self): self.navigate_to_saved_histories_page() @@ -150,21 +166,21 @@ class SavedHistoriesTestCase(SeleniumTestCase): menu_option.click() def click_popup_option(self, history_name, option_label): - history = None + 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 = name_cell + history_menu_button = name_cell break - if history is None: + if history_menu_button is None: raise AssertionError('Failed to find history with name [%s]' % history_name) - menu_button = name_cell.find_element_by_css_selector('.popup') - x_offset = menu_button.size['width'] - 5 - y_offset = menu_button.size['height'] - 5 - self.action_chains().move_to_element_with_offset(menu_button, x_offset, y_offset).click().perform() + 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() From 29ed1bec66ddfb5b1a8559a0a6a8f34aeb928c14 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 15:21:47 +0200 Subject: [PATCH 08/18] add multiple histories delete/undelete test --- test/selenium_tests/test_saved_histories.py | 54 ++++++++++++++++++--- 1 file changed, 46 insertions(+), 8 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 321fa4aba56..916eb184ee1 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -17,8 +17,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): @selenium_test def test_saved_histories_list(self): self.navigate_to_saved_histories_page() - # self.assert_grid_histories_are([HISTORY3_NAME, HISTORY2_NAME, 'Unnamed history']) - self.assert_history_in_grid(HISTORY2_NAME) + self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME]) @selenium_test def test_history_switch(self): @@ -81,7 +80,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): # Delete the history self.click_popup_option(HISTORY2_NAME, 'Delete') - self.assert_history_in_grid(HISTORY2_NAME, False) + self.assert_histories_in_grid([HISTORY2_NAME], False) self.show_advanced_search() self.select_filter('deleted', 'True') @@ -89,10 +88,39 @@ class SavedHistoriesTestCase(SeleniumTestCase): # Restore the history self.click_popup_option(HISTORY2_NAME, 'Undelete') + self.wait_for_selector_visible('.donemessage') self.select_filter('deleted', 'False') - self.assert_history_in_grid(HISTORY2_NAME) + self.assert_histories_in_grid([HISTORY2_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([HISTORY2_NAME, HISTORY3_NAME]) + delete_button = self.wait_for_selector_clickable(delete_button_selector) + delete_button.click() + + self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME], False) + + self.show_advanced_search() + self.select_filter('deleted', 'True') + time.sleep(1) + + # Restore multiple histories + self.check_histories([HISTORY2_NAME, HISTORY3_NAME]) + undelete_button = self.wait_for_selector_clickable(undelete_button_selector) + undelete_button.click() + + self.wait_for_selector_visible('.donemessage') + self.select_filter('deleted', 'False') + + self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME]) def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() @@ -101,12 +129,13 @@ class SavedHistoriesTestCase(SeleniumTestCase): actual_histories = set(actual_histories) self.assertEqual(expected_histories, actual_histories) - def assert_history_in_grid(self, history, present=True): - histories = self.get_histories() + def assert_histories_in_grid(self, expected_histories, present=True): + actual_histories = self.get_histories() + intersection = list(set(actual_histories).intersection(expected_histories)) if present: - assert history in histories + self.assertEqual(intersection, expected_histories) else: - assert history not in histories + self.assertEqual(intersection, []) def get_histories(self): time.sleep(1.5) @@ -185,6 +214,15 @@ class SavedHistoriesTestCase(SeleniumTestCase): popup_option = self.driver.find_element_by_link_text(option_label) popup_option.click() + 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() + def click_to_rename_history(self): self.history_panel_name_element().click() edit_title_input_selector = self.test_data['historyPanel']['selectors']['history']['nameEditableTextInput'] From 5dedd397718166723cdc0bb054565b69e7435d23 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 15:35:49 +0200 Subject: [PATCH 09/18] add sort by name test --- test/selenium_tests/test_saved_histories.py | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 916eb184ee1..fbc746d5aee 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -122,12 +122,27 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME]) + @selenium_test + def test_sort_by_name(self): + self.navigate_to_saved_histories_page() + + sort_link = self.wait_for_selector_clickable('.sort-link[sort_key="name"]') + sort_link.click() + + actual_histories = self.get_histories() + if 'Unnamed history' in actual_histories: + expected_histories = [HISTORY2_NAME, HISTORY3_NAME, 'Unnamed history'] + else: + expected_histories = [HISTORY1_NAME, HISTORY2_NAME, HISTORY3_NAME] + + self.assertEqual(actual_histories, expected_histories) + 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) + expected_histories = set(expected_histories) + self.assertEqual(actual_histories, expected_histories) def assert_histories_in_grid(self, expected_histories, present=True): actual_histories = self.get_histories() From e6ebc9e022dd184109374f7f30dec3505b9a2c6e Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 15:51:50 +0200 Subject: [PATCH 10/18] add standard search test --- test/selenium_tests/test_saved_histories.py | 32 +++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index fbc746d5aee..048aef531e6 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -6,6 +6,7 @@ from .framework import SeleniumTestCase, selenium_test HISTORY1_NAME = 'First' HISTORY2_NAME = 'Second' HISTORY3_NAME = 'Third' +HISTORY4_NAME = 'Four' class SavedHistoriesTestCase(SeleniumTestCase): @@ -137,6 +138,24 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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(HISTORY2_NAME) + self.send_enter(search_input) + + self.assert_grid_histories_are([HISTORY2_NAME]) + + self.unset_filter('free-text-search', HISTORY2_NAME) + search_input = self.wait_for_selector(input_selector) + search_input.send_keys(HISTORY4_NAME) + self.send_enter(search_input) + + self.assert_grid_histories_are(['No Items']) + def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() if not sort_matters: @@ -157,10 +176,19 @@ class SavedHistoriesTestCase(SeleniumTestCase): names = [] 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] - names.append(name_cell.text) + td = row.find_elements_by_tag_name('td') + name = td[1].text if td[0].text == '' else td[0].text + # name_cell = row.find_elements_by_tag_name('td')[1] + names.append(name) return names + def unset_filter(self, filter_key, filter_value): + close_button_selector = 'a[filter_key="%s"][filter_val="%s"]' % \ + (filter_key, filter_value) + close_button = self.wait_for_selector_clickable(close_button_selector) + close_button.click() + time.sleep(.5) + def navigate_to_saved_histories_page(self): self.home() self.click_masthead_user() # Open masthead menu From 90f0dfc8bcf04309873e8cd8771840c2c7e9fa8d Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 16:07:56 +0200 Subject: [PATCH 11/18] add advanced search test --- test/selenium_tests/test_saved_histories.py | 57 +++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 048aef531e6..0d0a92d8ec9 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -7,6 +7,8 @@ HISTORY1_NAME = 'First' HISTORY2_NAME = 'Second' HISTORY3_NAME = 'Third' HISTORY4_NAME = 'Four' +HISTORY3_TAGS = ['tag3'] +HISTORY4_TAGS = ['tag4'] class SavedHistoriesTestCase(SeleniumTestCase): @@ -156,6 +158,33 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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, HISTORY2_NAME) + self.assert_grid_histories_are([HISTORY2_NAME]) + self.unset_filter('name', HISTORY2_NAME) + + self.set_filter(name_filter_selector, HISTORY4_NAME) + self.assert_grid_histories_are(['No Items']) + self.unset_filter('name', HISTORY4_NAME) + + # Search by tags + self.set_filter(tags_filter_selector, HISTORY3_TAGS[0]) + self.assert_grid_histories_are([HISTORY3_NAME]) + self.unset_filter('tags', HISTORY3_TAGS[0]) + + self.set_filter(tags_filter_selector, HISTORY4_TAGS[0]) + self.assert_grid_histories_are(['No Items']) + self.unset_filter('tags', HISTORY4_TAGS[0]) + def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() if not sort_matters: @@ -182,6 +211,11 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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) @@ -189,6 +223,23 @@ class SavedHistoriesTestCase(SeleniumTestCase): close_button.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 navigate_to_saved_histories_page(self): self.home() self.click_masthead_user() # Open masthead menu @@ -207,8 +258,10 @@ class SavedHistoriesTestCase(SeleniumTestCase): SavedHistoriesTestCase.user_email = self._get_random_email() self.register(self.user_email) + self.create_history(HISTORY2_NAME) self.create_history(HISTORY3_NAME) + self.set_tags(HISTORY3_TAGS) def create_history(self, name): self.click_history_option('Create New') @@ -270,3 +323,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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() From 316eb330bb21b4bd54c340b389217de9f91f0097 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Thu, 7 Sep 2017 16:30:04 +0200 Subject: [PATCH 12/18] add permanently delete history test --- test/selenium_tests/test_saved_histories.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 0d0a92d8ec9..3962fd1b947 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -97,6 +97,24 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.assert_histories_in_grid([HISTORY2_NAME]) + @selenium_test + def test_permanently_delete_history(self): + self.create_history(HISTORY4_NAME) + + self.navigate_to_saved_histories_page() + self.assert_histories_in_grid([HISTORY4_NAME]) + + self.click_popup_option(HISTORY4_NAME, 'Delete Permanently') + alert = self.driver.switch_to.alert + alert.accept() + + self.assert_histories_in_grid([HISTORY4_NAME], False) + + self.show_advanced_search() + self.select_filter('deleted', 'True') + + self.assert_histories_in_grid([HISTORY4_NAME]) + @selenium_test def test_delete_and_undelete_multiple_histories(self): self.navigate_to_saved_histories_page() From ca59aaeda017d605f05f6a22b8c6dc09a6f3be3c Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Sun, 10 Sep 2017 17:16:26 +0200 Subject: [PATCH 13/18] add the tags test --- test/selenium_tests/test_saved_histories.py | 38 ++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 3962fd1b947..0f224300983 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -7,6 +7,7 @@ HISTORY1_NAME = 'First' HISTORY2_NAME = 'Second' HISTORY3_NAME = 'Third' HISTORY4_NAME = 'Four' +HISTORY2_TAGS = ['tag3'] HISTORY3_TAGS = ['tag3'] HISTORY4_TAGS = ['tag4'] @@ -203,6 +204,28 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.assert_grid_histories_are(['No Items']) self.unset_filter('tags', 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(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(HISTORY2_NAME) + tag_area = tags_cell.find_element_by_tag_name('textarea') + tag_area.send_keys(HISTORY2_TAGS[0]) + self.send_enter(tag_area) + + # Search by tag + tags_cell = self.get_history_tags_cell(HISTORY2_NAME) + tag = tags_cell.find_element_by_css_selector('span.tag-name') + tag.click() + + self.assert_grid_histories_are([HISTORY3_NAME, HISTORY2_NAME], False) + def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() if not sort_matters: @@ -225,7 +248,6 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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 - # name_cell = row.find_elements_by_tag_name('td')[1] names.append(name) return names @@ -328,6 +350,20 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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'): From 8533c717879f7505b8f293c1ba945f3db63addcb Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Sun, 10 Sep 2017 18:36:32 +0200 Subject: [PATCH 14/18] use the wait_for_and_click_selector function --- test/selenium_tests/test_saved_histories.py | 30 +++++++-------------- 1 file changed, 9 insertions(+), 21 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 0f224300983..ccb30806700 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -46,9 +46,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): # Publish the history self.click_popup_option(HISTORY2_NAME, 'Share or Publish') - selector = 'input[name="make_accessible_and_publish"]' - publish_button = self.wait_for_selector_clickable(selector) - publish_button.click() + self.wait_for_and_click_selector('input[name="make_accessible_and_publish"]') self.navigate_to_saved_histories_page() @@ -125,8 +123,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): # Delete multiple histories self.check_histories([HISTORY2_NAME, HISTORY3_NAME]) - delete_button = self.wait_for_selector_clickable(delete_button_selector) - delete_button.click() + self.wait_for_and_click_selector(delete_button_selector) self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME], False) @@ -136,8 +133,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): # Restore multiple histories self.check_histories([HISTORY2_NAME, HISTORY3_NAME]) - undelete_button = self.wait_for_selector_clickable(undelete_button_selector) - undelete_button.click() + self.wait_for_and_click_selector(undelete_button_selector) self.wait_for_selector_visible('.donemessage') self.select_filter('deleted', 'False') @@ -148,8 +144,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): def test_sort_by_name(self): self.navigate_to_saved_histories_page() - sort_link = self.wait_for_selector_clickable('.sort-link[sort_key="name"]') - sort_link.click() + self.wait_for_and_click_selector('.sort-link[sort_key="name"]') actual_histories = self.get_histories() if 'Unnamed history' in actual_histories: @@ -259,8 +254,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): def unset_filter(self, filter_key, filter_value): close_button_selector = 'a[filter_key="%s"][filter_val="%s"]' % \ (filter_key, filter_value) - close_button = self.wait_for_selector_clickable(close_button_selector) - close_button.click() + self.wait_for_and_click_selector(close_button_selector) time.sleep(.5) def set_tags(self, tags): @@ -268,8 +262,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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() + self.wait_for_and_click_selector(tag_icon_selector) tag_area_selector += ' .tags-input input' tag_area = self.wait_for_selector_clickable(tag_area_selector) @@ -283,12 +276,9 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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) - - saved_histories_link = self.wait_for_selector_clickable('a[href="/histories/list"]') - saved_histories_link.click() + self.wait_for_and_click_selector('a[href="/histories/list"]') def ensure_user_and_histories(self): if getattr(SavedHistoriesTestCase, 'user_email', None): @@ -313,14 +303,12 @@ class SavedHistoriesTestCase(SeleniumTestCase): def show_advanced_search(self): search_selector = '#standard-search .advanced-search-toggle' - search_link = self.wait_for_selector_clickable(search_selector) - search_link.click() + 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) - filter_link = self.wait_for_selector_clickable(filter_selector) - filter_link.click() + self.wait_for_and_click_selector(filter_selector) def click_history_option(self, option_label): self.home() From e2730ca7143f71758d6cd18f129c566447423302 Mon Sep 17 00:00:00 2001 From: John Chilton Date: Sun, 10 Sep 2017 17:43:22 -0400 Subject: [PATCH 15/18] Reduce duplication, increase robustness in Selenium history tests. - set_tags() appeared in both published and saved history tests, refactored into navigates_galaxy with function name history_panel_add_tags - is_displayed() appeared in both published and saved history tests, refactored into has_driver as selector_is_displayed - Introduced history_panel_rename to reduce duplication across history panel tests and newer published and saved history tests. - Removed custom history click option helper in saved and published history tests and just used the variant in navigates_galaxy. - use wait_for_and_click a couple more places... --- test/galaxy_selenium/has_driver.py | 4 ++ test/galaxy_selenium/navigates_galaxy.py | 27 +++++++++ test/selenium_tests/test_history_panel.py | 24 +++----- .../test_published_histories_grid.py | 58 +++---------------- test/selenium_tests/test_saved_histories.py | 42 +------------- 5 files changed, 50 insertions(+), 105 deletions(-) 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 8c180547935..c30dd90a2be 100644 --- a/test/galaxy_selenium/navigates_galaxy.py +++ b/test/galaxy_selenium/navigates_galaxy.py @@ -553,6 +553,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.history_panel_name_element().click() + 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..2efeb0151fb 100644 --- a/test/selenium_tests/test_published_histories_grid.py +++ b/test/selenium_tests/test_published_histories_grid.py @@ -153,34 +153,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' @@ -199,27 +180,24 @@ class HistoryGridTestCase(SeleniumTestCase): HistoryGridTestCase.user2_email = self._get_random_email("test2") self.register(self.user1_email) self.create_history(HISTORY1_NAME) - self.set_tags(HISTORY1_TAGS) + self.history_panel_add_tags(HISTORY1_TAGS) self.publish_current_history() self.create_history(HISTORY3_NAME) - self.set_tags(HISTORY3_TAGS) + self.history_panel_add_tags(HISTORY3_TAGS) self.set_annotation(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.history_panel_add_tags(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 +214,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 index ccb30806700..530f4305ca9 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -257,22 +257,6 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.wait_for_and_click_selector(close_button_selector) 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): - self.wait_for_and_click_selector(tag_icon_selector) - - 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 navigate_to_saved_histories_page(self): self.home() self.click_masthead_user() # Open masthead menu @@ -291,15 +275,12 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.create_history(HISTORY2_NAME) self.create_history(HISTORY3_NAME) - self.set_tags(HISTORY3_TAGS) + self.history_panel_add_tags(HISTORY3_TAGS) 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 show_advanced_search(self): search_selector = '#standard-search .advanced-search-toggle' @@ -310,14 +291,6 @@ class SavedHistoriesTestCase(SeleniumTestCase): (filter_key, filter_value) self.wait_for_and_click_selector(filter_selector) - 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_popup_option(self, history_name, option_label): history_menu_button = None grid = self.wait_for_selector('#grid-table-body') @@ -360,12 +333,3 @@ class SavedHistoriesTestCase(SeleniumTestCase): if history_name in histories: checkbox = td[0].find_element_by_tag_name('input') checkbox.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() From dcbe30515f02c3a9f7332f2f3a043132c6cf1fe5 Mon Sep 17 00:00:00 2001 From: John Chilton Date: Sun, 10 Sep 2017 19:44:16 -0400 Subject: [PATCH 16/18] More robust rename for histories. I think the wait_for_and_click_selector method will prevent errors like this one https://jenkins.galaxyproject.org/job/selenium/249/testReport/selenium_tests.test_published_histories_grid/HistoryGridTestCase/test_history_grid_histories/. --- test/galaxy_selenium/navigates_galaxy.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/test/galaxy_selenium/navigates_galaxy.py b/test/galaxy_selenium/navigates_galaxy.py index c30dd90a2be..c256ec9d4de 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] @@ -574,7 +577,7 @@ class NavigatesGalaxy(HasDriver): self.send_enter(editable_text_input_element) def history_panel_click_to_rename(self): - self.history_panel_name_element().click() + 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): From dcc18134e79bcae7fb055162ba9f8d5f74e66b65 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Mon, 11 Sep 2017 15:30:09 +0200 Subject: [PATCH 17/18] generate random history names --- test/selenium_tests/test_saved_histories.py | 131 ++++++++++---------- 1 file changed, 66 insertions(+), 65 deletions(-) diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 530f4305ca9..77ee3e17fe2 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -2,15 +2,6 @@ import time from .framework import SeleniumTestCase, selenium_test -# Test case data -HISTORY1_NAME = 'First' -HISTORY2_NAME = 'Second' -HISTORY3_NAME = 'Third' -HISTORY4_NAME = 'Four' -HISTORY2_TAGS = ['tag3'] -HISTORY3_TAGS = ['tag3'] -HISTORY4_TAGS = ['tag4'] - class SavedHistoriesTestCase(SeleniumTestCase): @@ -21,31 +12,29 @@ class SavedHistoriesTestCase(SeleniumTestCase): @selenium_test def test_saved_histories_list(self): self.navigate_to_saved_histories_page() - self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME]) + 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(HISTORY2_NAME, 'Switch') + self.click_popup_option(self.history2_name, 'Switch') time.sleep(1) history_name = self.history_panel_name_element() - - self.assertEqual(history_name.text, HISTORY2_NAME) + 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(HISTORY2_NAME, 'View') + self.click_popup_option(self.history2_name, 'View') history_name = self.wait_for_selector('.name.editable-text') - self.assertEqual(history_name.text, HISTORY2_NAME) + 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(HISTORY2_NAME, 'Share or Publish') + 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() @@ -54,7 +43,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): self.select_filter('sharing', 'published') time.sleep(1) - self.assert_grid_histories_are([HISTORY2_NAME]) + self.assert_histories_in_grid([self.history2_name]) @selenium_test def test_rename_history(self): @@ -65,54 +54,55 @@ class SavedHistoriesTestCase(SeleniumTestCase): # Rename the history history_name_input = self.wait_for_selector('input[name="name"]') history_name_input.clear() - history_name_input.send_keys(HISTORY1_NAME) + 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' % HISTORY1_NAME + 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_grid_histories_are([HISTORY1_NAME, HISTORY2_NAME, HISTORY3_NAME], False) + + 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(HISTORY2_NAME, 'Delete') + self.click_popup_option(self.history2_name, 'Delete') - self.assert_histories_in_grid([HISTORY2_NAME], False) + 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(HISTORY2_NAME, 'Undelete') + self.click_popup_option(self.history2_name, 'Undelete') self.wait_for_selector_visible('.donemessage') self.select_filter('deleted', 'False') - self.assert_histories_in_grid([HISTORY2_NAME]) + self.assert_histories_in_grid([self.history2_name]) @selenium_test def test_permanently_delete_history(self): - self.create_history(HISTORY4_NAME) + self.create_history(self.history4_name) self.navigate_to_saved_histories_page() - self.assert_histories_in_grid([HISTORY4_NAME]) + self.assert_histories_in_grid([self.history4_name]) - self.click_popup_option(HISTORY4_NAME, 'Delete Permanently') + self.click_popup_option(self.history4_name, 'Delete Permanently') alert = self.driver.switch_to.alert alert.accept() - self.assert_histories_in_grid([HISTORY4_NAME], False) + self.assert_histories_in_grid([self.history4_name], False) self.show_advanced_search() self.select_filter('deleted', 'True') - self.assert_histories_in_grid([HISTORY4_NAME]) + self.assert_histories_in_grid([self.history4_name]) @selenium_test def test_delete_and_undelete_multiple_histories(self): @@ -122,35 +112,38 @@ class SavedHistoriesTestCase(SeleniumTestCase): undelete_button_selector = 'input[type="button"][value="Undelete"]' # Delete multiple histories - self.check_histories([HISTORY2_NAME, HISTORY3_NAME]) + self.check_histories([self.history2_name, self.history3_name]) self.wait_for_and_click_selector(delete_button_selector) - self.assert_histories_in_grid([HISTORY2_NAME, HISTORY3_NAME], False) + 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([HISTORY2_NAME, HISTORY3_NAME]) + 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([HISTORY2_NAME, HISTORY3_NAME]) + 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() - if 'Unnamed history' in actual_histories: - expected_histories = [HISTORY2_NAME, HISTORY3_NAME, 'Unnamed history'] - else: - expected_histories = [HISTORY1_NAME, HISTORY2_NAME, HISTORY3_NAME] + + 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) @@ -160,14 +153,14 @@ class SavedHistoriesTestCase(SeleniumTestCase): input_selector = '#input-free-text-search-filter' search_input = self.wait_for_selector(input_selector) - search_input.send_keys(HISTORY2_NAME) + search_input.send_keys(self.history2_name) self.send_enter(search_input) - self.assert_grid_histories_are([HISTORY2_NAME]) + self.assert_grid_histories_are([self.history2_name]) - self.unset_filter('free-text-search', HISTORY2_NAME) + self.unset_filter('free-text-search', self.history2_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']) @@ -182,44 +175,44 @@ class SavedHistoriesTestCase(SeleniumTestCase): tags_filter_selector = '#input-tags-filter' # Search by name - self.set_filter(name_filter_selector, HISTORY2_NAME) - self.assert_grid_histories_are([HISTORY2_NAME]) - self.unset_filter('name', HISTORY2_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, HISTORY4_NAME) + self.set_filter(name_filter_selector, self.history4_name) self.assert_grid_histories_are(['No Items']) - self.unset_filter('name', HISTORY4_NAME) + self.unset_filter('name', self.history4_name) # Search by tags - self.set_filter(tags_filter_selector, HISTORY3_TAGS[0]) - self.assert_grid_histories_are([HISTORY3_NAME]) - self.unset_filter('tags', HISTORY3_TAGS[0]) + 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, HISTORY4_TAGS[0]) + self.set_filter(tags_filter_selector, self.history4_tags[0]) self.assert_grid_histories_are(['No Items']) - self.unset_filter('tags', HISTORY4_TAGS[0]) + 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(HISTORY2_NAME) + 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(HISTORY2_NAME) + tags_cell = self.get_history_tags_cell(self.history2_name) tag_area = tags_cell.find_element_by_tag_name('textarea') - tag_area.send_keys(HISTORY2_TAGS[0]) + tag_area.send_keys(self.history2_tags[0]) self.send_enter(tag_area) # Search by tag - tags_cell = self.get_history_tags_cell(HISTORY2_NAME) + 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([HISTORY3_NAME, HISTORY2_NAME], False) + self.assert_grid_histories_are([self.history2_name], False) def assert_grid_histories_are(self, expected_histories, sort_matters=True): actual_histories = self.get_histories() @@ -230,11 +223,11 @@ class SavedHistoriesTestCase(SeleniumTestCase): def assert_histories_in_grid(self, expected_histories, present=True): actual_histories = self.get_histories() - intersection = list(set(actual_histories).intersection(expected_histories)) + intersection = set(actual_histories).intersection(expected_histories) if present: - self.assertEqual(intersection, expected_histories) + self.assertEqual(intersection, set(expected_histories)) else: - self.assertEqual(intersection, []) + self.assertEqual(intersection, set()) def get_histories(self): time.sleep(1.5) @@ -271,11 +264,19 @@ class SavedHistoriesTestCase(SeleniumTestCase): return SavedHistoriesTestCase.user_email = self._get_random_email() - self.register(self.user_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.create_history(HISTORY2_NAME) - self.create_history(HISTORY3_NAME) - self.history_panel_add_tags(HISTORY3_TAGS) + 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() From 51464551647635e5a1859b3d42ddf281a4f89ad8 Mon Sep 17 00:00:00 2001 From: Evgeny Anatskiy Date: Mon, 11 Sep 2017 16:45:34 +0200 Subject: [PATCH 18/18] generate random history names for the published history grid tests --- .../test_published_histories_grid.py | 129 ++++++++++-------- test/selenium_tests/test_saved_histories.py | 8 +- 2 files changed, 82 insertions(+), 55 deletions(-) diff --git a/test/selenium_tests/test_published_histories_grid.py b/test/selenium_tests/test_published_histories_grid.py index 2efeb0151fb..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) @@ -173,25 +179,40 @@ 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.history_panel_add_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.history_panel_add_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.history_panel_add_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): diff --git a/test/selenium_tests/test_saved_histories.py b/test/selenium_tests/test_saved_histories.py index 77ee3e17fe2..c1b7feec624 100644 --- a/test/selenium_tests/test_saved_histories.py +++ b/test/selenium_tests/test_saved_histories.py @@ -1,6 +1,10 @@ import time -from .framework import SeleniumTestCase, selenium_test +from .framework import ( + retry_assertion_during_transitions, + selenium_test, + SeleniumTestCase, +) class SavedHistoriesTestCase(SeleniumTestCase): @@ -214,6 +218,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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: @@ -221,6 +226,7 @@ class SavedHistoriesTestCase(SeleniumTestCase): 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)