lambda _: _check_url(current_url),
message='waiting for url to change.'
'Current url: {:s}'.format(driver.current_url)
)
menu_tab = MAIN_MENU_TAB_TO_URL[tab]
css_path = '.primary-sidebar a#main-{:s}'.format(menu_tab)
Wait(driver, WAIT_BACKEND).until(
lambda _: _load_main_menu_tab_page(menu_tab),
message='waiting for {:s} main menu tab page to load'
''.format(tab)
)
@given(parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<main_menu_tab>.*)" tab in main menu sidebar'))
def g_click_on_the_given_main_menu_tab(selenium, browser_id_list,
main_menu_tab):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
_click_on_tab_in_main_menu_sidebar(driver, main_menu_tab)
@when(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<main_menu_tab>.*)" tab in main menu sidebar'))
@then(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<main_menu_tab>.*)" tab in main menu sidebar'))
def wt_click_on_the_given_main_menu_tab(selenium, browser_id_list,
main_menu_tab):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
item_name))
options = item.find_elements_by_css_selector('.settings-dropdown '
'.dropdown-menu-settings '
'li.clickable .item-label')
option_name = option_name.lower()
for option in options:
if option.text.lower() == option_name:
option.click()
break
else:
raise RuntimeError('no option named {:s} found'.format(option_name))
# TODO remove refresh after gui will become more responsive
@when(parsers.re(r'user of (?P<browser_id>.*?) sees that (?P<item_list>.*?) '
r'(has|have) disappeared from (?P<item_type>.*?) sidebar list'))
@then(parsers.re(r'user of (?P<browser_id>.*?) sees that (?P<item_list>.*?) '
r'(has|have) disappeared from (?P<item_type>.*?) sidebar list'))
@when(parsers.re(r'user of (?P<browser_id>.*?) does not see (?P<item_list>.*?) '
r'in (?P<item_type>.*?) sidebar list'))
@then(parsers.re(r'user of (?P<browser_id>.*?) does not see (?P<item_list>.*?) '
r'in (?P<item_type>.*?) sidebar list'))
def is_not_present_in_sidebar_list(selenium, browser_id, item_list, item_type):
driver = selenium[browser_id]
Wait(driver, MAX_REFRESH_COUNT * WAIT_BACKEND).until(
lambda d: refresh_and_call(d, _not_in_sidebar_list,
item_list, item_type),
message='searching for absence of {item} '
'on {list} list'.format(item=item_list,
list=item_type)
)
lambda _: _check_url(current_url),
message='waiting for url to change.'
'Current url: {:s}'.format(driver.current_url)
)
menu_tab = MAIN_MENU_TAB_TO_URL[tab]
css_path = '.primary-sidebar a#main-{:s}'.format(menu_tab)
Wait(driver, WAIT_BACKEND).until(
lambda _: _load_main_menu_tab_page(),
message='waiting for {:s} main menu tab page to load'
''.format(tab)
)
@given(parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<main_menu_tab>.*)" tab in main menu sidebar'))
def g_click_on_the_given_main_menu_tab(selenium, browser_id_list,
main_menu_tab):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
_click_on_tab_in_main_menu_sidebar(driver, main_menu_tab)
@when(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<main_menu_tab>.*)" tab in main menu sidebar'))
@then(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<main_menu_tab>.*)" tab in main menu sidebar'))
def wt_click_on_the_given_main_menu_tab(selenium, browser_id_list,
main_menu_tab):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
@when(parsers.parse('user of {browser_id} uses spaces select to change '
'data space to "{space_name}"'))
@then(parsers.parse('user of {browser_id} uses spaces select to change '
'data space to "{space_name}"'))
@repeat_failed(timeout=WAIT_BACKEND)
def change_space_view_in_data_tab_in_op(selenium, browser_id,
space_name, op_page):
driver = selenium[browser_id]
selector = op_page(driver).data.sidebar.space_selector
selector.expand()
selector.spaces[space_name].click()
@when(parsers.re(r'user of (?P<browser_id>.*?) clicks the button '
r'from top menu bar with tooltip '
r'"(?P<tooltip>Create directory|Create file|Share element|'
r'Edit metadata|Rename element|Change element permissions|'
r'Copy element|Cut element|Remove element|'
r'Show file distribution)"'))
@then(parsers.re(r'user of (?P<browser_id>.*?) clicks the button '
r'from top menu bar with tooltip '
r'"(?P<tooltip>Create directory|Create file|Share element|'
r'Edit metadata|Rename element|Change element permissions|'
r'Copy element|Cut element|Remove element|'
r'Show file distribution)"'))
@repeat_failed(timeout=WAIT_FRONTEND)
def click_tooltip_from_toolbar_in_data_tab_in_op(selenium, browser_id,
tooltip, op_page):
driver = selenium[browser_id]
btn = getattr(op_page(driver).data.toolbar, transform(tooltip))
btn.click()
@when('I try to login via facebook')
def facebook_attempt(browser):
browser.delete_all_cookies()
browser.get("http://*****:*****@when('I succeed at logging in via facebook')
def facebook_succeed(browser):
try:
elem = browser.find_element_by_id("email")
elem.send_keys("*****@*****.**")
elem = browser.find_element_by_id("pass")
elem.send_keys("phracking")
elem.send_keys(Keys.RETURN)
elem = browser.find_element_by_name("login")
elem.click()
except:
pass
@then(re(r'I should be redirected to (?P<destination>.*)'))
def redirected(browser, destination):
assert destination in browser.current_url
@then('the title should be backend.fail')
def page_viable(browser):
assert "backend.fail" in browser.title
with fake_logger("allure_pytest_bdd.plugin.AllureFileLogger", logger):
self.testdir.runpytest("-s", "-v", "--alluredir", self.testdir.tmpdir)
# print(a.stdout.lines)
# print(a.stderr.lines)
self.allure_report = AllureReport(self.testdir.tmpdir.strpath)
@pytest.fixture
def allured_testdir(testdir, request):
return AlluredTestdir(testdir, request)
@pytest.fixture
def context():
return dict()
@pytest.fixture
def allure_report(allured_testdir, context):
return allured_testdir.allure_report
@given(parsers.re("(?P<name>\\w+)(?P<extension>\\.\\w+) with content:(?:\n)(?P<content>[\\S|\\s]*)"))
def feature_definition(name, extension, content, testdir):
testdir.makefile(extension, **dict([(name, content)]))
@when("run pytest-bdd with allure")
def run(allured_testdir):
allured_testdir.run_with_allure()
__author__ = "Bartek Walkowicz"
__copyright__ = "Copyright (C) 2017 ACK CYFRONET AGH"
__license__ = "This software is released under the MIT license cited in " \
"LICENSE.txt"
def _click_on_btn_for_token(driver, oz_page, ordinal, btn):
token = oz_page(driver)['access tokens'].tokens[int(ordinal[:-2]) - 1]
action = getattr(token, btn)
action()
@given(
parsers.re(
r'user of (?P<browser_id>.*?) clicked on (?P<btn>copy|remove) '
r'icon for (?P<ordinal>1st|2nd|3rd|\d*?[4567890]th|\d*?11th|'
r'\d*?12th|\d*?13th|\d*?[^1]1st|\d*?[^1]2nd|\d*?[^1]3rd) '
r'item on tokens list in expanded "ACCESS TOKENS" Onezone panel'))
@repeat_failed(timeout=WAIT_BACKEND)
def g_click_on_btn_for_oz_access_token(selenium, browser_id, btn, ordinal,
oz_page):
driver = selenium[browser_id]
_click_on_btn_for_token(driver, oz_page, ordinal, btn)
@when(
parsers.re(
r'user of (?P<browser_id>.*?) clicks on (?P<btn>copy|remove) '
r'icon for (?P<ordinal>1st|2nd|3rd|\d*?[4567890]th|\d*?11th|'
r'\d*?12th|\d*?13th|\d*?[^1]1st|\d*?[^1]2nd|\d*?[^1]3rd) '
r'item on tokens list in expanded "ACCESS TOKENS" Onezone panel'))
@then(parsers.parse('user of {browser_id} presses backspace on keyboard'))
def press_enter_on_active_element(selenium, browser_id):
driver = selenium[browser_id]
driver.switch_to.active_element.send_keys(Keys.BACKSPACE)
@then(parsers.parse('user of {browser_id} should see {links_names} links'))
def link_with_text_present(selenium, browser_id, links_names):
driver = selenium[browser_id]
for name in parse_seq(links_names):
assert driver.find_element_by_link_text(name), \
'{} link not found'.format(name)
@given(
parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<link_name>.*)" link'))
def g_click_on_link_with_text(selenium, browser_id_list, link_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
driver.find_element_by_link_text(link_name).click()
@when(
parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<link_name>.*)" link'))
@then(
parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<link_name>.*)" link'))
def wt_click_on_link_with_text(selenium, browser_id_list, link_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
'of file browser'))
@then(
parsers.parse('user of {browser_id} scrolls to the bottom '
'of file browser'))
@repeat_failed(timeout=WAIT_FRONTEND)
def scroll_to_bottom_of_file_browser(browser_id, tmp_memory):
browser = tmp_memory[browser_id]['file_browser']
browser.scroll_to_bottom()
# @when(parsers.parse('user of {browser_id} sees that there is(are) {num:d} '
# 'item(s) in file browser'))
# @then(parsers.parse('user of {browser_id} sees that there is(are) {num:d} '
# 'item(s) in file browser'))
@when(
parsers.re('user of (?P<browser_id>.+?) sees that there '
'(is 1|are (?P<num>\d+)) items? in file browser'))
@then(
parsers.re('user of (?P<browser_id>.+?) sees that there '
'(is 1|are (?P<num>\d+)) items? in file browser'))
@repeat_failed(timeout=WAIT_BACKEND)
def assert_num_of_files_are_displayed_in_file_browser(browser_id, num,
tmp_memory):
browser = tmp_memory[browser_id]['file_browser']
err_msg = 'displayed number of files {} does not match expected {}'
files_num = browser.files_count
num = int(num) if num is not None else 1
assert files_num == num, err_msg.format(files_num, num)
@when(
parsers.parse('user of {browser_id} sees that item named "{item_name}" '
def when_browser_back_button(browser):
browser.back()
@when("I move forward one page")
def when_browser_forward_button(browser):
browser.forward()
@when("I reload the page")
def when_reload_the_page(browser):
browser.reload()
# too greedy: @when(parse('I press "{text}"'))
@when(parsers.re('^I press "(?P<text>[^"]+)"$'))
def when_press_button(browser: BaseWebDriver, text):
elm = find_by_text(browser, text).first
elm.click()
@when(parse('I press "{text}" in "{element}"'))
def when_press_button_form(browser: BaseWebDriver, text, element):
elm = find_child_by_text(browser, element, text).first
elm.click()
@then(parse('I should be on "{page}"'))
def should_be_on_page(browser, browser_base_url, page):
assert browser.url == absolute_url(browser_base_url, page)
'grains.get {grain}'.format(grain=grains[plane]),
'--out json',
]))
ip = json.loads(ip_output)['local']
try:
context['response'] = requests.get(
'{proto}://{ip}:{port}'.format(proto=protocols[protocol],
ip=ip,
port=port),
verify=False,
)
except Exception as exc:
context['exception'] = exc
@then(parsers.re(r"the server returns (?P<status_code>\d+) '(?P<reason>.+)'"),
converters=dict(status_code=int))
def server_returns(host, context, status_code, reason):
response = context.get('response')
assert response is not None
assert response.status_code == int(status_code)
assert response.reason == reason
@then("the server should not respond")
def server_does_not_respond(host, context):
assert 'exception' in context
assert isinstance(context['exception'],
requests.exceptions.ConnectionError)
import os.path
import pytest
from pytest_bdd import then, parsers
@pytest.fixture()
def test_context():
return {"last checked attachment": None}
@then(
parsers.re(
"this attachment with content:(?:\n)(?P<expected_content>[\\S|\\s]*)"))
def check_attachment_content(expected_content, test_context, testdir):
last_checked_attachment = test_context["last checked attachment"]
file_path = os.path.join(testdir.tmpdir.strpath,
last_checked_attachment["source"])
with open(file_path, "r") as file:
actual_content = file.read()
assert actual_content == expected_content
@then(parsers.parse("attachment {attachment_name} must be in {location_name}"))
def suitable_attachment(attachment_name, location_name, test_context,
allure_report):
test_case_report = allure_report.test_cases[0]
if location_name == "attachments":
@then(
parsers.parse('user of {browser_id} sees that provider popup for provider '
'named "{provider}" has appeared on world map'))
@repeat_failed(timeout=WAIT_FRONTEND)
def assert_provider_popup_has_appeared_on_map(selenium, browser_id, provider,
oz_page):
driver = selenium[browser_id]
err_msg = 'Popup displayed for provider named "{}" ' \
'instead of "{}"'
prov = oz_page(driver)['world map'].get_provider_with_displayed_popup()
assert provider == prov.name, err_msg.format(prov.name, provider)
@when(
parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<btn>Go to your files|copy hostname)" button in '
r'"(?P<provider>.+?)" provider\'s popup displayed on world map')
)
@then(
parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<btn>Go to your files|copy hostname)" button in '
r'"(?P<provider>.+?)" provider\'s popup displayed on world map')
)
@repeat_failed(timeout=WAIT_BACKEND)
def click_on_btn_in_provider_popup(selenium, browser_id, btn, provider,
oz_page):
driver = selenium[browser_id]
err_msg = 'Popup displayed for provider named "{}" ' \
'instead of "{}"'
prov = oz_page(driver)['world map'].get_provider_with_displayed_popup()
assert provider == prov.name, err_msg.format(prov.name, provider)
collapse_providers = driver.find_element_by_css_selector('#collapse-providers')
Wait(driver, WAIT_FRONTEND).until(
lambda s: collapse_providers.get_attribute('aria-expanded') == 'true',
message='waiting for list of providers to appear'
)
def the_provider_is_present(s):
providers = s.find_elements_by_css_selector('.provider-header')
named_providers = [e for e in providers if e.text == name]
if len(named_providers) > 0:
return named_providers[0]
else:
return None
Wait(driver, WAIT_FRONTEND).until(
the_provider_is_present,
message='waiting for provider {:s} to appear on the list'.format(name)
).click()
@given(parsers.re('users? of (?P<browser_id_list>.*) clicked on the (?P<providers>.*) '
'provider in Onezone providers sidebar panel'))
def g_click_on_provider_in_sidebar(selenium, browser_id_list, providers):
browser_ids = parse_seq(browser_id_list)
providers = parse_seq(providers)
for browser_id, provider in izip_longest(browser_ids, providers,
fillvalue=providers[-1]):
driver = selenium[browser_id]
_click_on_provider(driver, provider)
'named "{name}" in expanded "DATA SPACE MANAGEMENT" '
'Onezone panel by clicking on settings icon'))
@then(
parsers.parse('user of {browser_id} expands settings dropdown for space '
'named "{name}" in expanded "DATA SPACE MANAGEMENT" '
'Onezone panel by clicking on settings icon'))
@repeat_failed(timeout=WAIT_FRONTEND)
def expand_settings_dropdown_for_space_in_panel(selenium, browser_id, name,
oz_page):
driver = selenium[browser_id]
oz_page(driver)['data space management'].spaces[name].settings.expand()
@when(
parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<option>LEAVE|RENAME|ADD STORAGE|SET AS HOME)" item in '
r'settings dropdown for space named "(?P<name>.+?)" '
r'in expanded "DATA SPACE MANAGEMENT" Onezone panel'))
@then(
parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<option>LEAVE|RENAME|ADD STORAGE|SET AS HOME)" item in '
r'settings dropdown for space named "(?P<name>.+?)" '
r'in expanded "DATA SPACE MANAGEMENT" Onezone panel'))
@repeat_failed(timeout=WAIT_FRONTEND)
def click_on_settings_option_for_space_in_panel(selenium, browser_id, option,
name, oz_page):
driver = selenium[browser_id]
settings = oz_page(driver)['data space management'].spaces[name].settings
action = getattr(settings, option.lower().replace(' ', '_'))
action()
__author__ = "Jakub Kudzia"
__copyright__ = "Copyright (C) 2016 ACK CYFRONET AGH"
__license__ = "This software is released under the MIT license cited in " \
"LICENSE.txt"
from tests.utils.space_utils import unsupport_space
from tests.utils.acceptance_utils import list_parser
from tests.utils.space_utils import (create_space, support_space,
request_support, invite_to_space,
join_space, remove_user, delete_space,
assign_privileges)
from pytest_bdd import parsers, then, when
@when(parsers.re('(?P<user>\w+) creates spaces (?P<spaces>.*)'))
def spaces_creation(user, spaces, onedata_environment, context):
spaces = list_parser(spaces)
user = context.get_user(user)
for space in spaces:
space_id = create_space(user, space)
user.spaces.update({space: space_id})
user.created_spaces.update({space: space_id})
@when(parsers.re('(?P<user>\w+) gets token to support spaces (?P<spaces>.*)'))
def request_spaces_support(user, spaces, onedata_environment, context):
spaces = list_parser(spaces)
user = context.get_user(user)
for space in spaces:
token = request_support(user, space)
from tests.gui.utils.generic import repeat_failed, implicit_wait
from tests.utils.acceptance_utils import list_parser
__author__ = "Jakub Liput, Bartek Walkowicz"
__copyright__ = "Copyright (C) 2017 ACK CYFRONET AGH"
__license__ = "This software is released under the MIT license cited in " \
"LICENSE.txt"
@repeat_failed(timeout=WAIT_BACKEND)
def _expand_oz_panel(oz_page, driver, panel):
oz_page(driver)[panel].expand()
@given(parsers.re(r'users? of (?P<browser_id_list>.*) expanded the '
r'"(?P<panel_name>.*)" Onezone sidebar panel'))
def g_expand_oz_panel(selenium, browser_id_list, panel_name, oz_page):
for browser_id in list_parser(browser_id_list):
driver = selenium[browser_id]
_expand_oz_panel(oz_page, driver, panel_name)
@when(parsers.re(r'users? of (?P<browser_id_list>.*) expands? the '
r'"(?P<panel_name>.*)" Onezone sidebar panel'))
@then(parsers.re(r'users? of (?P<browser_id_list>.*) expands? the '
r'"(?P<panel_name>.*)" Onezone sidebar panel'))
def wt_expand_oz_panel(selenium, browser_id_list, panel_name, oz_page):
for browser_id in list_parser(browser_id_list):
driver = selenium[browser_id]
_expand_oz_panel(oz_page, driver, panel_name)
'new': cli.cmd_new,
'info': cli.cmd_info,
'stop': cli.cmd_stop,
'start': cli.cmd_start,
}
@given('I have a clean database')
def i_have_a_clean_slate():
database.init()
database.server.delete(database.db.name)
database.init()
view.sync_views(database.db)
@given(parsers.re('I have a stopped task "(?P<task_id>.+?)"'))
def i_have_a_stopped_task(doc_mgr, task_id):
task = doc_mgr.create_task(_id=task_id, is_active=True)
task.time_slices.append(document.TimeSlice(
start_time=datetime.datetime.utcnow() - datetime.timedelta(hours=1),
end_time=datetime.datetime.utcnow() - datetime.timedelta(minutes=30),
))
doc_mgr.update_task(task)
@given(parsers.re('I have a running task "(?P<task_id>.+?)"'))
def i_have_a_running_task(doc_mgr, task_id):
task = doc_mgr.create_task(_id=task_id, is_active=True)
task.time_slices.append(document.TimeSlice(
start_time=datetime.datetime.utcnow() - datetime.timedelta(hours=1),
))
parsers.parse('user of {browser_id} should see login button '
'for {provider_name}'))
def login_provider_buttons(selenium, browser_id, provider_name):
driver = selenium[browser_id]
assert driver.find_element_by_css_selector(
'.login-box a.login-icon-box.idp-{name}'.format(name=provider_name)
), 'login for provider {} not found'.format(provider_name)
def _click_login_provider_button(driver, provider_name):
driver.find_element_by_css_selector(
'.login-box a.login-icon-box.idp-{:s}'.format(provider_name)).click()
@given(
parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<provider_name>.*)" login button'))
def g_click_login_provider_button(selenium, browser_id_list, provider_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
_click_login_provider_button(driver, provider_name)
@when(
parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<provider_name>.*)" login button'))
def w_click_login_provider_button(selenium, browser_id_list, provider_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
_click_login_provider_button(driver, provider_name)
def _click_on_button_in_provider_popup(driver, name):
def go_to_files_button(s):
links = s.find_elements_by_css_selector('.provider-place-drop a, '
'.provider-place-drop button')
for e in links:
if e.text == name:
return e
Wait(driver, WAIT_FRONTEND).until(
go_to_files_button,
message='clicking on "{:s}" button in providers popup'.format(name)
).click()
@given(parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<btn_name>.+?)" button in provider popup'))
def g_click_on_go_to_files_provider(selenium, browser_id_list, btn_name):
for browser_id in list_parser(browser_id_list):
driver = selenium[browser_id]
_click_on_button_in_provider_popup(driver, btn_name)
@when(parsers.re('users? of (?P<browser_id_list>.*) clicks? on the '
'"(?P<btn_name>.+?)" button in provider popup'))
@then(parsers.re('users? of (?P<browser_id_list>.*) clicks? on the '
'"(?P<btn_name>.+?)" button in provider popup'))
def wt_click_on_go_to_files_provider(selenium, browser_id_list, btn_name):
for browser_id in list_parser(browser_id_list):
driver = selenium[browser_id]
_click_on_button_in_provider_popup(driver, btn_name)
@then(parsers.parse('user of {browser_id} should see login button '
'for {provider_name}'))
def login_provider_buttons(selenium, browser_id, provider_name):
driver = selenium[browser_id]
assert driver.find_element_by_css_selector(
'.login-box a.login-icon-box.{name}'.format(name=provider_name)
), 'login for provider {} not found'.format(provider_name)
def _click_login_provider_button(driver, provider_name):
driver.find_element_by_css_selector(
'.login-box a.login-icon-box.{:s}'.format(provider_name)
).click()
@given(parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<provider_name>.*)" login button'))
def g_click_login_provider_button(selenium, browser_id_list, provider_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
_click_login_provider_button(driver, provider_name)
@when(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<provider_name>.*)" login button'))
def w_click_login_provider_button(selenium, browser_id_list, provider_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
_click_login_provider_button(driver, provider_name)
@given(parsers.re('users? of (?P<browser_id_list>.*) logged '
try:
s.connect((ip, int(port)))
s.shutdown(socket.SHUT_RDWR)
return True
except:
return False
finally:
s.close()
@given('The webserver is Online')
def webserver():
"""Given: The webserver is Online."""
@when(parsers.re(r'I go to port "(?P<port>\d+)" on the webserver'))
def lb_port(port):
"""When: I go to port ## on the webserver."""
@then(parsers.re(r'a status code of 200 is returned for port "(?P<port>\d+)"'))
def port_online(port):
"""Then: a status code of 200 is returned"""
assert isOpen(webserver_ip, port)
r = requests.get(webserver_url[port])
assert r.status_code == 200
@then(parsers.re(r'I do not get a response from port "(?P<port>\d+)"'))
def port_offline(port):
@given("an empty wiki-scripts database")
def empty_wsdb(db):
# TODO: the db is currently function-scoped, so clearing is useless
# db.clear()
pass
@when("I synchronize the wiki-scripts database")
def sync_page_tables(mediawiki, db):
db.sync_with_api(mediawiki.api, with_content=True)
@when(parsers.parse("I create page \"{title}\""))
def create_page(mediawiki, title):
# all pages are created as empty
mediawiki.api.create(title, "", title)
@when(parsers.re("I move page \"(?P<src_title>.+?)\" to \"(?P<dest_title>.+?)\"(?P<noredirect> without leaving a redirect)?"))
def move_page(mediawiki, src_title, dest_title, noredirect):
noredirect = False if noredirect is None else True
mediawiki.api.move(src_title, dest_title, "moved due to BDD tests", noredirect=noredirect)
def _get_content_api(api, title):
result = api.call_api(action="query", titles=title, prop="revisions", rvprop="content|timestamp")
page = list(result["pages"].values())[0]
text = page["revisions"][0]["*"]
timestamp = page["revisions"][0]["timestamp"]
return text, timestamp, page["pageid"]
@when(parsers.parse("I edit page \"{title}\" to contain \"{content}\""))
def edit_page(mediawiki, title, content):
api = mediawiki.api
old_text, timestamp, pageid = _get_content_api(api, title)
__license__ = "This software is released under the MIT license cited in " \
"LICENSE.txt"
import re
from pytest_bdd import given, when, then, parsers
from selenium.webdriver.support.ui import WebDriverWait as Wait
from selenium.webdriver.support.expected_conditions import staleness_of
from tests.gui.utils.generic import parse_seq, repeat_failed, \
parse_url, redirect_display
from tests.gui.conftest import WAIT_BACKEND
@given(parsers.re("users? of (?P<browser_id_list>.*) opened Onezone URL"))
def g_visit_onezone(base_url, selenium, browser_id_list):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
driver.get(base_url)
@when(
parsers.re('user of (?P<browser_id>.+) should be '
'redirected to (?P<page>.+) page'))
@then(
parsers.re('user of (?P<browser_id>.+) should be '
'redirected to (?P<page>.+) page'))
def being_redirected_to_page(page, selenium, browser_id):
driver = selenium[browser_id]
Wait(driver, 5).until(lambda d: re.match(r'https?://.*?(/#)?(/.*)', d.
pass
@pytest.mark.integration
@scenario('fiddlefiles.feature', 'Viewing editing files of others')
def test_edit_copy_view():
pass
@pytest.mark.integration
@scenario('fiddlefiles.feature', 'Editing files of others')
def test_edit_copy():
pass
@given(re(r"I'm logged in as (?P<user>.*)"))
def myclient(user, client, admin_client, db):
if user == "no one":
return client
if user == "an admin":
return admin_client
obj = UserFactory(username=user)
client.login(user=obj)
return client
@given("There is a file")
def fiddlefile(db):
obj = UserFactory(username="******")
fiddle=DjangoFiddleFactory.build(owner=obj)
fiddle.save()
from assertpy import assert_that
from pytest_bdd import then, parsers
from pytest_selenium_enhancer import CustomWait
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException
from page_objects.selenium_generics import SeleniumGenerics
from utils.locators import Locators
from page_objects.dashboard_homepage import DashboardHomePage
from page_objects.dashboard_homeObject import DashboardWebsitePage
from page_objects.dashboard_websitepageObject import DashboardWebsitesPage
from page_objects.dashboard_mtps_pageObject import DashboardMTPsPage
from page_objects.locators import DashboardLoginPageLocators
@then(parsers.re("I expect that the title is '(?P<title>.*)'"))
def check_title_is(selenium, title):
assert_that(selenium.title).is_equal_to(title)
@then(parsers.re("I expect that the title is not '(?P<title>.*)'"))
def check_title_is_not(selenium, title):
assert_that(selenium.title).is_not_equal_to(title)
@then(parsers.re("I expect that the title contains '(?P<title>.*)'"))
def check_title_contains(selenium, title):
assert_that(selenium.title).contains(title)
@then(parsers.re("I expect that the title does not contain '(?P<title>.*)'"))
def check_title_not_contains(selenium, title):
def match_scenario(allure_report, context, scenario_name):
matcher = partial(match, has_test_case, scenario_name)
assert_that(allure_report, matcher())
context['scenario'] = matcher
@then(parsers.parse("this {item:w} has {status:w} status"))
def item_status(allure_report, context, item, status):
context_matcher = context[item]
matcher = partial(context_matcher, with_status, status)
assert_that(allure_report, matcher())
@then(
parsers.re("this (?P<item>\\w+) "
"has parameter (?:\")(?P<param_name>[\\w|\\s]*)(?:\") "
"with value (?:\")(?P<param_value>[\\w|\\s]*)(?:\")"))
def item_parameter(allure_report, context, item, param_name, param_value):
context_matcher = context[item]
matcher = partial(context_matcher, has_parameter, param_name, param_value)
assert_that(allure_report, matcher())
@then(
parsers.
re("this (?P<item>\\w+) contains (?:\")(?P<step>[\\w|\\s|>|<]+)(?:\") step"
))
def step_step(allure_report, context, item, step):
context_matcher = context[item]
matcher = partial(context_matcher, has_step, step)
context["step"] = matcher
@scenario(
"background.feature",
"Background steps are executed first",
)
def test():
pass
test(request)
@pytest.fixture
def foo():
return {}
@given(parsers.re(r'a background step with multiple lines:\n(?P<data>.+)', flags=re.DOTALL))
def multi_line(foo, data):
assert data == "one\ntwo"
@given('foo has a value "bar"')
def bar(foo):
foo["bar"] = "bar"
return foo["bar"]
@given('foo has a value "dummy"')
def dummy(foo):
foo["dummy"] = "dummy"
return foo["dummy"]
@then(
parsers.parse('user of {browser_id} uses spaces select to change '
'data space to "{space_name}"'))
@repeat_failed(timeout=WAIT_BACKEND)
def change_space_view_in_data_tab_in_op(selenium, browser_id, space_name,
op_page):
driver = selenium[browser_id]
selector = op_page(driver).data.sidebar.space_selector
selector.expand()
selector.spaces[space_name].click()
@when(
parsers.re(r'user of (?P<browser_id>.*?) clicks the button '
r'from top menu bar with tooltip '
r'"(?P<tooltip>Create directory|Create file|Share element|'
r'Edit metadata|Rename element|Change element permissions|'
r'Copy element|Cut element|Remove element|'
r'Show file distribution)"'))
@then(
parsers.re(r'user of (?P<browser_id>.*?) clicks the button '
r'from top menu bar with tooltip '
r'"(?P<tooltip>Create directory|Create file|Share element|'
r'Edit metadata|Rename element|Change element permissions|'
r'Copy element|Cut element|Remove element|'
r'Show file distribution)"'))
@repeat_failed(timeout=WAIT_FRONTEND)
def click_tooltip_from_toolbar_in_data_tab_in_op(selenium, browser_id, tooltip,
op_page):
driver = selenium[browser_id]
btn = getattr(op_page(driver).data.toolbar, transform(tooltip))
btn.click()
'{item_type} named "{item_name}"'))
def is_tool_icon_displayed(selenium, browser_id, tool_type, item_type,
item_name):
driver = selenium[browser_id]
Wait(driver, WAIT_FRONTEND).until(
lambda s: _is_tool_icon_displayed(driver, item_name, item_type,
tool_type),
message='checking if {tool_type} icon for {item_type} named '
'"{item_name}" is displayed'.format(tool_type=tool_type,
item_type=item_type,
item_name=item_name))
@when(
parsers.re(
r'user of (?P<browser_id>.*?) sees that (?P<item_type>.*?)s? '
r'named (?P<item_list>.*?) (has|have) disappeared from files list'))
@then(
parsers.re(
r'user of (?P<browser_id>.*?) sees that (?P<item_type>.*?)s? '
r'named (?P<item_list>.*?) (has|have) disappeared from files list'))
@when(
parsers.re(r'user of (?P<browser_id>.*?) does not see any '
r'(?P<item_type>.*?)s? named (?P<item_list>.*?) on files list'))
@then(
parsers.re(r'user of (?P<browser_id>.*?) does not see any '
r'(?P<item_type>.*?)s? named (?P<item_list>.*?) on files list'))
def is_not_present_in_file_list(selenium, browser_id, item_list, item_type):
driver = selenium[browser_id]
item_type = item_type.replace('directorie', 'directory')
Wait(driver, WAIT_FRONTEND).until(
)
assert len(pods) == pods_count
error_msg = (
"There is not exactly '{count}' pod(s) labeled '{label}' running "
"in namespace '{namespace}'".format(count=pods_count,
label=label,
namespace=namespace))
if node:
error_msg += "on node '{node}'".format(node=node)
utils.retry(_check_pods_count, times=20, wait=3, error_msg=error_msg)
_COUNT_RUNNING_PODS_PARSER = parsers.re(
r"we have (?P<pods_count>\d+) running pod labeled '(?P<label>[^']+)' "
r"in namespace '(?P<namespace>[^']+)'(?: on node '(?P<node>[^']+)')?")
# }}}
# Given {{{
@given('the Kubernetes API is available')
def check_service(host):
_verify_kubeapi_service(host)
@given(_COUNT_RUNNING_PODS_PARSER, converters=dict(pods_count=int))
def given_count_running_pods(request, k8s_client, pods_count, label, namespace,
node):
return count_running_pods(request, k8s_client, pods_count, label,
desc = yaml.load(desc)
for key, val in desc.items():
transfer_val = getattr(transfer, key.replace(' ', '_'))
assert transfer_val == str(val), \
'Transfer {} is {} instead of {} in {}'.format(key, transfer_val,
val, sufix)
def wt(name, func=None, converters=None):
if not func:
return partial(wt, name, converters=converters)
return then(name, converters)(when(name, converters)(func))
@wt(
parsers.re('user of (?P<browser_id>.*) sees (?P<item_type>file|directory)'
' in ongoing transfers:\n(?P<desc>(.|\s)*)'))
@repeat_failed(interval=0.5)
def assert_ongoing_transfer(selenium, browser_id, item_type, desc):
transfer = op_page(selenium[browser_id]).transfers.ongoing[0]
_assert_transfer(transfer, item_type, desc, 'ongoing')
@wt(
parsers.re('user of (?P<browser_id>.*) sees (?P<item_type>file|directory)'
' in ended transfers:\n(?P<desc>(.|\s)*)'))
@repeat_failed(interval=0.5, timeout=40)
def assert_finished_transfer(selenium, browser_id, item_type, desc):
transfer = op_page(selenium[browser_id]).transfers.ended[0]
_assert_transfer(transfer, item_type, desc, 'ended')
def test_background_check_order(request):
"""Test feature background to ensure that backound steps are executed first."""
@scenario("background.feature", "Background steps are executed first")
def test():
pass
test(request)
@pytest.fixture
def foo():
return {}
@given(parsers.re(r"a background step with multiple lines:\n(?P<data>.+)", flags=re.DOTALL))
def multi_line(foo, data):
assert data == "one\ntwo"
@given('foo has a value "bar"')
def bar(foo):
foo["bar"] = "bar"
return foo["bar"]
@given('foo has a value "dummy"')
def dummy(foo):
foo["dummy"] = "dummy"
return foo["dummy"]
@when(parsers.parse('user of {browser_id} presses backspace on keyboard'))
@then(parsers.parse('user of {browser_id} presses backspace on keyboard'))
def press_enter_on_active_element(selenium, browser_id):
driver = selenium[browser_id]
driver.switch_to.active_element.send_keys(Keys.BACKSPACE)
@then(parsers.parse('user of {browser_id} should see {links_names} links'))
def link_with_text_present(selenium, browser_id, links_names):
driver = selenium[browser_id]
for name in parse_seq(links_names):
assert driver.find_element_by_link_text(name), \
'{} link not found'.format(name)
@given(parsers.re('users? of (?P<browser_id_list>.*) clicked on the '
'"(?P<link_name>.*)" link'))
def g_click_on_link_with_text(selenium, browser_id_list, link_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
driver.find_element_by_link_text(link_name).click()
@when(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<link_name>.*)" link'))
@then(parsers.re('users? of (?P<browser_id_list>.*) clicks on the '
'"(?P<link_name>.*)" link'))
def wt_click_on_link_with_text(selenium, browser_id_list, link_name):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
driver.find_element_by_link_text(link_name).click()
pass
@pytest.mark.integration
@scenario('fiddlefiles.feature', 'Viewing editing files of others')
def test_edit_copy_view():
pass
@pytest.mark.integration
@scenario('fiddlefiles.feature', 'Editing files of others')
def test_edit_copy():
pass
@given(re(r"I'm logged in as (?P<user>.*)"))
def myclient(user, client, admin_client, db):
if user == "no one":
return client
if user == "an admin":
return admin_client
obj = UserFactory(username=user)
client.login(user=obj)
return client
@given("There is a file")
def fiddlefile(db):
obj = UserFactory(username="******")
fiddle = DjangoFiddleFactory.build(owner=obj)
fiddle.save()
@scenario_when('Argument in when, step 2')
def test_argument_in_when_step_2():
pass
def test_multiple_given(request):
"""Using the same given fixture raises an error."""
@scenario_args('Using the same given fixture raises an error')
def test():
pass
with pytest.raises(exceptions.GivenAlreadyUsed):
test(request)
@given(parsers.re(r'I have (?P<euro>\d+) Euro'), converters=dict(euro=int))
def i_have(euro, values):
assert euro == values.pop(0)
@when(parsers.re(r'I pay (?P<euro>\d+) Euro'), converters=dict(euro=int))
def i_pay(euro, values, request):
assert euro == values.pop(0)
@then(parsers.re(r'I should have (?P<euro>\d+) Euro'), converters=dict(euro=int))
def i_should_have(euro, values):
assert euro == values.pop(0)
# test backwards compartibility
from assertpy import assert_that
import os
import json
from utils.locators import Locators
from pytest_bdd import given, parsers
from pytest_selenium_enhancer import CustomWait
from selenium.webdriver.common.by import By
from page_objects.selenium_generics import SeleniumGenerics
from page_objects.dashboard_loginpage import DashboardLoginPage
from page_objects.dashboard_homeObject import DashboardWebsitePage
from page_objects.dashboard_websitepageObject import DashboardWebsitesPage
from page_objects.dashboard_mtps_pageObject import DashboardMTPsPage
from page_objects.changelog_loginpage import ChangeLogLoginPage
from page_objects.create_changelogpage import CreateChangeLogPage
@given(parsers.re("I open the url '(?P<page_url>.*)'"))
@given(parsers.re("I open the site '(?P<page_url>.*)'"))
@given(parsers.re("I navigate to page '(?P<page_url>.*)'"))
def open_webpage(selenium, base_url, page_url):
selenium.get('%s%s' % (base_url, page_url))
@given(parsers.re("I open the external url '(?P<site_url>.*)'"))
@given(parsers.re("I open the external site '(?P<site_url>.*)'"))
def open_external_webpage(selenium, site_url):
selenium.get(site_url)
@given(parsers.re("The element '(?P<locator_path>.*)' is displayed"))
def element_displayed(selenium, locators: Locators, locator_path):
CustomWait(selenium).wait_for_element_visible(value=locators.parse_and_get(locator_path))
@when(parsers.parse('user of {browser_id} scrolls to the bottom '
'of file browser'))
@then(parsers.parse('user of {browser_id} scrolls to the bottom '
'of file browser'))
@repeat_failed(timeout=WAIT_FRONTEND)
def scroll_to_bottom_of_file_browser(browser_id, tmp_memory):
browser = tmp_memory[browser_id]['file_browser']
browser.scroll_to_bottom()
# @when(parsers.parse('user of {browser_id} sees that there is(are) {num:d} '
# 'item(s) in file browser'))
# @then(parsers.parse('user of {browser_id} sees that there is(are) {num:d} '
# 'item(s) in file browser'))
@when(parsers.re('user of (?P<browser_id>.+?) sees that there '
'(is 1|are (?P<num>\d+)) items? in file browser'))
@then(parsers.re('user of (?P<browser_id>.+?) sees that there '
'(is 1|are (?P<num>\d+)) items? in file browser'))
@repeat_failed(timeout=WAIT_BACKEND)
def assert_num_of_files_are_displayed_in_file_browser(browser_id, num,
tmp_memory):
browser = tmp_memory[browser_id]['file_browser']
err_msg = 'displayed number of files {} does not match expected {}'
files_num = browser.files_count
num = int(num) if num is not None else 1
assert files_num == num, err_msg.format(files_num, num)
@when(parsers.parse('user of {browser_id} sees that item named "{item_name}" '
'is {item_attr} in file browser'))
@then(parsers.parse('user of {browser_id} sees that item named "{item_name}" '
@then(parsers.parse('user of {browser_id} sees {tool_type} icon for '
'{item_type} named "{item_name}"'))
def is_tool_icon_displayed(selenium, browser_id, tool_type,
item_type, item_name):
driver = selenium[browser_id]
Wait(driver, WAIT_FRONTEND).until(
lambda s: _is_tool_icon_displayed(driver, item_name,
item_type, tool_type),
message='checking if {tool_type} icon for {item_type} named '
'"{item_name}" is displayed'.format(tool_type=tool_type,
item_type=item_type,
item_name=item_name)
)
@when(parsers.re(r'user of (?P<browser_id>.*?) sees that (?P<item_type>.*?)s? '
r'named (?P<item_list>.*?) (has|have) disappeared from files list'))
@then(parsers.re(r'user of (?P<browser_id>.*?) sees that (?P<item_type>.*?)s? '
r'named (?P<item_list>.*?) (has|have) disappeared from files list'))
@when(parsers.re(r'user of (?P<browser_id>.*?) does not see any '
r'(?P<item_type>.*?)s? named (?P<item_list>.*?) on files list'))
@then(parsers.re(r'user of (?P<browser_id>.*?) does not see any '
r'(?P<item_type>.*?)s? named (?P<item_list>.*?) on files list'))
def is_not_present_in_file_list(selenium, browser_id, item_list, item_type):
driver = selenium[browser_id]
item_type = item_type.replace('directorie', 'directory')
Wait(driver, WAIT_FRONTEND).until(
lambda _: _not_in_file_list(driver, item_list, item_type),
message='waiting for {:s} item/items '
'to disappear from file list'.format(item_list)
)
from selenium.webdriver.common.by import By
from selenium.webdriver.support.select import Select
# Application imports
from utils.locators import Locators
from page_objects.dashboard_loginpage import DashboardLoginPage
from page_objects.dashboard_homepage import DashboardHomePage
from page_objects.dashboard_homeObject import DashboardWebsitePage
from page_objects.dashboard_websitepageObject import DashboardWebsitesPage
from page_objects.dashboard_prepare_MTPObject import DashboardPrepareMTPPage
from page_objects.dashboard_mtps_pageObject import DashboardMTPsPage
from page_objects.create_changelogpage import CreateChangeLogPage
@when(parsers.re("I set the locale for locators to '(?P<locale>.*)'"))
@when(parsers.re("I set the language for locators to '(?P<locale>.*)'"))
def set_locale(locators: Locators, locale):
locators.set_locale(locale)
@when(parsers.re("I click on '(?P<locator_path>.*)'"))
def click_element(selenium, locators: Locators, locator_path):
selenium.find_element(By.XPATH, locators.parse_and_get(locator_path)).click()
@when(parsers.re("I double click on '(?P<locator_path>.*)'"))
@when(parsers.re("I doubleclick on '(?P<locator_path>.*)'"))
def dbl_click_element(selenium, locators: Locators, locator_path):
element = selenium.find_element(By.XPATH, locators.parse_and_get(locator_path))
"background.feature",
"Background steps are executed first",
)
def test():
pass
test(request)
@pytest.fixture
def foo():
return {}
@given(
parsers.re(r'a background step with multiple lines:\n(?P<data>.+)',
flags=re.DOTALL))
def multi_line(foo, data):
assert data == "one\ntwo"
@given('foo has a value "bar"')
def bar(foo):
foo["bar"] = "bar"
return foo["bar"]
@given('foo has a value "dummy"')
def dummy(foo):
foo["dummy"] = "dummy"
return foo["dummy"]
"""Common steps using copy or paste text
"""
from pytest_bdd import when, then, parsers
from tests.gui.utils.generic import parse_seq
__author__ = "Bartosz Walkowicz"
__copyright__ = "Copyright (C) 2017 ACK CYFRONET AGH"
__license__ = "This software is released under the MIT license cited in " \
"LICENSE.txt"
@when(
parsers.re('user of (?P<browser_id>.*?) sends copied (?P<item_type>.*?) '
'to users? of (?P<browser_list>.*)'))
@then(
parsers.re('user of (?P<browser_id>.*?) sends copied (?P<item_type>.*?) '
'to users? of (?P<browser_list>.*)'))
def send_copied_item_to_other_users(browser_id, item_type, browser_list,
tmp_memory, displays, clipboard):
item = clipboard.paste(display=displays[browser_id])
for browser in parse_seq(browser_list):
tmp_memory[browser]['mailbox'][item_type.lower()] = item
@when(
parsers.parse('user of {browser_id} sees that copied token '
'matches displayed one'))
@then(
parsers.parse('user of {browser_id} sees that copied token '
"LICENSE.txt"
import re
from pytest_bdd import given, when, then, parsers
from selenium.webdriver.support.ui import WebDriverWait as Wait
from selenium.webdriver.support.expected_conditions import staleness_of
from tests.gui.utils.generic import parse_seq, repeat_failed, \
parse_url, redirect_display
from tests.gui.conftest import WAIT_BACKEND
@given(parsers.re("users? of (?P<browser_id_list>.*) opened Onezone URL"))
def g_visit_onezone(base_url, selenium, browser_id_list):
for browser_id in parse_seq(browser_id_list):
driver = selenium[browser_id]
driver.get(base_url)
@when(parsers.re('user of (?P<browser_id>.+) should be '
'redirected to (?P<page>.+) page'))
@then(parsers.re('user of (?P<browser_id>.+) should be '
'redirected to (?P<page>.+) page'))
def being_redirected_to_page(page, selenium, browser_id):
driver = selenium[browser_id]
Wait(driver, 5).until(
lambda d: re.match(r'https?://.*?(/#)?(/.*)',
d.current_url).group(2) == page,
@scenario_when('Argument in when, step 2')
def test_argument_in_when_step_2():
pass
def test_multiple_given(request):
"""Using the same given fixture raises an error."""
@scenario_args('Using the same given fixture raises an error')
def test():
pass
with pytest.raises(exceptions.GivenAlreadyUsed):
test(request)
@given(parsers.re(r'I have (?P<euro>\d+) Euro'), converters=dict(euro=int))
def i_have(euro, values):
assert euro == values.pop(0)
@when(parsers.re(r'I pay (?P<euro>\d+) Euro'), converters=dict(euro=int))
def i_pay(euro, values, request):
assert euro == values.pop(0)
@then(parsers.re(r'I should have (?P<euro>\d+) Euro'),
converters=dict(euro=int))
def i_should_have(euro, values):
assert euro == values.pop(0)
@when(parsers.parse('user of {browser_id} clicks on {tab_name} navigation '
'tab in metadata panel opened for "{item_name}"'))
@then(parsers.parse('user of {browser_id} clicks on {tab_name} navigation '
'tab in metadata panel opened for "{item_name}"'))
@repeat_failed(timeout=WAIT_FRONTEND)
def click_on_navigation_tab_in_metadata_panel(browser_id, tab_name,
item_name, tmp_memory):
browser = tmp_memory[browser_id]['file_browser']
tab = getattr(browser.get_metadata_for(item_name).navigation,
tab_name.lower())
tab()
@when(parsers.re('user of (?P<browser_id>.+?) sees that (?P<tab>JSON|RDF) '
'textarea placed in metadata panel opened for '
'"(?P<item_name>.+?)" contains "(?P<metadata_record>.+?)"'))
@then(parsers.re('user of (?P<browser_id>.+?) sees that (?P<tab>JSON|RDF) '
'textarea placed in metadata panel opened for '
'"(?P<item_name>.+?)" contains "(?P<metadata_record>.+?)"'))
@repeat_failed(timeout=WAIT_FRONTEND)
def assert_textarea_contains_record(browser_id, metadata_record, tab,
item_name, tmp_memory):
browser = tmp_memory[browser_id]['file_browser']
metadata_row = browser.get_metadata_for(item_name)
tab = getattr(metadata_row, tab.lower())
assert metadata_record in tab.text_area, \
'text in textarea : {} does not contain {}'.format(tab.text_area,
metadata_record)
def isOpen(ip, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(timeout)
try:
s.connect((ip, int(port)))
s.shutdown(socket.SHUT_RDWR)
return True
except:
return False
finally:
s.close()
@given('The Load Balancer is Online')
def load_balancer():
"""Given: The Load Balancer is Online."""
@when(parsers.re(r'I go to port "(?P<port>\d+)" on the Load Balancer'))
def lb_port(port):
"""When: I go to port ## on the Load Balancer."""
@then(parsers.re(r'a status code of 200 is returned for port "(?P<port>\d+)"'))
def port_online(port):
"""Then: a status code of 200 is returned"""
assert isOpen(load_balancer_ip, port)
r = requests.get(load_balancer_url[port])
assert r.status_code == 200
"""Common steps using copy or paste text
"""
from pytest_bdd import when, then, parsers
from tests.gui.utils.generic import parse_seq
__author__ = "Bartosz Walkowicz"
__copyright__ = "Copyright (C) 2017 ACK CYFRONET AGH"
__license__ = "This software is released under the MIT license cited in " \
"LICENSE.txt"
@when(parsers.re('user of (?P<browser_id>.*?) sends copied (?P<item_type>.*?) '
'to users? of (?P<browser_list>.*)'))
@then(parsers.re('user of (?P<browser_id>.*?) sends copied (?P<item_type>.*?) '
'to users? of (?P<browser_list>.*)'))
def send_copied_item_to_other_users(browser_id, item_type, browser_list,
tmp_memory, displays, clipboard):
item = clipboard.paste(display=displays[browser_id])
for browser in parse_seq(browser_list):
tmp_memory[browser]['mailbox'][item_type.lower()] = item
@when(parsers.parse('user of {browser_id} sees that copied token '
'matches displayed one'))
@then(parsers.parse('user of {browser_id} sees that copied token '
'matches displayed one'))
def assert_copied_token_match_displayed_one(browser_id, tmp_memory,
displays, clipboard):
@when(parsers.parse('user of {browser_id} sees '
'non-empty token in active modal'))
@then(parsers.parse('user of {browser_id} sees '
'non-empty token in active modal'))
def get_token_from_modal(selenium, browser_id, tmp_memory):
driver = selenium[browser_id]
modal = tmp_memory[browser_id]['window']['modal']
token_box = modal.find_element_by_css_selector('input[readonly]')
token = Wait(driver, WAIT_BACKEND).until(
lambda _: token_box.get_attribute('value'),
message='waiting for token to appear'
)
tmp_memory[browser_id]['token'] = token
@when(parsers.re(r'user of (?P<browser_id>.*?) clicks on '
r'((?P<in_type>.*?) )?input box in active modal'))
@then(parsers.re(r'user of (?P<browser_id>.*?) clicks on '
r'((?P<in_type>.*?) )?input box in active modal'))
def activate_input_box_in_modal(browser_id, in_type, tmp_memory):
modal = tmp_memory[browser_id]['window']['modal']
css_path = 'input#{}'.format(in_type_to_id[in_type]) if in_type else 'input'
in_box = modal.find_element_by_css_selector(css_path)
# send NULL to activates input box
in_box.send_keys(Keys.NULL)
@when(parsers.parse('user of {browser_id} clicks on '
'copy button in active modal'))
@then(parsers.parse('user of {browser_id} clicks on '
'copy button in active modal'))
def click_on_copy_btn_in_modal(selenium, browser_id, tmp_memory):
@when(parsers.parse('user of {browser_id} sees that provider popup for provider '
'named "{provider}" has appeared on world map'))
@then(parsers.parse('user of {browser_id} sees that provider popup for provider '
'named "{provider}" has appeared on world map'))
@repeat_failed(timeout=WAIT_FRONTEND)
def assert_provider_popup_has_appeared_on_map(selenium, browser_id,
provider, oz_page):
driver = selenium[browser_id]
err_msg = 'Popup displayed for provider named "{}" ' \
'instead of "{}"'
prov = oz_page(driver)['world map'].get_provider_with_displayed_popup()
assert provider == prov.name, err_msg.format(prov.name, provider)
@when(parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<btn>Go to your files|copy hostname)" button in '
r'"(?P<provider>.+?)" provider\'s popup displayed on world map'))
@then(parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<btn>Go to your files|copy hostname)" button in '
r'"(?P<provider>.+?)" provider\'s popup displayed on world map'))
@repeat_failed(timeout=WAIT_BACKEND)
def click_on_btn_in_provider_popup(selenium, browser_id, btn, provider, oz_page):
driver = selenium[browser_id]
err_msg = 'Popup displayed for provider named "{}" ' \
'instead of "{}"'
prov = oz_page(driver)['world map'].get_provider_with_displayed_popup()
assert provider == prov.name, err_msg.format(prov.name, provider)
action = getattr(prov, btn.lower().replace(' ', '_'))
action()
@when(parsers.parse('user of {browser_id} expands settings dropdown for space '
'named "{name}" in expanded "DATA SPACE MANAGEMENT" '
'Onezone panel by clicking on settings icon'))
@then(parsers.parse('user of {browser_id} expands settings dropdown for space '
'named "{name}" in expanded "DATA SPACE MANAGEMENT" '
'Onezone panel by clicking on settings icon'))
@repeat_failed(timeout=WAIT_FRONTEND)
def expand_settings_dropdown_for_space_in_panel(selenium, browser_id,
name, oz_page):
driver = selenium[browser_id]
oz_page(driver)['data space management'].spaces[name].settings.expand()
@when(parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<option>LEAVE|RENAME|ADD STORAGE|SET AS HOME)" item in '
r'settings dropdown for space named "(?P<name>.+?)" '
r'in expanded "DATA SPACE MANAGEMENT" Onezone panel'))
@then(parsers.re(r'user of (?P<browser_id>.+?) clicks on the '
r'"(?P<option>LEAVE|RENAME|ADD STORAGE|SET AS HOME)" item in '
r'settings dropdown for space named "(?P<name>.+?)" '
r'in expanded "DATA SPACE MANAGEMENT" Onezone panel'))
@repeat_failed(timeout=WAIT_FRONTEND)
def click_on_settings_option_for_space_in_panel(selenium, browser_id,
option, name, oz_page):
driver = selenium[browser_id]
settings = oz_page(driver)['data space management'].spaces[name].settings
action = getattr(settings, option.lower().replace(' ', '_'))
action()
@when(parsers.parse('user of {browser_id} clicks on "Add storage" button in '
