def setup(data):
common.access_golem(data.env.url, data.env.admin)
actions.store('test', actions.random_str())
index.create_access_project(data.test)
api.test.create_test(data.test, 'test_one')
actions.store('suite_name', actions.random_str())
api.suite.create_access_suite(data.test, data.suite_name)
def test_rename_test_does_not_exist(data):
test_name = actions.random_str()
new_name = actions.random_str()
response = test_.rename_test(data.project, test_name, new_name)
assert response.json()['errors'] == [
'Test {} does not exist'.format(test_name)
]
def setup(data):
actions.store('project', 'general')
actions.store('page_one', actions.random_str())
actions.store('page_two', actions.random_str())
project.create_project_if(data.project)
project.create_page(data.project, data.page_one)
project.create_page(data.project, data.page_two)
def setup(data):
project.using_project('general')
actions.store('dir', actions.random_str())
actions.store('test_name', actions.random_str())
actions.store('test', '{}.{}'.format(data.dir, data.test_name))
project.create_test_directory(data.project, data.dir)
project.create_test(data.project, data.test)
def setup(data):
project.using_project('general')
data.dir = actions.random_str()
data.page_name = actions.random_str()
data.page_full = '{}.{}'.format(data.dir, data.page_name)
project.create_page_directory(data.project, data.dir)
project.create_page(data.project, data.page_full)
def setup(data):
project.using_project('general')
actions.store('dir_one', actions.random_str())
actions.store('dir_two', '{}.{}'.format(actions.random_str(),
actions.random_str()))
project.create_test_directory(data.project, data.dir_one)
project.create_test_directory(data.project, data.dir_two)
def setup(data):
project.using_project('general')
actions.store('dir', actions.random_str())
project.create_page_directory(data.project, data.dir)
data.page_name = actions.random_str()
actions.store('page_full', '{}.{}'.format(data.dir, data.page_name))
project.create_page(data.project, data.page_full)
def test_edit_user_existing_username(data):
username1 = actions.random_str()
username2 = actions.random_str()
users.create_new_user(username1, '123456')
users.create_new_user(username2, '123456')
response = users.edit_user(username1, new_username=username2)
assert response.status_code == 200
assert response.json() == ['Username {} already exists'.format(username2)]
def test(data):
# to folder from root
test_name = actions.random_str()
full_name = '{}.{}'.format(actions.random_str(), test_name)
response = project.create_test(data.project, full_name)
assert response.status_code == 200
assert response.json()['errors'] == []
assert project.get_test_exists(data.project, full_name).json()
def setup(data):
data.username1 = actions.random_str()
data.username2 = actions.random_str()
utils.create_user(data.username1, '123456')
utils.create_user(data.username2, '123456')
common.access_golem(data.env.url, data.env.admin)
common.navigate_menu('Users')
users.wait_for_table_to_load()
def test_rename_test_directory_destination_exists(data):
dir_one = actions.random_str()
dir_two = actions.random_str()
project.create_test_directory(data.project, dir_one)
project.create_test_directory(data.project, dir_two)
response = test_.rename_test_directory(data.project, dir_one, dir_two)
assert response.json()['errors'] == [
'Path {} already exists'.format(dir_two)
]
def create_random_user(project_permissions=None):
username = actions.random_str()
password = actions.random_str()
permissions = [{
'project': pp[0],
'permission': pp[1]
} for pp in project_permissions]
users.create_new_user(username, password, project_permissions=permissions)
return {'username': username, 'password': password}
def test_rename_page_does_not_exist(data):
page_name = actions.random_str()
new_page_name = actions.random_str()
response = page.rename_page(data.project, page_name, new_page_name)
assert response.status_code == 200
assert response.json()['errors'] == [
'Page {} does not exist'.format(page_name)
]
assert not project.page_exists(data.project, new_page_name)
def test_rename_test_in_folder(data):
test_two = '{}.{}'.format(actions.random_str(), actions.random_str())
project.create_test(data.project, test_two)
new_test_name_two = '{}.{}'.format(actions.random_str(),
actions.random_str())
response = test_.rename_test(data.project, test_two, new_test_name_two)
assert response.json()['errors'] == []
assert not project.test_exists(data.project, test_two)
assert project.test_exists(data.project, new_test_name_two)
def test(data):
actions.store('folder_one', actions.random_str())
suite_list.add_folder(data.folder_one)
suite_list.assert_folder_exists(data.folder_one)
actions.store('folder_two', 'folder1.' + actions.random_str())
suite_list.add_folder(data.folder_two)
suite_list.assert_folder_exists(data.folder_two)
actions.refresh_page()
suite_list.assert_folder_exists(data.folder_one)
suite_list.assert_folder_exists(data.folder_two)
def test_rename_test_directory_to_parent(data):
dirname = actions.random_str()
subdir = '{}.{}'.format(dirname, actions.random_str())
project.create_test_directory(data.project, dirname)
project.create_test_directory(data.project, subdir)
response = test_.rename_test_directory(data.project, subdir, dirname)
assert response.json()['errors'] == [
'Path {} already exists'.format(dirname)
]
def test_delete_execution_execution_does_not_exist(data):
timestamp = actions.random_str()
suite_name = actions.random_str()
response = report.delete_execution_timestamp(data.project, suite_name,
timestamp)
assert response.status_code == 200
assert response.json() == [
'Execution for {} {} {} does not exist'.format(data.project,
suite_name, timestamp)
]
def test(data):
test_one = '{}.{}'.format(actions.random_str(), actions.random_str())
test_two = '{}.{}.{}'.format(actions.random_str(), actions.random_str(), actions.random_str())
test_list.add_test_to_current_folder(test_one)
test_list.add_test_to_current_folder(test_two)
test_list.assert_test_exists(test_one)
test_list.assert_test_exists(test_two)
actions.refresh_page()
test_list.assert_test_exists(test_one)
test_list.assert_test_exists(test_two)
def test(data):
folder_one = actions.random_str()
test_list.add_folder(folder_one)
test_list.assert_folder_exists(folder_one)
folder_two = 'folder1.' + actions.random_str()
test_list.add_folder(folder_two)
test_list.assert_folder_exists(folder_two)
actions.refresh_page()
test_list.assert_folder_exists(folder_one)
test_list.assert_folder_exists(folder_two)
def test_delete_test(data):
test_one = project.create_random_test(data.project)
response = test_.delete_test(data.project, test_one)
assert response.status_code == 200
assert response.json() == []
assert not project.test_exists(data.project, test_one)
test_two = '{}.{}'.format(actions.random_str(), actions.random_str())
project.create_test(data.project, test_two)
test_.delete_test(data.project, test_two)
assert not project.test_exists(data.project, test_two)
def test(data):
folder = actions.random_str()
test_list.add_folder(folder)
test_list.navigate_to_folder(folder)
test_one = actions.random_str()
test_list.add_test_to_current_folder(test_one)
test_two = 'foo.bar'
test_list.add_test_to_current_folder(test_two)
common.navigate_menu('Tests')
test_list.assert_test_exists('{}.{}'.format(folder, test_one))
test_list.assert_test_exists('{}.{}'.format(folder, test_two))
def test(data):
username = actions.random_str()
users.create_new_user(username, '123456', '*****@*****.**')
new_username = actions.random_str()
users.edit_user(username, new_username=new_username)
response = users.get_user(new_username)
assert response.json()['username'] == new_username
assert response.json()['email'] == '*****@*****.**'
users.edit_user(new_username, new_email='*****@*****.**')
response = users.get_user(new_username)
assert response.json()['username'] == new_username
assert response.json()['email'] == '*****@*****.**'
def test(data):
# to root
test_one = actions.random_str()
test_list.add_test(test_one)
test_list.assert_test_exists(test_one)
# to folder
test_two = 'folder1.' + actions.random_str()
test_list.add_test(test_two)
test_list.assert_test_exists(test_two)
actions.refresh_page()
test_list.assert_test_exists(test_one)
test_list.assert_test_exists(test_two)
def test(data):
folder_one = actions.random_str()
suite_list.add_folder(folder_one)
suite_list.assert_folder_exists(folder_one)
folder_two = '{}.{}'.format(actions.random_str(), actions.random_str())
suite_list.add_folder(folder_two)
suite_list.assert_folder_exists(folder_two)
actions.refresh_page()
suite_list.assert_folder_exists(folder_one)
suite_list.assert_folder_exists(folder_two)
def test(data):
# to root
page_one = actions.random_str()
page_list.add_page(page_one)
page_list.assert_page_exists(page_one)
# to folder
page_two = 'folder1.' + actions.random_str()
page_list.add_page(page_two)
page_list.assert_page_exists(page_two)
actions.refresh_page()
page_list.assert_page_exists(page_one)
page_list.assert_page_exists(page_two)
def test(data):
suite_list.dismiss_no_tests_alert_if()
# to root
actions.store('suite_one', actions.random_str())
suite_list.add_suite(data.suite_one)
suite_list.assert_suite_exists(data.suite_one)
# to folder
actions.store('suite_two', 'folder1.' + actions.random_str())
suite_list.add_suite(data.suite_two)
suite_list.assert_suite_exists(data.suite_two)
actions.refresh_page()
suite_list.assert_suite_exists(data.suite_one)
suite_list.assert_suite_exists(data.suite_two)
def test(data):
suite_list.dismiss_no_tests_alert_if()
# to root
suite_one = actions.random_str()
suite_list.add_suite(suite_one)
suite_list.assert_suite_exists(suite_one)
# to folder
suite_two = '{}.{}'.format(actions.random_str(), actions.random_str())
suite_list.add_suite(suite_two)
suite_list.assert_suite_exists(suite_two)
actions.refresh_page()
suite_list.assert_suite_exists(suite_one)
suite_list.assert_suite_exists(suite_two)
def test_new_superuser(data):
username = actions.random_str()
password = actions.random_str()
is_superuser = True
project_permissions = []
response = users.create_new_user(username, password, '', is_superuser,
project_permissions)
assert response.status_code == 200
response = users.get_user(username)
assert response.json()['username'] == username
assert response.json()['email'] is None
assert response.json()['is_superuser'] is True
assert response.json()['projects'] == {}
def test_edit_user(data):
username = actions.random_str()
users.create_new_user(username, '123456', '*****@*****.**')
new_username = actions.random_str()
new_email = '*****@*****.**'
new_project_permissions = [{'project': "projectname", 'permission': "admin"}]
response = users.edit_user(username, new_username, new_email, False, new_project_permissions)
assert response.status_code == 200
response = users.get_user(new_username)
assert response.json()['username'] == new_username
assert response.json()['email'] == new_email
assert response.json()['is_superuser'] is False
assert response.json()['projects'] == {'projectname': 'admin'}
def test_create_test_directory_exists(data):
dir_one = actions.random_str()
dir_two = '{}.{}'.format(actions.random_str(), actions.random_str())
project.create_test_directory(data.project, dir_one)
project.create_test_directory(data.project, dir_two)
response = project.create_test_directory(data.project, dir_one)
assert response.json()['errors'] == [
'A directory with that name already exists'
]
response = project.create_test_directory(data.project, dir_two)
assert response.json()['errors'] == [
'A directory with that name already exists'
]
