From ce906b1fef27839b51f029ad5ff8460994e07dfb Mon Sep 17 00:00:00 2001 From: Joseph Nuthalapati Date: Fri, 24 Jan 2020 16:07:13 +0530 Subject: [PATCH] functional-tests: Login only once per session Signed-off-by: Joseph Nuthalapati [sunil: Fix fixture name for searx] Signed-off-by: Sunil Mohan Adapa Reviewed-by: Sunil Mohan Adapa --- .../step_definitions/application.py | 432 +++++++++--------- .../step_definitions/interface.py | 59 +-- functional_tests/step_definitions/service.py | 25 +- functional_tests/step_definitions/site.py | 154 ++++--- functional_tests/step_definitions/system.py | 210 ++++----- functional_tests/support/interface.py | 7 +- functional_tests/support/site.py | 10 +- 7 files changed, 467 insertions(+), 430 deletions(-) diff --git a/functional_tests/step_definitions/application.py b/functional_tests/step_definitions/application.py index 293057173..7ed5750f3 100644 --- a/functional_tests/step_definitions/application.py +++ b/functional_tests/step_definitions/application.py @@ -23,488 +23,504 @@ from support import application @given(parsers.parse('the {app_name:w} application is installed')) -def application_is_installed(browser, app_name): - application.install(browser, app_name) - assert (application.is_installed(browser, app_name)) +def application_is_installed(session_browser, app_name): + application.install(session_browser, app_name) + assert (application.is_installed(session_browser, app_name)) @given(parsers.parse('the {app_name:w} application is enabled')) -def application_is_enabled(browser, app_name): - application.enable(browser, app_name) +def application_is_enabled(session_browser, app_name): + application.enable(session_browser, app_name) @given(parsers.parse('the {app_name:w} application is disabled')) -def application_is_disabled(browser, app_name): - application.disable(browser, app_name) +def application_is_disabled(session_browser, app_name): + application.disable(session_browser, app_name) @given(parsers.parse('the network time application is enabled')) -def ntp_is_enabled(browser): - application.enable(browser, 'ntp') +def ntp_is_enabled(session_browser): + application.enable(session_browser, 'ntp') @given(parsers.parse('the network time application is disabled')) -def ntp_is_disabled(browser): - application.disable(browser, 'ntp') +def ntp_is_disabled(session_browser): + application.disable(session_browser, 'ntp') @when(parsers.parse('I set the time zone to {time_zone:S}')) -def time_zone_set(browser, time_zone): - application.time_zone_set(browser, time_zone) +def time_zone_set(session_browser, time_zone): + application.time_zone_set(session_browser, time_zone) @then(parsers.parse('the time zone should be {time_zone:S}')) -def time_zone_assert(browser, time_zone): - assert time_zone == application.time_zone_get(browser) +def time_zone_assert(session_browser, time_zone): + assert time_zone == application.time_zone_get(session_browser) @given(parsers.parse('the service discovery application is enabled')) -def avahi_is_enabled(browser): - application.enable(browser, 'avahi') +def avahi_is_enabled(session_browser): + application.enable(session_browser, 'avahi') @given(parsers.parse('the service discovery application is disabled')) -def avahi_is_disabled(browser): - application.disable(browser, 'avahi') +def avahi_is_disabled(session_browser): + application.disable(session_browser, 'avahi') @when(parsers.parse('I enable the {app_name:w} application')) -def enable_application(browser, app_name): - application.enable(browser, app_name) +def enable_application(session_browser, app_name): + application.enable(session_browser, app_name) @when(parsers.parse('I disable the {app_name:w} application')) -def disable_application(browser, app_name): - application.disable(browser, app_name) +def disable_application(session_browser, app_name): + application.disable(session_browser, app_name) @when(parsers.parse('I enable the network time application')) -def enable_ntp(browser): - application.enable(browser, 'ntp') +def enable_ntp(session_browser): + application.enable(session_browser, 'ntp') @when(parsers.parse('I disable the network time application')) -def disable_ntp(browser): - application.disable(browser, 'ntp') +def disable_ntp(session_browser): + application.disable(session_browser, 'ntp') @when(parsers.parse('I enable the service discovery application')) -def enable_avahi(browser): - application.enable(browser, 'avahi') +def enable_avahi(session_browser): + application.enable(session_browser, 'avahi') @when(parsers.parse('I disable the service discovery application')) -def disable_avahi(browser): - application.disable(browser, 'avahi') +def disable_avahi(session_browser): + application.disable(session_browser, 'avahi') @given( parsers.parse('the domain name for {app_name:w} is set to {domain_name:S}') ) -def select_domain_name(browser, app_name, domain_name): - application.select_domain_name(browser, app_name, domain_name) +def select_domain_name(session_browser, app_name, domain_name): + application.select_domain_name(session_browser, app_name, domain_name) @given('the shadowsocks application is configured') -def configure_shadowsocks(browser): - application.configure_shadowsocks(browser, 'example.com', 'fakepassword') +def configure_shadowsocks(session_browser): + application.configure_shadowsocks(session_browser, 'example.com', + 'fakepassword') @when( parsers.parse( 'I configure shadowsocks with server {server:S} and password {password:w}' )) -def configure_shadowsocks_with_details(browser, server, password): - application.configure_shadowsocks(browser, server, password) +def configure_shadowsocks_with_details(session_browser, server, password): + application.configure_shadowsocks(session_browser, server, password) @then( parsers.parse( 'shadowsocks should be configured with server {server:S} and password {password:w}' )) -def assert_shadowsocks_configuration(browser, server, password): - assert (server, - password) == application.shadowsocks_get_configuration(browser) +def assert_shadowsocks_configuration(session_browser, server, password): + assert ( + server, + password) == application.shadowsocks_get_configuration(session_browser) @when(parsers.parse('I modify the maximum file size of coquelicot to {size:d}') ) -def modify_max_file_size(browser, size): - application.modify_max_file_size(browser, size) +def modify_max_file_size(session_browser, size): + application.modify_max_file_size(session_browser, size) @then(parsers.parse('the maximum file size of coquelicot should be {size:d}')) -def assert_max_file_size(browser, size): - assert application.get_max_file_size(browser) == size +def assert_max_file_size(session_browser, size): + assert application.get_max_file_size(session_browser) == size @when(parsers.parse('I modify the coquelicot upload password to {password:w}')) -def modify_upload_password(browser, password): - application.modify_upload_password(browser, password) +def modify_upload_password(session_browser, password): + application.modify_upload_password(session_browser, password) @given(parsers.parse('share {name:w} is not available')) -def remove_share(browser, name): - application.remove_share(browser, name) +def remove_share(session_browser, name): + application.remove_share(session_browser, name) @when(parsers.parse('I add a share {name:w} from path {path} for {group:w}')) -def add_share(browser, name, path, group): - application.add_share(browser, name, path, group) +def add_share(session_browser, name, path, group): + application.add_share(session_browser, name, path, group) @when( parsers.parse( 'I edit share {old_name:w} to {new_name:w} from path {path} for {group:w}' )) -def edit_share(browser, old_name, new_name, path, group): - application.edit_share(browser, old_name, new_name, path, group) +def edit_share(session_browser, old_name, new_name, path, group): + application.edit_share(session_browser, old_name, new_name, path, group) @when(parsers.parse('I remove share {name:w}')) -def remove_share2(browser, name): - application.remove_share(browser, name) +def remove_share2(session_browser, name): + application.remove_share(session_browser, name) @when(parsers.parse('I edit share {name:w} to be public')) -def edit_share_public_access(browser, name): - application.make_share_public(browser, name) +def edit_share_public_access(session_browser, name): + application.make_share_public(session_browser, name) @then( parsers.parse( 'the share {name:w} should be listed from path {path} for {group:w}')) -def verify_share(browser, name, path, group): - application.verify_share(browser, name, path, group) +def verify_share(session_browser, name, path, group): + application.verify_share(session_browser, name, path, group) @then(parsers.parse('the share {name:w} should not be listed')) -def verify_invalid_share(browser, name): +def verify_invalid_share(session_browser, name): with pytest.raises(splinter.exceptions.ElementDoesNotExist): - application.get_share(browser, name) + application.get_share(session_browser, name) @then(parsers.parse('the share {name:w} should be accessible')) -def access_share(browser, name): - application.access_share(browser, name) +def access_share(session_browser, name): + application.access_share(session_browser, name) @then(parsers.parse('the share {name:w} should not exist')) -def verify_nonexistant_share(browser, name): - application.verify_nonexistant_share(browser, name) +def verify_nonexistant_share(session_browser, name): + application.verify_nonexistant_share(session_browser, name) @then(parsers.parse('the share {name:w} should not be accessible')) -def verify_inaccessible_share(browser, name): - application.verify_inaccessible_share(browser, name) +def verify_inaccessible_share(session_browser, name): + application.verify_inaccessible_share(session_browser, name) @when(parsers.parse('I enable mediawiki public registrations')) -def enable_mediawiki_public_registrations(browser): - application.enable_mediawiki_public_registrations(browser) +def enable_mediawiki_public_registrations(session_browser): + application.enable_mediawiki_public_registrations(session_browser) @when(parsers.parse('I disable mediawiki public registrations')) -def disable_mediawiki_public_registrations(browser): - application.disable_mediawiki_public_registrations(browser) +def disable_mediawiki_public_registrations(session_browser): + application.disable_mediawiki_public_registrations(session_browser) @when(parsers.parse('I enable mediawiki private mode')) -def enable_mediawiki_private_mode(browser): - application.enable_mediawiki_private_mode(browser) +def enable_mediawiki_private_mode(session_browser): + application.enable_mediawiki_private_mode(session_browser) @when(parsers.parse('I disable mediawiki private mode')) -def disable_mediawiki_private_mode(browser): - application.disable_mediawiki_private_mode(browser) +def disable_mediawiki_private_mode(session_browser): + application.disable_mediawiki_private_mode(session_browser) @when(parsers.parse('I set the mediawiki admin password to {password}')) -def set_mediawiki_admin_password(browser, password): - application.set_mediawiki_admin_password(browser, password) +def set_mediawiki_admin_password(session_browser, password): + application.set_mediawiki_admin_password(session_browser, password) @when(parsers.parse('I enable message archive management')) -def mediawiki_enable_archive_management(browser): - application.enable_ejabberd_message_archive_management(browser) +def ejabberd_enable_archive_management(session_browser): + application.enable_ejabberd_message_archive_management(session_browser) @when(parsers.parse('I disable message archive management')) -def mediawiki_disable_archive_management(browser): - application.disable_ejabberd_message_archive_management(browser) +def ejabberd_disable_archive_management(session_browser): + application.disable_ejabberd_message_archive_management(session_browser) @when('there is an ikiwiki wiki') -def ikiwiki_create_wiki_if_needed(browser): - application.ikiwiki_create_wiki_if_needed(browser) +def ikiwiki_create_wiki_if_needed(session_browser): + application.ikiwiki_create_wiki_if_needed(session_browser) @when('I delete the ikiwiki wiki') -def ikiwiki_delete_wiki(browser): - application.ikiwiki_delete_wiki(browser) +def ikiwiki_delete_wiki(session_browser): + application.ikiwiki_delete_wiki(session_browser) @then('the ikiwiki wiki should be restored') -def ikiwiki_should_exist(browser): - assert application.ikiwiki_wiki_exists(browser) +def ikiwiki_should_exist(session_browser): + assert application.ikiwiki_wiki_exists(session_browser) @given('I have added a contact to my roster') -def ejabberd_add_contact(browser): - application.ejabberd_add_contact(browser) +def ejabberd_add_contact(session_browser): + application.ejabberd_add_contact(session_browser) @when('I delete the contact from my roster') -def ejabberd_delete_contact(browser): - application.ejabberd_delete_contact(browser) +def ejabberd_delete_contact(session_browser): + application.ejabberd_delete_contact(session_browser) @then('I should have a contact on my roster') -def ejabberd_should_have_contact(browser): - assert application.ejabberd_has_contact(browser) +def ejabberd_should_have_contact(session_browser): + assert application.ejabberd_has_contact(session_browser) @given(parsers.parse('tor relay is {enabled:w}')) -def tor_given_relay_enable(browser, enabled): - application.tor_feature_enable(browser, 'relay', enabled) +def tor_given_relay_enable(session_browser, enabled): + application.tor_feature_enable(session_browser, 'relay', enabled) @when(parsers.parse('I {enable:w} tor relay')) -def tor_relay_enable(browser, enable): - application.tor_feature_enable(browser, 'relay', enable) +def tor_relay_enable(session_browser, enable): + application.tor_feature_enable(session_browser, 'relay', enable) @then(parsers.parse('tor relay should be {enabled:w}')) -def tor_assert_relay_enabled(browser, enabled): - application.tor_assert_feature_enabled(browser, 'relay', enabled) +def tor_assert_relay_enabled(session_browser, enabled): + application.tor_assert_feature_enabled(session_browser, 'relay', enabled) @then(parsers.parse('tor {port_name:w} port should be displayed')) -def tor_assert_port_displayed(browser, port_name): - assert port_name in application.tor_get_relay_ports(browser) +def tor_assert_port_displayed(session_browser, port_name): + assert port_name in application.tor_get_relay_ports(session_browser) @given(parsers.parse('tor bridge relay is {enabled:w}')) -def tor_given_bridge_relay_enable(browser, enabled): - application.tor_feature_enable(browser, 'bridge-relay', enabled) +def tor_given_bridge_relay_enable(session_browser, enabled): + application.tor_feature_enable(session_browser, 'bridge-relay', enabled) @when(parsers.parse('I {enable:w} tor bridge relay')) -def tor_bridge_relay_enable(browser, enable): - application.tor_feature_enable(browser, 'bridge-relay', enable) +def tor_bridge_relay_enable(session_browser, enable): + application.tor_feature_enable(session_browser, 'bridge-relay', enable) @then(parsers.parse('tor bridge relay should be {enabled:w}')) -def tor_assert_bridge_relay_enabled(browser, enabled): - application.tor_assert_feature_enabled(browser, 'bridge-relay', enabled) +def tor_assert_bridge_relay_enabled(session_browser, enabled): + application.tor_assert_feature_enabled(session_browser, 'bridge-relay', + enabled) @given(parsers.parse('tor hidden services are {enabled:w}')) -def tor_given_hidden_services_enable(browser, enabled): - application.tor_feature_enable(browser, 'hidden-services', enabled) +def tor_given_hidden_services_enable(session_browser, enabled): + application.tor_feature_enable(session_browser, 'hidden-services', enabled) @when(parsers.parse('I {enable:w} tor hidden services')) -def tor_hidden_services_enable(browser, enable): - application.tor_feature_enable(browser, 'hidden-services', enable) +def tor_hidden_services_enable(session_browser, enable): + application.tor_feature_enable(session_browser, 'hidden-services', enable) @then(parsers.parse('tor hidden services should be {enabled:w}')) -def tor_assert_hidden_services_enabled(browser, enabled): - application.tor_assert_feature_enabled(browser, 'hidden-services', enabled) +def tor_assert_hidden_services_enabled(session_browser, enabled): + application.tor_assert_feature_enabled(session_browser, 'hidden-services', + enabled) @then(parsers.parse('tor hidden services information should be displayed')) -def tor_assert_hidden_services(browser): - application.tor_assert_hidden_services(browser) +def tor_assert_hidden_services(session_browser): + application.tor_assert_hidden_services(session_browser) @given(parsers.parse('download software packages over tor is {enabled:w}')) -def tor_given_download_software_over_tor_enable(browser, enabled): - application.tor_feature_enable(browser, 'software', enabled) +def tor_given_download_software_over_tor_enable(session_browser, enabled): + application.tor_feature_enable(session_browser, 'software', enabled) @when(parsers.parse('I {enable:w} download software packages over tor')) -def tor_download_software_over_tor_enable(browser, enable): - application.tor_feature_enable(browser, 'software', enable) +def tor_download_software_over_tor_enable(session_browser, enable): + application.tor_feature_enable(session_browser, 'software', enable) @then( parsers.parse('download software packages over tor should be {enabled:w}')) -def tor_assert_download_software_over_tor(browser, enabled): - application.tor_assert_feature_enabled(browser, 'software', enabled) +def tor_assert_download_software_over_tor(session_browser, enabled): + application.tor_assert_feature_enabled(session_browser, 'software', + enabled) @then( parsers.parse( '{domain:S} should be a tahoe {introducer_type:w} introducer')) -def tahoe_assert_introducer(browser, domain, introducer_type): - assert application.tahoe_get_introducer(browser, domain, introducer_type) +def tahoe_assert_introducer(session_browser, domain, introducer_type): + assert application.tahoe_get_introducer(session_browser, domain, + introducer_type) @then( parsers.parse( '{domain:S} should not be a tahoe {introducer_type:w} introducer')) -def tahoe_assert_not_introducer(browser, domain, introducer_type): - assert not application.tahoe_get_introducer(browser, domain, +def tahoe_assert_not_introducer(session_browser, domain, introducer_type): + assert not application.tahoe_get_introducer(session_browser, domain, introducer_type) @given(parsers.parse('{domain:S} is not a tahoe introducer')) -def tahoe_given_remove_introducer(browser, domain): - if application.tahoe_get_introducer(browser, domain, 'connected'): - application.tahoe_remove_introducer(browser, domain) +def tahoe_given_remove_introducer(session_browser, domain): + if application.tahoe_get_introducer(session_browser, domain, 'connected'): + application.tahoe_remove_introducer(session_browser, domain) @when(parsers.parse('I add {domain:S} as a tahoe introducer')) -def tahoe_add_introducer(browser, domain): - application.tahoe_add_introducer(browser, domain) +def tahoe_add_introducer(session_browser, domain): + application.tahoe_add_introducer(session_browser, domain) @given(parsers.parse('{domain:S} is a tahoe introducer')) -def tahoe_given_add_introducer(browser, domain): - if not application.tahoe_get_introducer(browser, domain, 'connected'): - application.tahoe_add_introducer(browser, domain) +def tahoe_given_add_introducer(session_browser, domain): + if not application.tahoe_get_introducer(session_browser, domain, + 'connected'): + application.tahoe_add_introducer(session_browser, domain) @when(parsers.parse('I remove {domain:S} as a tahoe introducer')) -def tahoe_remove_introducer(browser, domain): - application.tahoe_remove_introducer(browser, domain) +def tahoe_remove_introducer(session_browser, domain): + application.tahoe_remove_introducer(session_browser, domain) @given('the access rights are set to "only the owner can view or make changes"' ) -def radicale_given_owner_only(browser): - application.radicale_set_access_rights(browser, 'owner_only') +def radicale_given_owner_only(session_browser): + application.radicale_set_access_rights(session_browser, 'owner_only') @given( 'the access rights are set to "any user can view, but only the owner can make changes"' ) -def radicale_given_owner_write(browser): - application.radicale_set_access_rights(browser, 'owner_write') +def radicale_given_owner_write(session_browser): + application.radicale_set_access_rights(session_browser, 'owner_write') @given('the access rights are set to "any user can view or make changes"') -def radicale_given_authenticated(browser): - application.radicale_set_access_rights(browser, 'authenticated') +def radicale_given_authenticated(session_browser): + application.radicale_set_access_rights(session_browser, 'authenticated') @when('I change the access rights to "only the owner can view or make changes"' ) -def radicale_set_owner_only(browser): - application.radicale_set_access_rights(browser, 'owner_only') +def radicale_set_owner_only(session_browser): + application.radicale_set_access_rights(session_browser, 'owner_only') @when( 'I change the access rights to "any user can view, but only the owner can make changes"' ) -def radicale_set_owner_write(browser): - application.radicale_set_access_rights(browser, 'owner_write') +def radicale_set_owner_write(session_browser): + application.radicale_set_access_rights(session_browser, 'owner_write') @when('I change the access rights to "any user can view or make changes"') -def radicale_set_authenticated(browser): - application.radicale_set_access_rights(browser, 'authenticated') +def radicale_set_authenticated(session_browser): + application.radicale_set_access_rights(session_browser, 'authenticated') @then('the access rights should be "only the owner can view or make changes"') -def radicale_check_owner_only(browser): - assert application.radicale_get_access_rights(browser) == 'owner_only' +def radicale_check_owner_only(session_browser): + assert application.radicale_get_access_rights( + session_browser) == 'owner_only' @then( 'the access rights should be "any user can view, but only the owner can make changes"' ) -def radicale_check_owner_write(browser): - assert application.radicale_get_access_rights(browser) == 'owner_write' +def radicale_check_owner_write(session_browser): + assert application.radicale_get_access_rights( + session_browser) == 'owner_write' @then('the access rights should be "any user can view or make changes"') -def radicale_check_authenticated(browser): - assert application.radicale_get_access_rights(browser) == 'authenticated' +def radicale_check_authenticated(session_browser): + assert application.radicale_get_access_rights( + session_browser) == 'authenticated' @given(parsers.parse('the openvpn application is setup')) -def openvpn_setup(browser): - application.openvpn_setup(browser) +def openvpn_setup(session_browser): + application.openvpn_setup(session_browser) @given('I download openvpn profile') -def openvpn_download_profile(browser): - return application.openvpn_download_profile(browser) +def openvpn_download_profile(session_browser): + return application.openvpn_download_profile(session_browser) @then('the openvpn profile should be downloadable') -def openvpn_profile_downloadable(browser): - application.openvpn_download_profile(browser) +def openvpn_profile_downloadable(session_browser): + application.openvpn_download_profile(session_browser) @then('the openvpn profile downloaded should be same as before') -def openvpn_profile_download_compare(browser, openvpn_download_profile): - new_profile = application.openvpn_download_profile(browser) +def openvpn_profile_download_compare(session_browser, + openvpn_download_profile): + new_profile = application.openvpn_download_profile(session_browser) assert openvpn_download_profile == new_profile @given('public access is enabled in searx') -def searx_public_access_enabled(browser): - application.searx_enable_public_access(browser) +def searx_public_access_enabled(session_browser): + application.searx_enable_public_access(session_browser) @when('I enable public access in searx') -def searx_enable_public_access(browser): - application.searx_enable_public_access(browser) +def searx_enable_public_access(session_browser): + application.searx_enable_public_access(session_browser) @when('I disable public access in searx') -def searx_disable_public_access(browser): - application.searx_disable_public_access(browser) +def searx_disable_public_access(session_browser): + application.searx_disable_public_access(session_browser) @then(parsers.parse('{app_name:w} app should be visible on the front page')) -def app_visible_on_front_page(browser, app_name): - shortcuts = application.find_on_front_page(browser, app_name) +def app_visible_on_front_page(session_browser, app_name): + shortcuts = application.find_on_front_page(session_browser, app_name) assert len(shortcuts) == 1 @then(parsers.parse('{app_name:w} app should not be visible on the front page') ) -def app_not_visible_on_front_page(browser, app_name): - shortcuts = application.find_on_front_page(browser, app_name) +def app_not_visible_on_front_page(session_browser, app_name): + shortcuts = application.find_on_front_page(session_browser, app_name) assert len(shortcuts) == 0 @given('a public repository') @given('a repository') @given('at least one repository exists') -def gitweb_repo(browser): - application.gitweb_create_repo(browser, 'Test-repo', 'public', True) +def gitweb_repo(session_browser): + application.gitweb_create_repo(session_browser, 'Test-repo', 'public', + True) @given('a private repository') -def gitweb_private_repo(browser): - application.gitweb_create_repo(browser, 'Test-repo', 'private', True) +def gitweb_private_repo(session_browser): + application.gitweb_create_repo(session_browser, 'Test-repo', 'private', + True) @given('both public and private repositories exist') -def gitweb_public_and_private_repo(browser): - application.gitweb_create_repo(browser, 'Test-repo', 'public', True) - application.gitweb_create_repo(browser, 'Test-repo2', 'private', True) +def gitweb_public_and_private_repo(session_browser): + application.gitweb_create_repo(session_browser, 'Test-repo', 'public', + True) + application.gitweb_create_repo(session_browser, 'Test-repo2', 'private', + True) @given(parsers.parse("a {access:w} repository that doesn't exist")) -def gitweb_nonexistent_repo(browser, access): - application.gitweb_delete_repo(browser, 'Test-repo', ignore_missing=True) +def gitweb_nonexistent_repo(session_browser, access): + application.gitweb_delete_repo(session_browser, 'Test-repo', + ignore_missing=True) return dict(access=access) @given('all repositories are private') -def gitweb_all_repositories_private(browser): - application.gitweb_set_all_repos_private(browser) +def gitweb_all_repositories_private(session_browser): + application.gitweb_set_all_repos_private(session_browser) @given(parsers.parse('a repository metadata:\n{metadata}')) -def gitweb_repo_metadata(browser, metadata): +def gitweb_repo_metadata(session_browser, metadata): metadata_dict = {} for item in metadata.split('\n'): item = item.split(': ') @@ -513,18 +529,18 @@ def gitweb_repo_metadata(browser, metadata): @when('I create the repository') -def gitweb_create_repo(browser, access): - application.gitweb_create_repo(browser, 'Test-repo', access) +def gitweb_create_repo(session_browser, access): + application.gitweb_create_repo(session_browser, 'Test-repo', access) @when('I delete the repository') -def gitweb_delete_repo(browser): - application.gitweb_delete_repo(browser, 'Test-repo') +def gitweb_delete_repo(session_browser): + application.gitweb_delete_repo(session_browser, 'Test-repo') @when('I set the metadata of the repository') -def gitweb_edit_repo_metadata(browser, gitweb_repo_metadata): - application.gitweb_edit_repo_metadata(browser, 'Test-repo', +def gitweb_edit_repo_metadata(session_browser, gitweb_repo_metadata): + application.gitweb_edit_repo_metadata(session_browser, 'Test-repo', gitweb_repo_metadata) @@ -535,36 +551,38 @@ def gitweb_using_git_client(): @then('the repository should be restored') @then('the repository should be listed as a public') -def gitweb_repo_should_exists(browser): - assert application.gitweb_repo_exists(browser, 'Test-repo', +def gitweb_repo_should_exists(session_browser): + assert application.gitweb_repo_exists(session_browser, 'Test-repo', access='public') @then('the repository should be listed as a private') -def gitweb_private_repo_should_exists(browser): - assert application.gitweb_repo_exists(browser, 'Test-repo', 'private') +def gitweb_private_repo_should_exists(session_browser): + assert application.gitweb_repo_exists(session_browser, 'Test-repo', + 'private') @then('the repository should not be listed') -def gitweb_repo_should_not_exist(browser, gitweb_repo): - assert not application.gitweb_repo_exists(browser, gitweb_repo) +def gitweb_repo_should_not_exist(session_browser, gitweb_repo): + assert not application.gitweb_repo_exists(session_browser, gitweb_repo) @then('the public repository should be listed on gitweb') @then('the repository should be listed on gitweb') -def gitweb_repo_should_exist_on_gitweb(browser): - assert application.gitweb_site_repo_exists(browser, 'Test-repo') +def gitweb_repo_should_exist_on_gitweb(session_browser): + assert application.gitweb_site_repo_exists(session_browser, 'Test-repo') @then('the private repository should not be listed on gitweb') -def gitweb_private_repo_should_exists_on_gitweb(browser): - assert not application.gitweb_site_repo_exists(browser, 'Test-repo2') +def gitweb_private_repo_should_exists_on_gitweb(session_browser): + assert not application.gitweb_site_repo_exists(session_browser, + 'Test-repo2') @then('the metadata of the repository should be as set') -def gitweb_repo_metadata_should_match(browser, gitweb_repo_metadata): +def gitweb_repo_metadata_should_match(session_browser, gitweb_repo_metadata): actual_metadata = application.gitweb_get_repo_metadata( - browser, 'Test-repo') + session_browser, 'Test-repo') assert all(item in actual_metadata.items() for item in gitweb_repo_metadata.items()) @@ -605,11 +623,13 @@ def gitweb_repo_privately_writable(): @when(parsers.parse('I {task:w} the {share_type:w} samba share')) -def samba_enable_share(browser, task, share_type): +def samba_enable_share(session_browser, task, share_type): if task == 'enable': - application.samba_set_share(browser, share_type, status='enabled') + application.samba_set_share(session_browser, share_type, + status='enabled') elif task == 'disable': - application.samba_set_share(browser, share_type, status='disabled') + application.samba_set_share(session_browser, share_type, + status='disabled') @then(parsers.parse('I can write to the {share_type:w} samba share')) @@ -617,12 +637,14 @@ def samba_share_should_be_writable(share_type): application.samba_assert_share_is_writable(share_type) -@then(parsers.parse('a guest user can write to the {share_type:w} samba share')) +@then(parsers.parse('a guest user can write to the {share_type:w} samba share') + ) def samba_share_should_be_writable_to_guest(share_type): application.samba_assert_share_is_writable(share_type, as_guest=True) -@then(parsers.parse('a guest user can\'t access the {share_type:w} samba share')) +@then( + parsers.parse('a guest user can\'t access the {share_type:w} samba share')) def samba_share_should_not_be_accessible_to_guest(share_type): application.samba_assert_share_is_not_accessible(share_type, as_guest=True) diff --git a/functional_tests/step_definitions/interface.py b/functional_tests/step_definitions/interface.py index 257599cea..28e12634b 100644 --- a/functional_tests/step_definitions/interface.py +++ b/functional_tests/step_definitions/interface.py @@ -23,64 +23,65 @@ default_url = config['DEFAULT']['url'] @given("I'm a logged in user") -def logged_in_user(browser): - interface.login(browser, default_url, config['DEFAULT']['username'], +def logged_in_user(session_browser): + interface.login(session_browser, default_url, + config['DEFAULT']['username'], config['DEFAULT']['password']) @given("I'm a logged out user") -def logged_out_user(browser): - browser.visit(default_url + '/plinth/accounts/logout/') +def logged_out_user(session_browser): + session_browser.visit(default_url + '/plinth/accounts/logout/') @when("I log out") -def log_out_user(browser): - browser.visit(default_url + '/plinth/accounts/logout/') +def log_out_user(session_browser): + session_browser.visit(default_url + '/plinth/accounts/logout/') @then(parsers.parse('I should be prompted for login')) -def prompted_for_login(browser): - assert interface.is_login_prompt(browser) +def prompted_for_login(session_browser): + assert interface.is_login_prompt(session_browser) @given(parsers.parse("the user {name:w} doesn't exist")) -def new_user_does_not_exist(browser, name): - interface.delete_user(browser, name) +def new_user_does_not_exist(session_browser, name): + interface.delete_user(session_browser, name) @given(parsers.parse('the user {name:w} exists')) -def test_user_exists(browser, name): - interface.nav_to_module(browser, 'users') - user_link = browser.find_link_by_href('/plinth/sys/users/' + name + - '/edit/') +def test_user_exists(session_browser, name): + interface.nav_to_module(session_browser, 'users') + user_link = session_browser.find_link_by_href('/plinth/sys/users/' + name + + '/edit/') if not user_link: - create_user(browser, name, 'secret123') + create_user(session_browser, name, 'secret123') @when( parsers.parse('I create a user named {name:w} with password {password:w}')) -def create_user(browser, name, password): - interface.create_user(browser, name, password) +def create_user(session_browser, name, password): + interface.create_user(session_browser, name, password) @when(parsers.parse('I rename the user {old_name:w} to {new_name:w}')) -def rename_user(browser, old_name, new_name): - interface.rename_user(browser, old_name, new_name) +def rename_user(session_browser, old_name, new_name): + interface.rename_user(session_browser, old_name, new_name) @when(parsers.parse('I delete the user {name:w}')) -def delete_user(browser, name): - interface.delete_user(browser, name) +def delete_user(session_browser, name): + interface.delete_user(session_browser, name) @then(parsers.parse('{name:w} should be listed as a user')) -def new_user_is_listed(browser, name): - assert interface.is_user(browser, name) +def new_user_is_listed(session_browser, name): + assert interface.is_user(session_browser, name) @then(parsers.parse('{name:w} should not be listed as a user')) -def new_user_is_not_listed(browser, name): - assert not interface.is_user(browser, name) +def new_user_is_not_listed(session_browser, name): + assert not interface.is_user(session_browser, name) @given('a sample local file') @@ -90,10 +91,10 @@ def sample_local_file(): @when('I go to the status logs page') -def help_go_to_status_logs(browser): - interface.go_to_status_logs(browser) +def help_go_to_status_logs(session_browser): + interface.go_to_status_logs(session_browser) @then('status logs should be shown') -def help_status_logs_are_shown(browser): - assert interface.are_status_logs_shown(browser) +def help_status_logs_are_shown(session_browser): + assert interface.are_status_logs_shown(session_browser) diff --git a/functional_tests/step_definitions/service.py b/functional_tests/step_definitions/service.py index 5729dd67a..9b6f351d9 100644 --- a/functional_tests/step_definitions/service.py +++ b/functional_tests/step_definitions/service.py @@ -22,30 +22,31 @@ from support.service import eventually @then(parsers.parse('the {service_name:w} service should be running')) -def service_should_be_running(browser, service_name): - assert eventually(service.is_running, args=[browser, service_name]) +def service_should_be_running(session_browser, service_name): + assert eventually(service.is_running, args=[session_browser, service_name]) @then(parsers.parse('the {service_name:w} service should not be running')) -def service_should_not_be_running(browser, service_name): - assert eventually(service.is_not_running, args=[browser, service_name]) +def service_should_not_be_running(session_browser, service_name): + assert eventually(service.is_not_running, + args=[session_browser, service_name]) @then(parsers.parse('the network time service should be running')) -def ntp_should_be_running(browser): - assert service.is_running(browser, 'ntp') +def ntp_should_be_running(session_browser): + assert service.is_running(session_browser, 'ntp') @then(parsers.parse('the network time service should not be running')) -def ntp_should_not_be_running(browser): - assert not service.is_running(browser, 'ntp') +def ntp_should_not_be_running(session_browser): + assert not service.is_running(session_browser, 'ntp') @then(parsers.parse('the service discovery service should be running')) -def avahi_should_be_running(browser): - assert service.is_running(browser, 'avahi') +def avahi_should_be_running(session_browser): + assert service.is_running(session_browser, 'avahi') @then(parsers.parse('the service discovery service should not be running')) -def avahi_should_not_be_running(browser): - assert not service.is_running(browser, 'avahi') +def avahi_should_not_be_running(session_browser): + assert not service.is_running(session_browser, 'avahi') diff --git a/functional_tests/step_definitions/site.py b/functional_tests/step_definitions/site.py index b210fb346..8a6b89dbe 100644 --- a/functional_tests/step_definitions/site.py +++ b/functional_tests/step_definitions/site.py @@ -21,47 +21,48 @@ from support import interface, site @then(parsers.parse('the {site_name:w} site should be available')) -def site_should_be_available(browser, site_name): - assert site.is_available(browser, site_name) +def site_should_be_available(session_browser, site_name): + assert site.is_available(session_browser, site_name) @then(parsers.parse('the {site_name:w} site should not be available')) -def site_should_not_be_available(browser, site_name): - assert not site.is_available(browser, site_name) +def site_should_not_be_available(session_browser, site_name): + assert not site.is_available(session_browser, site_name) @when(parsers.parse('I access {app_name:w} application')) -def access_application(browser, app_name): - site.access_url(browser, app_name) +def access_application(session_browser, app_name): + site.access_url(session_browser, app_name) @when( parsers.parse( 'I upload an image named {image:S} to mediawiki with credentials {username:w} and ' '{password:w}')) -def upload_image(browser, username, password, image): - site.upload_image_mediawiki(browser, username, password, image) +def upload_image(session_browser, username, password, image): + site.upload_image_mediawiki(session_browser, username, password, image) @then(parsers.parse('there should be {image:S} image')) -def uploaded_image_should_be_available(browser, image): - uploaded_image = site.get_uploaded_image_in_mediawiki(browser, image) +def uploaded_image_should_be_available(session_browser, image): + uploaded_image = site.get_uploaded_image_in_mediawiki( + session_browser, image) assert image.lower() == uploaded_image.lower() @then( parsers.parse( 'I should be able to login to coquelicot with password {password:w}')) -def verify_upload_password(browser, password): - site.verify_coquelicot_upload_password(browser, password) +def verify_upload_password(session_browser, password): + site.verify_coquelicot_upload_password(session_browser, password) @when( parsers.parse( 'I upload the sample local file to coquelicot with password {password:w}' )) -def coquelicot_upload_file(browser, sample_local_file, password): - url = site.upload_file_to_coquelicot(browser, +def coquelicot_upload_file(session_browser, sample_local_file, password): + url = site.upload_file_to_coquelicot(session_browser, sample_local_file['file_path'], password) sample_local_file['upload_url'] = url @@ -80,165 +81,170 @@ def coquelicot_compare_upload_download_files(sample_local_file): @then(parsers.parse('the mediawiki site should allow creating accounts')) -def mediawiki_allows_creating_accounts(browser): - site.verify_mediawiki_create_account_link(browser) +def mediawiki_allows_creating_accounts(session_browser): + site.verify_mediawiki_create_account_link(session_browser) @then(parsers.parse('the mediawiki site should not allow creating accounts')) -def mediawiki_does_not_allow_creating_accounts(browser): - site.verify_mediawiki_no_create_account_link(browser) +def mediawiki_does_not_allow_creating_accounts(session_browser): + site.verify_mediawiki_no_create_account_link(session_browser) @then( parsers.parse('the mediawiki site should allow anonymous reads and writes') ) -def mediawiki_allows_anonymous_reads_edits(browser): - site.verify_mediawiki_anonymous_reads_edits_link(browser) +def mediawiki_allows_anonymous_reads_edits(session_browser): + site.verify_mediawiki_anonymous_reads_edits_link(session_browser) @then( parsers.parse( 'the mediawiki site should not allow anonymous reads and writes')) -def mediawiki_does_not_allow__account_creation_anonymous_reads_edits(browser): - site.verify_mediawiki_no_anonymous_reads_edits_link(browser) +def mediawiki_does_not_allow__account_creation_anonymous_reads_edits( + session_browser): + site.verify_mediawiki_no_anonymous_reads_edits_link(session_browser) @then( parsers.parse( 'I should see the Upload File option in the side pane when logged in ' 'with credentials {username:w} and {password:w}')) -def login_to_mediawiki_with_credentials(browser, username, password): - site.login_to_mediawiki_with_credentials(browser, username, password) +def login_to_mediawiki_with_credentials(session_browser, username, password): + site.login_to_mediawiki_with_credentials(session_browser, username, + password) @when('I delete the mediawiki main page') -def mediawiki_delete_main_page(browser): - site.mediawiki_delete_main_page(browser) +def mediawiki_delete_main_page(session_browser): + site.mediawiki_delete_main_page(session_browser) @then('the mediawiki main page should be restored') -def mediawiki_verify_text(browser): - assert site.mediawiki_has_main_page(browser) +def mediawiki_verify_text(session_browser): + assert site.mediawiki_has_main_page(session_browser) @when('all ed2k files are removed from mldonkey') -def mldonkey_remove_all_ed2k_files(browser): - site.mldonkey_remove_all_ed2k_files(browser) +def mldonkey_remove_all_ed2k_files(session_browser): + site.mldonkey_remove_all_ed2k_files(session_browser) @when('I upload a sample ed2k file to mldonkey') -def mldonkey_upload_sample_ed2k_file(browser): - site.mldonkey_upload_sample_ed2k_file(browser) +def mldonkey_upload_sample_ed2k_file(session_browser): + site.mldonkey_upload_sample_ed2k_file(session_browser) @then( parsers.parse( 'there should be {ed2k_files_number:d} ed2k files listed in mldonkey')) -def mldonkey_assert_number_of_ed2k_files(browser, ed2k_files_number): - assert ed2k_files_number == site.mldonkey_get_number_of_ed2k_files(browser) +def mldonkey_assert_number_of_ed2k_files(session_browser, ed2k_files_number): + assert ed2k_files_number == site.mldonkey_get_number_of_ed2k_files( + session_browser) @when('all torrents are removed from transmission') -def transmission_remove_all_torrents(browser): - site.transmission_remove_all_torrents(browser) +def transmission_remove_all_torrents(session_browser): + site.transmission_remove_all_torrents(session_browser) @when('I upload a sample torrent to transmission') -def transmission_upload_sample_torrent(browser): - site.transmission_upload_sample_torrent(browser) +def transmission_upload_sample_torrent(session_browser): + site.transmission_upload_sample_torrent(session_browser) @then( parsers.parse( 'there should be {torrents_number:d} torrents listed in transmission')) -def transmission_assert_number_of_torrents(browser, torrents_number): - assert torrents_number == site.transmission_get_number_of_torrents(browser) +def transmission_assert_number_of_torrents(session_browser, torrents_number): + assert torrents_number == site.transmission_get_number_of_torrents( + session_browser) @when('all torrents are removed from deluge') -def deluge_remove_all_torrents(browser): - site.deluge_remove_all_torrents(browser) +def deluge_remove_all_torrents(session_browser): + site.deluge_remove_all_torrents(session_browser) @when('I upload a sample torrent to deluge') -def deluge_upload_sample_torrent(browser): - site.deluge_upload_sample_torrent(browser) +def deluge_upload_sample_torrent(session_browser): + site.deluge_upload_sample_torrent(session_browser) @then( parsers.parse( 'there should be {torrents_number:d} torrents listed in deluge')) -def deluge_assert_number_of_torrents(browser, torrents_number): - assert torrents_number == site.deluge_get_number_of_torrents(browser) +def deluge_assert_number_of_torrents(session_browser, torrents_number): + assert torrents_number == site.deluge_get_number_of_torrents( + session_browser) @then('the calendar should be available') -def assert_calendar_is_available(browser): - assert site.calendar_is_available(browser) +def assert_calendar_is_available(session_browser): + assert site.calendar_is_available(session_browser) @then('the calendar should not be available') -def assert_calendar_is_not_available(browser): - assert not site.calendar_is_available(browser) +def assert_calendar_is_not_available(session_browser): + assert not site.calendar_is_available(session_browser) @then('the addressbook should be available') -def assert_addressbook_is_available(browser): - assert site.addressbook_is_available(browser) +def assert_addressbook_is_available(session_browser): + assert site.addressbook_is_available(session_browser) @then('the addressbook should not be available') -def assert_addressbook_is_not_available(browser): - assert not site.addressbook_is_available(browser) +def assert_addressbook_is_not_available(session_browser): + assert not site.addressbook_is_available(session_browser) @given(parsers.parse('syncthing folder {folder_name:w} is not present')) -def syncthing_folder_not_present(browser, folder_name): - if site.syncthing_folder_is_present(browser, folder_name): - site.syncthing_remove_folder(browser, folder_name) +def syncthing_folder_not_present(session_browser, folder_name): + if site.syncthing_folder_is_present(session_browser, folder_name): + site.syncthing_remove_folder(session_browser, folder_name) @given( parsers.parse( 'folder {folder_path:S} is present as syncthing folder {folder_name:w}' )) -def syncthing_folder_present(browser, folder_name, folder_path): - if not site.syncthing_folder_is_present(browser, folder_name): - site.syncthing_add_folder(browser, folder_name, folder_path) +def syncthing_folder_present(session_browser, folder_name, folder_path): + if not site.syncthing_folder_is_present(session_browser, folder_name): + site.syncthing_add_folder(session_browser, folder_name, folder_path) @when( parsers.parse( 'I add a folder {folder_path:S} as syncthing folder {folder_name:w}')) -def syncthing_add_folder(browser, folder_name, folder_path): - site.syncthing_add_folder(browser, folder_name, folder_path) +def syncthing_add_folder(session_browser, folder_name, folder_path): + site.syncthing_add_folder(session_browser, folder_name, folder_path) @when(parsers.parse('I remove syncthing folder {folder_name:w}')) -def syncthing_remove_folder(browser, folder_name): - site.syncthing_remove_folder(browser, folder_name) +def syncthing_remove_folder(session_browser, folder_name): + site.syncthing_remove_folder(session_browser, folder_name) @then(parsers.parse('syncthing folder {folder_name:w} should be present')) -def syncthing_assert_folder_present(browser, folder_name): - assert site.syncthing_folder_is_present(browser, folder_name) +def syncthing_assert_folder_present(session_browser, folder_name): + assert site.syncthing_folder_is_present(session_browser, folder_name) @then(parsers.parse('syncthing folder {folder_name:w} should not be present')) -def syncthing_assert_folder_not_present(browser, folder_name): - assert not site.syncthing_folder_is_present(browser, folder_name) +def syncthing_assert_folder_not_present(session_browser, folder_name): + assert not site.syncthing_folder_is_present(session_browser, folder_name) @given('I subscribe to a feed in ttrss') -def ttrss_subscribe(browser): - site.ttrss_subscribe(browser) +def ttrss_subscribe(session_browser): + site.ttrss_subscribe(session_browser) @when('I unsubscribe from the feed in ttrss') -def ttrss_unsubscribe(browser): - site.ttrss_unsubscribe(browser) +def ttrss_unsubscribe(session_browser): + site.ttrss_unsubscribe(session_browser) @then('I should be subscribed to the feed in ttrss') -def ttrss_assert_subscribed(browser): - assert site.ttrss_is_subscribed(browser) +def ttrss_assert_subscribed(session_browser): + assert site.ttrss_is_subscribed(session_browser) diff --git a/functional_tests/step_definitions/system.py b/functional_tests/step_definitions/system.py index 687a706dd..de04ce5d6 100644 --- a/functional_tests/step_definitions/system.py +++ b/functional_tests/step_definitions/system.py @@ -46,68 +46,68 @@ def downloaded_file_info(): @given(parsers.parse('the home page is {app_name:w}')) -def set_home_page(browser, app_name): - system.set_home_page(browser, app_name) +def set_home_page(session_browser, app_name): + system.set_home_page(session_browser, app_name) @given(parsers.parse('the domain name is set to {domain:S}')) -def set_domain_name(browser, domain): - system.set_domain_name(browser, domain) +def set_domain_name(session_browser, domain): + system.set_domain_name(session_browser, domain) @given('advanced mode is on') -def advanced_mode_is_on(browser): - system.set_advanced_mode(browser, True) +def advanced_mode_is_on(session_browser): + system.set_advanced_mode(session_browser, True) @when(parsers.parse('I change the hostname to {hostname:w}')) -def change_hostname_to(browser, hostname): - system.set_hostname(browser, hostname) +def change_hostname_to(session_browser, hostname): + system.set_hostname(session_browser, hostname) @when(parsers.parse('I change the domain name to {domain:S}')) -def change_domain_name_to(browser, domain): - system.set_domain_name(browser, domain) +def change_domain_name_to(session_browser, domain): + system.set_domain_name(session_browser, domain) @when(parsers.parse('I change the home page to {app_name:w}')) -def change_home_page_to(browser, app_name): - system.set_home_page(browser, app_name) +def change_home_page_to(session_browser, app_name): + system.set_home_page(session_browser, app_name) @when('I change the language to ') -def change_language(browser, language): - system.set_language(browser, language_codes[language]) +def change_language(session_browser, language): + system.set_language(session_browser, language_codes[language]) @then(parsers.parse('the hostname should be {hostname:w}')) -def hostname_should_be(browser, hostname): - assert system.get_hostname(browser) == hostname +def hostname_should_be(session_browser, hostname): + assert system.get_hostname(session_browser) == hostname @then(parsers.parse('the domain name should be {domain:S}')) -def domain_name_should_be(browser, domain): - assert system.get_domain_name(browser) == domain +def domain_name_should_be(session_browser, domain): + assert system.get_domain_name(session_browser) == domain @then('Plinth language should be ') -def plinth_language_should_be(browser, language): - assert system.check_language(browser, language_codes[language]) +def plinth_language_should_be(session_browser, language): + assert system.check_language(session_browser, language_codes[language]) @given('the list of snapshots is empty') -def empty_snapshots_list(browser): - system.delete_all_snapshots(browser) +def empty_snapshots_list(session_browser): + system.delete_all_snapshots(session_browser) @when('I manually create a snapshot') -def create_snapshot(browser): - system.create_snapshot(browser) +def create_snapshot(session_browser): + system.create_snapshot(session_browser) @then(parsers.parse('there should be {count:d} snapshot in the list')) -def verify_snapshot_count(browser, count): - num_snapshots = system.get_snapshot_count(browser) +def verify_snapshot_count(session_browser, count): + num_snapshots = system.get_snapshot_count(session_browser) assert num_snapshots == count @@ -118,14 +118,14 @@ def verify_snapshot_count(browser, count): '{software_enabled:w}, hourly limit {hourly:d}, daily limit {daily:d}' ', weekly limit {weekly:d}, monthly limit {monthly:d}, yearly limit ' '{yearly:d}')) -def snapshot_given_set_configuration(browser, free_space, timeline_enabled, - software_enabled, hourly, daily, weekly, - monthly, yearly): +def snapshot_given_set_configuration(session_browser, free_space, + timeline_enabled, software_enabled, + hourly, daily, weekly, monthly, yearly): timeline_enabled = (timeline_enabled == 'enabled') software_enabled = (software_enabled == 'enabled') - system.snapshot_set_configuration(browser, free_space, timeline_enabled, - software_enabled, hourly, daily, weekly, - monthly, yearly) + system.snapshot_set_configuration(session_browser, free_space, + timeline_enabled, software_enabled, + hourly, daily, weekly, monthly, yearly) @when( @@ -135,14 +135,14 @@ def snapshot_given_set_configuration(browser, free_space, timeline_enabled, 'software snapshots {software_enabled:w}, hourly limit {hourly:d}, ' 'daily limit {daily:d}, weekly limit {weekly:d}, monthly limit ' '{monthly:d}, yearly limit {yearly:d}')) -def snapshot_set_configuration(browser, free_space, timeline_enabled, +def snapshot_set_configuration(session_browser, free_space, timeline_enabled, software_enabled, hourly, daily, weekly, monthly, yearly): timeline_enabled = (timeline_enabled == 'enabled') software_enabled = (software_enabled == 'enabled') - system.snapshot_set_configuration(browser, free_space, timeline_enabled, - software_enabled, hourly, daily, weekly, - monthly, yearly) + system.snapshot_set_configuration(session_browser, free_space, + timeline_enabled, software_enabled, + hourly, daily, weekly, monthly, yearly) @then( @@ -152,59 +152,60 @@ def snapshot_set_configuration(browser, free_space, timeline_enabled, '{software_enabled:w}, hourly limit {hourly:d}, daily limit ' '{daily:d}, weekly limit {weekly:d}, monthly limit {monthly:d}, ' 'yearly limit {yearly:d}')) -def snapshot_assert_configuration(browser, free_space, timeline_enabled, - software_enabled, hourly, daily, weekly, - monthly, yearly): +def snapshot_assert_configuration(session_browser, free_space, + timeline_enabled, software_enabled, hourly, + daily, weekly, monthly, yearly): timeline_enabled = (timeline_enabled == 'enabled') software_enabled = (software_enabled == 'enabled') assert (free_space, timeline_enabled, software_enabled, hourly, daily, weekly, monthly, - yearly) == system.snapshot_get_configuration(browser) + yearly) == system.snapshot_get_configuration(session_browser) @then(parsers.parse('the home page should be {app_name:w}')) -def home_page_should_be(browser, app_name): - assert system.check_home_page_redirect(browser, app_name) +def home_page_should_be(session_browser, app_name): + assert system.check_home_page_redirect(session_browser, app_name) @given('dynamicdns is configured') -def dynamicdns_configure(browser): - system.dynamicdns_configure(browser) +def dynamicdns_configure(session_browser): + system.dynamicdns_configure(session_browser) @when('I change the dynamicdns configuration') -def dynamicdns_change_config(browser): - system.dynamicdns_change_config(browser) +def dynamicdns_change_config(session_browser): + system.dynamicdns_change_config(session_browser) @then('dynamicdns should have the original configuration') -def dynamicdns_has_original_config(browser): - assert system.dynamicdns_has_original_config(browser) +def dynamicdns_has_original_config(session_browser): + assert system.dynamicdns_has_original_config(session_browser) @when(parsers.parse('I create a backup of the {app_name:w} app data')) -def backup_create(browser, app_name): +def backup_create(session_browser, app_name): if config.getboolean('DEFAULT', 'delete_root_backup_archives'): - system.backup_delete_root_archives(browser) - system.backup_create(browser, app_name) + system.backup_delete_root_archives(session_browser) + system.backup_create(session_browser, app_name) @when(parsers.parse('I download the latest app data backup')) -def backup_download(browser, downloaded_file_info): - file_path = system.download_latest_backup(browser) +def backup_download(session_browser, downloaded_file_info): + file_path = system.download_latest_backup(session_browser) downloaded_file_info['path'] = file_path @when(parsers.parse('I restore the {app_name:w} app data backup')) -def backup_restore(browser, app_name): - system.backup_restore(browser, app_name) +def backup_restore(session_browser, app_name): + system.backup_restore(session_browser, app_name) @when(parsers.parse('I restore the downloaded app data backup')) -def backup_restore_from_upload(browser, app_name, downloaded_file_info): +def backup_restore_from_upload(session_browser, app_name, + downloaded_file_info): path = downloaded_file_info["path"] try: - system.backup_upload_and_restore(browser, app_name, path) + system.backup_upload_and_restore(session_browser, app_name, path) except Exception as err: raise err finally: @@ -212,125 +213,128 @@ def backup_restore_from_upload(browser, app_name, downloaded_file_info): @then('pagekite should be enabled') -def pagekite_assert_enabled(browser): - assert system.pagekite_is_enabled(browser) +def pagekite_assert_enabled(session_browser): + assert system.pagekite_is_enabled(session_browser) @then('pagekite should be disabled') -def pagekite_assert_disabled(browser): - assert not system.pagekite_is_enabled(browser) +def pagekite_assert_disabled(session_browser): + assert not system.pagekite_is_enabled(session_browser) @when( parsers.parse( 'I configure pagekite with host {host:S}, port {port:d}, kite name {kite_name:S} and kite secret {kite_secret:w}' )) -def pagekite_configure(browser, host, port, kite_name, kite_secret): - system.pagekite_configure(browser, host, port, kite_name, kite_secret) +def pagekite_configure(session_browser, host, port, kite_name, kite_secret): + system.pagekite_configure(session_browser, host, port, kite_name, + kite_secret) @then( parsers.parse( 'pagekite should be configured with host {host:S}, port {port:d}, kite name {kite_name:S} and kite secret {kite_secret:w}' )) -def pagekite_assert_configured(browser, host, port, kite_name, kite_secret): +def pagekite_assert_configured(session_browser, host, port, kite_name, + kite_secret): assert (host, port, kite_name, - kite_secret) == system.pagekite_get_configuration(browser) + kite_secret) == system.pagekite_get_configuration(session_browser) @given(parsers.parse('bind forwarders are set to {forwarders}')) -def bind_given_set_forwarders(browser, forwarders): - system.bind_set_forwarders(browser, forwarders) +def bind_given_set_forwarders(session_browser, forwarders): + system.bind_set_forwarders(session_browser, forwarders) @when(parsers.parse('I set bind forwarders to {forwarders}')) -def bind_set_forwarders(browser, forwarders): - system.bind_set_forwarders(browser, forwarders) +def bind_set_forwarders(session_browser, forwarders): + system.bind_set_forwarders(session_browser, forwarders) @then(parsers.parse('bind forwarders should be {forwarders}')) -def bind_assert_forwarders(browser, forwarders): - assert system.bind_get_forwarders(browser) == forwarders +def bind_assert_forwarders(session_browser, forwarders): + assert system.bind_get_forwarders(session_browser) == forwarders @given(parsers.parse('bind DNSSEC is {enable:w}')) -def bind_given_enable_dnssec(browser, enable): +def bind_given_enable_dnssec(session_browser, enable): should_enable = (enable == 'enabled') - system.bind_enable_dnssec(browser, should_enable) + system.bind_enable_dnssec(session_browser, should_enable) @when(parsers.parse('I {enable:w} bind DNSSEC')) -def bind_enable_dnssec(browser, enable): +def bind_enable_dnssec(session_browser, enable): should_enable = (enable == 'enable') - system.bind_enable_dnssec(browser, should_enable) + system.bind_enable_dnssec(session_browser, should_enable) @then(parsers.parse('bind DNSSEC should be {enabled:w}')) -def bind_assert_dnssec(browser, enabled): - assert system.bind_get_dnssec(browser) == (enabled == 'enabled') +def bind_assert_dnssec(session_browser, enabled): + assert system.bind_get_dnssec(session_browser) == (enabled == 'enabled') @given(parsers.parse('restricted console logins are {enabled}')) -def security_given_enable_restricted_logins(browser, enabled): +def security_given_enable_restricted_logins(session_browser, enabled): should_enable = (enabled == 'enabled') - system.security_enable_restricted_logins(browser, should_enable) + system.security_enable_restricted_logins(session_browser, should_enable) @when(parsers.parse('I {enable} restricted console logins')) -def security_enable_restricted_logins(browser, enable): +def security_enable_restricted_logins(session_browser, enable): should_enable = (enable == 'enable') - system.security_enable_restricted_logins(browser, should_enable) + system.security_enable_restricted_logins(session_browser, should_enable) @then(parsers.parse('restricted console logins should be {enabled}')) -def security_assert_restricted_logins(browser, enabled): +def security_assert_restricted_logins(session_browser, enabled): enabled = (enabled == 'enabled') - assert system.security_get_restricted_logins(browser) == enabled + assert system.security_get_restricted_logins(session_browser) == enabled @given(parsers.parse('automatic upgrades are {enabled:w}')) -def upgrades_given_enable_automatic(browser, enabled): +def upgrades_given_enable_automatic(session_browser, enabled): should_enable = (enabled == 'enabled') - system.upgrades_enable_automatic(browser, should_enable) + system.upgrades_enable_automatic(session_browser, should_enable) @when(parsers.parse('I {enable:w} automatic upgrades')) -def upgrades_enable_automatic(browser, enable): +def upgrades_enable_automatic(session_browser, enable): should_enable = (enable == 'enable') - system.upgrades_enable_automatic(browser, should_enable) + system.upgrades_enable_automatic(session_browser, should_enable) @then(parsers.parse('automatic upgrades should be {enabled:w}')) -def upgrades_assert_automatic(browser, enabled): +def upgrades_assert_automatic(session_browser, enabled): should_be_enabled = (enabled == 'enabled') - assert system.upgrades_get_automatic(browser) == should_be_enabled + assert system.upgrades_get_automatic(session_browser) == should_be_enabled @given( parsers.parse( 'the {key_type:w} key for {domain:S} is imported in monkeysphere')) -def monkeysphere_given_import_key(browser, key_type, domain): - system.monkeysphere_import_key(browser, key_type.lower(), domain) +def monkeysphere_given_import_key(session_browser, key_type, domain): + system.monkeysphere_import_key(session_browser, key_type.lower(), domain) @when(parsers.parse('I import {key_type:w} key for {domain:S} in monkeysphere') ) -def monkeysphere_import_key(browser, key_type, domain): - system.monkeysphere_import_key(browser, key_type.lower(), domain) +def monkeysphere_import_key(session_browser, key_type, domain): + system.monkeysphere_import_key(session_browser, key_type.lower(), domain) @then( parsers.parse( 'the {key_type:w} key should imported for {domain:S} in monkeysphere')) -def monkeysphere_assert_imported_key(browser, key_type, domain): - system.monkeysphere_assert_imported_key(browser, key_type.lower(), domain) +def monkeysphere_assert_imported_key(session_browser, key_type, domain): + system.monkeysphere_assert_imported_key(session_browser, key_type.lower(), + domain) @then( parsers.parse('I should be able to publish {key_type:w} key for ' '{domain:S} in monkeysphere')) -def monkeysphere_publish_key(browser, key_type, domain): - system.monkeysphere_publish_key(browser, key_type.lower(), domain) +def monkeysphere_publish_key(session_browser, key_type, domain): + system.monkeysphere_publish_key(session_browser, key_type.lower(), domain) @when(parsers.parse('I wait for {seconds} seconds')) @@ -340,15 +344,15 @@ def sleep_for(seconds): @when(parsers.parse('I open the main page')) -def open_main_page(browser): - system.open_main_page(browser) +def open_main_page(session_browser): + system.open_main_page(session_browser) @then(parsers.parse('the main page should be shown')) -def main_page_is_shown(browser): - assert (browser.url.endswith('/plinth/')) +def main_page_is_shown(session_browser): + assert (session_browser.url.endswith('/plinth/')) @given(parsers.parse('the network device is in the {zone:w} firewall zone')) -def networks_set_firewall_zone(browser, zone): - system.networks_set_firewall_zone(browser, zone) +def networks_set_firewall_zone(session_browser, zone): + system.networks_set_firewall_zone(session_browser, zone) diff --git a/functional_tests/support/interface.py b/functional_tests/support/interface.py index a24064782..e2f928a1a 100644 --- a/functional_tests/support/interface.py +++ b/functional_tests/support/interface.py @@ -36,10 +36,11 @@ default_url = config['DEFAULT']['url'] def login(browser, url, username, password): - browser.visit(url) - # XXX browser.visit goes to the web page with no cookies, - # hence there should be some kind of session storage for this to work + browser.visit(url) + apps_link = browser.find_link_by_href('/plinth/apps/') + if len(apps_link): + return login_button = browser.find_link_by_href('/plinth/accounts/login/') if login_button: diff --git a/functional_tests/support/site.py b/functional_tests/support/site.py index e4f8dac8f..c715b4fd4 100644 --- a/functional_tests/support/site.py +++ b/functional_tests/support/site.py @@ -85,15 +85,17 @@ def upload_file_to_coquelicot(browser, file_path, password): def verify_mediawiki_create_account_link(browser): - browser.visit(config['DEFAULT']['url'] + '/mediawiki') + browser.visit(config['DEFAULT']['url'] + + '/mediawiki/index.php/Special:CreateAccount') assert eventually(browser.is_element_present_by_id, - args=['pt-createaccount']) + args=['wpCreateaccount']) def verify_mediawiki_no_create_account_link(browser): - browser.visit(config['DEFAULT']['url'] + '/mediawiki') + browser.visit(config['DEFAULT']['url'] + + '/mediawiki/index.php/Special:CreateAccount') assert eventually(browser.is_element_not_present_by_id, - args=['pt-createaccount']) + args=['wpCreateaccount']) def verify_mediawiki_anonymous_reads_edits_link(browser):