opensource/galaxy
3
0
Fork 0
mirror of https://github.com/galaxyproject/galaxy.git synced 2026-09-24 16:30:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4587 from anatskiy/saved_histories_tests

Browse Source 
Add Selenium tests for the Saved Histories
This commit is contained in:
John Chilton
2017-09-11 11:20:57 -04:00
committed by GitHub
parent 1359965a99 5146455164
commit 31f2168c3d
5 changed files with 466 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/galaxy_selenium/has_driver.py
+4
View File
@@ -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
test/galaxy_selenium/navigates_galaxy.py
+32 -2
View File
@@ -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")
test/selenium_tests/test_history_panel.py
+7 -17
View File
@@ -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"]
test/selenium_tests/test_published_histories_grid.py
+81 -100
View File
@@ -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)
test/selenium_tests/test_saved_histories.py
+342
View File
@@ -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()