# HG changeset patch # User Andrew Halberstadt # Date 1523631970 14400 # Node ID 74448840c21fda21bee03f7b278294105b47a067 # Parent b2feac5f16e3b4f3c376f6e931162d88c90466b9 Bug 1445944 - [mozprofile] Convert mozprofile unittests to the pytest format r=davehunt This is a much cleaner and easier to understand test format. It will also make it easier to add tests for the upcoming ChromeProfile changes. MozReview-Commit-ID: DizKGt0qkPF diff --git a/testing/mozbase/mozprofile/tests/bug785146.py b/testing/mozbase/mozprofile/tests/bug785146.py deleted file mode 100755 --- a/testing/mozbase/mozprofile/tests/bug785146.py +++ /dev/null @@ -1,57 +0,0 @@ -#!/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 __future__ import absolute_import - -import mozfile -import os -import shutil -import sqlite3 -import tempfile -import unittest - -import mozunit - -from mozprofile.permissions import Permissions - - -class PermissionsTest(unittest.TestCase): - - locations = """http://mochi.test:8888 primary,privileged -http://127.0.0.1:80 noxul -http://127.0.0.1:8888 privileged -""" - - def setUp(self): - self.profile_dir = tempfile.mkdtemp() - self.locations_file = mozfile.NamedTemporaryFile() - self.locations_file.write(self.locations) - self.locations_file.flush() - - def tearDown(self): - if self.profile_dir: - shutil.rmtree(self.profile_dir) - if self.locations_file: - self.locations_file.close() - - def test_schema_version(self): - perms = Permissions(self.profile_dir, self.locations_file.name) - perms_db_filename = os.path.join(self.profile_dir, 'permissions.sqlite') - perms.write_db(self.locations_file) - - stmt = 'PRAGMA user_version;' - - con = sqlite3.connect(perms_db_filename) - cur = con.cursor() - cur.execute(stmt) - entries = cur.fetchall() - - schema_version = entries[0][0] - self.assertEqual(schema_version, 5) - - -if __name__ == '__main__': - mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/manifest.ini b/testing/mozbase/mozprofile/tests/manifest.ini --- a/testing/mozbase/mozprofile/tests/manifest.ini +++ b/testing/mozbase/mozprofile/tests/manifest.ini @@ -1,13 +1,12 @@ [DEFAULT] subsuite = mozbase, os == "linux" -[addonid.py] -[server_locations.py] +[test_addonid.py] +[test_server_locations.py] [test_preferences.py] -[permissions.py] -[bug758250.py] +[test_permissions.py] +[test_bug758250.py] [test_nonce.py] -[bug785146.py] [test_clone_cleanup.py] [test_profile.py] [test_profile_view.py] [test_addons.py] diff --git a/testing/mozbase/mozprofile/tests/addonid.py b/testing/mozbase/mozprofile/tests/test_addonid.py rename from testing/mozbase/mozprofile/tests/addonid.py rename to testing/mozbase/mozprofile/tests/test_addonid.py --- a/testing/mozbase/mozprofile/tests/addonid.py +++ b/testing/mozbase/mozprofile/tests/test_addonid.py @@ -1,59 +1,28 @@ #!/usr/bin/env python from __future__ import absolute_import import os -import tempfile -import unittest -import shutil import mozunit +import pytest from mozprofile import addons here = os.path.dirname(os.path.abspath(__file__)) -class AddonIDTest(unittest.TestCase): - """ Test finding the addon id in a variety of install.rdf styles """ +"""Test finding the addon id in a variety of install.rdf styles""" - def make_install_rdf(self, filecontents): - path = tempfile.mkdtemp() - f = open(os.path.join(path, "install.rdf"), "w") - f.write(filecontents) - f.close() - return path - def test_addonID(self): - testlist = self.get_test_list() - for t in testlist: - try: - p = self.make_install_rdf(t) - a = addons.AddonManager(os.path.join(p, "profile")) - addon_id = a.addon_details(p)['id'] - self.assertEqual(addon_id, "winning", "We got the addon id") - finally: - shutil.rmtree(p) - - def test_addonID_xpi(self): - a = addons.AddonManager("profile") - addon = a.addon_details(os.path.join(here, "addons", "empty.xpi")) - self.assertEqual(addon['id'], "test-empty@quality.mozilla.org", "We got the addon id") - - def get_test_list(self): - """ This just returns a hardcoded list of install.rdf snippets for testing. - When adding snippets for testing, remember that the id we're looking for - is "winning" (no quotes). So, make sure you have that id in your snippet - if you want it to pass. - """ - tests = [ - """ +ADDON_ID_TESTS = [ + """ winning MozMill 2.0a Adam Christian A testing extension based on the @@ -103,17 +72,18 @@ class AddonIDTest(unittest.TestCase): toolkit@mozilla.org 1.9.1 2.0* """, - """ {ec8030f7-c20a-464f-9b0e-13a3a9e97384} 3.5 8.* @@ -123,27 +93,29 @@ class AddonIDTest(unittest.TestCase): MozMill 2.0a Adam Christian A testing extension based on the Windmill Testing Framework client source true """, - """ winning foo 42 A testing extension based on the Windmill Testing Framework client source """, - """ {ec8030f7-c20a-464f-9b0e-13a3a9e97384} 3.5 8.* @@ -152,14 +124,36 @@ class AddonIDTest(unittest.TestCase): winning MozMill 2.0a Adam Christian A testing extension based on the Windmill Testing Framework client source true - """] - return tests + """, +] + + +@pytest.fixture(params=ADDON_ID_TESTS, ids=[str(i) for i in range(0, len(ADDON_ID_TESTS))]) +def profile(request, tmpdir): + test = request.param + path = tmpdir.mkdtemp().strpath + + with open(os.path.join(path, "install.rdf"), "w") as fh: + fh.write(test) + return path + + +def test_addonID(profile): + a = addons.AddonManager(os.path.join(profile, "profile")) + addon_id = a.addon_details(profile)['id'] + assert addon_id == "winning" + + +def test_addonID_xpi(): + a = addons.AddonManager("profile") + addon = a.addon_details(os.path.join(here, "addons", "empty.xpi")) + assert addon['id'] == "test-empty@quality.mozilla.org" if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/test_addons.py b/testing/mozbase/mozprofile/tests/test_addons.py --- a/testing/mozbase/mozprofile/tests/test_addons.py +++ b/testing/mozbase/mozprofile/tests/test_addons.py @@ -2,350 +2,366 @@ # 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 tempfile -import unittest import zipfile import mozunit +import pytest -import mozfile -import mozlog.unstructured as mozlog import mozprofile - from addon_stubs import generate_addon here = os.path.dirname(os.path.abspath(__file__)) -class TestAddonsManager(unittest.TestCase): - """ Class to test mozprofile.addons.AddonManager """ +@pytest.fixture +def profile(): + return mozprofile.Profile() - def setUp(self): - self.logger = mozlog.getLogger('mozprofile.addons') - self.logger.setLevel(mozlog.ERROR) - self.profile = mozprofile.profile.Profile() - self.am = self.profile.addons +@pytest.fixture +def am(profile): + return profile.addons - self.profile_path = self.profile.profile - self.tmpdir = tempfile.mkdtemp() - self.addCleanup(mozfile.remove, self.tmpdir) + +def test_install_multiple_same_source(tmpdir, am): + path = tmpdir.strpath - def test_install_multiple_same_source(self): - # Generate installer stubs for all possible types of addons - addon_xpi = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir) - addon_folder = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir, - xpi=False) + # Generate installer stubs for all possible types of addons + addon_xpi = generate_addon('test-addon-1@mozilla.org', + path=path) + addon_folder = generate_addon('test-addon-1@mozilla.org', + path=path, + xpi=False) + + # The same folder should not be installed twice + am.install([addon_folder, addon_folder]) + assert am.installed_addons == [addon_folder] + am.clean() - # The same folder should not be installed twice - self.am.install([addon_folder, addon_folder]) - self.assertEqual(self.am.installed_addons, [addon_folder]) - self.am.clean() + # The same XPI file should not be installed twice + am.install([addon_xpi, addon_xpi]) + assert am.installed_addons == [addon_xpi] + am.clean() - # The same XPI file should not be installed twice - self.am.install([addon_xpi, addon_xpi]) - self.assertEqual(self.am.installed_addons, [addon_xpi]) - self.am.clean() + # Even if it is the same id the add-on should be installed twice, if + # specified via XPI and folder + am.install([addon_folder, addon_xpi]) + assert len(am.installed_addons) == 2 + assert addon_folder in am.installed_addons + assert addon_xpi in am.installed_addons + am.clean() + - # Even if it is the same id the add-on should be installed twice, if - # specified via XPI and folder - self.am.install([addon_folder, addon_xpi]) - self.assertEqual(len(self.am.installed_addons), 2) - self.assertIn(addon_folder, self.am.installed_addons) - self.assertIn(addon_xpi, self.am.installed_addons) - self.am.clean() +def test_install_webextension_from_dir(tmpdir, am): + tmpdir = tmpdir.strpath - def test_install_webextension_from_dir(self): - addon = os.path.join(here, 'addons', 'apply-css.xpi') - zipped = zipfile.ZipFile(addon) - try: - zipped.extractall(self.tmpdir) - finally: - zipped.close() - self.am.install(self.tmpdir) - self.assertEqual(len(self.am.installed_addons), 1) - self.assertTrue(os.path.isdir(self.am.installed_addons[0])) + addon = os.path.join(here, 'addons', 'apply-css.xpi') + zipped = zipfile.ZipFile(addon) + try: + zipped.extractall(tmpdir) + finally: + zipped.close() + am.install(tmpdir) + assert len(am.installed_addons) == 1 + assert os.path.isdir(am.installed_addons[0]) + + +def test_install_webextension(am): + addon = os.path.join(here, 'addons', 'apply-css.xpi') + + am.install(addon) + assert len(am.installed_addons) == 1 + assert os.path.isfile(am.installed_addons[0]) + assert 'apply-css.xpi' == os.path.basename(am.installed_addons[0]) - def test_install_webextension(self): - addon = os.path.join(here, 'addons', 'apply-css.xpi') - self.am.install(addon) - self.assertEqual(len(self.am.installed_addons), 1) - self.assertTrue(os.path.isfile(self.am.installed_addons[0])) - self.assertEqual('apply-css.xpi', os.path.basename(self.am.installed_addons[0])) + details = am.addon_details(am.installed_addons[0]) + assert 'test-webext@quality.mozilla.org' == details['id'] + - details = self.am.addon_details(self.am.installed_addons[0]) - self.assertEqual('test-webext@quality.mozilla.org', details['id']) +def test_install_webextension_sans_id(am): + addon = os.path.join(here, 'addons', 'apply-css-sans-id.xpi') + am.install(addon) - def test_install_webextension_sans_id(self): - addon = os.path.join(here, 'addons', 'apply-css-sans-id.xpi') - self.am.install(addon) + assert len(am.installed_addons) == 1 + assert os.path.isfile(am.installed_addons[0]) + assert 'apply-css-sans-id.xpi' == os.path.basename(am.installed_addons[0]) + + details = am.addon_details(am.installed_addons[0]) + assert '@temporary-addon' in details['id'] - self.assertEqual(len(self.am.installed_addons), 1) - self.assertTrue(os.path.isfile(self.am.installed_addons[0])) - self.assertEqual('apply-css-sans-id.xpi', os.path.basename(self.am.installed_addons[0])) - details = self.am.addon_details(self.am.installed_addons[0]) - self.assertIn('@temporary-addon', details['id']) +def test_install_xpi(tmpdir, am): + tmpdir = tmpdir.strpath - def test_install_xpi(self): - addons_to_install = [] - addons_installed = [] + addons_to_install = [] + addons_installed = [] - # Generate installer stubs and install them - for ext in ['test-addon-1@mozilla.org', 'test-addon-2@mozilla.org']: - temp_addon = generate_addon(ext, path=self.tmpdir) - addons_to_install.append(self.am.addon_details(temp_addon)['id']) - self.am.install(temp_addon) + # Generate installer stubs and install them + for ext in ['test-addon-1@mozilla.org', 'test-addon-2@mozilla.org']: + temp_addon = generate_addon(ext, path=tmpdir) + addons_to_install.append(am.addon_details(temp_addon)['id']) + am.install(temp_addon) - # Generate a list of addons installed in the profile - addons_installed = [str(x[:-len('.xpi')]) for x in os.listdir(os.path.join( - self.profile.profile, 'extensions'))] - self.assertEqual(addons_to_install.sort(), addons_installed.sort()) + # Generate a list of addons installed in the profile + addons_installed = [str(x[:-len('.xpi')]) for x in os.listdir(os.path.join( + am.profile, 'extensions'))] + assert addons_to_install.sort() == addons_installed.sort() + + +def test_install_folder(tmpdir, am): + tmpdir = tmpdir.strpath - def test_install_folder(self): - # Generate installer stubs for all possible types of addons - addons = [] - addons.append(generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir)) - addons.append(generate_addon('test-addon-2@mozilla.org', - path=self.tmpdir, - xpi=False)) - addons.append(generate_addon('test-addon-3@mozilla.org', - path=self.tmpdir, - name='addon-3')) - addons.append(generate_addon('test-addon-4@mozilla.org', - path=self.tmpdir, - name='addon-4', - xpi=False)) - addons.sort() + # Generate installer stubs for all possible types of addons + addons = [] + addons.append(generate_addon('test-addon-1@mozilla.org', + path=tmpdir)) + addons.append(generate_addon('test-addon-2@mozilla.org', + path=tmpdir, + xpi=False)) + addons.append(generate_addon('test-addon-3@mozilla.org', + path=tmpdir, + name='addon-3')) + addons.append(generate_addon('test-addon-4@mozilla.org', + path=tmpdir, + name='addon-4', + xpi=False)) + addons.sort() - self.am.install(self.tmpdir) + am.install(tmpdir) + + assert am.installed_addons == addons - self.assertEqual(self.am.installed_addons, addons) + +def test_install_unpack(tmpdir, am): + tmpdir = tmpdir.strpath - def test_install_unpack(self): - # Generate installer stubs for all possible types of addons - addon_xpi = generate_addon('test-addon-unpack@mozilla.org', - path=self.tmpdir) - addon_folder = generate_addon('test-addon-unpack@mozilla.org', - path=self.tmpdir, - xpi=False) - addon_no_unpack = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir) + # Generate installer stubs for all possible types of addons + addon_xpi = generate_addon('test-addon-unpack@mozilla.org', + path=tmpdir) + addon_folder = generate_addon('test-addon-unpack@mozilla.org', + path=tmpdir, + xpi=False) + addon_no_unpack = generate_addon('test-addon-1@mozilla.org', + path=tmpdir) - # Test unpack flag for add-on as XPI - self.am.install(addon_xpi) - self.assertEqual(self.am.installed_addons, [addon_xpi]) - self.am.clean() + # Test unpack flag for add-on as XPI + am.install(addon_xpi) + assert am.installed_addons == [addon_xpi] + am.clean() - # Test unpack flag for add-on as folder - self.am.install(addon_folder) - self.assertEqual(self.am.installed_addons, [addon_folder]) - self.am.clean() - - # Test forcing unpack an add-on - self.am.install(addon_no_unpack, unpack=True) - self.assertEqual(self.am.installed_addons, [addon_no_unpack]) - self.am.clean() + # Test unpack flag for add-on as folder + am.install(addon_folder) + assert am.installed_addons == [addon_folder] + am.clean() - def test_install_after_reset(self): - # Installing the same add-on after a reset should not cause a failure - addon = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir, xpi=False) + # Test forcing unpack an add-on + am.install(addon_no_unpack, unpack=True) + assert am.installed_addons == [addon_no_unpack] + am.clean() - # We cannot use self.am because profile.reset() creates a new instance - self.profile.addons.install(addon) - self.profile.reset() - - self.profile.addons.install(addon) - self.assertEqual(self.profile.addons.installed_addons, [addon]) +def test_install_after_reset(tmpdir, profile): + tmpdir = tmpdir.strpath + am = profile.addons - def test_install_backup(self): - staged_path = os.path.join(self.profile_path, 'extensions') + # Installing the same add-on after a reset should not cause a failure + addon = generate_addon('test-addon-1@mozilla.org', + path=tmpdir, xpi=False) + + # We cannot use am because profile.reset() creates a new instance + am.install(addon) + profile.reset() - # Generate installer stubs for all possible types of addons - addon_xpi = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir) - addon_folder = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir, - xpi=False) - addon_name = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir, - name='test-addon-1-dupe@mozilla.org') + am.install(addon) + assert am.installed_addons == [addon] + + +def test_install_backup(tmpdir, am): + tmpdir = tmpdir.strpath + + staged_path = os.path.join(am.profile, 'extensions') - # Test backup of xpi files - self.am.install(addon_xpi) - self.assertIsNone(self.am.backup_dir) - - self.am.install(addon_xpi) - self.assertIsNotNone(self.am.backup_dir) - self.assertEqual(os.listdir(self.am.backup_dir), - ['test-addon-1@mozilla.org.xpi']) + # Generate installer stubs for all possible types of addons + addon_xpi = generate_addon('test-addon-1@mozilla.org', + path=tmpdir) + addon_folder = generate_addon('test-addon-1@mozilla.org', + path=tmpdir, + xpi=False) + addon_name = generate_addon('test-addon-1@mozilla.org', + path=tmpdir, + name='test-addon-1-dupe@mozilla.org') - self.am.clean() - self.assertEqual(os.listdir(staged_path), - ['test-addon-1@mozilla.org.xpi']) - self.am.clean() + # Test backup of xpi files + am.install(addon_xpi) + assert am.backup_dir is None - # Test backup of folders - self.am.install(addon_folder) - self.assertIsNone(self.am.backup_dir) + am.install(addon_xpi) + assert am.backup_dir is not None + assert os.listdir(am.backup_dir) == ['test-addon-1@mozilla.org.xpi'] - self.am.install(addon_folder) - self.assertIsNotNone(self.am.backup_dir) - self.assertEqual(os.listdir(self.am.backup_dir), - ['test-addon-1@mozilla.org']) + am.clean() + assert os.listdir(staged_path) == ['test-addon-1@mozilla.org.xpi'] + am.clean() + + # Test backup of folders + am.install(addon_folder) + assert am.backup_dir is None + + am.install(addon_folder) + assert am.backup_dir is not None + assert os.listdir(am.backup_dir) == ['test-addon-1@mozilla.org'] - self.am.clean() - self.assertEqual(os.listdir(staged_path), - ['test-addon-1@mozilla.org']) - self.am.clean() + am.clean() + assert os.listdir(staged_path) == ['test-addon-1@mozilla.org'] + am.clean() - # Test backup of xpi files with another file name - self.am.install(addon_name) - self.assertIsNone(self.am.backup_dir) + # Test backup of xpi files with another file name + am.install(addon_name) + assert am.backup_dir is None - self.am.install(addon_xpi) - self.assertIsNotNone(self.am.backup_dir) - self.assertEqual(os.listdir(self.am.backup_dir), - ['test-addon-1@mozilla.org.xpi']) + am.install(addon_xpi) + assert am.backup_dir is not None + assert os.listdir(am.backup_dir) == ['test-addon-1@mozilla.org.xpi'] - self.am.clean() - self.assertEqual(os.listdir(staged_path), - ['test-addon-1@mozilla.org.xpi']) - self.am.clean() + am.clean() + assert os.listdir(staged_path) == ['test-addon-1@mozilla.org.xpi'] + am.clean() + + +def test_install_invalid_addons(tmpdir, am): + tmpdir = tmpdir.strpath - def test_install_invalid_addons(self): - # Generate installer stubs for all possible types of addons - addons = [] - addons.append(generate_addon('test-addon-invalid-no-manifest@mozilla.org', - path=self.tmpdir, - xpi=False)) - addons.append(generate_addon('test-addon-invalid-no-id@mozilla.org', - path=self.tmpdir)) + # Generate installer stubs for all possible types of addons + addons = [] + addons.append(generate_addon('test-addon-invalid-no-manifest@mozilla.org', + path=tmpdir, + xpi=False)) + addons.append(generate_addon('test-addon-invalid-no-id@mozilla.org', + path=tmpdir)) - self.am.install(self.tmpdir) - - self.assertEqual(self.am.installed_addons, []) + am.install(tmpdir) - @unittest.skip("Feature not implemented as part of AddonManger") - def test_install_error(self): - """ Check install raises an error with an invalid addon""" + assert am.installed_addons == [] + - temp_addon = generate_addon('test-addon-invalid-version@mozilla.org') - # This should raise an error here - self.am.install(temp_addon) +@pytest.mark.xfail(reason="feature not implemented as part of AddonManger") +def test_install_error(am): + """ Check install raises an error with an invalid addon""" + temp_addon = generate_addon('test-addon-invalid-version@mozilla.org') + # This should raise an error here + with pytest.raises(Exception): + am.install(temp_addon) - def test_addon_details(self): - # Generate installer stubs for a valid and invalid add-on manifest - valid_addon = generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir) - invalid_addon = generate_addon('test-addon-invalid-not-wellformed@mozilla.org', - path=self.tmpdir) + +def test_addon_details(tmpdir, am): + tmpdir = tmpdir.strpath - # Check valid add-on - details = self.am.addon_details(valid_addon) - self.assertEqual(details['id'], 'test-addon-1@mozilla.org') - self.assertEqual(details['name'], 'Test Add-on 1') - self.assertEqual(details['unpack'], False) - self.assertEqual(details['version'], '0.1') + # Generate installer stubs for a valid and invalid add-on manifest + valid_addon = generate_addon('test-addon-1@mozilla.org', + path=tmpdir) + invalid_addon = generate_addon('test-addon-invalid-not-wellformed@mozilla.org', + path=tmpdir) - # Check invalid add-on - self.assertRaises(mozprofile.addons.AddonFormatError, - self.am.addon_details, invalid_addon) + # Check valid add-on + details = am.addon_details(valid_addon) + assert details['id'] == 'test-addon-1@mozilla.org' + assert details['name'] == 'Test Add-on 1' + assert not details['unpack'] + assert details['version'] == '0.1' - # Check invalid path - self.assertRaises(IOError, - self.am.addon_details, '') + # Check invalid add-on + with pytest.raises(mozprofile.addons.AddonFormatError): + am.addon_details(invalid_addon) - # Check invalid add-on format - addon_path = os.path.join(os.path.join(here, 'files'), 'not_an_addon.txt') - self.assertRaises(mozprofile.addons.AddonFormatError, - self.am.addon_details, addon_path) + # Check invalid path + with pytest.raises(IOError): + am.addon_details('') - @unittest.skip("Bug 900154") - def test_clean_addons(self): - addon_one = generate_addon('test-addon-1@mozilla.org') - addon_two = generate_addon('test-addon-2@mozilla.org') + # Check invalid add-on format + addon_path = os.path.join(os.path.join(here, 'files'), 'not_an_addon.txt') + with pytest.raises(mozprofile.addons.AddonFormatError): + am.addon_details(addon_path) - self.am.install(addon_one) - installed_addons = [str(x[:-len('.xpi')]) for x in os.listdir(os.path.join( - self.profile.profile, 'extensions'))] + +def test_clean_addons(am): + addon_one = generate_addon('test-addon-1@mozilla.org') + addon_two = generate_addon('test-addon-2@mozilla.org') - # Create a new profile based on an existing profile - # Install an extra addon in the new profile - # Cleanup addons - duplicate_profile = mozprofile.profile.Profile(profile=self.profile.profile, - addons=addon_two) - duplicate_profile.addons.clean() + am.install(addon_one) + installed_addons = [str(x[:-len('.xpi')]) for x in os.listdir(os.path.join( + am.profile, 'extensions'))] + + # Create a new profile based on an existing profile + # Install an extra addon in the new profile + # Cleanup addons + duplicate_profile = mozprofile.profile.Profile(profile=am.profile, + addons=addon_two) + duplicate_profile.addons.clean() - addons_after_cleanup = [str(x[:-len('.xpi')]) for x in os.listdir(os.path.join( - duplicate_profile.profile, 'extensions'))] - # New addons installed should be removed by clean_addons() - self.assertEqual(installed_addons, addons_after_cleanup) + addons_after_cleanup = [str(x[:-len('.xpi')]) for x in os.listdir(os.path.join( + duplicate_profile.profile, 'extensions'))] + # New addons installed should be removed by clean_addons() + assert installed_addons == addons_after_cleanup + - def test_noclean(self): - """test `restore=True/False` functionality""" - profile = tempfile.mkdtemp() - tmpdir = tempfile.mkdtemp() +def test_noclean(tmpdir): + """test `restore=True/False` functionality""" + profile = tmpdir.mkdtemp().strpath + tmpdir = tmpdir.mkdtemp().strpath - try: - # empty initially - self.assertFalse(bool(os.listdir(profile))) + # empty initially + assert not bool(os.listdir(profile)) - # make an addon - addons = [ - generate_addon('test-addon-1@mozilla.org', path=tmpdir), - os.path.join(here, 'addons', 'empty.xpi'), - ] + # make an addon + addons = [ + generate_addon('test-addon-1@mozilla.org', path=tmpdir), + os.path.join(here, 'addons', 'empty.xpi'), + ] - # install it with a restore=True AddonManager - am = mozprofile.addons.AddonManager(profile, restore=True) + # install it with a restore=True AddonManager + am = mozprofile.addons.AddonManager(profile, restore=True) - for addon in addons: - am.install(addon) + for addon in addons: + am.install(addon) - # now its there - self.assertEqual(os.listdir(profile), ['extensions']) - staging_folder = os.path.join(profile, 'extensions') - self.assertTrue(os.path.exists(staging_folder)) - self.assertEqual(len(os.listdir(staging_folder)), 2) + # now its there + assert os.listdir(profile) == ['extensions'] + staging_folder = os.path.join(profile, 'extensions') + assert os.path.exists(staging_folder) + assert len(os.listdir(staging_folder)) == 2 - del am + del am - self.assertEqual(os.listdir(profile), ['extensions']) - self.assertTrue(os.path.exists(staging_folder)) - self.assertEqual(os.listdir(staging_folder), []) - finally: - mozfile.rmtree(tmpdir) - mozfile.rmtree(profile) + assert os.listdir(profile) == ['extensions'] + assert os.path.exists(staging_folder) + assert os.listdir(staging_folder) == [] + + +def test_remove_addon(tmpdir, am): + tmpdir = tmpdir.strpath - def test_remove_addon(self): - addons = [] - addons.append(generate_addon('test-addon-1@mozilla.org', - path=self.tmpdir)) - addons.append(generate_addon('test-addon-2@mozilla.org', - path=self.tmpdir)) + addons = [] + addons.append(generate_addon('test-addon-1@mozilla.org', + path=tmpdir)) + addons.append(generate_addon('test-addon-2@mozilla.org', + path=tmpdir)) - self.am.install(self.tmpdir) + am.install(tmpdir) - extensions_path = os.path.join(self.profile_path, 'extensions') - staging_path = os.path.join(extensions_path) + extensions_path = os.path.join(am.profile, 'extensions') + staging_path = os.path.join(extensions_path) - for addon in self.am._addons: - self.am.remove_addon(addon) + for addon in am._addons: + am.remove_addon(addon) - self.assertEqual(os.listdir(staging_path), []) - self.assertEqual(os.listdir(extensions_path), []) + assert os.listdir(staging_path) == [] + assert os.listdir(extensions_path) == [] if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/bug758250.py b/testing/mozbase/mozprofile/tests/test_bug758250.py rename from testing/mozbase/mozprofile/tests/bug758250.py rename to testing/mozbase/mozprofile/tests/test_bug758250.py --- a/testing/mozbase/mozprofile/tests/bug758250.py +++ b/testing/mozbase/mozprofile/tests/test_bug758250.py @@ -1,57 +1,47 @@ #!/usr/bin/env python from __future__ import absolute_import import mozprofile import os import shutil -import tempfile -import unittest import mozunit - here = os.path.dirname(os.path.abspath(__file__)) +""" +use of --profile in mozrunner just blows away addon sources: +https://bugzilla.mozilla.org/show_bug.cgi?id=758250 +""" -class Bug758250(unittest.TestCase): - """ - use of --profile in mozrunner just blows away addon sources: - https://bugzilla.mozilla.org/show_bug.cgi?id=758250 - """ - def setUp(self): - self.tmpdir = tempfile.mkdtemp() - self.addon = os.path.join(here, 'addons', 'empty') +def test_profile_addon_cleanup(tmpdir): + tmpdir = tmpdir.mkdtemp().strpath + addon = os.path.join(here, 'addons', 'empty') - def tearDown(self): - # remove vestiges - shutil.rmtree(self.tmpdir) - - def test_profile_addon_cleanup(self): + # sanity check: the empty addon should be here + assert os.path.exists(addon) + assert os.path.isdir(addon) + assert os.path.exists(os.path.join(addon, 'install.rdf')) - # sanity check: the empty addon should be here - self.assertTrue(os.path.exists(self.addon)) - self.assertTrue(os.path.isdir(self.addon)) - self.assertTrue(os.path.exists(os.path.join(self.addon, 'install.rdf'))) - - # because we are testing data loss, let's make sure we make a copy - shutil.rmtree(self.tmpdir) - shutil.copytree(self.addon, self.tmpdir) - self.assertTrue(os.path.exists(os.path.join(self.tmpdir, 'install.rdf'))) + # because we are testing data loss, let's make sure we make a copy + shutil.rmtree(tmpdir) + shutil.copytree(addon, tmpdir) + assert os.path.exists(os.path.join(tmpdir, 'install.rdf')) - # make a starter profile - profile = mozprofile.FirefoxProfile() - path = profile.profile + # make a starter profile + profile = mozprofile.FirefoxProfile() + path = profile.profile - # make a new profile based on the old - newprofile = mozprofile.FirefoxProfile(profile=path, addons=[self.tmpdir]) - newprofile.cleanup() + # make a new profile based on the old + newprofile = mozprofile.FirefoxProfile(profile=path, addons=[tmpdir]) + newprofile.cleanup() - # the source addon *should* still exist - self.assertTrue(os.path.exists(self.tmpdir)) - self.assertTrue(os.path.exists(os.path.join(self.tmpdir, 'install.rdf'))) + # the source addon *should* still exist + assert os.path.exists(tmpdir) + assert os.path.exists(os.path.join(tmpdir, 'install.rdf')) if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/test_clone_cleanup.py b/testing/mozbase/mozprofile/tests/test_clone_cleanup.py --- a/testing/mozbase/mozprofile/tests/test_clone_cleanup.py +++ b/testing/mozbase/mozprofile/tests/test_clone_cleanup.py @@ -1,81 +1,84 @@ #!/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 __future__ import absolute_import - import os -import tempfile -import unittest import mozfile import mozunit +import pytest from mozprofile.profile import Profile +""" +test cleanup logic for the clone functionality +see https://bugzilla.mozilla.org/show_bug.cgi?id=642843 +""" -class CloneCleanupTest(unittest.TestCase): - """ - test cleanup logic for the clone functionality - see https://bugzilla.mozilla.org/show_bug.cgi?id=642843 - """ - def setUp(self): - # make a profile with one preference - path = tempfile.mktemp() - self.addCleanup(mozfile.remove, path) - self.profile = Profile(path, - preferences={'foo': 'bar'}, - restore=False) - user_js = os.path.join(self.profile.profile, 'user.js') - self.assertTrue(os.path.exists(user_js)) +@pytest.fixture +def profile(tmpdir): + # make a profile with one preference + path = tmpdir.mkdtemp().strpath + profile = Profile(path, + preferences={'foo': 'bar'}, + restore=False) + user_js = os.path.join(profile.profile, 'user.js') + assert os.path.exists(user_js) + return profile + - def test_restore_true(self): - counter = [0] +def test_restore_true(profile): + counter = [0] - def _feedback(dir, content): - # Called by shutil.copytree on each visited directory. - # Used here to display info. - # - # Returns the items that should be ignored by - # shutil.copytree when copying the tree, so always returns - # an empty list. - counter[0] += 1 - return [] + def _feedback(dir, content): + # Called by shutil.copytree on each visited directory. + # Used here to display info. + # + # Returns the items that should be ignored by + # shutil.copytree when copying the tree, so always returns + # an empty list. + counter[0] += 1 + return [] - # make a clone of this profile with restore=True - clone = Profile.clone(self.profile.profile, restore=True, - ignore=_feedback) - self.addCleanup(mozfile.remove, clone.profile) - + # make a clone of this profile with restore=True + clone = Profile.clone(profile.profile, restore=True, + ignore=_feedback) + try: clone.cleanup() # clone should be deleted - self.assertFalse(os.path.exists(clone.profile)) - self.assertTrue(counter[0] > 0) + assert not os.path.exists(clone.profile) + assert counter[0] > 0 + finally: + mozfile.remove(clone.profile) - def test_restore_false(self): - # make a clone of this profile with restore=False - clone = Profile.clone(self.profile.profile, restore=False) - self.addCleanup(mozfile.remove, clone.profile) +def test_restore_false(profile): + # make a clone of this profile with restore=False + clone = Profile.clone(profile.profile, restore=False) + try: clone.cleanup() # clone should still be around on the filesystem - self.assertTrue(os.path.exists(clone.profile)) + assert os.path.exists(clone.profile) + finally: + mozfile.remove(clone.profile) + - def test_cleanup_on_garbage_collected(self): - clone = Profile.clone(self.profile.profile) - self.addCleanup(mozfile.remove, clone.profile) - profile_dir = clone.profile - self.assertTrue(os.path.exists(profile_dir)) - del clone - # clone should be deleted - self.assertFalse(os.path.exists(profile_dir)) +def test_cleanup_on_garbage_collected(profile): + clone = Profile.clone(profile.profile) + profile_dir = clone.profile + assert os.path.exists(profile_dir) + del clone + + # clone should be deleted + assert not os.path.exists(profile_dir) if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/test_nonce.py b/testing/mozbase/mozprofile/tests/test_nonce.py --- a/testing/mozbase/mozprofile/tests/test_nonce.py +++ b/testing/mozbase/mozprofile/tests/test_nonce.py @@ -3,53 +3,46 @@ """ test nonce in prefs delimeters see https://bugzilla.mozilla.org/show_bug.cgi?id=722804 """ from __future__ import absolute_import import os -import tempfile -import unittest -import mozfile import mozunit from mozprofile.prefs import Preferences from mozprofile.profile import Profile -class PreferencesNonceTest(unittest.TestCase): - - def test_nonce(self): +def test_nonce(tmpdir): + # make a profile with one preference + path = tmpdir.strpath + profile = Profile(path, + preferences={'foo': 'bar'}, + restore=False) + user_js = os.path.join(profile.profile, 'user.js') + assert os.path.exists(user_js) - # make a profile with one preference - path = tempfile.mktemp() - self.addCleanup(mozfile.remove, path) - profile = Profile(path, - preferences={'foo': 'bar'}, - restore=False) - user_js = os.path.join(profile.profile, 'user.js') - self.assertTrue(os.path.exists(user_js)) + # ensure the preference is correct + prefs = Preferences.read_prefs(user_js) + assert dict(prefs) == {'foo': 'bar'} - # ensure the preference is correct - prefs = Preferences.read_prefs(user_js) - self.assertEqual(dict(prefs), {'foo': 'bar'}) - - del profile + del profile - # augment the profile with a second preference - profile = Profile(path, - preferences={'fleem': 'baz'}, - restore=True) - prefs = Preferences.read_prefs(user_js) - self.assertEqual(dict(prefs), {'foo': 'bar', 'fleem': 'baz'}) + # augment the profile with a second preference + profile = Profile(path, + preferences={'fleem': 'baz'}, + restore=True) + prefs = Preferences.read_prefs(user_js) + assert dict(prefs) == {'foo': 'bar', 'fleem': 'baz'} - # cleanup the profile; - # this should remove the new preferences but not the old - profile.cleanup() - prefs = Preferences.read_prefs(user_js) - self.assertEqual(dict(prefs), {'foo': 'bar'}) + # cleanup the profile; + # this should remove the new preferences but not the old + profile.cleanup() + prefs = Preferences.read_prefs(user_js) + assert dict(prefs) == {'foo': 'bar'} if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/permissions.py b/testing/mozbase/mozprofile/tests/test_permissions.py rename from testing/mozbase/mozprofile/tests/permissions.py rename to testing/mozbase/mozprofile/tests/test_permissions.py --- a/testing/mozbase/mozprofile/tests/permissions.py +++ b/testing/mozbase/mozprofile/tests/test_permissions.py @@ -1,205 +1,212 @@ #!/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 __future__ import absolute_import -import mozfile import os -import shutil import sqlite3 -import tempfile -import unittest import mozunit +import pytest from mozprofile.permissions import Permissions - -class PermissionsTest(unittest.TestCase): - - locations = """http://mochi.test:8888 primary,privileged +LOCATIONS = """http://mochi.test:8888 primary,privileged http://127.0.0.1:80 noxul http://127.0.0.1:8888 privileged """ - profile_dir = None - locations_file = None + +@pytest.fixture +def locations_file(tmpdir): + locations_file = tmpdir.join('locations.txt') + locations_file.write(LOCATIONS) + return locations_file.strpath + - def setUp(self): - self.profile_dir = tempfile.mkdtemp() - self.locations_file = mozfile.NamedTemporaryFile() - self.locations_file.write(self.locations) - self.locations_file.flush() +@pytest.fixture +def perms(tmpdir, locations_file): + return Permissions(tmpdir.mkdir('profile').strpath, locations_file) + + +def test_create_permissions_db(perms): + profile_dir = perms._profileDir + perms_db_filename = os.path.join(profile_dir, 'permissions.sqlite') + + select_stmt = 'select origin, type, permission from moz_hosts' - def tearDown(self): - if self.profile_dir: - shutil.rmtree(self.profile_dir) - if self.locations_file: - self.locations_file.close() + con = sqlite3.connect(perms_db_filename) + cur = con.cursor() + cur.execute(select_stmt) + entries = cur.fetchall() + + assert len(entries) == 3 + + assert entries[0][0] == 'http://mochi.test:8888' + assert entries[0][1] == 'allowXULXBL' + assert entries[0][2] == 1 - def write_perm_db(self, version=3): - permDB = sqlite3.connect(os.path.join(self.profile_dir, "permissions.sqlite")) - cursor = permDB.cursor() + assert entries[1][0] == 'http://127.0.0.1' + assert entries[1][1] == 'allowXULXBL' + assert entries[1][2] == 2 - cursor.execute("PRAGMA user_version=%d;" % version) + assert entries[2][0] == 'http://127.0.0.1:8888' + assert entries[2][1] == 'allowXULXBL' + assert entries[2][2] == 1 + + perms._locations.add_host('a.b.c', port='8081', scheme='https', options='noxul') + + cur.execute(select_stmt) + entries = cur.fetchall() - if version == 5: - cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( - id INTEGER PRIMARY KEY, - origin TEXT, - type TEXT, - permission INTEGER, - expireType INTEGER, - expireTime INTEGER, - modificationTime INTEGER)""") - elif version == 4: - cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( - id INTEGER PRIMARY KEY, - host TEXT, - type TEXT, - permission INTEGER, - expireType INTEGER, - expireTime INTEGER, - modificationTime INTEGER, - appId INTEGER, - isInBrowserElement INTEGER)""") - elif version == 3: - cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( - id INTEGER PRIMARY KEY, - host TEXT, - type TEXT, - permission INTEGER, - expireType INTEGER, - expireTime INTEGER, - appId INTEGER, - isInBrowserElement INTEGER)""") - elif version == 2: - cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( - id INTEGER PRIMARY KEY, - host TEXT, - type TEXT, - permission INTEGER, - expireType INTEGER, - expireTime INTEGER)""") - else: - raise Exception("version must be 2, 3, 4 or 5") + assert len(entries) == 4 + assert entries[3][0] == 'https://a.b.c:8081' + assert entries[3][1] == 'allowXULXBL' + assert entries[3][2] == 2 + + # when creating a DB we should default to user_version==5 + cur.execute('PRAGMA user_version') + entries = cur.fetchall() + assert entries[0][0] == 5 + + perms.clean_db() + # table should be removed + cur.execute("select * from sqlite_master where type='table'") + entries = cur.fetchall() + assert len(entries) == 0 + + +def test_nw_prefs(perms): + prefs, user_prefs = perms.network_prefs(False) + + assert len(user_prefs) == 0 + assert len(prefs) == 0 - permDB.commit() - cursor.close() + prefs, user_prefs = perms.network_prefs(True) + assert len(user_prefs) == 2 + assert user_prefs[0] == ('network.proxy.type', 2) + assert user_prefs[1][0] == 'network.proxy.autoconfig_url' - def test_create_permissions_db(self): - perms = Permissions(self.profile_dir, self.locations_file.name) - perms_db_filename = os.path.join(self.profile_dir, 'permissions.sqlite') - - select_stmt = 'select origin, type, permission from moz_hosts' + origins_decl = "var knownOrigins = (function () { return ['http://mochi.test:8888', " \ + "'http://127.0.0.1:80', 'http://127.0.0.1:8888'].reduce" + assert origins_decl in user_prefs[1][1] - con = sqlite3.connect(perms_db_filename) - cur = con.cursor() - cur.execute(select_stmt) - entries = cur.fetchall() + proxy_check = ("'http': 'PROXY mochi.test:8888'", + "'https': 'PROXY mochi.test:4443'", + "'ws': 'PROXY mochi.test:4443'", + "'wss': 'PROXY mochi.test:4443'") + assert all(c in user_prefs[1][1] for c in proxy_check) - self.assertEqual(len(entries), 3) - self.assertEqual(entries[0][0], 'http://mochi.test:8888') - self.assertEqual(entries[0][1], 'allowXULXBL') - self.assertEqual(entries[0][2], 1) +@pytest.fixture +def perms_db_filename(tmpdir): + return tmpdir.join('permissions.sqlite').strpath + - self.assertEqual(entries[1][0], 'http://127.0.0.1') - self.assertEqual(entries[1][1], 'allowXULXBL') - self.assertEqual(entries[1][2], 2) +@pytest.fixture +def permDB(perms_db_filename): + permDB = sqlite3.connect(perms_db_filename) + yield permDB + permDB.cursor().close() + - self.assertEqual(entries[2][0], 'http://127.0.0.1:8888') - self.assertEqual(entries[2][1], 'allowXULXBL') - self.assertEqual(entries[2][2], 1) - - perms._locations.add_host('a.b.c', port='8081', scheme='https', options='noxul') - - cur.execute(select_stmt) - entries = cur.fetchall() - - self.assertEqual(len(entries), 4) - self.assertEqual(entries[3][0], 'https://a.b.c:8081') - self.assertEqual(entries[3][1], 'allowXULXBL') - self.assertEqual(entries[3][2], 2) - - # when creating a DB we should default to user_version==5 - cur.execute('PRAGMA user_version') - entries = cur.fetchall() - self.assertEqual(entries[0][0], 5) +@pytest.fixture(params=range(2, 6)) +def version(request, perms_db_filename, permDB, locations_file): + version = request.param - perms.clean_db() - # table should be removed - cur.execute("select * from sqlite_master where type='table'") - entries = cur.fetchall() - self.assertEqual(len(entries), 0) - - def test_nw_prefs(self): - perms = Permissions(self.profile_dir, self.locations_file.name) - - prefs, user_prefs = perms.network_prefs(False) - - self.assertEqual(len(user_prefs), 0) - self.assertEqual(len(prefs), 0) - - prefs, user_prefs = perms.network_prefs(True) - self.assertEqual(len(user_prefs), 2) - self.assertEqual(user_prefs[0], ('network.proxy.type', 2)) - self.assertEqual(user_prefs[1][0], 'network.proxy.autoconfig_url') - - origins_decl = "var knownOrigins = (function () { return ['http://mochi.test:8888', " \ - "'http://127.0.0.1:80', 'http://127.0.0.1:8888'].reduce" - self.assertTrue(origins_decl in user_prefs[1][1]) + cursor = permDB.cursor() + cursor.execute("PRAGMA user_version=%d;" % version) - proxy_check = ("'http': 'PROXY mochi.test:8888'", - "'https': 'PROXY mochi.test:4443'", - "'ws': 'PROXY mochi.test:4443'", - "'wss': 'PROXY mochi.test:4443'") - self.assertTrue(all(c in user_prefs[1][1] for c in proxy_check)) - - def verify_user_version(self, version): - """Verifies that we call INSERT statements using the correct number - of columns for existing databases. - """ - self.write_perm_db(version=version) - Permissions(self.profile_dir, self.locations_file.name) - perms_db_filename = os.path.join(self.profile_dir, 'permissions.sqlite') - - select_stmt = 'select * from moz_hosts' - - con = sqlite3.connect(perms_db_filename) - cur = con.cursor() - cur.execute(select_stmt) - entries = cur.fetchall() - - self.assertEqual(len(entries), 3) + if version == 5: + cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( + id INTEGER PRIMARY KEY, + origin TEXT, + type TEXT, + permission INTEGER, + expireType INTEGER, + expireTime INTEGER, + modificationTime INTEGER)""") + elif version == 4: + cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( + id INTEGER PRIMARY KEY, + host TEXT, + type TEXT, + permission INTEGER, + expireType INTEGER, + expireTime INTEGER, + modificationTime INTEGER, + appId INTEGER, + isInBrowserElement INTEGER)""") + elif version == 3: + cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( + id INTEGER PRIMARY KEY, + host TEXT, + type TEXT, + permission INTEGER, + expireType INTEGER, + expireTime INTEGER, + appId INTEGER, + isInBrowserElement INTEGER)""") + elif version == 2: + cursor.execute("""CREATE TABLE IF NOT EXISTS moz_hosts ( + id INTEGER PRIMARY KEY, + host TEXT, + type TEXT, + permission INTEGER, + expireType INTEGER, + expireTime INTEGER)""") + else: + raise Exception("version must be 2, 3, 4 or 5") + permDB.commit() - columns = { - 1: 6, - 2: 6, - 3: 8, - 4: 9, - 5: 7, - }[version] + # Create a permissions object to read the db + Permissions(os.path.dirname(perms_db_filename), locations_file) + return version + - self.assertEqual(len(entries[0]), columns) - for x in range(4, columns): - self.assertEqual(entries[0][x], 0) +def test_verify_user_version(version, permDB): + """Verifies that we call INSERT statements using the correct number + of columns for existing databases. + """ + select_stmt = 'select * from moz_hosts' + + cur = permDB.cursor() + cur.execute(select_stmt) + entries = cur.fetchall() + + assert len(entries) == 3 - def test_existing_permissions_db_v2(self): - self.verify_user_version(2) + columns = { + 1: 6, + 2: 6, + 3: 8, + 4: 9, + 5: 7, + }[version] - def test_existing_permissions_db_v3(self): - self.verify_user_version(3) + assert len(entries[0]) == columns + for x in range(4, columns): + assert entries[0][x] == 0 + - def test_existing_permissions_db_v4(self): - self.verify_user_version(4) +def test_schema_version(perms, locations_file): + profile_dir = perms._profileDir + perms_db_filename = os.path.join(profile_dir, 'permissions.sqlite') + perms.write_db(open(locations_file, 'w+b')) + + stmt = 'PRAGMA user_version;' - def test_existing_permissions_db_v5(self): - self.verify_user_version(5) + con = sqlite3.connect(perms_db_filename) + cur = con.cursor() + cur.execute(stmt) + entries = cur.fetchall() + + schema_version = entries[0][0] + assert schema_version == 5 if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/test_preferences.py b/testing/mozbase/mozprofile/tests/test_preferences.py --- a/testing/mozbase/mozprofile/tests/test_preferences.py +++ b/testing/mozbase/mozprofile/tests/test_preferences.py @@ -6,390 +6,405 @@ from __future__ import absolute_import import mozfile import mozhttpd import os import shutil import tempfile -import unittest import mozunit +import pytest from mozprofile.cli import MozProfileCLI from mozprofile.prefs import Preferences, PreferencesReadError from mozprofile.profile import Profile here = os.path.dirname(os.path.abspath(__file__)) -class PreferencesTest(unittest.TestCase): - """test mozprofile preference handling""" +# preferences from files/prefs_with_comments.js +_prefs_with_comments = {'browser.startup.homepage': 'http://planet.mozilla.org', + 'zoom.minPercent': 30, + 'zoom.maxPercent': 300, + 'webgl.verbose': 'false'} + - # preferences from files/prefs_with_comments.js - _prefs_with_comments = {'browser.startup.homepage': 'http://planet.mozilla.org', - 'zoom.minPercent': 30, - 'zoom.maxPercent': 300, - 'webgl.verbose': 'false'} - - def run_command(self, *args): - """ - invokes mozprofile command line via the CLI factory - - args : command line arguments (equivalent of sys.argv[1:]) - """ - +@pytest.fixture +def run_command(): + """ + invokes mozprofile command line via the CLI factory + - args : command line arguments (equivalent of sys.argv[1:]) + """ + def inner(*args): # instantiate the factory cli = MozProfileCLI(list(args)) # create the profile profile = cli.profile() # return path to profile return profile.profile + return inner - def compare_generated(self, _prefs, commandline): - """ - writes out to a new profile with mozprofile command line - reads the generated preferences with prefs.py - compares the results - cleans up - """ - profile = self.run_command(*commandline) + +@pytest.fixture +def compare_generated(run_command): + """ + writes out to a new profile with mozprofile command line + reads the generated preferences with prefs.py + compares the results + cleans up + """ + def inner(prefs, commandline): + profile = run_command(*commandline) prefs_file = os.path.join(profile, 'user.js') - self.assertTrue(os.path.exists(prefs_file)) + assert os.path.exists(prefs_file) read = Preferences.read_prefs(prefs_file) - if isinstance(_prefs, dict): + if isinstance(prefs, dict): read = dict(read) - self.assertEqual(_prefs, read) + assert prefs == read shutil.rmtree(profile) + return inner - def test_basic_prefs(self): - """test setting a pref from the command line entry point""" - _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"} - commandline = [] - _prefs = _prefs.items() - for pref, value in _prefs: - commandline += ["--pref", "%s:%s" % (pref, value)] - self.compare_generated(_prefs, commandline) +def test_basic_prefs(compare_generated): + """test setting a pref from the command line entry point""" + + _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"} + commandline = [] + _prefs = _prefs.items() + for pref, value in _prefs: + commandline += ["--pref", "%s:%s" % (pref, value)] + compare_generated(_prefs, commandline) + - def test_ordered_prefs(self): - """ensure the prefs stay in the right order""" - _prefs = [("browser.startup.homepage", "http://planet.mozilla.org/"), - ("zoom.minPercent", 30), - ("zoom.maxPercent", 300), - ("webgl.verbose", 'false')] - commandline = [] - for pref, value in _prefs: - commandline += ["--pref", "%s:%s" % (pref, value)] - _prefs = [(i, Preferences.cast(j)) for i, j in _prefs] - self.compare_generated(_prefs, commandline) +def test_ordered_prefs(compare_generated): + """ensure the prefs stay in the right order""" + _prefs = [("browser.startup.homepage", "http://planet.mozilla.org/"), + ("zoom.minPercent", 30), + ("zoom.maxPercent", 300), + ("webgl.verbose", 'false')] + commandline = [] + for pref, value in _prefs: + commandline += ["--pref", "%s:%s" % (pref, value)] + _prefs = [(i, Preferences.cast(j)) for i, j in _prefs] + compare_generated(_prefs, commandline) - def test_ini(self): - # write the .ini file - _ini = """[DEFAULT] +def test_ini(compare_generated): + # write the .ini file + _ini = """[DEFAULT] browser.startup.homepage = http://planet.mozilla.org/ [foo] browser.startup.homepage = http://github.com/ """ - try: - fd, name = tempfile.mkstemp(suffix='.ini') - os.write(fd, _ini) - os.close(fd) - commandline = ["--preferences", name] + try: + fd, name = tempfile.mkstemp(suffix='.ini') + os.write(fd, _ini) + os.close(fd) + commandline = ["--preferences", name] - # test the [DEFAULT] section - _prefs = {'browser.startup.homepage': 'http://planet.mozilla.org/'} - self.compare_generated(_prefs, commandline) + # test the [DEFAULT] section + _prefs = {'browser.startup.homepage': 'http://planet.mozilla.org/'} + compare_generated(_prefs, commandline) - # test a specific section - _prefs = {'browser.startup.homepage': 'http://github.com/'} - commandline[-1] = commandline[-1] + ':foo' - self.compare_generated(_prefs, commandline) + # test a specific section + _prefs = {'browser.startup.homepage': 'http://github.com/'} + commandline[-1] = commandline[-1] + ':foo' + compare_generated(_prefs, commandline) + + finally: + # cleanup + os.remove(name) - finally: - # cleanup - os.remove(name) - def test_ini_keep_case(self): - """ - Read a preferences config file with a preference in camel-case style. - Check that the read preference name has not been lower-cased - """ - # write the .ini file - _ini = """[DEFAULT] +def test_ini_keep_case(compare_generated): + """ + Read a preferences config file with a preference in camel-case style. + Check that the read preference name has not been lower-cased + """ + # write the .ini file + _ini = """[DEFAULT] general.warnOnAboutConfig = False """ - try: - fd, name = tempfile.mkstemp(suffix='.ini') - os.write(fd, _ini) - os.close(fd) - commandline = ["--preferences", name] + try: + fd, name = tempfile.mkstemp(suffix='.ini') + os.write(fd, _ini) + os.close(fd) + commandline = ["--preferences", name] - # test the [DEFAULT] section - _prefs = {'general.warnOnAboutConfig': 'False'} - self.compare_generated(_prefs, commandline) + # test the [DEFAULT] section + _prefs = {'general.warnOnAboutConfig': 'False'} + compare_generated(_prefs, commandline) - finally: - # cleanup - os.remove(name) + finally: + # cleanup + os.remove(name) + - def test_reset_should_remove_added_prefs(self): - """Check that when we call reset the items we expect are updated""" - profile = Profile() - prefs_file = os.path.join(profile.profile, 'user.js') +def test_reset_should_remove_added_prefs(): + """Check that when we call reset the items we expect are updated""" + profile = Profile() + prefs_file = os.path.join(profile.profile, 'user.js') - # we shouldn't have any initial preferences - initial_prefs = Preferences.read_prefs(prefs_file) - self.assertFalse(initial_prefs) - initial_prefs = open(prefs_file).read().strip() - self.assertFalse(initial_prefs) + # we shouldn't have any initial preferences + initial_prefs = Preferences.read_prefs(prefs_file) + assert not initial_prefs + initial_prefs = open(prefs_file).read().strip() + assert not initial_prefs - # add some preferences - prefs1 = [("mr.t.quotes", "i aint getting on no plane!")] - profile.set_preferences(prefs1) - self.assertEqual(prefs1, Preferences.read_prefs(prefs_file)) - lines = open(prefs_file).read().strip().splitlines() - self.assertTrue(any(line.startswith('#MozRunner Prefs Start') for line in lines)) - self.assertTrue(any(line.startswith('#MozRunner Prefs End') for line in lines)) + # add some preferences + prefs1 = [("mr.t.quotes", "i aint getting on no plane!")] + profile.set_preferences(prefs1) + assert prefs1 == Preferences.read_prefs(prefs_file) + lines = open(prefs_file).read().strip().splitlines() + assert any(line.startswith('#MozRunner Prefs Start') for line in lines) + assert any(line.startswith('#MozRunner Prefs End') for line in lines) - profile.reset() - self.assertNotEqual(prefs1, - Preferences.read_prefs(os.path.join(profile.profile, 'user.js')), - "I pity the fool who left my pref") + profile.reset() + assert prefs1 != Preferences.read_prefs(os.path.join(profile.profile, 'user.js')) + - def test_reset_should_keep_user_added_prefs(self): - """Check that when we call reset the items we expect are updated""" - profile = Profile() - prefs_file = os.path.join(profile.profile, 'user.js') +def test_reset_should_keep_user_added_prefs(): + """Check that when we call reset the items we expect are updated""" + profile = Profile() + prefs_file = os.path.join(profile.profile, 'user.js') - # we shouldn't have any initial preferences - initial_prefs = Preferences.read_prefs(prefs_file) - self.assertFalse(initial_prefs) - initial_prefs = open(prefs_file).read().strip() - self.assertFalse(initial_prefs) + # we shouldn't have any initial preferences + initial_prefs = Preferences.read_prefs(prefs_file) + assert not initial_prefs + initial_prefs = open(prefs_file).read().strip() + assert not initial_prefs - # add some preferences - prefs1 = [("mr.t.quotes", "i aint getting on no plane!")] - profile.set_persistent_preferences(prefs1) - self.assertEqual(prefs1, Preferences.read_prefs(prefs_file)) - lines = open(prefs_file).read().strip().splitlines() - self.assertTrue(any(line.startswith('#MozRunner Prefs Start') for line in lines)) - self.assertTrue(any(line.startswith('#MozRunner Prefs End') for line in lines)) + # add some preferences + prefs1 = [("mr.t.quotes", "i aint getting on no plane!")] + profile.set_persistent_preferences(prefs1) + assert prefs1 == Preferences.read_prefs(prefs_file) + lines = open(prefs_file).read().strip().splitlines() + assert any(line.startswith('#MozRunner Prefs Start') for line in lines) + assert any(line.startswith('#MozRunner Prefs End') for line in lines) - profile.reset() - self.assertEqual(prefs1, - Preferences.read_prefs(os.path.join(profile.profile, 'user.js')), - "I pity the fool who left my pref") + profile.reset() + assert prefs1 == Preferences.read_prefs(os.path.join(profile.profile, 'user.js')) + - def test_magic_markers(self): - """ensure our magic markers are working""" +def test_magic_markers(): + """ensure our magic markers are working""" - profile = Profile() - prefs_file = os.path.join(profile.profile, 'user.js') + profile = Profile() + prefs_file = os.path.join(profile.profile, 'user.js') - # we shouldn't have any initial preferences - initial_prefs = Preferences.read_prefs(prefs_file) - self.assertFalse(initial_prefs) - initial_prefs = open(prefs_file).read().strip() - self.assertFalse(initial_prefs) + # we shouldn't have any initial preferences + initial_prefs = Preferences.read_prefs(prefs_file) + assert not initial_prefs + initial_prefs = open(prefs_file).read().strip() + assert not initial_prefs - # add some preferences - prefs1 = [("browser.startup.homepage", "http://planet.mozilla.org/"), - ("zoom.minPercent", 30)] - profile.set_preferences(prefs1) - self.assertEqual(prefs1, Preferences.read_prefs(prefs_file)) - lines = open(prefs_file).read().strip().splitlines() - self.assertTrue(bool([line for line in lines - if line.startswith('#MozRunner Prefs Start')])) - self.assertTrue(bool([line for line in lines - if line.startswith('#MozRunner Prefs End')])) + # add some preferences + prefs1 = [("browser.startup.homepage", "http://planet.mozilla.org/"), + ("zoom.minPercent", 30)] + profile.set_preferences(prefs1) + assert prefs1 == Preferences.read_prefs(prefs_file) + lines = open(prefs_file).read().strip().splitlines() + assert bool([line for line in lines + if line.startswith('#MozRunner Prefs Start')]) + assert bool([line for line in lines + if line.startswith('#MozRunner Prefs End')]) - # add some more preferences - prefs2 = [("zoom.maxPercent", 300), - ("webgl.verbose", 'false')] - profile.set_preferences(prefs2) - self.assertEqual(prefs1 + prefs2, Preferences.read_prefs(prefs_file)) - lines = open(prefs_file).read().strip().splitlines() - self.assertTrue(len([line for line in lines - if line.startswith('#MozRunner Prefs Start')]) == 2) - self.assertTrue(len([line for line in lines - if line.startswith('#MozRunner Prefs End')]) == 2) + # add some more preferences + prefs2 = [("zoom.maxPercent", 300), + ("webgl.verbose", 'false')] + profile.set_preferences(prefs2) + assert prefs1 + prefs2 == Preferences.read_prefs(prefs_file) + lines = open(prefs_file).read().strip().splitlines() + assert len([line for line in lines + if line.startswith('#MozRunner Prefs Start')]) == 2 + assert len([line for line in lines + if line.startswith('#MozRunner Prefs End')]) == 2 - # now clean it up - profile.clean_preferences() - final_prefs = Preferences.read_prefs(prefs_file) - self.assertFalse(final_prefs) - lines = open(prefs_file).read().strip().splitlines() - self.assertTrue('#MozRunner Prefs Start' not in lines) - self.assertTrue('#MozRunner Prefs End' not in lines) + # now clean it up + profile.clean_preferences() + final_prefs = Preferences.read_prefs(prefs_file) + assert not final_prefs + lines = open(prefs_file).read().strip().splitlines() + assert '#MozRunner Prefs Start' not in lines + assert '#MozRunner Prefs End' not in lines + - def test_preexisting_preferences(self): - """ensure you don't clobber preexisting preferences""" +def test_preexisting_preferences(): + """ensure you don't clobber preexisting preferences""" - # make a pretend profile - tempdir = tempfile.mkdtemp() + # make a pretend profile + tempdir = tempfile.mkdtemp() - try: - # make a user.js - contents = """ + try: + # make a user.js + contents = """ user_pref("webgl.enabled_for_all_sites", true); user_pref("webgl.force-enabled", true); """ - user_js = os.path.join(tempdir, 'user.js') - f = open(user_js, 'w') - f.write(contents) - f.close() + user_js = os.path.join(tempdir, 'user.js') + f = open(user_js, 'w') + f.write(contents) + f.close() - # make sure you can read it - prefs = Preferences.read_prefs(user_js) - original_prefs = [('webgl.enabled_for_all_sites', True), ('webgl.force-enabled', True)] - self.assertTrue(prefs == original_prefs) + # make sure you can read it + prefs = Preferences.read_prefs(user_js) + original_prefs = [('webgl.enabled_for_all_sites', True), ('webgl.force-enabled', True)] + assert prefs == original_prefs - # now read this as a profile - profile = Profile(tempdir, preferences={"browser.download.dir": "/home/jhammel"}) + # now read this as a profile + profile = Profile(tempdir, preferences={"browser.download.dir": "/home/jhammel"}) - # make sure the new pref is now there - new_prefs = original_prefs[:] + [("browser.download.dir", "/home/jhammel")] - prefs = Preferences.read_prefs(user_js) - self.assertTrue(prefs == new_prefs) + # make sure the new pref is now there + new_prefs = original_prefs[:] + [("browser.download.dir", "/home/jhammel")] + prefs = Preferences.read_prefs(user_js) + assert prefs == new_prefs - # clean up the added preferences - profile.cleanup() - del profile + # clean up the added preferences + profile.cleanup() + del profile - # make sure you have the original preferences - prefs = Preferences.read_prefs(user_js) - self.assertTrue(prefs == original_prefs) - finally: - shutil.rmtree(tempdir) + # make sure you have the original preferences + prefs = Preferences.read_prefs(user_js) + assert prefs == original_prefs + finally: + shutil.rmtree(tempdir) + - def test_can_read_prefs_with_multiline_comments(self): - """ - Ensure that multiple comments in the file header do not break reading - the prefs (https://bugzilla.mozilla.org/show_bug.cgi?id=1233534). - """ - user_js = tempfile.NamedTemporaryFile(suffix='.js', delete=False) - self.addCleanup(mozfile.remove, user_js.name) +def test_can_read_prefs_with_multiline_comments(): + """ + Ensure that multiple comments in the file header do not break reading + the prefs (https://bugzilla.mozilla.org/show_bug.cgi?id=1233534). + """ + user_js = tempfile.NamedTemporaryFile(suffix='.js', delete=False) + try: with user_js: user_js.write(""" # Mozilla User Preferences /* Do not edit this file. - * - * If you make changes to this file while the application is running, - * the changes will be overwritten when the application exits. - * - * To make a manual change to preferences, you can visit the URL about:config - */ +* +* If you make changes to this file while the application is running, +* the changes will be overwritten when the application exits. +* +* To make a manual change to preferences, you can visit the URL about:config +*/ user_pref("webgl.enabled_for_all_sites", true); user_pref("webgl.force-enabled", true); """) - self.assertEqual( - Preferences.read_prefs(user_js.name), - [('webgl.enabled_for_all_sites', True), - ('webgl.force-enabled', True)] - ) + assert Preferences.read_prefs(user_js.name) == [ + ('webgl.enabled_for_all_sites', True), + ('webgl.force-enabled', True) + ] + finally: + mozfile.remove(user_js.name) - def test_json(self): - _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"} - json = '{"browser.startup.homepage": "http://planet.mozilla.org/"}' + +def test_json(compare_generated): + _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"} + json = '{"browser.startup.homepage": "http://planet.mozilla.org/"}' - # just repr it...could use the json module but we don't need it here - with mozfile.NamedTemporaryFile(suffix='.json') as f: - f.write(json) - f.flush() + # just repr it...could use the json module but we don't need it here + with mozfile.NamedTemporaryFile(suffix='.json') as f: + f.write(json) + f.flush() - commandline = ["--preferences", f.name] - self.compare_generated(_prefs, commandline) + commandline = ["--preferences", f.name] + compare_generated(_prefs, commandline) + - def test_json_datatypes(self): - # minPercent is at 30.1 to test if non-integer data raises an exception - json = """{"zoom.minPercent": 30.1, "zoom.maxPercent": 300}""" +def test_json_datatypes(): + # minPercent is at 30.1 to test if non-integer data raises an exception + json = """{"zoom.minPercent": 30.1, "zoom.maxPercent": 300}""" - with mozfile.NamedTemporaryFile(suffix='.json') as f: - f.write(json) - f.flush() - - with self.assertRaises(PreferencesReadError): - Preferences.read_json(f._path) + with mozfile.NamedTemporaryFile(suffix='.json') as f: + f.write(json) + f.flush() - def test_prefs_write(self): - """test that the Preferences.write() method correctly serializes preferences""" + with pytest.raises(PreferencesReadError): + Preferences.read_json(f._path) - _prefs = {'browser.startup.homepage': "http://planet.mozilla.org", - 'zoom.minPercent': 30, - 'zoom.maxPercent': 300} + +def test_prefs_write(): + """test that the Preferences.write() method correctly serializes preferences""" - # make a Preferences manager with the testing preferences - preferences = Preferences(_prefs) + _prefs = {'browser.startup.homepage': "http://planet.mozilla.org", + 'zoom.minPercent': 30, + 'zoom.maxPercent': 300} + + # make a Preferences manager with the testing preferences + preferences = Preferences(_prefs) - # write them to a temporary location - path = None - read_prefs = None - try: - with mozfile.NamedTemporaryFile(suffix='.js', delete=False) as f: - path = f.name - preferences.write(f, _prefs) + # write them to a temporary location + path = None + read_prefs = None + try: + with mozfile.NamedTemporaryFile(suffix='.js', delete=False) as f: + path = f.name + preferences.write(f, _prefs) - # read them back and ensure we get what we put in - read_prefs = dict(Preferences.read_prefs(path)) + # read them back and ensure we get what we put in + read_prefs = dict(Preferences.read_prefs(path)) - finally: - # cleanup - if path and os.path.exists(path): - os.remove(path) + finally: + # cleanup + if path and os.path.exists(path): + os.remove(path) - self.assertEqual(read_prefs, _prefs) + assert read_prefs == _prefs + - def test_read_prefs_with_comments(self): - """test reading preferences from a prefs.js file that contains comments""" +def test_read_prefs_with_comments(): + """test reading preferences from a prefs.js file that contains comments""" - path = os.path.join(here, 'files', 'prefs_with_comments.js') - self.assertEqual(dict(Preferences.read_prefs(path)), self._prefs_with_comments) + path = os.path.join(here, 'files', 'prefs_with_comments.js') + assert dict(Preferences.read_prefs(path)) == _prefs_with_comments + - def test_read_prefs_with_interpolation(self): - """test reading preferences from a prefs.js file whose values - require interpolation""" +def test_read_prefs_with_interpolation(): + """test reading preferences from a prefs.js file whose values + require interpolation""" - expected_prefs = { - "browser.foo": "http://server-name", - "zoom.minPercent": 30, - "webgl.verbose": "false", - "browser.bar": "somethingxyz" - } - values = { - "server": "server-name", - "abc": "something" - } - path = os.path.join(here, 'files', 'prefs_with_interpolation.js') - read_prefs = Preferences.read_prefs(path, interpolation=values) - self.assertEqual(dict(read_prefs), expected_prefs) + expected_prefs = { + "browser.foo": "http://server-name", + "zoom.minPercent": 30, + "webgl.verbose": "false", + "browser.bar": "somethingxyz" + } + values = { + "server": "server-name", + "abc": "something" + } + path = os.path.join(here, 'files', 'prefs_with_interpolation.js') + read_prefs = Preferences.read_prefs(path, interpolation=values) + assert dict(read_prefs) == expected_prefs - def test_read_prefs_ttw(self): - """test reading preferences through the web via mozhttpd""" + +def test_read_prefs_ttw(): + """test reading preferences through the web via mozhttpd""" - # create a MozHttpd instance - docroot = os.path.join(here, 'files') - host = '127.0.0.1' - port = 8888 - httpd = mozhttpd.MozHttpd(host=host, port=port, docroot=docroot) + # create a MozHttpd instance + docroot = os.path.join(here, 'files') + host = '127.0.0.1' + port = 8888 + httpd = mozhttpd.MozHttpd(host=host, port=port, docroot=docroot) - # create a preferences instance - prefs = Preferences() + # create a preferences instance + prefs = Preferences() - try: - # start server - httpd.start(block=False) + try: + # start server + httpd.start(block=False) - # read preferences through the web - read = prefs.read_prefs('http://%s:%d/prefs_with_comments.js' % (host, port)) - self.assertEqual(dict(read), self._prefs_with_comments) - finally: - httpd.stop() + # read preferences through the web + read = prefs.read_prefs('http://%s:%d/prefs_with_comments.js' % (host, port)) + assert dict(read) == _prefs_with_comments + finally: + httpd.stop() if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/test_profile.py b/testing/mozbase/mozprofile/tests/test_profile.py --- a/testing/mozbase/mozprofile/tests/test_profile.py +++ b/testing/mozbase/mozprofile/tests/test_profile.py @@ -1,35 +1,36 @@ #!/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 __future__ import absolute_import -import unittest import os import mozunit +import pytest from mozprofile import Profile -class TestProfile(unittest.TestCase): +def test_with_profile_should_cleanup(): + with Profile() as profile: + assert os.path.exists(profile.profile) - def test_with_profile_should_cleanup(self): - with Profile() as profile: - self.assertTrue(os.path.exists(profile.profile)) - # profile is cleaned - self.assertFalse(os.path.exists(profile.profile)) + # profile is cleaned + assert not os.path.exists(profile.profile) + - def test_with_profile_should_cleanup_even_on_exception(self): - with self.assertRaises(ZeroDivisionError): - with Profile() as profile: - self.assertTrue(os.path.exists(profile.profile)) - 1 / 0 # will raise ZeroDivisionError - # profile is cleaned - self.assertFalse(os.path.exists(profile.profile)) +def test_with_profile_should_cleanup_even_on_exception(): + with pytest.raises(ZeroDivisionError): + with Profile() as profile: + assert os.path.exists(profile.profile) + 1 / 0 # will raise ZeroDivisionError + + # profile is cleaned + assert not os.path.exists(profile.profile) if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/test_profile_view.py b/testing/mozbase/mozprofile/tests/test_profile_view.py --- a/testing/mozbase/mozprofile/tests/test_profile_view.py +++ b/testing/mozbase/mozprofile/tests/test_profile_view.py @@ -1,82 +1,74 @@ #!/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 __future__ import absolute_import -import mozfile import mozprofile import os -import tempfile -import unittest import mozunit here = os.path.dirname(os.path.abspath(__file__)) -class TestProfilePrint(unittest.TestCase): +def test_profileprint(tmpdir): + """ + test the summary function + """ - def test_profileprint(self): - """ - test the summary function - """ - - keys = set(['Files', 'Path', 'user.js']) - ff_prefs = mozprofile.FirefoxProfile.preferences # shorthand - pref_string = '\n'.join(['%s: %s' % (key, ff_prefs[key]) - for key in sorted(ff_prefs.keys())]) + keys = set(['Files', 'Path', 'user.js']) + ff_prefs = mozprofile.FirefoxProfile.preferences # shorthand + pref_string = '\n'.join(['%s: %s' % (key, ff_prefs[key]) + for key in sorted(ff_prefs.keys())]) - tempdir = tempfile.mkdtemp() - try: - profile = mozprofile.FirefoxProfile(tempdir) - parts = profile.summary(return_parts=True) - parts = dict(parts) + tmpdir = tmpdir.strpath + profile = mozprofile.FirefoxProfile(tmpdir) + parts = profile.summary(return_parts=True) + parts = dict(parts) - self.assertEqual(parts['Path'], tempdir) - self.assertEqual(set(parts.keys()), keys) - self.assertEqual(pref_string, parts['user.js'].strip()) + assert parts['Path'] == tmpdir + assert set(parts.keys()) == keys + assert pref_string == parts['user.js'].strip() + - except BaseException: - raise - finally: - mozfile.rmtree(tempdir) +def test_str_cast(): + """Test casting to a string.""" + profile = mozprofile.Profile() + assert str(profile) == profile.summary().encode("utf-8") + - def test_str_cast(self): - """Test casting to a string.""" - profile = mozprofile.Profile() - self.assertEqual(str(profile), profile.summary().encode("utf-8")) +def test_unicode_cast(): + """Test casting to a unicode string.""" + profile = mozprofile.Profile() + assert unicode(profile) == profile.summary() + - def test_unicode_cast(self): - """Test casting to a unicode string.""" - profile = mozprofile.Profile() - self.assertEqual(unicode(profile), profile.summary()) +def test_profile_diff(): + profile1 = mozprofile.Profile() + profile2 = mozprofile.Profile(preferences=dict(foo='bar')) - def test_profile_diff(self): - profile1 = mozprofile.Profile() - profile2 = mozprofile.Profile(preferences=dict(foo='bar')) + # diff a profile against itself; no difference + assert mozprofile.diff(profile1, profile1) == [] - # diff a profile against itself; no difference - self.assertEqual([], mozprofile.diff(profile1, profile1)) - - # diff two profiles - diff = dict(mozprofile.diff(profile1, profile2)) - self.assertEqual(diff.keys(), ['user.js']) - lines = [line.strip() for line in diff['user.js'].splitlines()] - self.assertTrue('+foo: bar' in lines) + # diff two profiles + diff = dict(mozprofile.diff(profile1, profile2)) + assert diff.keys() == ['user.js'] + lines = [line.strip() for line in diff['user.js'].splitlines()] + assert '+foo: bar' in lines - # diff a blank vs FirefoxProfile - ff_profile = mozprofile.FirefoxProfile() - diff = dict(mozprofile.diff(profile2, ff_profile)) - self.assertEqual(diff.keys(), ['user.js']) - lines = [line.strip() for line in diff['user.js'].splitlines()] - self.assertTrue('-foo: bar' in lines) - ff_pref_lines = ['+%s: %s' % (key, value) - for key, value in mozprofile.FirefoxProfile.preferences.items()] - self.assertTrue(set(ff_pref_lines).issubset(lines)) + # diff a blank vs FirefoxProfile + ff_profile = mozprofile.FirefoxProfile() + diff = dict(mozprofile.diff(profile2, ff_profile)) + assert diff.keys() == ['user.js'] + lines = [line.strip() for line in diff['user.js'].splitlines()] + assert '-foo: bar' in lines + ff_pref_lines = ['+%s: %s' % (key, value) + for key, value in mozprofile.FirefoxProfile.preferences.items()] + assert set(ff_pref_lines).issubset(lines) if __name__ == '__main__': mozunit.main() diff --git a/testing/mozbase/mozprofile/tests/server_locations.py b/testing/mozbase/mozprofile/tests/test_server_locations.py rename from testing/mozbase/mozprofile/tests/server_locations.py rename to testing/mozbase/mozprofile/tests/test_server_locations.py --- a/testing/mozbase/mozprofile/tests/server_locations.py +++ b/testing/mozbase/mozprofile/tests/test_server_locations.py @@ -1,156 +1,146 @@ #!/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 __future__ import absolute_import -import mozfile -import unittest - import mozunit +import pytest from mozprofile.permissions import ServerLocations, \ MissingPrimaryLocationError, MultiplePrimaryLocationsError, \ - DuplicateLocationError, BadPortLocationError, LocationsSyntaxError + BadPortLocationError, LocationsSyntaxError -class ServerLocationsTest(unittest.TestCase): - """test server locations""" - - locations = """# This is the primary location from which tests run. +LOCATIONS = """# This is the primary location from which tests run. # http://mochi.test:8888 primary,privileged # a few test locations http://127.0.0.1:80 privileged http://127.0.0.1:8888 privileged https://test:80 privileged http://example.org:80 privileged http://test1.example.org privileged - """ +""" - locations_no_primary = """http://secondary.test:80 privileged +LOCATIONS_NO_PRIMARY = """http://secondary.test:80 privileged http://tertiary.test:8888 privileged """ - locations_bad_port = """http://mochi.test:8888 primary,privileged +LOCATIONS_BAD_PORT = """http://mochi.test:8888 primary,privileged http://127.0.0.1:80 privileged http://127.0.0.1:8888 privileged http://test:badport privileged http://example.org:80 privileged """ - def compare_location(self, location, scheme, host, port, options): - self.assertEqual(location.scheme, scheme) - self.assertEqual(location.host, host) - self.assertEqual(location.port, port) - self.assertEqual(location.options, options) - def create_temp_file(self, contents): - f = mozfile.NamedTemporaryFile() +def compare_location(location, scheme, host, port, options): + assert location.scheme == scheme + assert location.host == host + assert location.port == port + assert location.options == options + + +@pytest.fixture +def create_temp_file(tmpdir): + def inner(contents): + f = tmpdir.mkdtemp().join('locations.txt') f.write(contents) - f.flush() - return f + return f.strpath + return inner + - def test_server_locations(self): - # write a permissions file - f = self.create_temp_file(self.locations) +def test_server_locations(create_temp_file): + # write a permissions file + f = create_temp_file(LOCATIONS) - # read the locations - locations = ServerLocations(f.name) + # read the locations + locations = ServerLocations(f) - # ensure that they're what we expect - self.assertEqual(len(locations), 6) - i = iter(locations) - self.compare_location(next(i), 'http', 'mochi.test', '8888', - ['primary', 'privileged']) - self.compare_location(next(i), 'http', '127.0.0.1', '80', - ['privileged']) - self.compare_location(next(i), 'http', '127.0.0.1', '8888', - ['privileged']) - self.compare_location(next(i), 'https', 'test', '80', ['privileged']) - self.compare_location(next(i), 'http', 'example.org', '80', - ['privileged']) - self.compare_location(next(i), 'http', 'test1.example.org', '8888', - ['privileged']) + # ensure that they're what we expect + assert len(locations) == 6 + i = iter(locations) + compare_location(next(i), 'http', 'mochi.test', '8888', ['primary', 'privileged']) + compare_location(next(i), 'http', '127.0.0.1', '80', ['privileged']) + compare_location(next(i), 'http', '127.0.0.1', '8888', ['privileged']) + compare_location(next(i), 'https', 'test', '80', ['privileged']) + compare_location(next(i), 'http', 'example.org', '80', ['privileged']) + compare_location(next(i), 'http', 'test1.example.org', '8888', ['privileged']) - locations.add_host('mozilla.org') - self.assertEqual(len(locations), 7) - self.compare_location(next(i), 'http', 'mozilla.org', '80', - ['privileged']) + locations.add_host('mozilla.org') + assert len(locations) == 7 + compare_location(next(i), 'http', 'mozilla.org', '80', ['privileged']) - # test some errors - self.assertRaises(MultiplePrimaryLocationsError, locations.add_host, - 'primary.test', options='primary') + # test some errors + with pytest.raises(MultiplePrimaryLocationsError): + locations.add_host('primary.test', options='primary') - # We no longer throw these DuplicateLocation Error - try: - locations.add_host('127.0.0.1') - except DuplicateLocationError: - self.assertTrue(False, "Should no longer throw DuplicateLocationError") + # assert we don't throw DuplicateLocationError + locations.add_host('127.0.0.1') - self.assertRaises(BadPortLocationError, locations.add_host, '127.0.0.1', - port='abc') + with pytest.raises(BadPortLocationError): + locations.add_host('127.0.0.1', port='abc') + + # test some errors in locations file + f = create_temp_file(LOCATIONS_NO_PRIMARY) - # test some errors in locations file - f = self.create_temp_file(self.locations_no_primary) - - exc = None - try: - ServerLocations(f.name) - except LocationsSyntaxError as e: - exc = e - self.assertNotEqual(exc, None) - self.assertEqual(exc.err.__class__, MissingPrimaryLocationError) - self.assertEqual(exc.lineno, 3) + exc = None + try: + ServerLocations(f) + except LocationsSyntaxError as e: + exc = e + assert exc is not None + assert exc.err.__class__ == MissingPrimaryLocationError + assert exc.lineno == 3 - # test bad port in a locations file to ensure lineno calculated - # properly. - f = self.create_temp_file(self.locations_bad_port) + # test bad port in a locations file to ensure lineno calculated + # properly. + f = create_temp_file(LOCATIONS_BAD_PORT) - exc = None - try: - ServerLocations(f.name) - except LocationsSyntaxError as e: - exc = e - self.assertNotEqual(exc, None) - self.assertEqual(exc.err.__class__, BadPortLocationError) - self.assertEqual(exc.lineno, 4) + exc = None + try: + ServerLocations(f) + except LocationsSyntaxError as e: + exc = e + assert exc is not None + assert exc.err.__class__ == BadPortLocationError + assert exc.lineno == 4 + - def test_server_locations_callback(self): - class CallbackTest(object): - last_locations = None +def test_server_locations_callback(create_temp_file): + class CallbackTest(object): + last_locations = None - def callback(self, locations): - self.last_locations = locations + def callback(self, locations): + self.last_locations = locations - c = CallbackTest() - f = self.create_temp_file(self.locations) - locations = ServerLocations(f.name, c.callback) + c = CallbackTest() + f = create_temp_file(LOCATIONS) + locations = ServerLocations(f, c.callback) - # callback should be for all locations in file - self.assertEqual(len(c.last_locations), 6) + # callback should be for all locations in file + assert len(c.last_locations) == 6 - # validate arbitrary one - self.compare_location(c.last_locations[2], 'http', '127.0.0.1', '8888', - ['privileged']) + # validate arbitrary one + compare_location(c.last_locations[2], 'http', '127.0.0.1', '8888', ['privileged']) - locations.add_host('a.b.c') + locations.add_host('a.b.c') - # callback should be just for one location - self.assertEqual(len(c.last_locations), 1) - self.compare_location(c.last_locations[0], 'http', 'a.b.c', '80', - ['privileged']) + # callback should be just for one location + assert len(c.last_locations) == 1 + compare_location(c.last_locations[0], 'http', 'a.b.c', '80', ['privileged']) - # read a second file, which should generate a callback with both - # locations. - f = self.create_temp_file(self.locations_no_primary) - locations.read(f.name) - self.assertEqual(len(c.last_locations), 2) + # read a second file, which should generate a callback with both + # locations. + f = create_temp_file(LOCATIONS_NO_PRIMARY) + locations.read(f) + assert len(c.last_locations) == 2 if __name__ == '__main__': mozunit.main()