mirror of
https://github.com/freedombox/FreedomBox.git
synced 2026-03-11 09:04:54 +00:00
functional-tests: Login only once per session
Signed-off-by: Joseph Nuthalapati <njoseph@riseup.net> [sunil: Fix fixture name for searx] Signed-off-by: Sunil Mohan Adapa <sunil@medhas.org> Reviewed-by: Sunil Mohan Adapa <sunil@medhas.org>
This commit is contained in:
Joseph Nuthalapati
Sunil Mohan Adapa
parent
420e3846a0
commit
ce906b1fef
@ -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)
|
||||
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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')
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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 <language>')
|
||||
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 <language>')
|
||||
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)
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user