def test_backup_restore(session_browser):
"""Test backup and restore of configuration."""
_set_configuration(session_browser,
free_space=30,
timeline_enabled=False,
software_enabled=False,
hourly=10,
daily=3,
weekly=2,
monthly=2,
yearly=0)
functional.backup_create(session_browser, 'snapshot', 'test_snapshot')
_set_configuration(session_browser,
free_space=20,
timeline_enabled=True,
software_enabled=True,
hourly=3,
daily=2,
weekly=1,
monthly=1,
yearly=1)
functional.backup_restore(session_browser, 'snapshot', 'test_snapshot')
assert _get_configuration(session_browser) == (30, False, False, 10, 3, 2,
2, 0)
def test_backup_restore(self, session_browser):
"""Test backing up and restoring."""
_set_share(session_browser, 'home', status='enabled')
functional.backup_create(session_browser, 'samba', 'test_samba')
_set_share(session_browser, 'home', status='disabled')
functional.backup_restore(session_browser, 'samba', 'test_samba')
assert functional.service_is_running(session_browser, 'samba')
_assert_share_is_writable('home')
def test_backup_restore(self, session_browser):
"""Test backing up and restoring."""
functional.app_enable(session_browser, 'calibre')
_add_library(session_browser, 'FunctionalTest')
functional.backup_create(session_browser, 'calibre', 'test_calibre')
_delete_library(session_browser, 'FunctionalTest')
functional.backup_restore(session_browser, 'calibre', 'test_calibre')
assert _is_library_available(session_browser, 'FunctionalTest')
def test_backup_restore(self, session_browser):
"""Test backing up and restoring."""
_create_repo(session_browser, 'Test-repo', ok_if_exists=True)
functional.backup_create(session_browser, 'gitweb', 'test_gitweb')
_delete_repo(session_browser, 'Test-repo')
functional.backup_restore(session_browser, 'gitweb', 'test_gitweb')
assert _repo_exists(session_browser, 'Test-repo')
assert functional.is_available(session_browser, 'gitweb')
def test_browser_waits_after_restore(session_browser):
"""Test that browser waits for redirect after restoring a backup."""
functional.backup_create(session_browser, 'bind', 'test_backups')
functional.backup_restore(session_browser, 'bind', 'test_backups')
_open_main_page(session_browser)
time.sleep(5)
_assert_main_page_is_shown(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore of app data."""
functional.app_enable(session_browser, 'openvpn')
profile = _download_profile(session_browser)
functional.backup_create(session_browser, 'openvpn', 'test_openvpn')
functional.backup_restore(session_browser, 'openvpn', 'test_openvpn')
_profile_download_compare(session_browser, profile)
def test_backup(session_browser):
"""Test backing up and restoring."""
functional.app_enable(session_browser, 'wordpress')
_write_post(session_browser, 'FunctionalTest')
functional.backup_create(session_browser, 'wordpress', 'test_wordpress')
_delete_post(session_browser, 'FunctionalTest')
functional.backup_restore(session_browser, 'wordpress', 'test_wordpress')
assert _get_post(session_browser, 'FunctionalTest')
def test_backup_restore(session_browser):
"""Test backup and restore of configuration."""
_enable_restricted_logins(session_browser, True)
functional.backup_create(session_browser, 'security', 'test_security')
_enable_restricted_logins(session_browser, False)
functional.backup_restore(session_browser, 'security', 'test_security')
assert _get_restricted_logins(session_browser)
def test_backup_restore(session_browser):
"""Test backup and restore of configuration."""
_enable_automatic(session_browser, True)
functional.backup_create(session_browser, 'upgrades', 'test_upgrades')
_enable_automatic(session_browser, False)
functional.backup_restore(session_browser, 'upgrades', 'test_upgrades')
assert _get_automatic(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore of app data."""
functional.app_enable(session_browser, 'ejabberd')
_jsxc_add_contact(session_browser)
functional.backup_create(session_browser, 'ejabberd', 'test_ejabberd')
_jsxc_delete_contact(session_browser)
functional.backup_restore(session_browser, 'ejabberd', 'test_ejabberd')
_jsxc_assert_has_contact(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore of app data."""
functional.app_enable(session_browser, 'ikiwiki')
_create_wiki_if_needed(session_browser)
functional.backup_create(session_browser, 'ikiwiki', 'test_ikiwiki')
_delete_wiki(session_browser)
functional.backup_restore(session_browser, 'ikiwiki', 'test_ikiwiki')
assert _wiki_exists(session_browser)
def test_backup_and_restore(self, session_browser):
functional.app_enable(session_browser, 'bepasty')
password_added = _add_and_save_password(session_browser)
functional.backup_create(session_browser, 'bepasty', 'test_bepasty')
_remove_all_passwords(session_browser)
functional.backup_restore(session_browser, 'bepasty', 'test_bepasty')
assert functional.is_available(session_browser, 'bepasty')
assert _can_login(session_browser, password_added)
def test_backup_restore(session_browser):
"""Test backup and restore of configuration."""
_configure(session_browser, _configs['gnudip1'])
functional.backup_create(session_browser, 'dynamicdns',
'test_dynamicdns')
_configure(session_browser, _configs['gnudip2'])
functional.backup_restore(session_browser, 'dynamicdns',
'test_dynamicdns')
_assert_has_config(session_browser, _configs['gnudip1'])
def test_backup_restore(session_browser):
"""Test backup and restore."""
_remove_share(session_browser, 'tmp')
_add_share(session_browser, 'tmp', '/tmp', 'admin')
functional.backup_create(session_browser, 'sharing', 'test_sharing')
_remove_share(session_browser, 'tmp')
functional.backup_restore(session_browser, 'sharing', 'test_sharing')
_verify_share(session_browser, 'tmp', '/tmp', 'admin')
_access_share(session_browser, 'tmp')
def test_backup_restore(self, session_browser):
"""Test backup and restore of configuration."""
functional.app_enable(session_browser, 'radicale')
_set_access_rights(session_browser, 'owner_only')
functional.backup_create(session_browser, 'radicale', 'test_radicale')
_set_access_rights(session_browser, 'owner_write')
functional.backup_restore(session_browser, 'radicale', 'test_radicale')
assert functional.service_is_running(session_browser, 'radicale')
assert _get_access_rights(session_browser) == 'owner_only'
def test_backup_restore(session_browser):
"""Test backup and restore of app data."""
functional.app_enable(session_browser, APP_ID)
_subscribe(session_browser)
functional.backup_create(session_browser, APP_ID, 'test_ttrss')
_unsubscribe(session_browser)
functional.backup_restore(session_browser, APP_ID, 'test_ttrss')
assert functional.service_is_running(session_browser, APP_ID)
assert _is_subscribed(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore."""
functional.app_enable(session_browser, 'deluge')
_remove_all_torrents(session_browser)
_upload_sample_torrent(session_browser)
functional.backup_create(session_browser, 'deluge', 'test_deluge')
_remove_all_torrents(session_browser)
functional.backup_restore(session_browser, 'deluge', 'test_deluge')
assert functional.service_is_running(session_browser, 'deluge')
assert _get_number_of_torrents(session_browser) == 1
def test_backup_restore(self, session_browser):
"""Test backup and restore."""
functional.app_enable(session_browser, 'bind')
functional.set_forwarders(session_browser, '1.1.1.1')
_enable_dnssec(session_browser, False)
functional.backup_create(session_browser, 'bind', 'test_bind')
functional.set_forwarders(session_browser, '1.0.0.1')
_enable_dnssec(session_browser, True)
functional.backup_restore(session_browser, 'bind', 'test_bind')
assert functional.get_forwarders(session_browser) == '1.1.1.1'
assert not _get_dnssec(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore of configuration."""
_configure(session_browser, 'example.com', 'beforebackup123')
functional.backup_create(session_browser, 'shadowsocks',
'test_shadowsocks')
_configure(session_browser, 'example.org', 'afterbackup123')
functional.backup_restore(session_browser, 'shadowsocks',
'test_shadowsocks')
assert functional.service_is_running(session_browser, 'shadowsocks')
assert _get_configuration(session_browser) == ('example.com',
'beforebackup123')
def test_backup_restore(self, session_browser):
"""Test backup and restore of app data."""
functional.app_enable(session_browser, 'transmission')
_remove_all_torrents(session_browser)
_upload_sample_torrent(session_browser)
functional.backup_create(session_browser, 'transmission',
'test_transmission')
_remove_all_torrents(session_browser)
functional.backup_restore(session_browser, 'transmission',
'test_transmission')
assert functional.service_is_running(session_browser, 'transmission')
_assert_number_of_torrents(session_browser, 1)
def test_backup_restore(self, session_browser):
"""Test backup and restore of configuration."""
functional.app_enable(session_browser, 'pagekite')
_configure(session_browser, 'beforebackup.example.com', 8081,
'beforebackup.example.com', 'beforebackupsecret')
functional.backup_create(session_browser, 'pagekite', 'test_pagekite')
_configure(session_browser, 'afterbackup.example.com', 8082,
'afterbackup.example.com', 'afterbackupsecret')
functional.backup_restore(session_browser, 'pagekite', 'test_pagekite')
assert functional.service_is_running(session_browser, 'pagekite')
assert ('beforebackup.example.com', 8081, 'beforebackup.example.com',
'beforebackupsecret') == _get_configuration(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore of app data."""
functional.app_enable(session_browser, self.app_name)
if _folder_is_present(session_browser, 'Test'):
_remove_folder(session_browser, 'Test')
_add_folder(session_browser, 'Test', '/tmp')
functional.backup_create(session_browser, self.app_name,
'test_syncthing')
_remove_folder(session_browser, 'Test')
functional.backup_restore(session_browser, self.app_name,
'test_syncthing')
assert _folder_is_present(session_browser, 'Test')
def test_backup_restore(self, session_browser):
"""Test backup and restore of pages and images."""
if not _image_exists(session_browser, 'Noise.png'):
_upload_image(session_browser, 'admin', 'whatever123', 'Noise.png')
functional.backup_create(session_browser, 'mediawiki',
'test_mediawiki')
_enable_public_registrations(session_browser)
_delete_image(session_browser, 'admin', 'whatever123', 'Noise.png')
_delete_main_page(session_browser, 'admin', 'whatever123')
functional.backup_restore(session_browser, 'mediawiki',
'test_mediawiki')
assert _has_main_page(session_browser)
assert _image_exists(session_browser, 'Noise.png')
_verify_create_account_link(session_browser)
def test_backup_restore(self, session_browser):
"""Test backup and restore of configuration."""
functional.app_enable(session_browser, 'tor')
_feature_enable(session_browser, 'relay', should_enable=True)
_feature_enable(session_browser, 'bridge-relay', should_enable=True)
_feature_enable(session_browser, 'hidden-services', should_enable=True)
functional.backup_create(session_browser, 'tor', 'test_tor')
_feature_enable(session_browser, 'relay', should_enable=False)
_feature_enable(session_browser,
'hidden-services',
should_enable=False)
functional.backup_restore(session_browser, 'tor', 'test_tor')
assert functional.service_is_running(session_browser, 'tor')
_assert_feature_enabled(session_browser, 'relay', enabled=True)
_assert_feature_enabled(session_browser, 'bridge-relay', enabled=True)
_assert_feature_enabled(session_browser,
'hidden-services',
enabled=True)
def backup_restore(session_browser, app_name, archive_name):
functional.backup_restore(session_browser, app_name, archive_name)
def test_backup(session_browser):
"""Test backing up and restoring."""
functional.backup_create(session_browser, 'jsxc', 'test_jsxc')
functional.backup_restore(session_browser, 'jsxc', 'test_jsxc')
assert functional.is_available(session_browser, 'jsxc')
def test_backup_restore(session_browser):
"""Test backup and restore."""
functional.app_enable(session_browser, 'searx')
functional.backup_create(session_browser, 'searx', 'test_searx')
functional.backup_restore(session_browser, 'searx', 'test_searx')
assert functional.is_available(session_browser, 'searx')
