Bug 1445944 - [mozprofile] Convert mozprofile unittests to the pytest format r=davehunt
authorAndrew Halberstadt <ahalberstadt@mozilla.com>
Fri, 13 Apr 2018 11:06:10 -0400
changeset 467470 74448840c21fda21bee03f7b278294105b47a067
parent 467469 df5d226d1df3204b7fb4b975e7075a3a3e7a9775
child 467471 96f6bb303871f2ffade8413902135803422a46eb
push id9165
push userasasaki@mozilla.com
push dateThu, 26 Apr 2018 21:04:54 +0000
treeherdermozilla-beta@064c3804de2e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdavehunt
bugs1445944
milestone61.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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
testing/mozbase/mozprofile/tests/addonid.py
testing/mozbase/mozprofile/tests/bug758250.py
testing/mozbase/mozprofile/tests/bug785146.py
testing/mozbase/mozprofile/tests/manifest.ini
testing/mozbase/mozprofile/tests/permissions.py
testing/mozbase/mozprofile/tests/server_locations.py
testing/mozbase/mozprofile/tests/test_addonid.py
testing/mozbase/mozprofile/tests/test_addons.py
testing/mozbase/mozprofile/tests/test_bug758250.py
testing/mozbase/mozprofile/tests/test_clone_cleanup.py
testing/mozbase/mozprofile/tests/test_nonce.py
testing/mozbase/mozprofile/tests/test_permissions.py
testing/mozbase/mozprofile/tests/test_preferences.py
testing/mozbase/mozprofile/tests/test_profile.py
testing/mozbase/mozprofile/tests/test_profile_view.py
testing/mozbase/mozprofile/tests/test_server_locations.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()
--- 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]
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 = [
-            """<?xml version="1.0"?>
+ADDON_ID_TESTS = [
+    """
 <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
    <Description about="urn:mozilla:install-manifest">
      <em:id>winning</em:id>
      <em:name>MozMill</em:name>
      <em:version>2.0a</em:version>
      <em:creator>Adam Christian</em:creator>
      <em:description>A testing extension based on the
@@ -103,17 +72,18 @@ class AddonIDTest(unittest.TestCase):
          <Description>
           <em:id>toolkit@mozilla.org</em:id>
           <em:minVersion>1.9.1</em:minVersion>
           <em:maxVersion>2.0*</em:maxVersion>
          </Description>
      </em:targetApplication>
    </Description>
 </RDF>""",
-            """<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    """
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
    <Description about="urn:mozilla:install-manifest">
      <em:targetApplication>
        <!-- Firefox -->
        <Description>
          <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
          <em:minVersion>3.5</em:minVersion>
          <em:maxVersion>8.*</em:maxVersion>
@@ -123,27 +93,29 @@ class AddonIDTest(unittest.TestCase):
      <em:name>MozMill</em:name>
      <em:version>2.0a</em:version>
      <em:creator>Adam Christian</em:creator>
      <em:description>A testing extension based on the
             Windmill Testing Framework client source</em:description>
      <em:unpack>true</em:unpack>
     </Description>
  </RDF>""",
-            """<RDF xmlns="http://www.mozilla.org/2004/em-rdf#"
+    """
+<RDF xmlns="http://www.mozilla.org/2004/em-rdf#"
         xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <rdf:Description about="urn:mozilla:install-manifest">
      <id>winning</id>
      <name>foo</name>
      <version>42</version>
      <description>A testing extension based on the
             Windmill Testing Framework client source</description>
  </rdf:Description>
 </RDF>""",
-            """<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    """
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      xmlns:foobar="http://www.mozilla.org/2004/em-rdf#">
    <Description about="urn:mozilla:install-manifest">
      <foobar:targetApplication>
        <!-- Firefox -->
        <Description>
          <foobar:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</foobar:id>
          <foobar:minVersion>3.5</foobar:minVersion>
          <foobar:maxVersion>8.*</foobar:maxVersion>
@@ -152,14 +124,36 @@ class AddonIDTest(unittest.TestCase):
      <foobar:id>winning</foobar:id>
      <foobar:name>MozMill</foobar:name>
      <foobar:version>2.0a</foobar:version>
      <foobar:creator>Adam Christian</foobar:creator>
      <foobar:description>A testing extension based on the
             Windmill Testing Framework client source</foobar:description>
      <foobar:unpack>true</foobar:unpack>
     </Description>
- </RDF>"""]
-        return tests
+ </RDF>""",
+]
+
+
+@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()
--- 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()
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()
--- 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()
--- 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()
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()
--- 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()
--- 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()
--- 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()
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()