diff options
Diffstat (limited to 'testing/firefox-ui')
81 files changed, 4705 insertions, 0 deletions
diff --git a/testing/firefox-ui/.flake8 b/testing/firefox-ui/.flake8 new file mode 100644 index 000000000..ad0819adf --- /dev/null +++ b/testing/firefox-ui/.flake8 @@ -0,0 +1,3 @@ +[flake8] +max-line-length = 99 +exclude = __init__.py, diff --git a/testing/firefox-ui/harness/MANIFEST.in b/testing/firefox-ui/harness/MANIFEST.in new file mode 100644 index 000000000..cf628b039 --- /dev/null +++ b/testing/firefox-ui/harness/MANIFEST.in @@ -0,0 +1,2 @@ +exclude MANIFEST.in +include requirements.txt diff --git a/testing/firefox-ui/harness/firefox_ui_harness/__init__.py b/testing/firefox-ui/harness/firefox_ui_harness/__init__.py new file mode 100644 index 000000000..02ae10cdf --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/__init__.py @@ -0,0 +1,8 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +__version__ = '1.4.0' + +import cli_functional +import cli_update diff --git a/testing/firefox-ui/harness/firefox_ui_harness/arguments/__init__.py b/testing/firefox-ui/harness/firefox_ui_harness/arguments/__init__.py new file mode 100644 index 000000000..57dc77f60 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/arguments/__init__.py @@ -0,0 +1,6 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_ui_harness.arguments.base import FirefoxUIArguments +from firefox_ui_harness.arguments.update import UpdateArguments diff --git a/testing/firefox-ui/harness/firefox_ui_harness/arguments/base.py b/testing/firefox-ui/harness/firefox_ui_harness/arguments/base.py new file mode 100644 index 000000000..e6427e764 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/arguments/base.py @@ -0,0 +1,18 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from marionette_harness import BaseMarionetteArguments + + +class FirefoxUIBaseArguments(object): + name = 'Firefox UI Tests' + args = [] + + +class FirefoxUIArguments(BaseMarionetteArguments): + + def __init__(self, **kwargs): + super(FirefoxUIArguments, self).__init__(**kwargs) + + self.register_argument_container(FirefoxUIBaseArguments()) diff --git a/testing/firefox-ui/harness/firefox_ui_harness/arguments/update.py b/testing/firefox-ui/harness/firefox_ui_harness/arguments/update.py new file mode 100644 index 000000000..9b6d3e5e0 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/arguments/update.py @@ -0,0 +1,65 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from base import FirefoxUIArguments + + +class UpdateBaseArguments(object): + name = 'Firefox UI Update Tests' + args = [ + [['--update-allow-mar-channel'], { + 'dest': 'update_mar_channels', + 'default': [], + 'action': 'append', + 'metavar': 'MAR_CHANNEL', + 'help': 'Additional MAR channel to be allowed for updates, ' + 'e.g. "firefox-mozilla-beta" for updating a release ' + 'build to the latest beta build.' + }], + [['--update-channel'], { + 'dest': 'update_channel', + 'metavar': 'CHANNEL', + 'help': 'Channel to use for the update check.' + }], + [['--update-direct-only'], { + 'dest': 'update_direct_only', + 'default': False, + 'action': 'store_true', + 'help': 'Only perform a direct update' + }], + [['--update-fallback-only'], { + 'dest': 'update_fallback_only', + 'default': False, + 'action': 'store_true', + 'help': 'Only perform a fallback update' + }], + [['--update-override-url'], { + 'dest': 'update_override_url', + 'metavar': 'URL', + 'help': 'Force specified URL to use for update checks.' + }], + [['--update-target-version'], { + 'dest': 'update_target_version', + 'metavar': 'VERSION', + 'help': 'Version of the updated build.' + }], + [['--update-target-buildid'], { + 'dest': 'update_target_buildid', + 'metavar': 'BUILD_ID', + 'help': 'Build ID of the updated build.' + }], + ] + + def verify_usage_handler(self, args): + if args.update_direct_only and args.update_fallback_only: + raise ValueError('Arguments --update-direct-only and --update-fallback-only ' + 'are mutually exclusive.') + + +class UpdateArguments(FirefoxUIArguments): + + def __init__(self, **kwargs): + super(UpdateArguments, self).__init__(**kwargs) + + self.register_argument_container(UpdateBaseArguments()) diff --git a/testing/firefox-ui/harness/firefox_ui_harness/cli_functional.py b/testing/firefox-ui/harness/firefox_ui_harness/cli_functional.py new file mode 100644 index 000000000..e83d88b51 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/cli_functional.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python + +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from marionette_harness.runtests import cli as mn_cli + +from firefox_ui_harness.arguments import FirefoxUIArguments +from firefox_ui_harness.runners import FirefoxUITestRunner + + +def cli(args=None): + mn_cli(runner_class=FirefoxUITestRunner, + parser_class=FirefoxUIArguments, + args=args, + ) + + +if __name__ == '__main__': + cli() diff --git a/testing/firefox-ui/harness/firefox_ui_harness/cli_update.py b/testing/firefox-ui/harness/firefox_ui_harness/cli_update.py new file mode 100644 index 000000000..27446a099 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/cli_update.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python + +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from marionette_harness.runtests import cli as mn_cli + +from firefox_ui_harness.arguments import UpdateArguments +from firefox_ui_harness.runners import UpdateTestRunner + + +def cli(args=None): + mn_cli(runner_class=UpdateTestRunner, + parser_class=UpdateArguments, + args=args, + ) + + +if __name__ == '__main__': + cli() diff --git a/testing/firefox-ui/harness/firefox_ui_harness/runners/__init__.py b/testing/firefox-ui/harness/firefox_ui_harness/runners/__init__.py new file mode 100644 index 000000000..9022a45b8 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/runners/__init__.py @@ -0,0 +1,6 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_ui_harness.runners.base import FirefoxUITestRunner +from firefox_ui_harness.runners.update import UpdateTestRunner diff --git a/testing/firefox-ui/harness/firefox_ui_harness/runners/base.py b/testing/firefox-ui/harness/firefox_ui_harness/runners/base.py new file mode 100644 index 000000000..66c2a5308 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/runners/base.py @@ -0,0 +1,45 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import shutil +import tempfile + +import mozfile +import mozinfo + +from marionette_harness import BaseMarionetteTestRunner, MarionetteTestCase + + +class FirefoxUITestRunner(BaseMarionetteTestRunner): + + def __init__(self, **kwargs): + super(FirefoxUITestRunner, self).__init__(**kwargs) + + # select the appropriate GeckoInstance + self.app = 'fxdesktop' + + self.test_handlers = [MarionetteTestCase] + + def duplicate_application(self, application_folder): + """Creates a copy of the specified binary.""" + + if self.workspace: + target_folder = os.path.join(self.workspace_path, 'application.copy') + else: + target_folder = tempfile.mkdtemp('.application.copy') + + self.logger.info('Creating a copy of the application at "%s".' % target_folder) + mozfile.remove(target_folder) + shutil.copytree(application_folder, target_folder) + + return target_folder + + def get_application_folder(self, binary): + """Returns the directory of the application.""" + if mozinfo.isMac: + end_index = binary.find('.app') + 4 + return binary[:end_index] + else: + return os.path.dirname(binary) diff --git a/testing/firefox-ui/harness/firefox_ui_harness/runners/update.py b/testing/firefox-ui/harness/firefox_ui_harness/runners/update.py new file mode 100644 index 000000000..fe4936f68 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/runners/update.py @@ -0,0 +1,101 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import sys + +import mozfile +import mozinstall + +from firefox_ui_harness.runners import FirefoxUITestRunner +from firefox_ui_harness.testcases import UpdateTestCase + + +DEFAULT_PREFS = { + # Bug 1355026: Re-enable when support for the new simplified UI update is available + 'app.update.doorhanger': False, + 'app.update.log': True, + 'startup.homepage_override_url': 'about:blank', +} + + +class UpdateTestRunner(FirefoxUITestRunner): + + def __init__(self, **kwargs): + super(UpdateTestRunner, self).__init__(**kwargs) + + self.original_bin = self.bin + + self.prefs.update(DEFAULT_PREFS) + + # In case of overriding the update URL, set the appropriate preference + override_url = kwargs.pop('update_override_url', None) + if override_url: + self.prefs.update({'app.update.url.override': override_url}) + + self.run_direct_update = not kwargs.pop('update_fallback_only', False) + self.run_fallback_update = not kwargs.pop('update_direct_only', False) + + self.test_handlers = [UpdateTestCase] + + def run_tests(self, tests): + # Used to store the last occurred exception because we execute + # run_tests() multiple times + self.exc_info = None + + failed = 0 + source_folder = self.get_application_folder(self.original_bin) + + results = {} + + def _run_tests(tags): + application_folder = None + + try: + # Backup current tags + test_tags = self.test_tags + + application_folder = self.duplicate_application(source_folder) + self.bin = mozinstall.get_binary(application_folder, 'Firefox') + + self.test_tags = tags + super(UpdateTestRunner, self).run_tests(tests) + + except Exception: + self.exc_info = sys.exc_info() + self.logger.error('Failure during execution of the update test.', + exc_info=self.exc_info) + + finally: + self.test_tags = test_tags + + self.logger.info('Removing copy of the application at "%s"' % application_folder) + try: + mozfile.remove(application_folder) + except IOError as e: + self.logger.error('Cannot remove copy of application: "%s"' % str(e)) + + # Run direct update tests if wanted + if self.run_direct_update: + _run_tests(tags=['direct']) + failed += self.failed + results['Direct'] = False if self.failed else True + + # Run fallback update tests if wanted + if self.run_fallback_update: + _run_tests(tags=['fallback']) + failed += self.failed + results['Fallback'] = False if self.failed else True + + self.logger.info("Summary of update tests:") + for test_type, result in results.iteritems(): + self.logger.info("\t%s update test ran and %s" % + (test_type, 'PASSED' if result else 'FAILED')) + + # Combine failed tests for all run_test() executions + self.failed = failed + + # If exceptions happened, re-throw the last one + if self.exc_info: + ex_type, exception, tb = self.exc_info + raise ex_type, exception, tb diff --git a/testing/firefox-ui/harness/firefox_ui_harness/testcases.py b/testing/firefox-ui/harness/firefox_ui_harness/testcases.py new file mode 100644 index 000000000..abcbd6555 --- /dev/null +++ b/testing/firefox-ui/harness/firefox_ui_harness/testcases.py @@ -0,0 +1,420 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import pprint +from datetime import datetime + +import mozfile + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.api.software_update import SoftwareUpdate +from firefox_puppeteer.ui.update_wizard import UpdateWizardDialog +from marionette_driver import Wait +from marionette_driver.errors import NoSuchWindowException +from marionette_harness import MarionetteTestCase + + +class UpdateTestCase(PuppeteerMixin, MarionetteTestCase): + + TIMEOUT_UPDATE_APPLY = 300 + TIMEOUT_UPDATE_CHECK = 30 + TIMEOUT_UPDATE_DOWNLOAD = 720 + + # For the old update wizard, the errors are displayed inside the dialog. For the + # handling of updates in the about window the errors are displayed in new dialogs. + # When the old wizard is open we have to set the preference, so the errors will be + # shown as expected, otherwise we would have unhandled modal dialogs when errors are + # raised. See: + # http://mxr.mozilla.org/mozilla-central/source/toolkit/mozapps/update/nsUpdateService.js?rev=a9240b1eb2fb#4813 + # http://mxr.mozilla.org/mozilla-central/source/toolkit/mozapps/update/nsUpdateService.js?rev=a9240b1eb2fb#4756 + PREF_APP_UPDATE_ALTWINDOWTYPE = 'app.update.altwindowtype' + + def __init__(self, *args, **kwargs): + super(UpdateTestCase, self).__init__(*args, **kwargs) + + self.update_channel = kwargs.pop('update_channel') + self.update_mar_channels = set(kwargs.pop('update_mar_channels')) + + self.target_buildid = kwargs.pop('update_target_buildid') + self.target_version = kwargs.pop('update_target_version') + + def setUp(self, is_fallback=False): + super(UpdateTestCase, self).setUp() + + self.software_update = SoftwareUpdate(self.marionette) + self.download_duration = None + + # If a custom update channel has to be set, force a restart of + # Firefox to actually get it applied as a default pref. Use the clean + # option to force a non in_app restart, which would allow Firefox to + # dump the logs to the console. + if self.update_channel: + self.software_update.update_channel = self.update_channel + self.restart(clean=True) + + self.assertEqual(self.software_update.update_channel, self.update_channel) + + # If requested modify the list of allowed MAR channels + if self.update_mar_channels: + self.software_update.mar_channels.add_channels(self.update_mar_channels) + + self.assertTrue(self.update_mar_channels.issubset( + self.software_update.mar_channels.channels), + 'Allowed MAR channels have been set: expected "{}" in "{}"'.format( + ', '.join(self.update_mar_channels), + ', '.join(self.software_update.mar_channels.channels))) + + # Ensure that there exists no already partially downloaded update + self.remove_downloaded_update() + + # Dictionary which holds the information for each update + self.update_status = { + 'build_pre': self.software_update.build_info, + 'build_post': None, + 'fallback': is_fallback, + 'patch': {}, + 'success': False, + } + + # Check if the user has permissions to run the update + self.assertTrue(self.software_update.allowed, + 'Current user has permissions to update the application.') + + def tearDown(self): + try: + self.browser.tabbar.close_all_tabs([self.browser.tabbar.selected_tab]) + + # Add content of the update log file for detailed failures when applying an update + self.update_status['update_log'] = self.read_update_log() + + # Print results for now until we have treeherder integration + output = pprint.pformat(self.update_status) + self.logger.info('Update test results: \n{}'.format(output)) + finally: + super(UpdateTestCase, self).tearDown() + + # Ensure that no trace of an partially downloaded update remain + self.remove_downloaded_update() + + @property + def patch_info(self): + """ Returns information about the active update in the queue. + + :returns: A dictionary with information about the active patch + """ + patch = self.software_update.patch_info + patch['download_duration'] = self.download_duration + + return patch + + def check_for_updates(self, about_window, timeout=TIMEOUT_UPDATE_CHECK): + """Clicks on "Check for Updates" button, and waits for check to complete. + + :param about_window: Instance of :class:`AboutWindow`. + :param timeout: How long to wait for the update check to finish. Optional, + defaults to 60s. + + :returns: True, if an update is available. + """ + self.assertEqual(about_window.deck.selected_panel, + about_window.deck.check_for_updates) + + about_window.deck.check_for_updates.button.click() + Wait(self.marionette, timeout=self.TIMEOUT_UPDATE_CHECK).until( + lambda _: about_window.deck.selected_panel not in + (about_window.deck.check_for_updates, about_window.deck.checking_for_updates), + message='Check for updates has been finished.') + + return about_window.deck.selected_panel != about_window.deck.no_updates_found + + def check_update_applied(self): + """Check that the update has been applied correctly""" + self.update_status['build_post'] = self.software_update.build_info + + # Ensure that the target version is the same or higher. No downgrade + # should have happened. + version_check = self.marionette.execute_script(""" + Components.utils.import("resource://gre/modules/Services.jsm"); + + return Services.vc.compare(arguments[0], arguments[1]); + """, script_args=(self.update_status['build_post']['version'], + self.update_status['build_pre']['version'])) + + self.assertGreaterEqual(version_check, 0, + 'A downgrade from version {} to {} is not allowed'.format( + self.update_status['build_pre']['version'], + self.update_status['build_post']['version'])) + + self.assertNotEqual(self.update_status['build_post']['buildid'], + self.update_status['build_pre']['buildid'], + 'The staged update to buildid {} has not been applied'.format( + self.update_status['patch']['buildid'])) + + self.assertEqual(self.update_status['build_post']['buildid'], + self.update_status['patch']['buildid'], + 'Unexpected target buildid after applying the patch, {} != {}'.format( + self.update_status['build_post']['buildid'], + self.update_status['patch']['buildid'])) + + self.assertEqual(self.update_status['build_post']['locale'], + self.update_status['build_pre']['locale'], + 'Unexpected change of the locale from {} to {}'.format( + self.update_status['build_pre']['locale'], + self.update_status['build_post']['locale'])) + + self.assertEqual(self.update_status['build_post']['disabled_addons'], + self.update_status['build_pre']['disabled_addons'], + 'Application-wide addons have been unexpectedly disabled: {}'.format( + ', '.join(set(self.update_status['build_pre']['locale']) - + set(self.update_status['build_post']['locale'])) + )) + + if self.target_version: + self.assertEqual(self.update_status['build_post']['version'], + self.target_version, + 'Current target version {} does not match expected version {}'.format( + self.update_status['build_post']['version'], self.target_version)) + + if self.target_buildid: + self.assertEqual(self.update_status['build_post']['buildid'], + self.target_buildid, + 'Current target buildid {} does not match expected buildid {}'.format( + self.update_status['build_post']['buildid'], self.target_buildid)) + + self.update_status['success'] = True + + def check_update_not_applied(self): + """Check that the update has not been applied due to a forced invalidation of the patch""" + build_info = self.software_update.build_info + + # Ensure that the version has not been changed + version_check = self.marionette.execute_script(""" + Components.utils.import("resource://gre/modules/Services.jsm"); + + return Services.vc.compare(arguments[0], arguments[1]); + """, script_args=(build_info['version'], + self.update_status['build_pre']['version'])) + + self.assertEqual(version_check, 0, + 'An update from version {} to {} has been unexpectedly applied'.format( + self.update_status['build_pre']['version'], + build_info['version'])) + + # Check that the build id of the source build and the current build are identical + self.assertEqual(build_info['buildid'], + self.update_status['build_pre']['buildid'], + 'The build id has been unexpectedly changed from {} to {}'.format( + self.update_status['build_pre']['buildid'], build_info['buildid'])) + + def download_update(self, window, wait_for_finish=True, timeout=TIMEOUT_UPDATE_DOWNLOAD): + """ Download the update patch. + + :param window: Instance of :class:`AboutWindow` or :class:`UpdateWizardDialog`. + :param wait_for_finish: If True the function has to wait for the download to be finished. + Optional, default to `True`. + :param timeout: How long to wait for the download to finish. Optional, default to 360s. + """ + + def download_via_update_wizard(dialog): + """ Download the update via the old update wizard dialog. + + :param dialog: Instance of :class:`UpdateWizardDialog`. + """ + self.marionette.set_pref(self.PREF_APP_UPDATE_ALTWINDOWTYPE, dialog.window_type) + + try: + # If updates have already been found, proceed to download + if dialog.wizard.selected_panel in [dialog.wizard.updates_found_basic, + dialog.wizard.error_patching, + ]: + dialog.select_next_page() + + # If incompatible add-on are installed, skip over the wizard page + # TODO: Remove once we no longer support version Firefox 45.0ESR + if self.puppeteer.utils.compare_version(self.puppeteer.appinfo.version, + '49.0a1') == -1: + if dialog.wizard.selected_panel == dialog.wizard.incompatible_list: + dialog.select_next_page() + + # Updates were stored in the cache, so no download is necessary + if dialog.wizard.selected_panel in [dialog.wizard.finished, + dialog.wizard.finished_background, + ]: + pass + + # Download the update + elif dialog.wizard.selected_panel == dialog.wizard.downloading: + if wait_for_finish: + start_time = datetime.now() + self.wait_for_download_finished(dialog, timeout) + self.download_duration = (datetime.now() - start_time).total_seconds() + + Wait(self.marionette).until(lambda _: ( + dialog.wizard.selected_panel in [dialog.wizard.finished, + dialog.wizard.finished_background, + ]), + message='Final wizard page has been selected.') + + else: + raise Exception('Invalid wizard page for downloading an update: {}'.format( + dialog.wizard.selected_panel)) + + finally: + self.marionette.clear_pref(self.PREF_APP_UPDATE_ALTWINDOWTYPE) + + # The old update wizard dialog has to be handled differently. It's necessary + # for fallback updates and invalid add-on versions. + if isinstance(window, UpdateWizardDialog): + download_via_update_wizard(window) + return + + if window.deck.selected_panel == window.deck.download_and_install: + window.deck.download_and_install.button.click() + + # Wait for the download to start + Wait(self.marionette).until(lambda _: ( + window.deck.selected_panel != window.deck.download_and_install), + message='Download of the update has been started.') + + if wait_for_finish: + start_time = datetime.now() + self.wait_for_download_finished(window, timeout) + self.download_duration = (datetime.now() - start_time).total_seconds() + + def download_and_apply_available_update(self, force_fallback=False): + """Checks, downloads, and applies an available update. + + :param force_fallback: Optional, if `True` invalidate current update status. + Defaults to `False`. + """ + # Open the about window and check for updates + about_window = self.browser.open_about_window() + + try: + update_available = self.check_for_updates(about_window) + self.assertTrue(update_available, + "Available update has been found") + + # Download update and wait until it has been applied + self.download_update(about_window) + self.wait_for_update_applied(about_window) + + finally: + self.update_status['patch'] = self.patch_info + + if force_fallback: + # Set the downloaded update into failed state + self.software_update.force_fallback() + + # Restart Firefox to apply the downloaded update + self.restart() + + def download_and_apply_forced_update(self): + self.check_update_not_applied() + + # The update wizard dialog opens automatically after the restart but with a short delay + dialog = Wait(self.marionette, ignored_exceptions=[NoSuchWindowException]).until( + lambda _: self.puppeteer.windows.switch_to(lambda win: type(win) is UpdateWizardDialog) + ) + + # In case of a broken complete update the about window has to be used + if self.update_status['patch']['is_complete']: + about_window = None + try: + self.assertEqual(dialog.wizard.selected_panel, + dialog.wizard.error) + dialog.close() + + # Open the about window and check for updates + about_window = self.browser.open_about_window() + update_available = self.check_for_updates(about_window) + self.assertTrue(update_available, + 'Available update has been found') + + # Download update and wait until it has been applied + self.download_update(about_window) + self.wait_for_update_applied(about_window) + + finally: + if about_window: + self.update_status['patch'] = self.patch_info + + else: + try: + self.assertEqual(dialog.wizard.selected_panel, + dialog.wizard.error_patching) + + # Start downloading the fallback update + self.download_update(dialog) + + finally: + self.update_status['patch'] = self.patch_info + + # Restart Firefox to apply the update + self.restart() + + def read_update_log(self): + """Read the content of the update log file for the last update attempt.""" + path = os.path.join(os.path.dirname(self.software_update.staging_directory), + 'last-update.log') + try: + with open(path, 'rb') as f: + return f.read().splitlines() + except IOError as exc: + self.logger.warning(str(exc)) + return None + + def remove_downloaded_update(self): + """Remove an already downloaded update from the update staging directory. + + Hereby not only remove the update subdir but everything below 'updates'. + """ + path = os.path.dirname(self.software_update.staging_directory) + self.logger.info('Clean-up update staging directory: {}'.format(path)) + mozfile.remove(path) + + def wait_for_download_finished(self, window, timeout=TIMEOUT_UPDATE_DOWNLOAD): + """ Waits until download is completed. + + :param window: Instance of :class:`AboutWindow` or :class:`UpdateWizardDialog`. + :param timeout: How long to wait for the download to finish. Optional, + default to 360 seconds. + """ + # The old update wizard dialog has to be handled differently. It's necessary + # for fallback updates and invalid add-on versions. + if isinstance(window, UpdateWizardDialog): + Wait(self.marionette, timeout=timeout).until( + lambda _: window.wizard.selected_panel != window.wizard.downloading, + message='Download has been completed.') + + self.assertNotIn(window.wizard.selected_panel, + [window.wizard.error, window.wizard.error_extra]) + return + + Wait(self.marionette, timeout=timeout).until( + lambda _: window.deck.selected_panel not in + (window.deck.download_and_install, window.deck.downloading), + message='Download has been completed.') + + self.assertNotEqual(window.deck.selected_panel, + window.deck.download_failed) + + def wait_for_update_applied(self, about_window, timeout=TIMEOUT_UPDATE_APPLY): + """ Waits until the downloaded update has been applied. + + :param about_window: Instance of :class:`AboutWindow`. + :param timeout: How long to wait for the update to apply. Optional, + default to 300 seconds + """ + Wait(self.marionette, timeout=timeout).until( + lambda _: about_window.deck.selected_panel == about_window.deck.apply, + message='Final wizard page has been selected.') + + # Wait for update to be staged because for update tests we modify the update + # status file to enforce the fallback update. If we modify the file before + # Firefox does, Firefox will override our change and we will have no fallback update. + Wait(self.marionette, timeout=timeout).until( + lambda _: 'applied' in self.software_update.active_update.state, + message='Update has been applied.') diff --git a/testing/firefox-ui/harness/requirements.txt b/testing/firefox-ui/harness/requirements.txt new file mode 100644 index 000000000..54114debb --- /dev/null +++ b/testing/firefox-ui/harness/requirements.txt @@ -0,0 +1,5 @@ +firefox-puppeteer >= 52.1.0, <53.0.0 +marionette-harness >= 4.0.0 +mozfile >= 1.2 +mozinfo >= 0.8 +mozinstall >= 1.12 diff --git a/testing/firefox-ui/harness/setup.py b/testing/firefox-ui/harness/setup.py new file mode 100644 index 000000000..1799d5057 --- /dev/null +++ b/testing/firefox-ui/harness/setup.py @@ -0,0 +1,44 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import re +from setuptools import setup, find_packages + +THIS_DIR = os.path.dirname(os.path.realpath(__name__)) + + +def read(*parts): + with open(os.path.join(THIS_DIR, *parts)) as f: + return f.read() + + +def get_version(): + return re.findall("__version__ = '([\d\.]+)'", + read('firefox_ui_harness', '__init__.py'), re.M)[0] + +long_description = """Custom Marionette runner classes and entry scripts for Firefox Desktop +specific Marionette tests. +""" + +setup(name='firefox-ui-harness', + version=get_version(), + description="Firefox UI Harness", + long_description=long_description, + classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers + keywords='mozilla', + author='Auto-tools', + author_email='tools-marionette@lists.mozilla.org', + url='https://wiki.mozilla.org/Auto-tools/Projects/Marionette/Harnesses/FirefoxUI', + license='MPL', + packages=find_packages(), + include_package_data=True, + zip_safe=False, + install_requires=read('requirements.txt').splitlines(), + entry_points=""" + [console_scripts] + firefox-ui-functional = firefox_ui_harness.cli_functional:cli + firefox-ui-update = firefox_ui_harness.cli_update:cli + """, + ) diff --git a/testing/firefox-ui/mach_commands.py b/testing/firefox-ui/mach_commands.py new file mode 100644 index 000000000..368b673a2 --- /dev/null +++ b/testing/firefox-ui/mach_commands.py @@ -0,0 +1,120 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from __future__ import absolute_import, unicode_literals + +import os +import sys + +from mozbuild.base import ( + MachCommandBase, + MachCommandConditions as conditions, +) + +from mach.decorators import ( + Command, + CommandProvider, +) + + +def setup_argument_parser_functional(): + from firefox_ui_harness.arguments.base import FirefoxUIArguments + from mozlog.structured import commandline + parser = FirefoxUIArguments() + commandline.add_logging_group(parser) + return parser + + +def setup_argument_parser_update(): + from firefox_ui_harness.arguments.update import UpdateArguments + from mozlog.structured import commandline + parser = UpdateArguments() + commandline.add_logging_group(parser) + return parser + + +def run_firefox_ui_test(testtype=None, topsrcdir=None, **kwargs): + from mozlog.structured import commandline + from argparse import Namespace + import firefox_ui_harness + + if testtype == 'functional': + parser = setup_argument_parser_functional() + else: + parser = setup_argument_parser_update() + + test_types = { + 'functional': { + 'default_tests': [ + os.path.join('puppeteer', 'manifest.ini'), + os.path.join('functional', 'manifest.ini'), + ], + 'cli_module': firefox_ui_harness.cli_functional, + }, + 'update': { + 'default_tests': [ + os.path.join('update', 'manifest.ini'), + ], + 'cli_module': firefox_ui_harness.cli_update, + } + } + + fxui_dir = os.path.join(topsrcdir, 'testing', 'firefox-ui') + + # Set the resources path which is used to serve test data via wptserve + if not kwargs['server_root']: + kwargs['server_root'] = os.path.join(fxui_dir, 'resources') + + # If called via "mach test" a dictionary of tests is passed in + if 'test_objects' in kwargs: + tests = [] + for obj in kwargs['test_objects']: + tests.append(obj['file_relpath']) + kwargs['tests'] = tests + elif not kwargs.get('tests'): + # If no tests have been selected, set default ones + kwargs['tests'] = [os.path.join(fxui_dir, 'tests', test) + for test in test_types[testtype]['default_tests']] + + kwargs['logger'] = commandline.setup_logging('Firefox UI - {} Tests'.format(testtype), + {"mach": sys.stdout}) + + args = Namespace() + + for k, v in kwargs.iteritems(): + setattr(args, k, v) + + parser.verify_usage(args) + + failed = test_types[testtype]['cli_module'].cli(args=vars(args)) + + if failed > 0: + return 1 + else: + return 0 + + +@CommandProvider +class MachCommands(MachCommandBase): + """Mach command provider for Firefox ui tests.""" + + @Command('firefox-ui-functional', category='testing', + conditions=[conditions.is_firefox], + description='Run the functional test suite of Firefox UI tests.', + parser=setup_argument_parser_functional, + ) + def run_firefox_ui_functional(self, **kwargs): + kwargs['binary'] = kwargs['binary'] or self.get_binary_path('app') + return run_firefox_ui_test(testtype='functional', + topsrcdir=self.topsrcdir, **kwargs) + + @Command('firefox-ui-update', category='testing', + conditions=[conditions.is_firefox], + description='Run the update test suite of Firefox UI tests.', + parser=setup_argument_parser_update, + ) + def run_firefox_ui_update(self, **kwargs): + kwargs['binary'] = kwargs['binary'] or self.get_binary_path('app') + return run_firefox_ui_test(testtype='update', + topsrcdir=self.topsrcdir, **kwargs) diff --git a/testing/firefox-ui/moz.build b/testing/firefox-ui/moz.build new file mode 100644 index 000000000..dd7311c03 --- /dev/null +++ b/testing/firefox-ui/moz.build @@ -0,0 +1,11 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +FIREFOX_UI_FUNCTIONAL_MANIFESTS += ["tests/functional/manifest.ini"] +FIREFOX_UI_UPDATE_MANIFESTS += ["tests/update/manifest.ini"] +# TODO: Move to testing/marionette/puppeteer/firefox +PUPPETEER_FIREFOX_MANIFESTS += ["tests/puppeteer/manifest.ini"] + +with Files("**"): + BUG_COMPONENT = ("Testing", "Firefox UI Tests") diff --git a/testing/firefox-ui/resources/addons/extensions/restartless_addon_signed.xpi b/testing/firefox-ui/resources/addons/extensions/restartless_addon_signed.xpi Binary files differnew file mode 100644 index 000000000..ed86213e7 --- /dev/null +++ b/testing/firefox-ui/resources/addons/extensions/restartless_addon_signed.xpi diff --git a/testing/firefox-ui/resources/addons/extensions/restartless_addon_unsigned.xpi b/testing/firefox-ui/resources/addons/extensions/restartless_addon_unsigned.xpi Binary files differnew file mode 100644 index 000000000..d0768103d --- /dev/null +++ b/testing/firefox-ui/resources/addons/extensions/restartless_addon_unsigned.xpi diff --git a/testing/firefox-ui/resources/cookies/cookie_single.html b/testing/firefox-ui/resources/cookies/cookie_single.html new file mode 100644 index 000000000..d4a02b45b --- /dev/null +++ b/testing/firefox-ui/resources/cookies/cookie_single.html @@ -0,0 +1,16 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> +<script type="text/javascript"> + function setCookie() + { + var date = new Date(); + date.setDate(new Date().getDate() + 36); + document.cookie = "litmus_1=true;expires=" + date.toGMTString(); + } +</script> +</head> + +<body onload="setCookie()"> +</body> +</html> diff --git a/testing/firefox-ui/resources/images/firefox_favicon.ico b/testing/firefox-ui/resources/images/firefox_favicon.ico Binary files differnew file mode 100644 index 000000000..2c2f81768 --- /dev/null +++ b/testing/firefox-ui/resources/images/firefox_favicon.ico diff --git a/testing/firefox-ui/resources/images/mozilla_favicon.ico b/testing/firefox-ui/resources/images/mozilla_favicon.ico Binary files differnew file mode 100644 index 000000000..d44438903 --- /dev/null +++ b/testing/firefox-ui/resources/images/mozilla_favicon.ico diff --git a/testing/firefox-ui/resources/images/mozilla_logo.jpg b/testing/firefox-ui/resources/images/mozilla_logo.jpg Binary files differnew file mode 100644 index 000000000..231b385ee --- /dev/null +++ b/testing/firefox-ui/resources/images/mozilla_logo.jpg diff --git a/testing/firefox-ui/resources/layout/mozilla.html b/testing/firefox-ui/resources/layout/mozilla.html new file mode 100644 index 000000000..9224533bf --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla.html @@ -0,0 +1,45 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla</title> + <link rel="shortcut icon" type="image/ico" href="../images/mozilla_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#community">Community</a> | + <a href="#project">Project</a> | + <a href="#organization">Organization</a> + + <div id="content"> + <h1 id="page-title"> + <strong>We believe</strong> that the internet should be public, + open and accessible. + </h1> + + <h2><a name="community">Community</a></h2> + <p id="community"> + We're a global community of thousands who believe in the power + of technology to enrich people's lives. + <a href="mozilla_community.html">More</a> + </p> + + <h2><a name="project">Project</a></h2> + <p id="project"> + We're an open source project whose code is used for some of the + Internet's most innovative applications. + <a href="mozilla_projects.html">More</a> + </p> + + <h2><a name="organization">Organization</a></h2> + <p id="organization"> + We're a public benefit organization dedicated to making the + Internet better for everyone. + <a href="mozilla_mission.html">More</a> + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_community.html b/testing/firefox-ui/resources/layout/mozilla_community.html new file mode 100644 index 000000000..c8da6afd8 --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_community.html @@ -0,0 +1,57 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Community</title> + <link rel="shortcut icon" type="image/ico" href="../images/seamonkey_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#history">History</a> | + <a href="#communicate">Communicate</a> | + <a href="#more">More</a> + + <div id="content"> + <h1 id="page-title" name="page-title">Our Community</h1> + + <h2><a name="history">History</a></h2> + <p id="history"> + When www.mozilla.org was launched in 1998 all community activity + occurred right here on this site. Since then the community has + grown much bigger and there are now many different sites, + forums, blogs and newsgroups in different places that track + different parts of the project. These pages aim to be a + comprehensive list to all of the different community resources + available. If you know of something that's not on these lists + that should be, please contact us and we'll update these + pages. + </p> + + <h2><a name="communicate">Communicate</a></h2> + <p id="communicate"> + There are a number of different ways community members + communicate and coordinate (people use mailing lists and + newsgroups, blogs, forums, wikis and they even meet in real + life sometimes too) and all of these options might be + overwhelming at first. Hopefully this set of links will provide + some useful pointers to help you figure out where to go to find + what you're looking for. If you do get lost though and need + some help, feel free to ask for more information. + </p> + + <h2><a name="more">More</a></h2> + <p id="more"> + Please note that this is intended to be an entry point that + provides a high-level overview of the different community areas. + If you're looking for more detailed information about a specific + topic, please look at our Developer, + <a href="mozilla_contribute.html">Contribute</a> and Support + pages or take a look at the other information referenced + throughout this site. + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_contribute.html b/testing/firefox-ui/resources/layout/mozilla_contribute.html new file mode 100644 index 000000000..cf5e54b85 --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_contribute.html @@ -0,0 +1,70 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Contribute</title> + <link rel="shortcut icon" type="image/ico" href="../images/thunderbird_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#summary">Summary</a> | + <a href="#contribute">Contribute</a> + + <div id="content"> + <h1 id="page-title">Get Involved</h1> + + <h2><a name="summary">Summary</a></h2> + <p id="summary"> + You can <a href="mozilla_mission.html">build a better Internet</a> + by getting involved with Mozilla. You don't have to be a C++ + guru (or even know what that means!) and you don't need to spend + lots of time. Take a look at the opportunities below and feel + free to ask if you have any questions. + </p> + + <h2><a name="contribute">Contribute</a></h2> + <p id="contribute"> + <h3>Area of Interest</h3> + <i>Browse contribution opportunities by area of interest.</i> + + <ul id="areas_of_interest"> + <li id="browser_choice"> + <h4>Web Browser Choice</h4> + <p> + Mozilla has always believed that the freedom to + make informed choices should be central to making + the Web, and the world, a better place. Tell us + why having a choice of browser is important to you + and help us spread the word about how others can + take control of their online lives. + </p> + </li> + <li id="helping_users"> + <h4>Helping Users</h4> + <p> + Interested in helping others get the most out of + using Firefox and other Mozilla projects? Our + support process relies on enthusiastic + contributors like you. Find out more about + supporting Firefox, Thunderbird and other Mozilla + projects. + </p> + </li> + <li id="localization"> + <h4>Localization</h4> + <p> + Get involved with Mozilla by making Firefox, + Thunderbird and other projects available in your + language. Also help us tell the world about how + Mozilla is building a better Internet by + translating content on our web sites. + </p> + </li> + </ul> + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_governance.html b/testing/firefox-ui/resources/layout/mozilla_governance.html new file mode 100644 index 000000000..8e25aaabd --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_governance.html @@ -0,0 +1,38 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Governance</title> + <link rel="shortcut icon" type="image/ico" href="../images/firefox_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#summary">Summary</a> | + <a href="#more">More</a> + + <div id="content"> + <h1 id="page-title">Governance</h1> + + <h2><a name="summary">Summary</a></h2> + <p id="summary"> + Mozilla is an open source project governed as a meritocracy. Our + community is structured as a virtual organization where + authority is distributed to both volunteer and employed + community members as they show their abilities through + contributions to the project. + </p> + + <h2><a name="more">More</a></h2> + <p id="more"> + <ul id="list"> + <li id="roles">Roles and Responsibilities</li> + <li id="policies">Policies</li> + <li id="discussion">Discussion</li> + </ul> + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_grants.html b/testing/firefox-ui/resources/layout/mozilla_grants.html new file mode 100644 index 000000000..c8935c4fb --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_grants.html @@ -0,0 +1,72 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Grants</title> + <link rel="shortcut icon" type="image/ico" href="../images/mozilla_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#summary">Summary</a> | + <a href="#goals">Goals</a> + + <div id="content"> + <h1 id="page-title">Mozilla Grants</h1> + + <h2><a name="summary">Summary</a></h2> + <p id="summary"> + Since 2006, Mozilla has awarded over two million dollars to fund + projects that contribute to the health of the Open Web. The + Mozilla Grants program is jointly funded by the Mozilla + Corporation and the Mozilla Foundation, and awards financial + support to individuals and organizations whose work supports and + enhances the mission and values of the Mozilla Project. + </p> + + <h2><a name="goals">Goals</a></h2> + <p id="goals"> + Mozilla makes grants to individuals and organizations all over + the world. We mainly fund activity that supports the Mozilla + Grants program's four target areas: + + <ul id="goal_list"> + <li id="accessibility"> + <strong>Accessibility:</strong> Mozilla believes that + the Internet truly is for everyone, and that those with + disabilities should be able to participate on the Web + along with their sighted and hearing peers. As part of + our accessibility strategy, we are funding the + development of free, open source options for those with + visual and auditory impairments. + </li> + + <li id="community"> + <strong>Community:</strong> Mozilla offers suppport to + the broader free culture and open source community, as + part of Mozilla's general effort to 'give back', aiding + in the creation of technologies and projects that + increase the health of the open Web ecosystem. + </li> + + <li id="education"> + <strong>Education:</strong> As part of Mozilla's broader + education initiative, we support educational + institutions that are producing the next generation of + innovative creators of software. + </li> + + <li id="open_source"> + <strong>Open Source:</strong> These grants support the + creation and adoption of Web standards, open source + principles, and the overall principles of transparency, + collaboration, and openness that free and open source + software projects adhere to. + </li> + </ul> + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_mission.html b/testing/firefox-ui/resources/layout/mozilla_mission.html new file mode 100644 index 000000000..c9ed2bd85 --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_mission.html @@ -0,0 +1,51 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Mission</title> + <link rel="shortcut icon" type="image/ico" href="../images/seamonkey_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#mission">Mission</a> | + <a href="#organization">Organization</a> | + <a href="#goal">Goal</a> + + <div id="content" name="content"> + <h1 id="page-title" name="page-title">Mission</h1> + + <h2><a name="mission">Mission</a></h2> + <p id="mission_statement"> + Mozilla's mission is to <strong>promote openness, innovation, + and opportunity on the web</strong>. We do this by creating + great software, like the Firefox browser, and building + movements, like Drumbeat, that give people tools to take control + of their online lives. + </p> + + <h2><a name="organization">Organization</a></h2> + <p id="organization"> + As a non-profit organization, we define success in terms of + building communities and enriching people's lives instead of + benefiting our shareholders (guess what: we don't even have + shareholders). We believe in the power and potential of the + Internet and want to see it thrive for everyone, everywhere. + </p> + + <h2><a name="goal">Goal</a></h2> + <p id="goal"> + <strong> + Building a better Internet is an ambitious goal, but we + believe that it is possible + </strong> + when people who share our passion get involved. Coders, artists, + writers, testers, surfers, students, grandparents; anyone who + uses and cares about the web can help make it even better. + <a href="mozilla_contribute.html">Find out how you can help</a>. + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_organizations.html b/testing/firefox-ui/resources/layout/mozilla_organizations.html new file mode 100644 index 000000000..9d2ae9ff0 --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_organizations.html @@ -0,0 +1,39 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Organizations</title> + <link rel="shortcut icon" type="image/ico" href="../images/thunderbird_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#summary">Summary</a> | + <a href="#organization">Organization</a> + + <div id="content"> + <h1 id="page-title">Mozilla Organizations</h1> + + <h2><a name="summary">Summary</a></h2> + <p id="summary"> + Mozilla is a global community of people creating a better + Internet. We build public benefit into the Internet by creating + free, open source products and technologies that improve the + online experience for people everywhere. + </p> + + <h2><a name="organization">Organization</a></h2> + <p id="organization"> + There are several organizations that support the Mozilla + community and Mozilla's principles. They include the non-profit + Mozilla Foundation as well as two wholly owned taxable + subsidiaries, the Mozilla Corporation and Mozilla Messaging. + Mozilla considers itself a hybrid organization, combining non- + profit and market strategies to ensure the Internet remains a + shared public resource. + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/layout/mozilla_projects.html b/testing/firefox-ui/resources/layout/mozilla_projects.html new file mode 100644 index 000000000..a4ec7c840 --- /dev/null +++ b/testing/firefox-ui/resources/layout/mozilla_projects.html @@ -0,0 +1,60 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <title>Mozilla Projects</title> + <link rel="shortcut icon" type="image/ico" href="../images/firefox_favicon.ico" /> +</head> + +<body> + <a href="mozilla.html"> + <img id="mozilla_logo" src="../images/mozilla_logo.jpg" /> + </a> + + <a href="#summary">Summary</a> | + <a href="#applications">Applications</a> + + <div id="content"> + <h1 id="page-title">Our Projects</h1> + + <h2><a name="summary">Summary</a></h2> + <p id="summary"> + The Mozilla community produces a lot of great software and acts + as an incubator for innovative ideas as a way to advance our + <a href="mozilla_mission.html">mission</a> of building a better + Internet. + </p> + + <h2><a name="applications">Applications</a></h2> + <p id="applications"> + <p> + These applications are developed by the Mozilla community + and their code is hosted on mozilla.org. + </p> + + <ul id="product_list"> + <li id="bugzilla"> + <h3><strong>Bugzilla</strong></h3> + Bugzilla is a bug tracking system designed to help teams + manage software development. Hundreds of organizations + across the globe are using this powerful tool to get + organized and communicate effectively. + </li> + + <li id="camino"> + <h3><strong>Camino</strong></h3> + Camino is a Web browser optimized for Mac OS X with a + Cocoa user interface, and powerful Gecko layout engine. + It's the simple, secure, and fast browser for Mac OS X. + </li> + + <li id="firefox"> + <h3><strong>Firefox for Desktop</strong></h3> + The award-winning Firefox Web browser has security, + speed and new features that will change the way you use + the Web. Don’t settle for anything less. + </li> + </ul> + </p> + </div> +</body> +</html> diff --git a/testing/firefox-ui/resources/private_browsing/about.html b/testing/firefox-ui/resources/private_browsing/about.html new file mode 100644 index 000000000..30b211be6 --- /dev/null +++ b/testing/firefox-ui/resources/private_browsing/about.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> +<head> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> +</head> + +<body> + <div id="about_pb">About Private Browsing</div> +</body> +</html> diff --git a/testing/firefox-ui/resources/security/enable_privilege.html b/testing/firefox-ui/resources/security/enable_privilege.html new file mode 100644 index 000000000..9d18e4684 --- /dev/null +++ b/testing/firefox-ui/resources/security/enable_privilege.html @@ -0,0 +1,21 @@ +<!DOCTYPE html> +<html lang="en" dir="ltr"> + <head> + <title>Test page for enablePrivilege</title> + <script> + function init() { + var result = document.getElementById("result"); + try { + netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect"); + result.textContent = "FAIL"; + } + catch (ex) { + result.textContent = "PASS"; + } + } + </script> + </head> + <body onload="init();"> + <p id="result"></p> + </body> +</html> diff --git a/testing/firefox-ui/resources/support.html b/testing/firefox-ui/resources/support.html new file mode 100644 index 000000000..b794e9ef9 --- /dev/null +++ b/testing/firefox-ui/resources/support.html @@ -0,0 +1,19 @@ +<!DOCTYPE html> +<html> +<head> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script type="text/javascript"> + function show() { + var results = /\?topic=(.+)$/.exec(window.document.location); + var topic = decodeURIComponent(results[1].replace(/\+/g, " ")) + var node = document.getElementById("topic"); + + node.textContent = topic; + } + </script> +</head> + +<body onload="show()"> + <div id="topic"></div> +</body> +</html> diff --git a/testing/firefox-ui/tests/functional/keyboard_shortcuts/manifest.ini b/testing/firefox-ui/tests/functional/keyboard_shortcuts/manifest.ini new file mode 100644 index 000000000..97ec827f1 --- /dev/null +++ b/testing/firefox-ui/tests/functional/keyboard_shortcuts/manifest.ini @@ -0,0 +1,4 @@ +[DEFAULT] +tags = local + +[test_browser_window.py] diff --git a/testing/firefox-ui/tests/functional/keyboard_shortcuts/test_browser_window.py b/testing/firefox-ui/tests/functional/keyboard_shortcuts/test_browser_window.py new file mode 100644 index 000000000..5b656d0e5 --- /dev/null +++ b/testing/firefox-ui/tests/functional/keyboard_shortcuts/test_browser_window.py @@ -0,0 +1,56 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestBrowserWindowShortcuts(PuppeteerMixin, MarionetteTestCase): + + def test_addons_manager(self): + # If an about:xyz page is visible, no new tab will be opened + with self.marionette.using_context('content'): + self.marionette.navigate('about:') + + # TODO: To be moved to the upcoming add-ons library + def opener(tab): + tab.window.send_shortcut(tab.window.localize_entity('addons.commandkey'), + accel=True, shift=True) + self.browser.tabbar.open_tab(opener) + + # TODO: Marionette currently fails to detect the correct tab + # with self.marionette.using_content('content'): + # self.wait_for_condition(lambda mn: mn.get_url() == "about:addons") + + # TODO: remove extra switch once it is done automatically + self.browser.tabbar.tabs[1].switch_to() + self.browser.tabbar.close_tab() + + def test_search_field(self): + current_name = self.marionette.execute_script(""" + return window.document.activeElement.localName; + """) + + # This doesn't test anything if we're already at input. + self.assertNotEqual(current_name, "input") + + # TODO: To be moved to the upcoming search library + if self.puppeteer.platform == 'linux': + key = 'searchFocusUnix.commandkey' + else: + key = 'searchFocus.commandkey' + self.browser.send_shortcut(self.browser.localize_entity(key), + accel=True) + + # TODO: Check that the right input box is focused + # Located below searchbar as class="autocomplete-textbox textbox-input" + # Anon locator has not been released yet (bug 1080764) + def has_input_selected(mn): + selection_name = mn.execute_script(""" + return window.document.activeElement.localName; + """) + return selection_name == "input" + + Wait(self.marionette).until(has_input_selected) diff --git a/testing/firefox-ui/tests/functional/locationbar/manifest.ini b/testing/firefox-ui/tests/functional/locationbar/manifest.ini new file mode 100644 index 000000000..72adfd767 --- /dev/null +++ b/testing/firefox-ui/tests/functional/locationbar/manifest.ini @@ -0,0 +1,9 @@ +[DEFAULT] +tags = local + +[test_access_locationbar.py] +disabled = Bug 1168727 - Timeout when opening auto-complete popup +[test_escape_autocomplete.py] +[test_favicon_in_autocomplete.py] +[test_suggest_bookmarks.py] + diff --git a/testing/firefox-ui/tests/functional/locationbar/test_access_locationbar.py b/testing/firefox-ui/tests/functional/locationbar/test_access_locationbar.py new file mode 100644 index 000000000..160a402c2 --- /dev/null +++ b/testing/firefox-ui/tests/functional/locationbar/test_access_locationbar.py @@ -0,0 +1,60 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestAccessLocationBar(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestAccessLocationBar, self).setUp() + + # Clear complete history so there's no interference from previous entries. + self.puppeteer.places.remove_all_history() + + self.test_urls = [ + 'layout/mozilla_projects.html', + 'layout/mozilla.html', + 'layout/mozilla_mission.html' + ] + self.test_urls = [self.marionette.absolute_url(t) + for t in self.test_urls] + + self.locationbar = self.browser.navbar.locationbar + self.autocomplete_results = self.locationbar.autocomplete_results + self.urlbar = self.locationbar.urlbar + + def test_access_locationbar_history(self): + + # Open some local pages, then about:blank + def load_urls(): + with self.marionette.using_context('content'): + for url in self.test_urls: + self.marionette.navigate(url) + self.puppeteer.places.wait_for_visited(self.test_urls, load_urls) + with self.marionette.using_context('content'): + self.marionette.navigate('about:blank') + + # Need to blur url bar or autocomplete won't load - bug 1038614 + self.marionette.execute_script("""arguments[0].blur();""", script_args=[self.urlbar]) + + # Clear contents of url bar to focus, then arrow down for list of visited sites + # Verify that autocomplete is open and results are displayed + self.locationbar.clear() + self.urlbar.send_keys(self.puppeteer.keys.ARROW_DOWN) + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_open) + Wait(self.marionette).until(lambda _: len(self.autocomplete_results.visible_results) > 1) + + # Arrow down again to select first item in list, appearing in reversed order, as loaded. + # Verify first item. + self.urlbar.send_keys(self.puppeteer.keys.ARROW_DOWN) + Wait(self.marionette).until(lambda _: self.autocomplete_results.selected_index == '0') + self.assertIn('mission', self.locationbar.value) + + # Navigate to the currently selected url + # Verify it loads by comparing the page url to the test url + self.urlbar.send_keys(self.puppeteer.keys.ENTER) + self.assertEqual(self.locationbar.value, self.test_urls[-1]) diff --git a/testing/firefox-ui/tests/functional/locationbar/test_escape_autocomplete.py b/testing/firefox-ui/tests/functional/locationbar/test_escape_autocomplete.py new file mode 100644 index 000000000..209d9b0f5 --- /dev/null +++ b/testing/firefox-ui/tests/functional/locationbar/test_escape_autocomplete.py @@ -0,0 +1,56 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestEscapeAutocomplete(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestEscapeAutocomplete, self).setUp() + + # Clear complete history so there's no interference from previous entries. + self.puppeteer.places.remove_all_history() + + self.test_urls = [ + 'layout/mozilla.html', + 'layout/mozilla_community.html', + ] + self.test_urls = [self.marionette.absolute_url(t) + for t in self.test_urls] + + self.test_string = 'mozilla' + + self.locationbar = self.browser.navbar.locationbar + self.autocomplete_results = self.locationbar.autocomplete_results + + def tearDown(self): + self.autocomplete_results.close(force=True) + + super(TestEscapeAutocomplete, self).tearDown() + + def test_escape_autocomplete(self): + # Open some local pages + def load_urls(): + with self.marionette.using_context('content'): + for url in self.test_urls: + self.marionette.navigate(url) + self.puppeteer.places.wait_for_visited(self.test_urls, load_urls) + + # Clear the location bar, type the test string, check that autocomplete list opens + self.locationbar.clear() + self.locationbar.urlbar.send_keys(self.test_string) + self.assertEqual(self.locationbar.value, self.test_string) + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_open) + + # Press escape, check location bar value, check autocomplete list closed + self.locationbar.urlbar.send_keys(self.puppeteer.keys.ESCAPE) + self.assertEqual(self.locationbar.value, self.test_string) + Wait(self.marionette).until(lambda _: not self.autocomplete_results.is_open) + + # Press escape again and check that locationbar returns to the page url + self.locationbar.urlbar.send_keys(self.puppeteer.keys.ESCAPE) + self.assertEqual(self.locationbar.value, self.test_urls[-1]) diff --git a/testing/firefox-ui/tests/functional/locationbar/test_favicon_in_autocomplete.py b/testing/firefox-ui/tests/functional/locationbar/test_favicon_in_autocomplete.py new file mode 100644 index 000000000..6e8a5f6b1 --- /dev/null +++ b/testing/firefox-ui/tests/functional/locationbar/test_favicon_in_autocomplete.py @@ -0,0 +1,62 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestFaviconInAutocomplete(PuppeteerMixin, MarionetteTestCase): + + PREF_SUGGEST_SEARCHES = 'browser.urlbar.suggest.searches' + PREF_SUGGEST_BOOKMARK = 'browser.urlbar.suggest.bookmark' + + def setUp(self): + super(TestFaviconInAutocomplete, self).setUp() + + # Disable suggestions for searches and bookmarks to get results only for history + self.marionette.set_pref(self.PREF_SUGGEST_SEARCHES, False) + self.marionette.set_pref(self.PREF_SUGGEST_BOOKMARK, False) + + self.puppeteer.places.remove_all_history() + + self.test_urls = [self.marionette.absolute_url('layout/mozilla.html')] + + self.test_string = 'mozilla' + self.test_favicon = 'mozilla_favicon.ico' + + self.autocomplete_results = self.browser.navbar.locationbar.autocomplete_results + + def tearDown(self): + try: + self.autocomplete_results.close(force=True) + self.marionette.clear_pref(self.PREF_SUGGEST_SEARCHES) + self.marionette.clear_pref(self.PREF_SUGGEST_BOOKMARK) + finally: + super(TestFaviconInAutocomplete, self).tearDown() + + def test_favicon_in_autocomplete(self): + # Open the test page + def load_urls(): + with self.marionette.using_context('content'): + self.marionette.navigate(self.test_urls[0]) + self.puppeteer.places.wait_for_visited(self.test_urls, load_urls) + + locationbar = self.browser.navbar.locationbar + + # Clear the location bar, type the test string, check that autocomplete list opens + locationbar.clear() + locationbar.urlbar.send_keys(self.test_string) + self.assertEqual(locationbar.value, self.test_string) + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_complete) + + result = self.autocomplete_results.visible_results[1] + + result_icon = self.marionette.execute_script(""" + return arguments[0].image; + """, script_args=[result]) + + self.assertIn(self.test_favicon, result_icon) + + self.autocomplete_results.close() diff --git a/testing/firefox-ui/tests/functional/locationbar/test_suggest_bookmarks.py b/testing/firefox-ui/tests/functional/locationbar/test_suggest_bookmarks.py new file mode 100644 index 000000000..9abc2d6cb --- /dev/null +++ b/testing/firefox-ui/tests/functional/locationbar/test_suggest_bookmarks.py @@ -0,0 +1,96 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, Wait +from marionette_harness import MarionetteTestCase + + +class TestStarInAutocomplete(PuppeteerMixin, MarionetteTestCase): + """ This replaces + http://hg.mozilla.org/qa/mozmill-tests/file/default/firefox/tests/functional/testAwesomeBar/testSuggestBookmarks.js + Check a star appears in autocomplete list for a bookmarked page. + """ + + PREF_SUGGEST_SEARCHES = 'browser.urlbar.suggest.searches' + + def setUp(self): + super(TestStarInAutocomplete, self).setUp() + + self.bookmark_panel = None + self.test_urls = [self.marionette.absolute_url('layout/mozilla_grants.html')] + + # Disable search suggestions to only get results for history and bookmarks + self.marionette.set_pref(self.PREF_SUGGEST_SEARCHES, False) + + with self.marionette.using_context('content'): + self.marionette.navigate('about:blank') + + self.puppeteer.places.remove_all_history() + + def tearDown(self): + # Close the autocomplete results + try: + if self.bookmark_panel: + self.marionette.execute_script(""" + arguments[0].hidePopup(); + """, script_args=[self.bookmark_panel]) + + self.browser.navbar.locationbar.autocomplete_results.close() + self.puppeteer.places.restore_default_bookmarks() + self.marionette.clear_pref(self.PREF_SUGGEST_SEARCHES) + finally: + super(TestStarInAutocomplete, self).tearDown() + + def test_star_in_autocomplete(self): + search_string = 'grants' + + def visit_urls(): + with self.marionette.using_context('content'): + for url in self.test_urls: + self.marionette.navigate(url) + + # Navigate to all the urls specified in self.test_urls and wait for them to + # be registered as visited + self.puppeteer.places.wait_for_visited(self.test_urls, visit_urls) + + # Bookmark the current page using the bookmark menu + self.browser.menubar.select_by_id('bookmarksMenu', + 'menu_bookmarkThisPage') + + # TODO: Replace hard-coded selector with library method when one is available + self.bookmark_panel = self.marionette.find_element(By.ID, 'editBookmarkPanel') + done_button = self.marionette.find_element(By.ID, 'editBookmarkPanelDoneButton') + + Wait(self.marionette).until( + lambda mn: self.bookmark_panel.get_attribute('panelopen') == 'true') + done_button.click() + + # We must open the blank page so the autocomplete result isn't "Switch to tab" + with self.marionette.using_context('content'): + self.marionette.navigate('about:blank') + + self.puppeteer.places.remove_all_history() + + # Focus the locationbar, delete any contents there, and type the search string + locationbar = self.browser.navbar.locationbar + locationbar.clear() + locationbar.urlbar.send_keys(search_string) + autocomplete_results = locationbar.autocomplete_results + + # Wait for the search string to be present, for the autocomplete results to appear + # and for there to be exactly one autocomplete result + Wait(self.marionette).until(lambda mn: locationbar.value == search_string) + Wait(self.marionette).until(lambda mn: autocomplete_results.is_complete) + Wait(self.marionette).until(lambda mn: len(autocomplete_results.visible_results) == 2) + + # Compare the highlighted text in the autocomplete result to the search string + first_result = autocomplete_results.visible_results[1] + matching_titles = autocomplete_results.get_matching_text(first_result, 'title') + for title in matching_titles: + Wait(self.marionette).until(lambda mn: title.lower() == search_string) + + self.assertIn('bookmark', + first_result.get_attribute('type'), + 'The auto-complete result is a bookmark') diff --git a/testing/firefox-ui/tests/functional/manifest.ini b/testing/firefox-ui/tests/functional/manifest.ini new file mode 100644 index 000000000..bc254e962 --- /dev/null +++ b/testing/firefox-ui/tests/functional/manifest.ini @@ -0,0 +1,5 @@ +[include:keyboard_shortcuts/manifest.ini] +[include:locationbar/manifest.ini] +[include:private_browsing/manifest.ini] +[include:security/manifest.ini] +[include:sessionstore/manifest.ini] diff --git a/testing/firefox-ui/tests/functional/private_browsing/manifest.ini b/testing/firefox-ui/tests/functional/private_browsing/manifest.ini new file mode 100644 index 000000000..405753082 --- /dev/null +++ b/testing/firefox-ui/tests/functional/private_browsing/manifest.ini @@ -0,0 +1,4 @@ +[DEFAULT] +tags = local + +[test_about_private_browsing.py]
\ No newline at end of file diff --git a/testing/firefox-ui/tests/functional/private_browsing/test_about_private_browsing.py b/testing/firefox-ui/tests/functional/private_browsing/test_about_private_browsing.py new file mode 100644 index 000000000..4b22d03ea --- /dev/null +++ b/testing/firefox-ui/tests/functional/private_browsing/test_about_private_browsing.py @@ -0,0 +1,60 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.ui.browser.window import BrowserWindow +from marionette_driver import By, Wait +from marionette_harness import MarionetteTestCase + + +class TestAboutPrivateBrowsing(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestAboutPrivateBrowsing, self).setUp() + + # Use a fake local support URL + support_url = 'about:blank?' + self.marionette.set_pref('app.support.baseURL', support_url) + + self.pb_url = support_url + 'private-browsing' + + def tearDown(self): + try: + self.marionette.clear_pref('app.support.baseURL') + finally: + super(TestAboutPrivateBrowsing, self).tearDown() + + def testCheckAboutPrivateBrowsing(self): + self.assertFalse(self.browser.is_private) + + with self.marionette.using_context('content'): + self.marionette.navigate('about:privatebrowsing') + + status_node = self.marionette.find_element(By.CSS_SELECTOR, 'p.showNormal') + self.assertEqual(status_node.text, + self.browser.localize_entity('aboutPrivateBrowsing.notPrivate'), + 'Status text indicates we are not in private browsing mode') + + def window_opener(win): + with win.marionette.using_context('content'): + button = self.marionette.find_element(By.ID, 'startPrivateBrowsing') + button.click() + + pb_window = self.browser.open_window(callback=window_opener, + expected_window_class=BrowserWindow) + + try: + self.assertTrue(pb_window.is_private) + + def tab_opener(tab): + with tab.marionette.using_context('content'): + link = tab.marionette.find_element(By.ID, 'learnMore') + link.click() + + tab = pb_window.tabbar.open_tab(trigger=tab_opener) + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda _: tab.location == self.pb_url) + + finally: + pb_window.close() diff --git a/testing/firefox-ui/tests/functional/security/manifest.ini b/testing/firefox-ui/tests/functional/security/manifest.ini new file mode 100644 index 000000000..46aeaf5c3 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/manifest.ini @@ -0,0 +1,22 @@ +[DEFAULT] +tags = remote + +[test_dv_certificate.py] +[test_enable_privilege.py] +tags = local +[test_ev_certificate.py] +skip-if = true # Bug 1407663 +[test_mixed_content_page.py] +[test_mixed_script_content_blocking.py] +[test_no_certificate.py] +tags = local +[test_safe_browsing_initial_download.py] +[test_safe_browsing_notification.py] +[test_safe_browsing_warning_pages.py] +[test_security_notification.py] +[test_ssl_disabled_error_page.py] +[test_ssl_status_after_restart.py] +skip-if = (os == "win" && os_version == "5.1") # Bug 1167179: Fails to open popups after restart +[test_submit_unencrypted_info_warning.py] +[test_unknown_issuer.py] +[test_untrusted_connection_error_page.py] diff --git a/testing/firefox-ui/tests/functional/security/test_dv_certificate.py b/testing/firefox-ui/tests/functional/security/test_dv_certificate.py new file mode 100644 index 000000000..565f64996 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_dv_certificate.py @@ -0,0 +1,85 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestDVCertificate(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestDVCertificate, self).setUp() + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.browser.navbar.locationbar.identity_popup + + self.url = 'https://ssl-dv.mozqa.com' + + def tearDown(self): + try: + self.browser.switch_to() + self.identity_popup.close(force=True) + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestDVCertificate, self).tearDown() + + def test_dv_cert(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + self.assertEqual(self.locationbar.identity_box.get_property('className'), + 'verifiedDomain') + + # Open the identity popup + self.locationbar.open_identity_popup() + + # Check the identity popup doorhanger + self.assertEqual(self.identity_popup.element.get_attribute('connection'), 'secure') + + cert = self.browser.tabbar.selected_tab.certificate + + # The shown host equals to the certificate + self.assertEqual(self.identity_popup.view.main.host.get_property('textContent'), + cert['commonName']) + + # Only the secure label is visible in the main view + secure_label = self.identity_popup.view.main.secure_connection_label + self.assertNotEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = self.identity_popup.view.main.insecure_connection_label + self.assertEqual(insecure_label.value_of_css_property('display'), 'none') + + self.identity_popup.view.main.expander.click() + Wait(self.marionette).until( + lambda _: self.identity_popup.view.security.selected, + message='Security view of identity popup has not been selected.') + + # Only the secure label is visible in the security view + secure_label = self.identity_popup.view.security.secure_connection_label + self.assertNotEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = self.identity_popup.view.security.insecure_connection_label + self.assertEqual(insecure_label.value_of_css_property('display'), 'none') + + verifier_label = self.browser.localize_property('identity.identified.verifier') + self.assertEqual(self.identity_popup.view.security.verifier.get_property('textContent'), + verifier_label.replace("%S", cert['issuerOrganization'])) + + def opener(mn): + self.identity_popup.view.security.more_info_button.click() + + page_info_window = self.browser.open_page_info_window(opener) + deck = page_info_window.deck + + self.assertEqual(deck.selected_panel, deck.security) + + self.assertEqual(deck.security.domain.get_property('value'), + cert['commonName']) + + self.assertEqual(deck.security.owner.get_property('value'), + page_info_window.localize_property('securityNoOwner')) + + self.assertEqual(deck.security.verifier.get_property('value'), + cert['issuerOrganization']) diff --git a/testing/firefox-ui/tests/functional/security/test_enable_privilege.py b/testing/firefox-ui/tests/functional/security/test_enable_privilege.py new file mode 100644 index 000000000..17e883cc5 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_enable_privilege.py @@ -0,0 +1,17 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from marionette_driver import By +from marionette_harness import MarionetteTestCase + + +class TestEnablePrivilege(MarionetteTestCase): + + def test_enable_privilege(self): + with self.marionette.using_context('content'): + url = self.marionette.absolute_url('security/enable_privilege.html') + self.marionette.navigate(url) + + result = self.marionette.find_element(By.ID, 'result') + self.assertEqual(result.get_property('textContent'), 'PASS') diff --git a/testing/firefox-ui/tests/functional/security/test_ev_certificate.py b/testing/firefox-ui/tests/functional/security/test_ev_certificate.py new file mode 100644 index 000000000..f5acf5795 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_ev_certificate.py @@ -0,0 +1,112 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestEVCertificate(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestEVCertificate, self).setUp() + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + self.url = 'https://ssl-ev.mozqa.com/' + + def tearDown(self): + try: + self.browser.switch_to() + self.identity_popup.close(force=True) + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestEVCertificate, self).tearDown() + + def test_ev_certificate(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + # Check the identity box + self.assertEqual(self.locationbar.identity_box.get_property('className'), + 'verifiedIdentity') + + # Get the information from the certificate + cert = self.browser.tabbar.selected_tab.certificate + address = self.puppeteer.security.get_address_from_certificate(cert) + + # Check the identity popup label displays + self.assertEqual(self.locationbar.identity_organization_label.get_property('value'), + cert['organization']) + self.assertEqual(self.locationbar.identity_country_label.get_property('value'), + '(' + address['country'] + ')') + + # Open the identity popup + self.locationbar.open_identity_popup() + + # Check the idenity popup doorhanger + self.assertEqual(self.identity_popup.element.get_attribute('connection'), 'secure-ev') + + # For EV certificates no hostname but the organization name is shown + self.assertEqual(self.identity_popup.view.main.host.get_property('textContent'), + cert['organization']) + + # Only the secure label is visible in the main view + secure_label = self.identity_popup.view.main.secure_connection_label + self.assertNotEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = self.identity_popup.view.main.insecure_connection_label + self.assertEqual(insecure_label.value_of_css_property('display'), 'none') + + self.identity_popup.view.main.expander.click() + Wait(self.marionette).until(lambda _: self.identity_popup.view.security.selected) + + security_view = self.identity_popup.view.security + + # Only the secure label is visible in the security view + secure_label = security_view.secure_connection_label + self.assertNotEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = security_view.insecure_connection_label + self.assertEqual(insecure_label.value_of_css_property('display'), 'none') + + # Check the organization name + self.assertEqual(security_view.owner.get_property('textContent'), cert['organization']) + + # Check the owner location string + # More information: + # hg.mozilla.org/mozilla-central/file/eab4a81e4457/browser/base/content/browser.js#l7012 + location = self.browser.localize_property('identity.identified.state_and_country') + location = location.replace('%S', address['state'], 1).replace('%S', address['country']) + location = address['city'] + '\n' + location + self.assertEqual(security_view.owner_location.get_property('textContent'), location) + + # Check the verifier + l10n_verifier = self.browser.localize_property('identity.identified.verifier') + l10n_verifier = l10n_verifier.replace('%S', cert['issuerOrganization']) + self.assertEqual(security_view.verifier.get_property('textContent'), l10n_verifier) + + # Open the Page Info window by clicking the More Information button + page_info = self.browser.open_page_info_window( + lambda _: self.identity_popup.view.security.more_info_button.click()) + + try: + # Verify that the current panel is the security panel + self.assertEqual(page_info.deck.selected_panel, page_info.deck.security) + + # Verify the domain listed on the security panel + self.assertIn(cert['commonName'], + page_info.deck.security.domain.get_property('value')) + + # Verify the owner listed on the security panel + self.assertEqual(page_info.deck.security.owner.get_property('value'), + cert['organization']) + + # Verify the verifier listed on the security panel + self.assertEqual(page_info.deck.security.verifier.get_property('value'), + cert['issuerOrganization']) + finally: + page_info.close() + self.browser.focus() diff --git a/testing/firefox-ui/tests/functional/security/test_mixed_content_page.py b/testing/firefox-ui/tests/functional/security/test_mixed_content_page.py new file mode 100644 index 000000000..c146b46f4 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_mixed_content_page.py @@ -0,0 +1,55 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_harness import MarionetteTestCase + + +class TestMixedContentPage(PuppeteerMixin, MarionetteTestCase): + def setUp(self): + super(TestMixedContentPage, self).setUp() + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + self.url = 'https://mozqa.com/data/firefox/security/mixedcontent.html' + + def tearDown(self): + try: + self.identity_popup.close(force=True) + finally: + super(TestMixedContentPage, self).tearDown() + + def test_mixed_content(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + self.assertEqual(self.locationbar.identity_box.get_property('className'), + 'unknownIdentity mixedDisplayContent') + + # Open the identity popup + self.locationbar.open_identity_popup() + + # Only the insecure label is visible in the main view + secure_label = self.identity_popup.view.main.secure_connection_label + self.assertEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = self.identity_popup.view.main.insecure_connection_label + self.assertNotEqual(insecure_label.value_of_css_property('display'), 'none') + + # TODO: Bug 1177417 - Needs to open and close the security view, but a second + # click on the expander doesn't hide the security view + # self.identity_popup.view.main.expander.click() + # Wait(self.marionette).until(lambda _: self.identity_popup.view.security.selected) + + # Only the insecure label is visible in the security view + secure_label = self.identity_popup.view.security.secure_connection_label + self.assertEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = self.identity_popup.view.security.insecure_connection_label + self.assertNotEqual(insecure_label.value_of_css_property('display'), 'none') + + # owner is not visible + owner = self.identity_popup.view.security.owner + self.assertEqual(owner.value_of_css_property('display'), 'none') diff --git a/testing/firefox-ui/tests/functional/security/test_mixed_script_content_blocking.py b/testing/firefox-ui/tests/functional/security/test_mixed_script_content_blocking.py new file mode 100644 index 000000000..796b1dc29 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_mixed_script_content_blocking.py @@ -0,0 +1,87 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, Wait +from marionette_harness import MarionetteTestCase + + +class TestMixedScriptContentBlocking(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestMixedScriptContentBlocking, self).setUp() + + self.url = 'https://mozqa.com/data/firefox/security/mixed_content_blocked/index.html' + + self.test_elements = [ + ('result1', 'Insecure script one'), + ('result2', 'Insecure script from iFrame'), + ('result3', 'Insecure plugin'), + ('result4', 'Insecure stylesheet'), + ] + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + def tearDown(self): + try: + self.identity_popup.close(force=True) + finally: + super(TestMixedScriptContentBlocking, self).tearDown() + + def _expect_protection_status(self, enabled): + if enabled: + color, identity, state = ( + 'rgb(0, 136, 0)', + 'verifiedDomain mixedActiveBlocked', + 'blocked' + ) + else: + color, identity, state = ( + 'rgb(255, 0, 0)', + 'unknownIdentity mixedActiveContent', + 'unblocked' + ) + + # First call to Wait() needs a longer timeout due to the reload of the web page. + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda _: self.locationbar.identity_box.get_property('className') == identity, + message='Expected identity "{}" not found'.format(identity) + ) + + with self.marionette.using_context('content'): + for identifier, description in self.test_elements: + el = self.marionette.find_element(By.ID, identifier) + Wait(self.marionette).until( + lambda mn: el.value_of_css_property('color') == color, + message=("%s has been %s" % (description, state)) + ) + + def expect_protection_enabled(self): + self._expect_protection_status(True) + + def expect_protection_disabled(self): + self._expect_protection_status(False) + + def test_mixed_content_page(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + self.expect_protection_enabled() + + # Disable mixed content blocking via identity popup + self.locationbar.open_identity_popup() + self.identity_popup.view.main.expander.click() + Wait(self.marionette).until(lambda _: self.identity_popup.view.security.selected) + + disable_button = self.identity_popup.view.security.disable_mixed_content_blocking_button + disable_button.click() + + self.expect_protection_disabled() + + # A reload keeps blocking disabled + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + self.expect_protection_disabled() diff --git a/testing/firefox-ui/tests/functional/security/test_no_certificate.py b/testing/firefox-ui/tests/functional/security/test_no_certificate.py new file mode 100644 index 000000000..a3b7bf98a --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_no_certificate.py @@ -0,0 +1,81 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from urlparse import urlparse + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import expected, Wait +from marionette_harness import MarionetteTestCase + + +class TestNoCertificate(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestNoCertificate, self).setUp() + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + self.url = self.marionette.absolute_url('layout/mozilla.html') + + def tearDown(self): + try: + self.browser.switch_to() + self.identity_popup.close(force=True) + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestNoCertificate, self).tearDown() + + def test_no_certificate(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + # Check the favicon + # TODO: find a better way to check, e.g., mozmill's isDisplayed + favicon_hidden = self.marionette.execute_script(""" + return arguments[0].hasAttribute("hidden"); + """, script_args=[self.browser.navbar.locationbar.identity_icon]) + self.assertFalse(favicon_hidden, 'The identity icon is visible') + + # Check that the identity box organization label is blank + self.assertEqual(self.locationbar.identity_organization_label.get_property('value'), '', + 'The organization has no label') + + # Open the identity popup + self.locationbar.open_identity_popup() + + # Check the idenity popup doorhanger + self.assertEqual(self.identity_popup.element.get_attribute('connection'), 'not-secure') + + # The expander for the security view does not exist + expected.element_not_present(lambda m: self.identity_popup.main.expander) + + # Only the insecure label is visible + secure_label = self.identity_popup.view.main.secure_connection_label + self.assertEqual(secure_label.value_of_css_property('display'), 'none') + + insecure_label = self.identity_popup.view.main.insecure_connection_label + self.assertNotEqual(insecure_label.value_of_css_property('display'), 'none') + + self.identity_popup.view.main.expander.click() + Wait(self.marionette).until(lambda _: self.identity_popup.view.security.selected) + + # Open the Page Info window by clicking the "More Information" button + page_info = self.browser.open_page_info_window( + lambda _: self.identity_popup.view.security.more_info_button.click()) + + # Verify that the current panel is the security panel + self.assertEqual(page_info.deck.selected_panel, page_info.deck.security) + + # Check the domain listed on the security panel contains the url's host name + self.assertIn(urlparse(self.url).hostname, + page_info.deck.security.domain.get_property('value')) + + # Check the owner label equals localized 'securityNoOwner' + self.assertEqual(page_info.deck.security.owner.get_property('value'), + page_info.localize_property('securityNoOwner')) + + # Check the verifier label equals localized 'notset' + self.assertEqual(page_info.deck.security.verifier.get_property('value'), + page_info.localize_property('notset')) diff --git a/testing/firefox-ui/tests/functional/security/test_safe_browsing_initial_download.py b/testing/firefox-ui/tests/functional/security/test_safe_browsing_initial_download.py new file mode 100644 index 000000000..6f9c50ffb --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_safe_browsing_initial_download.py @@ -0,0 +1,84 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import os + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase + + +class TestSafeBrowsingInitialDownload(PuppeteerMixin, MarionetteTestCase): + + file_extensions = [ + 'pset', + 'sbstore', + ] + + prefs_download_lists = [ + 'urlclassifier.blockedTable', + 'urlclassifier.downloadAllowTable', + 'urlclassifier.downloadBlockTable', + 'urlclassifier.malwareTable', + 'urlclassifier.phishTable', + 'urlclassifier.trackingTable', + 'urlclassifier.trackingWhitelistTable', + ] + + prefs_provider_update_time = { + # Force an immediate download of the safebrowsing files + 'browser.safebrowsing.provider.google.nextupdatetime': 1, + 'browser.safebrowsing.provider.mozilla.nextupdatetime': 1, + } + + prefs_safebrowsing = { + 'browser.safebrowsing.debug': True, + 'browser.safebrowsing.blockedURIs.enabled': True, + 'browser.safebrowsing.downloads.enabled': True, + 'browser.safebrowsing.phishing.enabled': True, + 'browser.safebrowsing.malware.enabled': True, + 'privacy.trackingprotection.enabled': True, + 'privacy.trackingprotection.pbmode.enabled': True, + } + + def get_safebrowsing_files(self): + files = [] + for pref_name in self.prefs_download_lists: + base_names = self.marionette.get_pref(pref_name).split(',') + for ext in self.file_extensions: + files.extend(['{file}.{ext}'.format(file=f, ext=ext) for f in base_names if f]) + + return set(sorted(files)) + + def setUp(self): + super(TestSafeBrowsingInitialDownload, self).setUp() + + # Force the preferences for the new profile + enforce_prefs = self.prefs_safebrowsing + enforce_prefs.update(self.prefs_provider_update_time) + self.marionette.enforce_gecko_prefs(enforce_prefs) + + self.safebrowsing_path = os.path.join(self.marionette.instance.profile.profile, + 'safebrowsing') + self.safebrowsing_files = self.get_safebrowsing_files() + + def tearDown(self): + try: + # Restart with a fresh profile + self.restart(clean=True) + finally: + super(TestSafeBrowsingInitialDownload, self).tearDown() + + def test_safe_browsing_initial_download(self): + def check_downloaded(_): + return reduce(lambda state, pref: state and int(self.marionette.get_pref(pref)) != 1, + self.prefs_provider_update_time.keys(), True) + + try: + Wait(self.marionette, timeout=60).until( + check_downloaded, message='Not all safebrowsing files have been downloaded') + finally: + files_on_disk_toplevel = os.listdir(self.safebrowsing_path) + for f in self.safebrowsing_files: + self.assertIn(f, files_on_disk_toplevel) diff --git a/testing/firefox-ui/tests/functional/security/test_safe_browsing_notification.py b/testing/firefox-ui/tests/functional/security/test_safe_browsing_notification.py new file mode 100644 index 000000000..5fb3d0389 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_safe_browsing_notification.py @@ -0,0 +1,149 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import time + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, expected, Wait +from marionette_harness import MarionetteTestCase + + +class TestSafeBrowsingNotificationBar(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSafeBrowsingNotificationBar, self).setUp() + + self.test_data = [ + # Unwanted software URL + { + # First two properties are not needed, + # since these errors are not reported + 'button_property': None, + 'report_page': None, + 'unsafe_page': 'https://www.itisatrap.org/firefox/unwanted.html' + }, + # Phishing URL info + { + 'button_property': 'safebrowsing.notADeceptiveSiteButton.label', + 'report_page': 'google.com/safebrowsing/report_error', + 'unsafe_page': 'https://www.itisatrap.org/firefox/its-a-trap.html' + }, + # Malware URL object + { + 'button_property': 'safebrowsing.notAnAttackButton.label', + 'report_page': 'stopbadware.org', + 'unsafe_page': 'https://www.itisatrap.org/firefox/its-an-attack.html' + } + ] + + self.marionette.set_pref('browser.safebrowsing.phishing.enabled', True) + self.marionette.set_pref('browser.safebrowsing.malware.enabled', True) + + # Give the browser a little time, because SafeBrowsing.jsm takes a while + # between start up and adding the example urls to the db. + # hg.mozilla.org/mozilla-central/file/46aebcd9481e/browser/base/content/browser.js#l1194 + time.sleep(3) + + # TODO: Bug 1139544: While we don't have a reliable way to close the safe browsing + # notification bar when a test fails, run this test in a new tab. + self.browser.tabbar.open_tab() + + def tearDown(self): + try: + self.puppeteer.utils.permissions.remove('https://www.itisatrap.org', 'safe-browsing') + self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]]) + self.marionette.clear_pref('browser.safebrowsing.phishing.enabled') + self.marionette.clear_pref('browser.safebrowsing.malware.enabled') + finally: + super(TestSafeBrowsingNotificationBar, self).tearDown() + + def test_notification_bar(self): + with self.marionette.using_context('content'): + for item in self.test_data: + button_property = item['button_property'] + report_page, unsafe_page = item['report_page'], item['unsafe_page'] + + # Navigate to the unsafe page + # Check "ignore warning" link then notification bar's "not badware" button + # Only do this if feature supports it + if button_property is not None: + self.marionette.navigate(unsafe_page) + # Wait for the DOM to receive events for about:blocked + time.sleep(1) + self.check_ignore_warning_button(unsafe_page) + self.check_not_badware_button(button_property, report_page) + + # Return to the unsafe page + # Check "ignore warning" link then notification bar's "get me out" button + self.marionette.navigate(unsafe_page) + # Wait for the DOM to receive events for about:blocked + time.sleep(1) + self.check_ignore_warning_button(unsafe_page) + self.check_get_me_out_of_here_button() + + # Return to the unsafe page + # Check "ignore warning" link then notification bar's "X" button + self.marionette.navigate(unsafe_page) + # Wait for the DOM to receive events for about:blocked + time.sleep(1) + self.check_ignore_warning_button(unsafe_page) + self.check_x_button() + + def check_ignore_warning_button(self, unsafe_page): + button = self.marionette.find_element(By.ID, 'ignoreWarningButton') + button.click() + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + expected.element_present(By.ID, 'main-feature'), + message='Expected target element "#main-feature" has not been found', + ) + self.assertEquals(self.marionette.get_url(), self.browser.get_final_url(unsafe_page)) + + # Clean up here since the permission gets set in this function + self.puppeteer.utils.permissions.remove('https://www.itisatrap.org', 'safe-browsing') + + # Check the not a forgery or attack button in the notification bar + def check_not_badware_button(self, button_property, report_page): + with self.marionette.using_context('chrome'): + # TODO: update to use safe browsing notification bar class when bug 1139544 lands + label = self.browser.localize_property(button_property) + button = (self.marionette.find_element(By.ID, 'content') + .find_element('anon attribute', {'label': label})) + + self.browser.tabbar.open_tab(lambda _: button.click()) + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda mn: report_page in mn.get_url(), + message='The expected safe-browsing report page has not been opened', + ) + + with self.marionette.using_context('chrome'): + self.browser.tabbar.close_tab() + + def check_get_me_out_of_here_button(self): + with self.marionette.using_context('chrome'): + # TODO: update to use safe browsing notification bar class when bug 1139544 lands + label = self.browser.localize_property('safebrowsing.getMeOutOfHereButton.label') + button = (self.marionette.find_element(By.ID, 'content') + .find_element('anon attribute', {'label': label})) + button.click() + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda mn: self.browser.default_homepage in mn.get_url(), + message='The default home page has not been loaded', + ) + + def check_x_button(self): + with self.marionette.using_context('chrome'): + # TODO: update to use safe browsing notification bar class when bug 1139544 lands + button = (self.marionette.find_element(By.ID, 'content') + .find_element('anon attribute', {'value': 'blocked-badware-page'}) + .find_element('anon attribute', + {'class': 'messageCloseButton close-icon tabbable'})) + button.click() + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + expected.element_stale(button), + message='The notification bar has not been closed', + ) diff --git a/testing/firefox-ui/tests/functional/security/test_safe_browsing_warning_pages.py b/testing/firefox-ui/tests/functional/security/test_safe_browsing_warning_pages.py new file mode 100644 index 000000000..968a9464b --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_safe_browsing_warning_pages.py @@ -0,0 +1,115 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import time + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, expected, Wait +from marionette_harness import MarionetteTestCase + + +class TestSafeBrowsingWarningPages(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSafeBrowsingWarningPages, self).setUp() + + self.urls = [ + # Unwanted software URL + 'https://www.itisatrap.org/firefox/unwanted.html', + # Phishing URL + 'https://www.itisatrap.org/firefox/its-a-trap.html', + # Malware URL + 'https://www.itisatrap.org/firefox/its-an-attack.html' + ] + + self.marionette.set_pref('app.support.baseURL', + self.marionette.absolute_url("support.html?topic=")) + self.marionette.set_pref('browser.safebrowsing.phishing.enabled', True) + self.marionette.set_pref('browser.safebrowsing.malware.enabled', True) + + # Give the browser a little time, because SafeBrowsing.jsm takes a + # while between start up and adding the example urls to the db. + # hg.mozilla.org/mozilla-central/file/46aebcd9481e/browser/base/content/browser.js#l1194 + time.sleep(3) + + # TODO: Bug 1139544: While we don't have a reliable way to close the safe browsing + # notification bar when a test fails, run this test in a new tab. + self.browser.tabbar.open_tab() + + def tearDown(self): + try: + self.puppeteer.utils.permissions.remove('https://www.itisatrap.org', 'safe-browsing') + self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]]) + self.marionette.clear_pref('app.support.baseURL') + self.marionette.clear_pref('browser.safebrowsing.malware.enabled') + self.marionette.clear_pref('browser.safebrowsing.phishing.enabled') + finally: + super(TestSafeBrowsingWarningPages, self).tearDown() + + def test_warning_pages(self): + with self.marionette.using_context("content"): + for unsafe_page in self.urls: + # Load a test page, then test the get me out button + self.marionette.navigate(unsafe_page) + # Wait for the DOM to receive events for about:blocked + time.sleep(1) + self.check_get_me_out_of_here_button(unsafe_page) + + # Load the test page again, then test the report button + self.marionette.navigate(unsafe_page) + # Wait for the DOM to receive events for about:blocked + time.sleep(1) + self.check_report_button(unsafe_page) + + # Load the test page again, then test the ignore warning button + self.marionette.navigate(unsafe_page) + # Wait for the DOM to receive events for about:blocked + time.sleep(1) + self.check_ignore_warning_button(unsafe_page) + + def check_get_me_out_of_here_button(self, unsafe_page): + button = self.marionette.find_element(By.ID, "getMeOutButton") + button.click() + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda mn: self.browser.default_homepage in mn.get_url()) + + def check_report_button(self, unsafe_page): + # Get the URL of the support site for phishing and malware. This may result in a redirect. + with self.marionette.using_context('chrome'): + url = self.marionette.execute_script(""" + Components.utils.import("resource://gre/modules/Services.jsm"); + return Services.urlFormatter.formatURLPref("app.support.baseURL") + + "phishing-malware"; + """) + + button = self.marionette.find_element(By.ID, "reportButton") + button.click() + + # Wait for the button to become stale, whereby a longer timeout is needed + # here to not fail in case of slow connections. + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + expected.element_stale(button)) + + # Wait for page load to be completed, so we can verify the URL even if a redirect happens. + # TODO: Bug 1140470: use replacement for mozmill's waitforPageLoad + expected_url = self.browser.get_final_url(url) + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda mn: expected_url == mn.get_url(), + message="The expected URL '{}' has not been loaded".format(expected_url) + ) + + topic = self.marionette.find_element(By.ID, "topic") + self.assertEquals(topic.text, "phishing-malware") + + def check_ignore_warning_button(self, unsafe_page): + button = self.marionette.find_element(By.ID, 'ignoreWarningButton') + button.click() + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + expected.element_present(By.ID, 'main-feature')) + self.assertEquals(self.marionette.get_url(), self.browser.get_final_url(unsafe_page)) + + # Clean up by removing safe browsing permission for unsafe page + self.puppeteer.utils.permissions.remove('https://www.itisatrap.org', 'safe-browsing') diff --git a/testing/firefox-ui/tests/functional/security/test_security_notification.py b/testing/firefox-ui/tests/functional/security/test_security_notification.py new file mode 100644 index 000000000..5825d0364 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_security_notification.py @@ -0,0 +1,62 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import time + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, Wait +from marionette_driver.errors import MarionetteException +from marionette_harness import MarionetteTestCase + + +class TestSecurityNotification(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSecurityNotification, self).setUp() + + self.urls = [ + # Invalid cert page + 'https://ssl-expired.mozqa.com', + # Secure page + 'https://ssl-ev.mozqa.com/', + # Insecure page + 'http://no-ssl.mozqa.com' + ] + + self.identity_box = self.browser.navbar.locationbar.identity_box + + def test_invalid_cert(self): + with self.marionette.using_context('content'): + # Go to a site that has an invalid (expired) cert + self.assertRaises(MarionetteException, self.marionette.navigate, self.urls[0]) + + # Wait for the DOM to receive events + time.sleep(1) + + # Verify the text in Technical Content contains the page with invalid cert + text = self.marionette.find_element(By.ID, 'badCertTechnicalInfo') + self.assertIn(self.urls[0][8:], text.get_property('textContent')) + + # Verify the "Go Back" and "Advanced" buttons appear + self.assertIsNotNone(self.marionette.find_element(By.ID, 'returnButton')) + self.assertIsNotNone(self.marionette.find_element(By.ID, 'advancedButton')) + + # Verify the error code is correct + self.assertIn('SEC_ERROR_EXPIRED_CERTIFICATE', text.get_property('textContent')) + + def test_secure_website(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.urls[1]) + + Wait(self.marionette).until(lambda _: ( + self.identity_box.get_property('className') == 'verifiedIdentity') + ) + + def test_insecure_website(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.urls[2]) + + Wait(self.marionette).until(lambda _: ( + self.identity_box.get_property('className') == 'unknownIdentity') + ) diff --git a/testing/firefox-ui/tests/functional/security/test_ssl_disabled_error_page.py b/testing/firefox-ui/tests/functional/security/test_ssl_disabled_error_page.py new file mode 100644 index 000000000..d1d9c531f --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_ssl_disabled_error_page.py @@ -0,0 +1,60 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import time + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, expected, Wait +from marionette_driver.errors import MarionetteException +from marionette_harness import MarionetteTestCase + + +class TestSSLDisabledErrorPage(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSSLDisabledErrorPage, self).setUp() + + self.url = 'https://tlsv1-0.mozqa.com' + + self.puppeteer.utils.sanitize({"sessions": True}) + + # Disable SSL 3.0, TLS 1.0 and TLS 1.1 for secure connections + # by forcing the use of TLS 1.2 + # see: http://kb.mozillazine.org/Security.tls.version.*#Possible_values_and_their_effects + self.marionette.set_pref('security.tls.version.min', 3) + self.marionette.set_pref('security.tls.version.max', 3) + + def tearDown(self): + try: + self.marionette.clear_pref('security.tls.version.min') + self.marionette.clear_pref('security.tls.version.max') + finally: + super(TestSSLDisabledErrorPage, self).tearDown() + + def test_ssl_disabled_error_page(self): + with self.marionette.using_context('content'): + # Open the test page + self.assertRaises(MarionetteException, self.marionette.navigate, self.url) + + # Wait for the DOM to receive events + time.sleep(1) + + # Verify "Secure Connection Failed" error page title + title = self.marionette.find_element(By.CLASS_NAME, 'title-text') + nss_failure2title = self.browser.localize_entity('nssFailure2.title') + self.assertEquals(title.get_property('textContent'), nss_failure2title) + + # Verify the error message is correct + short_description = self.marionette.find_element(By.ID, 'errorShortDescText') + self.assertIn('SSL_ERROR_UNSUPPORTED_VERSION', + short_description.get_property('textContent')) + self.assertIn('mozqa.com', short_description.get_property('textContent')) + + # Verify that the "Restore" button appears and works + reset_button = self.marionette.find_element(By.ID, 'prefResetButton') + reset_button.click() + + # With the preferences reset, the page has to load correctly + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + expected.element_present(By.LINK_TEXT, 'http://quality.mozilla.org')) diff --git a/testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py b/testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py new file mode 100644 index 000000000..f274d8f2f --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py @@ -0,0 +1,124 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import Wait +from marionette_harness import MarionetteTestCase, skip_if_e10s + + +class TestSSLStatusAfterRestart(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSSLStatusAfterRestart, self).setUp() + + self.test_data = ( + { + 'url': 'https://ssl-dv.mozqa.com', + 'identity': '', + 'type': 'secure' + }, + { + 'url': 'https://ssl-ev.mozqa.com/', + 'identity': 'Mozilla Corporation', + 'type': 'secure-ev' + }, + { + 'url': 'https://ssl-ov.mozqa.com/', + 'identity': '', + 'type': 'secure' + } + ) + + # Set browser to restore previous session + self.marionette.set_pref('browser.startup.page', 3) + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]]) + self.browser.switch_to() + self.identity_popup.close(force=True) + self.marionette.clear_pref('browser.startup.page') + finally: + super(TestSSLStatusAfterRestart, self).tearDown() + + @skip_if_e10s("Bug 1325047") + def test_ssl_status_after_restart(self): + for item in self.test_data: + with self.marionette.using_context('content'): + self.marionette.navigate(item['url']) + self.verify_certificate_status(item) + self.browser.tabbar.open_tab() + + self.restart() + + # Refresh references to elements + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + for index, item in enumerate(self.test_data): + self.browser.tabbar.tabs[index].select() + self.verify_certificate_status(item) + + def verify_certificate_status(self, item): + url, identity, cert_type = item['url'], item['identity'], item['type'] + + # Check the favicon + # TODO: find a better way to check, e.g., mozmill's isDisplayed + favicon_hidden = self.marionette.execute_script(""" + return arguments[0].hasAttribute("hidden"); + """, script_args=[self.browser.navbar.locationbar.identity_icon]) + self.assertFalse(favicon_hidden) + + self.locationbar.open_identity_popup() + + # Check the type shown on the identity popup doorhanger + self.assertEqual(self.identity_popup.element.get_attribute('connection'), + cert_type) + + self.identity_popup.view.main.expander.click() + Wait(self.marionette).until(lambda _: self.identity_popup.view.security.selected) + + # Check the identity label + self.assertEqual(self.locationbar.identity_organization_label.get_property('value'), + identity) + + # Get the information from the certificate + cert = self.browser.tabbar.selected_tab.certificate + + # Open the Page Info window by clicking the More Information button + page_info = self.browser.open_page_info_window( + lambda _: self.identity_popup.view.security.more_info_button.click()) + + # Verify that the current panel is the security panel + self.assertEqual(page_info.deck.selected_panel, page_info.deck.security) + + # Verify the domain listed on the security panel + # If this is a wildcard cert, check only the domain + if cert['commonName'].startswith('*'): + self.assertIn(self.puppeteer.security.get_domain_from_common_name(cert['commonName']), + page_info.deck.security.domain.get_property('value'), + 'Expected domain found in certificate for ' + url) + else: + self.assertEqual(page_info.deck.security.domain.get_property('value'), + cert['commonName'], + 'Domain value matches certificate common name.') + + # Verify the owner listed on the security panel + if identity != '': + owner = cert['organization'] + else: + owner = page_info.localize_property('securityNoOwner') + + self.assertEqual(page_info.deck.security.owner.get_property('value'), owner, + 'Expected owner label found for ' + url) + + # Verify the verifier listed on the security panel + self.assertEqual(page_info.deck.security.verifier.get_property('value'), + cert['issuerOrganization'], + 'Verifier matches issuer of certificate for ' + url) + page_info.close() diff --git a/testing/firefox-ui/tests/functional/security/test_submit_unencrypted_info_warning.py b/testing/firefox-ui/tests/functional/security/test_submit_unencrypted_info_warning.py new file mode 100644 index 000000000..a2f431fb5 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_submit_unencrypted_info_warning.py @@ -0,0 +1,65 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, expected, Wait +from marionette_driver.errors import NoAlertPresentException +from marionette_driver.marionette import Alert +from marionette_harness import MarionetteTestCase + + +class TestSubmitUnencryptedInfoWarning(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSubmitUnencryptedInfoWarning, self).setUp() + + self.url = 'https://ssl-dv.mozqa.com/data/firefox/security/unencryptedsearch.html' + self.test_string = 'mozilla' + + self.marionette.set_pref('security.warn_submit_insecure', True) + + def tearDown(self): + try: + self.marionette.clear_pref('security.warn_submit_insecure') + finally: + super(TestSubmitUnencryptedInfoWarning, self).tearDown() + + def test_submit_unencrypted_info_warning(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + # Get the page's search box and submit button. + searchbox = self.marionette.find_element(By.ID, 'q') + button = self.marionette.find_element(By.ID, 'submit') + + # Use the page's search box to submit information. + searchbox.send_keys(self.test_string) + button.click() + + # Get the expected warning text and replace its two instances of "##" with "\n\n". + message = self.browser.localize_property('formPostSecureToInsecureWarning.message') + message = message.replace('##', '\n\n') + + # Wait for the warning, verify the expected text matches warning, accept the warning + warning = Alert(self.marionette) + try: + Wait(self.marionette, + ignored_exceptions=NoAlertPresentException, + timeout=self.marionette.timeout.page_load).until( + lambda _: warning.text == message) + finally: + warning.accept() + + # Wait for the search box to become stale, then wait for the page to be reloaded. + Wait(self.marionette).until(expected.element_stale(searchbox)) + + # TODO: Bug 1140470: use replacement for mozmill's waitforPageLoad + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda mn: mn.execute_script('return document.readyState == "DOMContentLoaded" ||' + ' document.readyState == "complete";') + ) + + # Check that search_term contains the test string. + search_term = self.marionette.find_element(By.ID, 'search-term') + self.assertEqual(search_term.get_property('textContent'), self.test_string) diff --git a/testing/firefox-ui/tests/functional/security/test_unknown_issuer.py b/testing/firefox-ui/tests/functional/security/test_unknown_issuer.py new file mode 100644 index 000000000..b329f2500 --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_unknown_issuer.py @@ -0,0 +1,34 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import time + +from marionette_driver import By +from marionette_driver.errors import MarionetteException +from marionette_harness import MarionetteTestCase + + +class TestUnknownIssuer(MarionetteTestCase): + + def setUp(self): + super(TestUnknownIssuer, self).setUp() + + self.url = 'https://ssl-unknownissuer.mozqa.com' + + def test_unknown_issuer(self): + with self.marionette.using_context('content'): + # Go to a site that has a cert with an unknown issuer + self.assertRaises(MarionetteException, self.marionette.navigate, self.url) + + # Wait for the DOM to receive events + time.sleep(1) + + # Check for the correct error code + error = self.marionette.find_element(By.ID, 'errorCode') + self.assertEquals(error.get_property('textContent'), + 'SEC_ERROR_UNKNOWN_ISSUER') + + # Verify the "Go Back" and "Advanced" buttons appear + self.assertIsNotNone(self.marionette.find_element(By.ID, 'returnButton')) + self.assertIsNotNone(self.marionette.find_element(By.ID, 'advancedButton')) diff --git a/testing/firefox-ui/tests/functional/security/test_untrusted_connection_error_page.py b/testing/firefox-ui/tests/functional/security/test_untrusted_connection_error_page.py new file mode 100644 index 000000000..0dbce1c8f --- /dev/null +++ b/testing/firefox-ui/tests/functional/security/test_untrusted_connection_error_page.py @@ -0,0 +1,35 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import time + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, Wait +from marionette_driver.errors import MarionetteException +from marionette_harness import MarionetteTestCase + + +class TestUntrustedConnectionErrorPage(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestUntrustedConnectionErrorPage, self).setUp() + + self.url = 'https://ssl-selfsigned.mozqa.com' + + def test_untrusted_connection_error_page(self): + self.marionette.set_context('content') + + # In some localized builds, the default page redirects + target_url = self.browser.get_final_url(self.browser.default_homepage) + + self.assertRaises(MarionetteException, self.marionette.navigate, self.url) + + # Wait for the DOM to receive events + time.sleep(1) + + button = self.marionette.find_element(By.ID, "returnButton") + button.click() + + Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( + lambda mn: target_url == self.marionette.get_url()) diff --git a/testing/firefox-ui/tests/functional/sessionstore/manifest.ini b/testing/firefox-ui/tests/functional/sessionstore/manifest.ini new file mode 100644 index 000000000..c2d0a02b8 --- /dev/null +++ b/testing/firefox-ui/tests/functional/sessionstore/manifest.ini @@ -0,0 +1,5 @@ +[DEFAULT] +tags = local + +[test_restore_windows_after_restart.py] +skip-if = (os == "win" || e10s) # Bug 1291844 and Bug 1228446 diff --git a/testing/firefox-ui/tests/functional/sessionstore/test_restore_windows_after_restart.py b/testing/firefox-ui/tests/functional/sessionstore/test_restore_windows_after_restart.py new file mode 100644 index 000000000..cc7de728b --- /dev/null +++ b/testing/firefox-ui/tests/functional/sessionstore/test_restore_windows_after_restart.py @@ -0,0 +1,150 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_harness import MarionetteTestCase + + +class TestRestoreWindowsAfterRestart(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestRestoreWindowsAfterRestart, self).setUp() + + # Each list element represents a window of tabs loaded at + # some testing URL + self.test_windows = set([ + # Window 1. Note the comma after the absolute_url call - + # this is Python's way of declaring a 1 item tuple. + (self.marionette.absolute_url('layout/mozilla.html'), ), + + # Window 2 + (self.marionette.absolute_url('layout/mozilla_organizations.html'), + self.marionette.absolute_url('layout/mozilla_community.html')), + + # Window 3 + (self.marionette.absolute_url('layout/mozilla_governance.html'), + self.marionette.absolute_url('layout/mozilla_grants.html')), + ]) + + self.private_windows = set([ + (self.marionette.absolute_url('layout/mozilla_mission.html'), + self.marionette.absolute_url('layout/mozilla_organizations.html')), + + (self.marionette.absolute_url('layout/mozilla_projects.html'), + self.marionette.absolute_url('layout/mozilla_mission.html')), + ]) + + self.marionette.enforce_gecko_prefs({ + # Set browser to restore previous session + 'browser.startup.page': 3, + # Make the content load right away instead of waiting for + # the user to click on the background tabs + 'browser.sessionstore.restore_on_demand': False, + # Avoid race conditions by having the content process never + # send us session updates unless the parent has explicitly asked + # for them via the TabStateFlusher. + 'browser.sessionstore.debug.no_auto_updates': True, + }) + + def tearDown(self): + try: + # Create a fresh profile for subsequent tests. + self.restart(clean=True) + finally: + super(TestRestoreWindowsAfterRestart, self).tearDown() + + def test_with_variety(self): + """ Opens a set of windows, both standard and private, with + some number of tabs in them. Once the tabs have loaded, restarts + the browser, and then ensures that the standard tabs have been + restored, and that the private ones have not. + """ + self.open_windows(self.test_windows) + self.open_windows(self.private_windows, is_private=True) + + self.restart() + + windows = self.puppeteer.windows.all + + # There's no guarantee that Marionette will return us an + # iterator for the opened windows that will match the + # order within our window list. Instead, we'll convert + # the list of URLs within each open window to a set of + # tuples that will allow us to do a direct comparison + # while allowing the windows to be in any order. + opened_windows = set() + for win in windows: + urls = tuple() + for tab in win.tabbar.tabs: + urls = urls + tuple([tab.location]) + opened_windows.add(urls) + + self.assertEqual(opened_windows, self.test_windows) + + def open_windows(self, window_sets, is_private=False): + """ Opens a set of windows with tabs pointing at some + URLs. + + @param window_sets (list) + A set of URL tuples. Each tuple within window_sets + represents a window, and each URL in the URL + tuples represents what will be loaded in a tab. + + Note that if is_private is False, then the first + URL tuple will be opened in the current window, and + subequent tuples will be opened in new windows. + + Example: + + set( + (self.marionette.absolute_url('layout/mozilla_1.html'), + self.marionette.absolute_url('layout/mozilla_2.html')), + + (self.marionette.absolute_url('layout/mozilla_3.html'), + self.marionette.absolute_url('layout/mozilla_4.html')), + ) + + This would take the currently open window, and load + mozilla_1.html and mozilla_2.html in new tabs. It would + then open a new, second window, and load tabs at + mozilla_3.html and mozilla_4.html. + @param is_private (boolean, optional) + Whether or not any new windows should be a private browsing + windows. + """ + + if (is_private): + win = self.browser.open_browser(is_private=True) + win.switch_to() + else: + win = self.browser + + for index, urls in enumerate(window_sets): + if index > 0: + win = self.browser.open_browser(is_private=is_private) + win.switch_to() + self.open_tabs(win, urls) + + def open_tabs(self, win, urls): + """ Opens a set of URLs inside a window in new tabs. + + @param win (browser window) + The browser window to load the tabs in. + @param urls (tuple) + A tuple of URLs to load in this window. The + first URL will be loaded in the currently selected + browser tab. Subsequent URLs will be loaded in + new tabs. + """ + # If there are any remaining URLs for this window, + # open some new tabs and navigate to them. + with self.marionette.using_context('content'): + if isinstance(urls, str): + self.marionette.navigate(urls) + else: + for index, url in enumerate(urls): + if index > 0: + with self.marionette.using_context('chrome'): + win.tabbar.open_tab() + self.marionette.navigate(url) diff --git a/testing/firefox-ui/tests/puppeteer/manifest.ini b/testing/firefox-ui/tests/puppeteer/manifest.ini new file mode 100644 index 000000000..2eb24b6dc --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/manifest.ini @@ -0,0 +1,24 @@ +[DEFAULT] +tags = local + +# API tests +[test_appinfo.py] +[test_l10n.py] +[test_places.py] +[test_security.py] +tags = remote +[test_software_update.py] +tags = remote +[test_utils.py] + +# UI tests +[test_about_window.py] +[test_menubar.py] +[test_notifications.py] +[test_page_info_window.py] +[test_tabbar.py] +[test_toolbars.py] +tags = remote +[test_update_wizard.py] +tags = remote +[test_windows.py] diff --git a/testing/firefox-ui/tests/puppeteer/test_about_window.py b/testing/firefox-ui/tests/puppeteer/test_about_window.py new file mode 100644 index 000000000..c957211bb --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_about_window.py @@ -0,0 +1,74 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.ui.deck import Panel +from marionette_harness import MarionetteTestCase + + +class TestAboutWindow(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestAboutWindow, self).setUp() + + self.about_window = self.browser.open_about_window() + self.deck = self.about_window.deck + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestAboutWindow, self).tearDown() + + def test_basic(self): + self.assertEqual(self.about_window.window_type, 'Browser:About') + + def test_elements(self): + """Test correct retrieval of elements.""" + self.assertNotEqual(self.about_window.dtds, []) + + self.assertEqual(self.deck.element.get_property('localName'), 'deck') + + # apply panel + panel = self.deck.apply + self.assertEqual(panel.element.get_property('localName'), 'hbox') + self.assertEqual(panel.button.get_property('localName'), 'button') + + # check_for_updates panel + panel = self.deck.check_for_updates + self.assertEqual(panel.element.get_property('localName'), 'hbox') + self.assertEqual(panel.button.get_property('localName'), 'button') + + # checking_for_updates panel + self.assertEqual(self.deck.checking_for_updates.element.get_property('localName'), 'hbox') + + # download_and_install panel + panel = self.deck.download_and_install + self.assertEqual(panel.element.get_property('localName'), 'hbox') + self.assertEqual(panel.button.get_property('localName'), 'button') + + # download_failed panel + self.assertEqual(self.deck.download_failed.element.get_property('localName'), 'hbox') + + # downloading panel + self.assertEqual(self.deck.downloading.element.get_property('localName'), 'hbox') + + # check deck attributes + self.assertIsInstance(self.deck.selected_index, int) + self.assertIsInstance(self.deck.selected_panel, Panel) + + def test_open_window(self): + """Test various opening strategies.""" + def opener(win): + self.browser.menubar.select_by_id('helpMenu', 'aboutName') + + open_strategies = ('menu', + opener, + ) + + self.about_window.close() + for trigger in open_strategies: + about_window = self.browser.open_about_window(trigger=trigger) + self.assertEquals(about_window, self.puppeteer.windows.current) + about_window.close() diff --git a/testing/firefox-ui/tests/puppeteer/test_appinfo.py b/testing/firefox-ui/tests/puppeteer/test_appinfo.py new file mode 100644 index 000000000..f0be0f616 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_appinfo.py @@ -0,0 +1,31 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import mozversion + +from firefox_puppeteer import PuppeteerMixin +from marionette_harness import MarionetteTestCase + + +class TestAppInfo(PuppeteerMixin, MarionetteTestCase): + + def test_valid_properties(self): + binary = self.marionette.bin + version_info = mozversion.get_version(binary=binary) + + self.assertEqual(self.puppeteer.appinfo.ID, version_info['application_id']) + self.assertEqual(self.puppeteer.appinfo.name, version_info['application_name']) + self.assertEqual(self.puppeteer.appinfo.vendor, version_info['application_vendor']) + self.assertEqual(self.puppeteer.appinfo.version, version_info['application_version']) + # Bug 1298328 - Platform buildid mismatch due to incremental builds + # self.assertEqual(self.puppeteer.appinfo.platformBuildID, + # version_info['platform_buildid']) + self.assertEqual(self.puppeteer.appinfo.platformVersion, version_info['platform_version']) + self.assertIsNotNone(self.puppeteer.appinfo.locale) + self.assertIsNotNone(self.puppeteer.appinfo.user_agent) + self.assertIsNotNone(self.puppeteer.appinfo.XPCOMABI) + + def test_invalid_properties(self): + with self.assertRaises(AttributeError): + self.puppeteer.appinfo.unknown diff --git a/testing/firefox-ui/tests/puppeteer/test_l10n.py b/testing/firefox-ui/tests/puppeteer/test_l10n.py new file mode 100644 index 000000000..08f41f9d7 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_l10n.py @@ -0,0 +1,51 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.api.l10n import L10n +from marionette_driver import By +from marionette_driver.errors import NoSuchElementException +from marionette_harness import MarionetteTestCase + + +class TestL10n(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestL10n, self).setUp() + + self.l10n = L10n(self.marionette) + + def test_dtd_entity_chrome(self): + dtds = ['chrome://global/locale/about.dtd', + 'chrome://browser/locale/baseMenuOverlay.dtd'] + + value = self.l10n.localize_entity(dtds, 'helpSafeMode.label') + elm = self.marionette.find_element(By.ID, 'helpSafeMode') + self.assertEqual(value, elm.get_attribute('label')) + + self.assertRaises(NoSuchElementException, + self.l10n.localize_entity, dtds, 'notExistent') + + def test_dtd_entity_content(self): + dtds = ['chrome://global/locale/about.dtd', + 'chrome://global/locale/aboutSupport.dtd'] + + value = self.l10n.localize_entity(dtds, 'aboutSupport.pageTitle') + + self.marionette.set_context(self.marionette.CONTEXT_CONTENT) + self.marionette.navigate('about:support') + + elm = self.marionette.find_element(By.TAG_NAME, 'title') + self.assertEqual(value, elm.text) + + def test_properties(self): + properties = ['chrome://global/locale/filepicker.properties', + 'chrome://global/locale/findbar.properties'] + + # TODO: Find a way to verify the retrieved translated string + value = self.l10n.localize_property(properties, 'NotFound') + self.assertNotEqual(value, '') + + self.assertRaises(NoSuchElementException, + self.l10n.localize_property, properties, 'notExistent') diff --git a/testing/firefox-ui/tests/puppeteer/test_menubar.py b/testing/firefox-ui/tests/puppeteer/test_menubar.py new file mode 100644 index 000000000..ddc6117bf --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_menubar.py @@ -0,0 +1,30 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver.errors import NoSuchElementException +from marionette_harness import MarionetteTestCase + + +class TestMenuBar(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestMenuBar, self).setUp() + + def test_click_item_in_menubar(self): + def opener(_): + self.browser.menubar.select_by_id('file-menu', + 'menu_newNavigatorTab') + + self.browser.tabbar.open_tab(trigger=opener) + + self.browser.tabbar.tabs[-1].close() + + def test_click_non_existent_menu_and_item(self): + with self.assertRaises(NoSuchElementException): + self.browser.menubar.select_by_id('foobar-menu', + 'menu_newNavigatorTab') + + with self.assertRaises(NoSuchElementException): + self.browser.menubar.select_by_id('file-menu', 'menu_foobar') diff --git a/testing/firefox-ui/tests/puppeteer/test_notifications.py b/testing/firefox-ui/tests/puppeteer/test_notifications.py new file mode 100644 index 000000000..de44c7434 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_notifications.py @@ -0,0 +1,82 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.ui.browser.notifications import ( + AddOnInstallFailedNotification, + AddOnInstallConfirmationNotification, +) +from marionette_driver import By +from marionette_driver.errors import TimeoutException +from marionette_harness import MarionetteTestCase + + +class TestNotifications(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestNotifications, self).setUp() + + self.marionette.set_pref('extensions.install.requireSecureOrigin', False) + + self.addons_url = self.marionette.absolute_url('addons/extensions/') + self.puppeteer.utils.permissions.add(self.marionette.baseurl, 'install') + + def tearDown(self): + try: + self.marionette.clear_pref('extensions.install.requireSecureOrigin') + self.marionette.clear_pref('xpinstall.signatures.required') + + self.puppeteer.utils.permissions.remove(self.addons_url, 'install') + + if self.browser.notification: + self.browser.notification.close(force=True) + finally: + super(TestNotifications, self).tearDown() + + def test_open_close_notification(self): + """Trigger and dismiss a notification""" + self.assertIsNone(self.browser.notification) + self.trigger_addon_notification('restartless_addon_signed.xpi') + self.browser.notification.close() + self.assertIsNone(self.browser.notification) + + def test_wait_for_notification_timeout(self): + """Wait for a notification when one is not shown""" + message = 'No notification was shown' + with self.assertRaisesRegexp(TimeoutException, message): + self.browser.wait_for_notification() + + def test_wait_for_specific_notification_timeout(self): + """Wait for a notification when one is not shown""" + message = 'AddOnInstallFailedNotification was not shown' + with self.assertRaisesRegexp(TimeoutException, message): + self.browser.wait_for_notification(AddOnInstallFailedNotification) + + def test_wait_for_no_notification_timeout(self): + """Wait for no notification when one is shown""" + message = 'Unexpected notification shown' + self.trigger_addon_notification('restartless_addon_signed.xpi') + with self.assertRaisesRegexp(TimeoutException, message): + self.browser.wait_for_notification(None) + + def test_notification_with_origin(self): + """Trigger a notification with an origin""" + self.trigger_addon_notification('restartless_addon_signed.xpi') + self.assertIn(self.browser.notification.origin, self.marionette.baseurl) + self.assertIsNotNone(self.browser.notification.label) + + def test_addon_install_failed_notification(self): + """Trigger add-on blocked notification using an unsigned add-on""" + # Ensure that installing unsigned extensions will fail + self.marionette.set_pref('xpinstall.signatures.required', True) + + self.trigger_addon_notification( + 'restartless_addon_unsigned.xpi', + notification=AddOnInstallFailedNotification) + + def trigger_addon_notification(self, addon, notification=AddOnInstallConfirmationNotification): + with self.marionette.using_context('content'): + self.marionette.navigate(self.addons_url) + self.marionette.find_element(By.LINK_TEXT, addon).click() + self.browser.wait_for_notification(notification) diff --git a/testing/firefox-ui/tests/puppeteer/test_page_info_window.py b/testing/firefox-ui/tests/puppeteer/test_page_info_window.py new file mode 100644 index 000000000..d86cbee3c --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_page_info_window.py @@ -0,0 +1,100 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_harness import MarionetteTestCase + + +class TestPageInfoWindow(PuppeteerMixin, MarionetteTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestPageInfoWindow, self).tearDown() + + def test_elements(self): + """Test correct retrieval of elements.""" + page_info = self.browser.open_page_info_window() + + self.assertNotEqual(page_info.dtds, []) + self.assertNotEqual(page_info.properties, []) + + self.assertEqual(page_info.deck.element.get_property('localName'), 'deck') + + # feed panel + self.assertEqual(page_info.deck.feed.element.get_property('localName'), 'vbox') + + # general panel + self.assertEqual(page_info.deck.general.element.get_property('localName'), 'vbox') + + # media panel + self.assertEqual(page_info.deck.media.element.get_property('localName'), 'vbox') + + # permissions panel + self.assertEqual(page_info.deck.permissions.element.get_property('localName'), 'vbox') + + # security panel + panel = page_info.deck.select(page_info.deck.security) + + self.assertEqual(panel.element.get_property('localName'), 'vbox') + + self.assertEqual(panel.domain.get_property('localName'), 'textbox') + self.assertEqual(panel.owner.get_property('localName'), 'textbox') + self.assertEqual(panel.verifier.get_property('localName'), 'textbox') + + self.assertEqual(panel.view_certificate.get_property('localName'), 'button') + self.assertEqual(panel.view_cookies.get_property('localName'), 'button') + self.assertEqual(panel.view_passwords.get_property('localName'), 'button') + + def test_select(self): + """Test properties and methods for switching between panels.""" + page_info = self.browser.open_page_info_window() + deck = page_info.deck + + self.assertEqual(deck.selected_panel, deck.general) + + self.assertEqual(deck.select(deck.security), deck.security) + self.assertEqual(deck.selected_panel, deck.security) + + def test_open_window(self): + """Test various opening strategies.""" + def opener(win): + self.browser.menubar.select_by_id('tools-menu', 'menu_pageInfo') + + open_strategies = ('menu', + 'shortcut', + opener, + ) + + for trigger in open_strategies: + if trigger == 'shortcut' and self.puppeteer.platform == 'windows_nt': + # The shortcut for page info window does not exist on windows. + self.assertRaises(ValueError, self.browser.open_page_info_window, + trigger=trigger) + continue + + page_info = self.browser.open_page_info_window(trigger=trigger) + self.assertEquals(page_info, self.puppeteer.windows.current) + page_info.close() + + def test_close_window(self): + """Test various closing strategies.""" + def closer(win): + win.send_shortcut(win.localize_entity('closeWindow.key'), + accel=True) + + # Close a tab by each trigger method + close_strategies = ('menu', + 'shortcut', + closer, + ) + for trigger in close_strategies: + # menu only works on OS X + if trigger == 'menu' and self.puppeteer.platform != 'darwin': + continue + + page_info = self.browser.open_page_info_window() + page_info.close(trigger=trigger) + self.assertTrue(page_info.closed) diff --git a/testing/firefox-ui/tests/puppeteer/test_places.py b/testing/firefox-ui/tests/puppeteer/test_places.py new file mode 100644 index 000000000..95d0f23a4 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_places.py @@ -0,0 +1,85 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import By, Wait +from marionette_harness import MarionetteTestCase + + +class TestPlaces(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestPlaces, self).setUp() + + self.urls = [self.marionette.absolute_url('layout/mozilla_governance.html'), + self.marionette.absolute_url('layout/mozilla_grants.html'), + ] + + def tearDown(self): + try: + self.puppeteer.places.restore_default_bookmarks() + self.puppeteer.places.remove_all_history() + finally: + super(TestPlaces, self).tearDown() + + def get_all_urls_in_history(self): + return self.marionette.execute_script(""" + let hs = Components.classes["@mozilla.org/browser/nav-history-service;1"] + .getService(Components.interfaces.nsINavHistoryService); + let urls = []; + + let options = hs.getNewQueryOptions(); + options.resultType = options.RESULTS_AS_URI; + + let root = hs.executeQuery(hs.getNewQuery(), options).root + root.containerOpen = true; + for (let i = 0; i < root.childCount; i++) { + urls.push(root.getChild(i).uri) + } + root.containerOpen = false; + + return urls; + """) + + def test_plugins(self): + # TODO: Once we use a plugin, add a test case to verify that the data will be removed + self.puppeteer.places.clear_plugin_data() + + def test_bookmarks(self): + star_button = self.marionette.find_element(By.ID, 'bookmarks-menu-button') + + # Visit URLs and bookmark them all + for url in self.urls: + with self.marionette.using_context('content'): + self.marionette.navigate(url) + + Wait(self.marionette).until( + lambda _: self.puppeteer.places.is_bookmark_star_button_ready()) + star_button.click() + Wait(self.marionette).until(lambda _: self.puppeteer.places.is_bookmarked(url)) + + ids = self.puppeteer.places.get_folder_ids_for_url(url) + self.assertEqual(len(ids), 1) + self.assertEqual(ids[0], self.puppeteer.places.bookmark_folders.unfiled) + + # Restore default bookmarks, so the added URLs are gone + self.puppeteer.places.restore_default_bookmarks() + for url in self.urls: + self.assertFalse(self.puppeteer.places.is_bookmarked(url)) + + def test_history(self): + self.assertEqual(len(self.get_all_urls_in_history()), 0) + + # Visit pages and check that they are all present + def load_urls(): + with self.marionette.using_context('content'): + for url in self.urls: + self.marionette.navigate(url) + self.puppeteer.places.wait_for_visited(self.urls, load_urls) + + self.assertEqual(self.get_all_urls_in_history(), self.urls) + + # Check that both pages are no longer in the remove_all_history + self.puppeteer.places.remove_all_history() + self.assertEqual(len(self.get_all_urls_in_history()), 0) diff --git a/testing/firefox-ui/tests/puppeteer/test_security.py b/testing/firefox-ui/tests/puppeteer/test_security.py new file mode 100644 index 000000000..879053e5a --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_security.py @@ -0,0 +1,45 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.errors import NoCertificateError +from marionette_harness import MarionetteTestCase + + +class TestSecurity(PuppeteerMixin, MarionetteTestCase): + + def test_get_address_from_certificate(self): + url = 'https://ssl-ev.mozqa.com' + + with self.marionette.using_context(self.marionette.CONTEXT_CONTENT): + self.marionette.navigate(url) + + cert = self.browser.tabbar.tabs[0].certificate + self.assertIn(cert['commonName'], url) + self.assertEqual(cert['organization'], 'Mozilla Corporation') + self.assertEqual(cert['issuerOrganization'], 'DigiCert Inc') + + address = self.puppeteer.security.get_address_from_certificate(cert) + self.assertIsNotNone(address) + self.assertIsNotNone(address['city']) + self.assertIsNotNone(address['country']) + self.assertIsNotNone(address['postal_code']) + self.assertIsNotNone(address['state']) + self.assertIsNotNone(address['street']) + + def test_get_certificate(self): + url_http = self.marionette.absolute_url('layout/mozilla.html') + url_https = 'https://ssl-ev.mozqa.com' + + # Test EV certificate + with self.marionette.using_context(self.marionette.CONTEXT_CONTENT): + self.marionette.navigate(url_https) + cert = self.browser.tabbar.tabs[0].certificate + self.assertIn(cert['commonName'], url_https) + + # HTTP connections do not have a SSL certificate + with self.marionette.using_context(self.marionette.CONTEXT_CONTENT): + self.marionette.navigate(url_http) + with self.assertRaises(NoCertificateError): + self.browser.tabbar.tabs[0].certificate diff --git a/testing/firefox-ui/tests/puppeteer/test_software_update.py b/testing/firefox-ui/tests/puppeteer/test_software_update.py new file mode 100644 index 000000000..4bad47d94 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_software_update.py @@ -0,0 +1,134 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import os + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.api.software_update import SoftwareUpdate +from marionette_harness import MarionetteTestCase + + +class TestSoftwareUpdate(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSoftwareUpdate, self).setUp() + + self.software_update = SoftwareUpdate(self.marionette) + + self.saved_mar_channels = self.software_update.mar_channels.channels + self.software_update.mar_channels.channels = set(['expected', 'channels']) + + def tearDown(self): + try: + self.software_update.mar_channels.channels = self.saved_mar_channels + finally: + super(TestSoftwareUpdate, self).tearDown() + + def test_abi(self): + self.assertTrue(self.software_update.ABI) + + def test_allowed(self): + self.assertTrue(self.software_update.allowed) + + def test_build_info(self): + build_info = self.software_update.build_info + self.assertEqual(build_info['disabled_addons'], None) + self.assertIn('Mozilla/', build_info['user_agent']) + self.assertEqual(build_info['mar_channels'], set(['expected', 'channels'])) + self.assertTrue(build_info['version']) + self.assertTrue(build_info['buildid'].isdigit()) + self.assertTrue(build_info['locale']) + self.assertIn('force=1', build_info['update_url']) + self.assertIn('xml', build_info['update_snippet']) + self.assertEqual(build_info['channel'], self.software_update.update_channel) + + def test_force_fallback(self): + status_file = os.path.join(self.software_update.staging_directory, 'update.status') + + try: + self.software_update.force_fallback() + with open(status_file, 'r') as f: + content = f.read() + self.assertEqual(content, 'failed: 6\n') + finally: + os.remove(status_file) + + def test_get_update_url(self): + update_url = self.software_update.get_update_url() + self.assertIn('Firefox', update_url) + self.assertNotIn('force=1', update_url) + update_url = self.software_update.get_update_url(True) + self.assertIn('Firefox', update_url) + self.assertIn('force=1', update_url) + + def test_os_version(self): + self.assertTrue(self.software_update.os_version) + + def test_staging_directory(self): + self.assertTrue(self.software_update.staging_directory) + + +class TestUpdateChannel(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestUpdateChannel, self).setUp() + + self.software_update = SoftwareUpdate(self.marionette) + + self.saved_channel = self.software_update.update_channel + self.software_update.update_channel = 'expected_channel' + + def tearDown(self): + try: + self.software_update.update_channel = self.saved_channel + finally: + super(TestUpdateChannel, self).tearDown() + + def test_update_channel_default_channel(self): + # Without a restart the update channel will not change. + self.assertEqual(self.software_update.update_channel, self.saved_channel) + + def test_update_channel_set_channel(self): + try: + # Use the clean option to force a non in_app restart, which would allow + # Firefox to dump the logs to the console. + self.restart(clean=True) + self.assertEqual(self.software_update.update_channel, 'expected_channel') + finally: + self.software_update.update_channel = self.saved_channel + self.restart(clean=True) + + +class TestMARChannels(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestMARChannels, self).setUp() + + self.software_update = SoftwareUpdate(self.marionette) + + self.saved_mar_channels = self.software_update.mar_channels.channels + self.software_update.mar_channels.channels = set(['expected', 'channels']) + + def tearDown(self): + try: + self.software_update.mar_channels.channels = self.saved_mar_channels + finally: + super(TestMARChannels, self).tearDown() + + def test_mar_channels_channels(self): + self.assertEqual(self.software_update.mar_channels.channels, set(['expected', 'channels'])) + + def test_mar_channels_set_channels(self): + self.software_update.mar_channels.channels = set(['a', 'b', 'c']) + self.assertEqual(self.software_update.mar_channels.channels, set(['a', 'b', 'c'])) + + def test_mar_channels_add_channels(self): + self.software_update.mar_channels.add_channels(set(['some', 'new', 'channels'])) + self.assertEqual( + self.software_update.mar_channels.channels, + set(['expected', 'channels', 'some', 'new'])) + + def test_mar_channels_remove_channels(self): + self.software_update.mar_channels.remove_channels(set(['expected'])) + self.assertEqual(self.software_update.mar_channels.channels, set(['channels'])) diff --git a/testing/firefox-ui/tests/puppeteer/test_tabbar.py b/testing/firefox-ui/tests/puppeteer/test_tabbar.py new file mode 100644 index 000000000..7da3f7ee7 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_tabbar.py @@ -0,0 +1,191 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.errors import NoCertificateError +from marionette_harness import MarionetteTestCase + + +class TestTabBar(PuppeteerMixin, MarionetteTestCase): + + def tearDown(self): + try: + self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]]) + finally: + super(TestTabBar, self).tearDown() + + def test_basics(self): + tabbar = self.browser.tabbar + + self.assertEqual(tabbar.window, self.browser) + + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + + self.assertEqual(tabbar.newtab_button.get_property('localName'), 'toolbarbutton') + self.assertEqual(tabbar.toolbar.get_property('localName'), 'tabs') + + def test_open_close(self): + tabbar = self.browser.tabbar + + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(tabbar.selected_index, 0) + + # Open with default trigger, and force closing the tab + tabbar.open_tab() + tabbar.close_tab(force=True) + + # Open a new tab by each trigger method + open_strategies = ('button', + 'menu', + 'shortcut', + lambda tab: tabbar.newtab_button.click() + ) + for trigger in open_strategies: + new_tab = tabbar.open_tab(trigger=trigger) + self.assertEqual(len(tabbar.tabs), 2) + self.assertEqual(new_tab.handle, self.marionette.current_window_handle) + self.assertEqual(new_tab.handle, tabbar.tabs[1].handle) + + tabbar.close_tab() + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + self.assertNotEqual(new_tab.handle, tabbar.tabs[0].handle) + + # Close a tab by each trigger method + close_strategies = ('button', + 'menu', + 'shortcut', + lambda tab: tab.close_button.click()) + for trigger in close_strategies: + new_tab = tabbar.open_tab() + self.assertEqual(len(tabbar.tabs), 2) + self.assertEqual(new_tab.handle, self.marionette.current_window_handle) + self.assertEqual(new_tab.handle, tabbar.tabs[1].handle) + + tabbar.close_tab(trigger=trigger) + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + self.assertNotEqual(new_tab.handle, tabbar.tabs[0].handle) + + def test_close_not_selected_tab(self): + tabbar = self.browser.tabbar + + new_tab = tabbar.open_tab() + tabbar.close_tab(tabbar.tabs[0], trigger="button") + + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(new_tab, tabbar.tabs[0]) + + def test_close_all_tabs_except_first(self): + tabbar = self.browser.tabbar + + orig_tab = tabbar.tabs[0] + + for i in range(0, 3): + tabbar.open_tab() + + tabbar.close_all_tabs([orig_tab]) + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(orig_tab.handle, self.marionette.current_window_handle) + + def test_switch_to(self): + tabbar = self.browser.tabbar + + # Open a new tab in the foreground (will be auto-selected) + new_tab = tabbar.open_tab() + self.assertEqual(new_tab.handle, self.marionette.current_window_handle) + self.assertEqual(tabbar.selected_index, 1) + self.assertEqual(tabbar.selected_tab, new_tab) + + # Switch by index + tabbar.switch_to(0) + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + + # Switch by tab + tabbar.switch_to(new_tab) + self.assertEqual(new_tab.handle, self.marionette.current_window_handle) + + # Switch by callback + tabbar.switch_to(lambda tab: tab.window.tabbar.selected_tab != tab) + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + + tabbar.close_tab(tabbar.tabs[1]) + + +class TestTab(PuppeteerMixin, MarionetteTestCase): + + def tearDown(self): + try: + self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]]) + finally: + super(TestTab, self).tearDown() + + def test_basic(self): + tab = self.browser.tabbar.tabs[0] + + self.assertEqual(tab.window, self.browser) + + self.assertEqual(tab.tab_element.get_property('localName'), 'tab') + self.assertEqual(tab.close_button.get_property('localName'), 'toolbarbutton') + + def test_certificate(self): + url = self.marionette.absolute_url('layout/mozilla.html') + + with self.marionette.using_context(self.marionette.CONTEXT_CONTENT): + self.marionette.navigate(url) + with self.assertRaises(NoCertificateError): + self.browser.tabbar.tabs[0].certificate + + def test_close(self): + tabbar = self.browser.tabbar + + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(tabbar.selected_index, 0) + + # Force closing the tab + new_tab = tabbar.open_tab() + new_tab.close(force=True) + + # Close a tab by each trigger method + close_strategies = ('button', + 'menu', + 'shortcut', + lambda tab: tab.close_button.click()) + for trigger in close_strategies: + new_tab = tabbar.open_tab() + self.assertEqual(len(tabbar.tabs), 2) + self.assertEqual(new_tab.handle, self.marionette.current_window_handle) + self.assertEqual(new_tab.handle, tabbar.tabs[1].handle) + + new_tab.close(trigger=trigger) + self.assertEqual(len(tabbar.tabs), 1) + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + self.assertNotEqual(new_tab.handle, tabbar.tabs[0].handle) + + def test_location(self): + url = self.marionette.absolute_url('layout/mozilla.html') + with self.marionette.using_context(self.marionette.CONTEXT_CONTENT): + self.marionette.navigate(url) + self.assertEqual(self.browser.tabbar.tabs[0].location, url) + + def test_switch_to(self): + tabbar = self.browser.tabbar + + new_tab = tabbar.open_tab() + + # Switch to the first tab, which will not select it + tabbar.tabs[0].switch_to() + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + # Bug 1128656: We cannot test as long as switch_to_window() auto-selects the tab + # self.assertEqual(tabbar.selected_index, 1) + # self.assertEqual(tabbar.selected_tab, new_tab) + + # Now select the first tab + tabbar.tabs[0].select() + self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle) + self.assertTrue(tabbar.tabs[0].selected) + self.assertFalse(tabbar.tabs[1].selected) + + new_tab.close() diff --git a/testing/firefox-ui/tests/puppeteer/test_toolbars.py b/testing/firefox-ui/tests/puppeteer/test_toolbars.py new file mode 100644 index 000000000..8150be7e1 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_toolbars.py @@ -0,0 +1,283 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_driver import expected, By, Wait +from marionette_driver.errors import NoSuchElementException +from marionette_harness import MarionetteTestCase + + +class TestNavBar(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestNavBar, self).setUp() + + self.navbar = self.browser.navbar + self.url = self.marionette.absolute_url('layout/mozilla.html') + + with self.marionette.using_context('content'): + self.marionette.navigate('about:blank') + + # TODO: check why self.puppeteer.places.remove_all_history() does not work here + self.marionette.execute_script(""" + let count = gBrowser.sessionHistory.count; + gBrowser.sessionHistory.PurgeHistory(count); + """) + + def test_elements(self): + self.assertEqual(self.navbar.back_button.get_property('localName'), 'toolbarbutton') + self.assertEqual(self.navbar.forward_button.get_property('localName'), 'toolbarbutton') + self.assertEqual(self.navbar.home_button.get_property('localName'), 'toolbarbutton') + self.assertEqual(self.navbar.menu_button.get_property('localName'), 'toolbarbutton') + self.assertEqual(self.navbar.toolbar.get_property('localName'), 'toolbar') + + def test_buttons(self): + self.marionette.set_context('content') + + # Load initial web page + self.marionette.navigate(self.url) + Wait(self.marionette).until(expected.element_present(lambda m: + m.find_element(By.ID, 'mozilla_logo'))) + + with self.marionette.using_context('chrome'): + # Both buttons are disabled + self.assertFalse(self.navbar.back_button.is_enabled()) + self.assertFalse(self.navbar.forward_button.is_enabled()) + + # Go to the homepage + self.navbar.home_button.click() + + Wait(self.marionette).until(expected.element_not_present(lambda m: + m.find_element(By.ID, 'mozilla_logo'))) + self.assertEqual(self.marionette.get_url(), self.browser.default_homepage) + + with self.marionette.using_context('chrome'): + # Only back button is enabled + self.assertTrue(self.navbar.back_button.is_enabled()) + self.assertFalse(self.navbar.forward_button.is_enabled()) + + # Navigate back + self.navbar.back_button.click() + + Wait(self.marionette).until(expected.element_present(lambda m: + m.find_element(By.ID, 'mozilla_logo'))) + self.assertEqual(self.marionette.get_url(), self.url) + + with self.marionette.using_context('chrome'): + # Only forward button is enabled + self.assertFalse(self.navbar.back_button.is_enabled()) + self.assertTrue(self.navbar.forward_button.is_enabled()) + + # Navigate forward + self.navbar.forward_button.click() + + Wait(self.marionette).until(expected.element_not_present(lambda m: + m.find_element(By.ID, 'mozilla_logo'))) + self.assertEqual(self.marionette.get_url(), self.browser.default_homepage) + + +class TestLocationBar(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestLocationBar, self).setUp() + + self.locationbar = self.browser.navbar.locationbar + + def test_elements(self): + self.assertEqual(self.locationbar.urlbar.get_property('localName'), 'textbox') + self.assertIn('urlbar-input', self.locationbar.urlbar_input.get_property('className')) + + self.assertEqual(self.locationbar.connection_icon.get_property('localName'), 'image') + self.assertEqual(self.locationbar.identity_box.get_property('localName'), 'box') + self.assertEqual(self.locationbar.identity_country_label.get_property('localName'), + 'label') + self.assertEqual(self.locationbar.identity_organization_label.get_property('localName'), + 'label') + self.assertEqual(self.locationbar.identity_icon.get_property('localName'), 'image') + self.assertEqual(self.locationbar.history_drop_marker.get_property('localName'), + 'dropmarker') + self.assertEqual(self.locationbar.reload_button.get_property('localName'), + 'toolbarbutton') + self.assertEqual(self.locationbar.stop_button.get_property('localName'), + 'toolbarbutton') + + self.assertEqual(self.locationbar.contextmenu.get_property('localName'), 'menupopup') + self.assertEqual(self.locationbar.get_contextmenu_entry('paste').get_attribute('cmd'), + 'cmd_paste') + + def test_reload(self): + event_types = ["shortcut", "shortcut2", "button"] + for event in event_types: + # TODO: Until we have waitForPageLoad, this only tests API + # compatibility. + self.locationbar.reload_url(event, force=True) + self.locationbar.reload_url(event, force=False) + + def test_focus_and_clear(self): + self.locationbar.urlbar.send_keys("zyx") + self.locationbar.clear() + self.assertEqual(self.locationbar.value, '') + + self.locationbar.urlbar.send_keys("zyx") + self.assertEqual(self.locationbar.value, 'zyx') + + self.locationbar.clear() + self.assertEqual(self.locationbar.value, '') + + def test_load_url(self): + data_uri = 'data:text/html,<title>Title</title>' + self.locationbar.load_url(data_uri) + + with self.marionette.using_context('content'): + Wait(self.marionette).until(lambda mn: mn.get_url() == data_uri) + + +class TestAutoCompleteResults(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestAutoCompleteResults, self).setUp() + + self.browser.navbar.locationbar.clear() + + self.autocomplete_results = self.browser.navbar.locationbar.autocomplete_results + + def tearDown(self): + try: + self.autocomplete_results.close(force=True) + except NoSuchElementException: + # TODO: A NoSuchElementException is thrown here when tests accessing the + # autocomplete_results element are skipped. + pass + finally: + super(TestAutoCompleteResults, self).tearDown() + + def test_popup_elements(self): + # TODO: This test is not very robust because it relies on the history + # in the default profile. + self.assertFalse(self.autocomplete_results.is_open) + self.browser.navbar.locationbar.urlbar.send_keys('a') + results = self.autocomplete_results.results + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_complete) + visible_result_count = len(self.autocomplete_results.visible_results) + self.assertTrue(visible_result_count > 0) + self.assertEqual(visible_result_count, + int(results.get_property('itemCount'))) + + def test_close(self): + self.browser.navbar.locationbar.urlbar.send_keys('a') + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_open) + # The Wait in the library implementation will fail this if this doesn't + # end up closing. + self.autocomplete_results.close() + + def test_force_close(self): + self.browser.navbar.locationbar.urlbar.send_keys('a') + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_open) + # The Wait in the library implementation will fail this if this doesn't + # end up closing. + self.autocomplete_results.close(force=True) + + def test_matching_text(self): + # The default profile always has existing bookmarks. So no sites have to + # be visited and bookmarked. + for input_text in ('about', 'zilla'): + self.browser.navbar.locationbar.urlbar.clear() + self.browser.navbar.locationbar.urlbar.send_keys(input_text) + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_open) + Wait(self.marionette).until(lambda _: self.autocomplete_results.is_complete) + visible_results = self.autocomplete_results.visible_results + self.assertTrue(len(visible_results) > 0) + + for result in visible_results: + # check matching text only for results of type bookmark + if result.get_attribute('type') != 'bookmark': + continue + title_matches = self.autocomplete_results.get_matching_text(result, "title") + url_matches = self.autocomplete_results.get_matching_text(result, "url") + all_matches = title_matches + url_matches + self.assertTrue(len(all_matches) > 0) + for match_fragment in all_matches: + self.assertIn(match_fragment.lower(), input_text) + + self.autocomplete_results.close() + + +class TestIdentityPopup(PuppeteerMixin, MarionetteTestCase): + def setUp(self): + super(TestIdentityPopup, self).setUp() + + self.locationbar = self.browser.navbar.locationbar + self.identity_popup = self.locationbar.identity_popup + + self.url = 'https://ssl-ev.mozqa.com' + + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + def tearDown(self): + try: + self.identity_popup.close(force=True) + finally: + super(TestIdentityPopup, self).tearDown() + + def test_elements(self): + self.locationbar.open_identity_popup() + + # Test main view elements + main = self.identity_popup.view.main + self.assertEqual(main.element.get_property('localName'), 'panelview') + + self.assertEqual(main.expander.get_property('localName'), 'button') + self.assertEqual(main.host.get_property('localName'), 'label') + self.assertEqual(main.insecure_connection_label.get_property('localName'), + 'description') + self.assertEqual(main.internal_connection_label.get_property('localName'), + 'description') + self.assertEqual(main.secure_connection_label.get_property('localName'), + 'description') + + self.assertEqual(main.permissions.get_property('localName'), 'vbox') + + # Test security view elements + security = self.identity_popup.view.security + self.assertEqual(security.element.get_property('localName'), 'panelview') + + self.assertEqual(security.host.get_property('localName'), 'label') + self.assertEqual(security.insecure_connection_label.get_property('localName'), + 'description') + self.assertEqual(security.secure_connection_label.get_property('localName'), + 'description') + + self.assertEqual(security.owner.get_property('localName'), 'description') + self.assertEqual(security.owner_location.get_property('localName'), 'description') + self.assertEqual(security.verifier.get_property('localName'), 'description') + + self.assertEqual(security.disable_mixed_content_blocking_button.get_property('localName'), + 'button') + self.assertEqual(security.enable_mixed_content_blocking_button.get_property('localName'), + 'button') + + self.assertEqual(security.more_info_button.get_property('localName'), 'button') + + def test_open_close(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + self.assertFalse(self.identity_popup.is_open) + + self.locationbar.open_identity_popup() + + self.identity_popup.close() + self.assertFalse(self.identity_popup.is_open) + + def test_force_close(self): + with self.marionette.using_context('content'): + self.marionette.navigate(self.url) + + self.assertFalse(self.identity_popup.is_open) + + self.locationbar.open_identity_popup() + + self.identity_popup.close(force=True) + self.assertFalse(self.identity_popup.is_open) diff --git a/testing/firefox-ui/tests/puppeteer/test_update_wizard.py b/testing/firefox-ui/tests/puppeteer/test_update_wizard.py new file mode 100644 index 000000000..7170ea8e2 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_update_wizard.py @@ -0,0 +1,67 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.ui.deck import Panel +from firefox_puppeteer.ui.update_wizard import UpdateWizardDialog +from marionette_harness import MarionetteTestCase + + +class TestUpdateWizard(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestUpdateWizard, self).setUp() + + def opener(win): + self.marionette.execute_script(""" + let updatePrompt = Components.classes["@mozilla.org/updates/update-prompt;1"] + .createInstance(Components.interfaces.nsIUpdatePrompt); + updatePrompt.checkForUpdates(); + """) + + self.dialog = self.browser.open_window(callback=opener, + expected_window_class=UpdateWizardDialog) + self.wizard = self.dialog.wizard + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestUpdateWizard, self).tearDown() + + def test_basic(self): + self.assertEqual(self.dialog.window_type, 'Update:Wizard') + self.assertNotEqual(self.dialog.dtds, []) + self.assertNotEqual(self.dialog.properties, []) + + def test_elements(self): + """Test correct retrieval of elements.""" + self.assertEqual(self.wizard.element.get_property('localName'), 'wizard') + + buttons = ('cancel_button', 'extra1_button', 'extra2_button', + 'finish_button', 'next_button', 'previous_button', + ) + for button in buttons: + self.assertEqual(getattr(self.wizard, button).get_property('localName'), + 'button') + + panels = ('checking', 'downloading', 'dummy', 'error_patching', 'error', + 'error_extra', 'finished', 'finished_background', + 'manual_update', 'no_updates_found', 'updates_found_basic', + ) + for panel in panels: + self.assertEqual(getattr(self.wizard, panel).element.get_property('localName'), + 'wizardpage') + + # elements of the checking panel + self.assertEqual(self.wizard.checking.progress.get_property('localName'), + 'progressmeter') + + # elements of the downloading panel + self.assertEqual(self.wizard.downloading.progress.get_property('localName'), + 'progressmeter') + + # check wizard attributes + self.assertIsInstance(self.wizard.selected_index, int) + self.assertIsInstance(self.wizard.selected_panel, Panel) diff --git a/testing/firefox-ui/tests/puppeteer/test_utils.py b/testing/firefox-ui/tests/puppeteer/test_utils.py new file mode 100644 index 000000000..664722cce --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_utils.py @@ -0,0 +1,48 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_puppeteer import PuppeteerMixin +from marionette_harness import MarionetteTestCase + + +class TestSanitize(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + super(TestSanitize, self).setUp() + + # Clear all previous history and cookies. + self.puppeteer.places.remove_all_history() + with self.marionette.using_context('content'): + self.marionette.delete_all_cookies() + + self.urls = [ + 'layout/mozilla_projects.html', + 'layout/mozilla.html', + 'layout/mozilla_mission.html', + 'cookies/cookie_single.html' + ] + self.urls = [self.marionette.absolute_url(url) for url in self.urls] + + # Open the test urls, including the single cookie setting page. + def load_urls(): + with self.marionette.using_context('content'): + for url in self.urls: + self.marionette.navigate(url) + self.puppeteer.places.wait_for_visited(self.urls, load_urls) + + def test_sanitize_history(self): + """ Clears history. """ + self.assertEqual(self.puppeteer.places.get_all_urls_in_history(), self.urls) + self.puppeteer.utils.sanitize(data_type={"history": True}) + self.assertEqual(self.puppeteer.places.get_all_urls_in_history(), []) + + def test_sanitize_cookies(self): + """ Clears cookies. """ + with self.marionette.using_context('content'): + self.assertIsNotNone(self.marionette.get_cookie('litmus_1')) + + self.puppeteer.utils.sanitize(data_type={"cookies": True}) + + with self.marionette.using_context('content'): + self.assertIsNone(self.marionette.get_cookie('litmus_1')) diff --git a/testing/firefox-ui/tests/puppeteer/test_windows.py b/testing/firefox-ui/tests/puppeteer/test_windows.py new file mode 100644 index 000000000..1ba13fa37 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_windows.py @@ -0,0 +1,259 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import firefox_puppeteer.errors as errors + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.ui.windows import BaseWindow +from marionette_driver import By, Wait +from marionette_driver.errors import NoSuchWindowException +from marionette_harness import MarionetteTestCase + + +class BaseWindowTestCase(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + """ + These tests open and close windows pretty rapidly, which + (since bug 1261842) can cause content processes to be + spawned and discarded in large numbers. By default, Firefox + has a 5 second timeout for shutting down content processes, + but we can get into cases where the content process just + doesn't have enough time to get itself all sorted before + the timeout gets hit, which results in the parent killing + the content process manually, which generates a crash report, + which causes these tests to orange. We side-step this by + setting dom.ipc.tabs.shutdownTimeoutSecs to 0, which disables + the shutdown timer. + """ + super(BaseWindowTestCase, self).setUp() + + self.marionette.set_pref('dom.ipc.tabs.shutdownTimeoutSecs', 0) + + def tearDown(self): + try: + self.marionette.clear_pref('dom.ipc.tabs.shutdownTimeoutSecs') + finally: + super(BaseWindowTestCase, self).tearDown() + + +class TestWindows(BaseWindowTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestWindows, self).tearDown() + + def test_switch_to(self): + url = self.marionette.absolute_url('layout/mozilla.html') + + # Open two more windows + for index in range(0, 2): + self.marionette.execute_script(""" window.open(); """) + + windows = self.puppeteer.windows.all + self.assertEquals(len(windows), 3) + + # Switch to the 2nd window + self.puppeteer.windows.switch_to(windows[1].handle) + self.assertEquals(windows[1].handle, self.marionette.current_chrome_window_handle) + + # TODO: Needs updated tabs module for improved navigation + with self.marionette.using_context('content'): + self.marionette.navigate(url) + + # Switch to the last window and find 2nd window by URL + self.puppeteer.windows.switch_to(windows[2].handle) + + # TODO: A window can have multiple tabs, so this may need an update + # when the tabs module gets implemented + def find_by_url(win): + with win.marionette.using_context('content'): + return win.marionette.get_url() == url + + self.puppeteer.windows.switch_to(find_by_url) + self.assertEquals(windows[1].handle, self.marionette.current_chrome_window_handle) + + self.puppeteer.windows.switch_to(find_by_url) + + # Switching to an unknown handles has to fail + self.assertRaises(NoSuchWindowException, + self.puppeteer.windows.switch_to, "humbug") + self.assertRaises(NoSuchWindowException, + self.puppeteer.windows.switch_to, lambda win: False) + + self.puppeteer.windows.close_all([self.browser]) + self.browser.switch_to() + + self.assertEqual(len(self.puppeteer.windows.all), 1) + + def test_switch_to_unknown_window_type(self): + def open_by_js(_): + with self.marionette.using_context('chrome'): + self.marionette.execute_script(""" + window.open('chrome://browser/content/safeMode.xul', '_blank', + 'chrome,centerscreen,resizable=no'); + """) + + win = self.browser.open_window(callback=open_by_js, expected_window_class=BaseWindow) + win.close() + self.browser.switch_to() + + +class TestBaseWindow(BaseWindowTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + BaseWindowTestCase.tearDown(self) + + def test_basics(self): + # force BaseWindow instance + win1 = BaseWindow(self.marionette, self.browser.handle) + + self.assertEquals(win1.handle, self.marionette.current_chrome_window_handle) + self.assertEquals(win1.window_element, + self.marionette.find_element(By.CSS_SELECTOR, ':root')) + self.assertEquals(win1.window_element.get_attribute('windowtype'), + self.marionette.get_window_type()) + self.assertFalse(win1.closed) + + # Test invalid parameters for BaseWindow constructor + self.assertRaises(errors.UnknownWindowError, + BaseWindow, self.marionette, 10) + + # Test invalid shortcuts + self.assertRaises(KeyError, + win1.send_shortcut, 'l', acel=True) + + def test_open_close(self): + # force BaseWindow instance + win1 = BaseWindow(self.marionette, self.browser.handle) + + # Open a new window (will be focused), and check states + win2 = win1.open_window() + + # force BaseWindow instance + win2 = BaseWindow(self.marionette, win2.handle) + + self.assertEquals(len(self.marionette.chrome_window_handles), 2) + self.assertNotEquals(win1.handle, win2.handle) + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + + win2.close() + + self.assertTrue(win2.closed) + self.assertEquals(len(self.marionette.chrome_window_handles), 1) + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + Wait(self.marionette).until(lambda _: win1.focused) # catch the no focused window + + win1.focus() + + # Open and close a new window by a custom callback + def opener(window): + window.marionette.execute_script(""" window.open(); """) + + def closer(window): + window.marionette.execute_script(""" window.close(); """) + + win2 = win1.open_window(callback=opener) + + # force BaseWindow instance + win2 = BaseWindow(self.marionette, win2.handle) + + self.assertEquals(len(self.marionette.chrome_window_handles), 2) + win2.close(callback=closer) + + win1.focus() + + # Check for an unexpected window class + self.assertRaises(errors.UnexpectedWindowTypeError, + win1.open_window, expected_window_class=BaseWindow) + self.puppeteer.windows.close_all([win1]) + + def test_switch_to_and_focus(self): + # force BaseWindow instance + win1 = BaseWindow(self.marionette, self.browser.handle) + + # Open a new window (will be focused), and check states + win2 = win1.open_window() + + # force BaseWindow instance + win2 = BaseWindow(self.marionette, win2.handle) + + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + self.assertEquals(win2.handle, self.puppeteer.windows.focused_chrome_window_handle) + self.assertFalse(win1.focused) + self.assertTrue(win2.focused) + + # Switch back to win1 without moving the focus, but focus separately + win1.switch_to() + self.assertEquals(win1.handle, self.marionette.current_chrome_window_handle) + self.assertTrue(win2.focused) + + win1.focus() + self.assertTrue(win1.focused) + + # Switch back to win2 by focusing it directly + win2.focus() + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + self.assertEquals(win2.handle, self.puppeteer.windows.focused_chrome_window_handle) + self.assertTrue(win2.focused) + + # Close win2, and check that it keeps active but looses focus + win2.switch_to() + win2.close() + + win1.switch_to() + + +class TestBrowserWindow(BaseWindowTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + BaseWindowTestCase.tearDown(self) + + def test_basic(self): + self.assertNotEqual(self.browser.dtds, []) + self.assertNotEqual(self.browser.properties, []) + + self.assertFalse(self.browser.is_private) + + self.assertIsNotNone(self.browser.menubar) + self.assertIsNotNone(self.browser.navbar) + self.assertIsNotNone(self.browser.tabbar) + + def test_open_close(self): + # open and close a new browser windows by menu + win2 = self.browser.open_browser(trigger='menu') + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertFalse(self.browser.is_private) + win2.close(trigger='menu') + + # open and close a new browser window by shortcut + win2 = self.browser.open_browser(trigger='shortcut') + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertFalse(self.browser.is_private) + win2.close(trigger='shortcut') + + # open and close a new private browsing window + win2 = self.browser.open_browser(is_private=True) + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertTrue(win2.is_private) + win2.close() + + # open and close a new private browsing window + win2 = self.browser.open_browser(trigger='shortcut', is_private=True) + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertTrue(win2.is_private) + win2.close() + + # force closing a window + win2 = self.browser.open_browser() + self.assertEquals(win2, self.puppeteer.windows.current) + win2.close(force=True) diff --git a/testing/firefox-ui/tests/update/direct/manifest.ini b/testing/firefox-ui/tests/update/direct/manifest.ini new file mode 100644 index 000000000..f5edb3c10 --- /dev/null +++ b/testing/firefox-ui/tests/update/direct/manifest.ini @@ -0,0 +1,4 @@ +[DEFAULT] +tags = direct + +[test_direct_update.py] diff --git a/testing/firefox-ui/tests/update/direct/test_direct_update.py b/testing/firefox-ui/tests/update/direct/test_direct_update.py new file mode 100644 index 000000000..41842349e --- /dev/null +++ b/testing/firefox-ui/tests/update/direct/test_direct_update.py @@ -0,0 +1,21 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_ui_harness.testcases import UpdateTestCase + + +class TestDirectUpdate(UpdateTestCase): + + def setUp(self): + UpdateTestCase.setUp(self, is_fallback=False) + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + UpdateTestCase.tearDown(self) + + def test_update(self): + self.download_and_apply_available_update(force_fallback=False) + self.check_update_applied() diff --git a/testing/firefox-ui/tests/update/fallback/manifest.ini b/testing/firefox-ui/tests/update/fallback/manifest.ini new file mode 100644 index 000000000..704686db7 --- /dev/null +++ b/testing/firefox-ui/tests/update/fallback/manifest.ini @@ -0,0 +1,4 @@ +[DEFAULT] +tags = fallback + +[test_fallback_update.py] diff --git a/testing/firefox-ui/tests/update/fallback/test_fallback_update.py b/testing/firefox-ui/tests/update/fallback/test_fallback_update.py new file mode 100644 index 000000000..264142bd8 --- /dev/null +++ b/testing/firefox-ui/tests/update/fallback/test_fallback_update.py @@ -0,0 +1,22 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +from firefox_ui_harness.testcases import UpdateTestCase + + +class TestFallbackUpdate(UpdateTestCase): + + def setUp(self): + UpdateTestCase.setUp(self, is_fallback=True) + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + UpdateTestCase.tearDown(self) + + def test_update(self): + self.download_and_apply_available_update(force_fallback=True) + self.download_and_apply_forced_update() + self.check_update_applied() diff --git a/testing/firefox-ui/tests/update/manifest.ini b/testing/firefox-ui/tests/update/manifest.ini new file mode 100644 index 000000000..2a126e331 --- /dev/null +++ b/testing/firefox-ui/tests/update/manifest.ini @@ -0,0 +1,2 @@ +[include:direct/manifest.ini] +[include:fallback/manifest.ini] |
