diff --git a/tests/__init__.py b/tests/__init__.py
index 5b0c9716..9a5dbd46 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -50,8 +50,25 @@ def patch_config():
 patch_config()
 
 
+def get_vcr_path(file_path, test_method):
+    cassette_dir = os.path.join(base_dir, 'vcr-request-data')
+    # In pytest style unit tests, we don't have access to self.id so this code replicates that
+    # value
+    filename_prefix = [os.path.abspath(os.path.dirname(file_path))]
+    while True:
+        if os.path.basename(filename_prefix[0]) == 'tests':
+            break
+        filename_prefix.insert(0, os.path.abspath(os.path.join(filename_prefix[0], os.pardir)))
+    filename_prefix = [os.path.basename(dir_path) for dir_path in filename_prefix]
+    filename = '.'.join(filename_prefix + [
+        os.path.splitext(os.path.basename(file_path))[0],
+        test_method.im_class.__name__,
+        test_method.im_func.__name__])
+    return os.path.join(cassette_dir, filename)
+
+
 def uncompress_vcrpy_cassette():
-    cassette_dir = base_dir + '/vcr-request-data/'
+    cassette_dir = os.path.join(base_dir, 'vcr-request-data')
     if not os.path.exists(cassette_dir):
         archive = cassette_dir.rstrip('/') + ".tar.gz"
         with tarfile.open(archive, mode='r:gz') as t:
diff --git a/tests/test_auth.py b/tests/test_auth.py
index 309acc99..0692d2d7 100644
--- a/tests/test_auth.py
+++ b/tests/test_auth.py
@@ -22,8 +22,7 @@
 # Written by Matt Prahl <mprahl@redhat.com>
 from os import path, environ
 
-from nose.tools import eq_
-import unittest
+import pytest
 import mock
 from mock import patch, PropertyMock, Mock
 import kerberos
@@ -35,7 +34,7 @@ import module_build_service.errors
 import module_build_service.config as mbs_config
 
 
-class TestAuthModule(unittest.TestCase):
+class TestAuthModule:
     def test_get_user_no_token(self):
         base_dir = path.abspath(path.dirname(__file__))
         client_secrets = path.join(base_dir, "client_secrets.json")
@@ -44,11 +43,9 @@ class TestAuthModule(unittest.TestCase):
             request = mock.MagicMock()
             request.cookies.return_value = {}
 
-            with self.assertRaises(module_build_service.errors.Unauthorized) as cm:
+            with pytest.raises(module_build_service.errors.Unauthorized) as cm:
                 module_build_service.auth.get_user(request)
-
-            self.assertEquals(str(cm.exception),
-                              "No 'authorization' header found.")
+                assert str(cm.value) == "No 'authorization' header found."
 
     @patch('module_build_service.auth._get_token_info')
     @patch('module_build_service.auth._get_user_info')
@@ -73,11 +70,9 @@ class TestAuthModule(unittest.TestCase):
             request.headers.__setitem__.side_effect = headers.__setitem__
             request.headers.__contains__.side_effect = headers.__contains__
 
-            with self.assertRaises(module_build_service.errors.Unauthorized) as cm:
+            with pytest.raises(module_build_service.errors.Unauthorized) as cm:
                 module_build_service.auth.get_user(request)
-
-            self.assertEquals(str(cm.exception),
-                              "OIDC token invalid or expired.")
+                assert str(cm.value) == "OIDC token invalid or expired."
 
     @patch('module_build_service.auth._get_token_info')
     @patch('module_build_service.auth._get_user_info')
@@ -103,24 +98,22 @@ class TestAuthModule(unittest.TestCase):
             request.headers.__contains__.side_effect = headers.__contains__
 
             username, groups = module_build_service.auth.get_user(request)
-            eq_(username, name)
-            eq_(groups, set(get_user_info.return_value["groups"]))
+            assert username == name
+            assert groups == set(get_user_info.return_value["groups"])
 
     @patch.object(mbs_config.Config, 'no_auth', new_callable=PropertyMock, return_value=True)
     def test_disable_authentication(self, conf_no_auth):
         request = mock.MagicMock()
         username, groups = module_build_service.auth.get_user(request)
-        eq_(username, "anonymous")
-        eq_(groups, {"packager"})
+        assert username == "anonymous"
+        assert groups == {"packager"}
 
     @patch('module_build_service.auth.client_secrets', None)
     def test_misconfiguring_oidc_client_secrets_should_be_failed(self):
         request = mock.MagicMock()
-        with self.assertRaises(module_build_service.errors.Forbidden) as cm:
+        with pytest.raises(module_build_service.errors.Forbidden) as cm:
             module_build_service.auth.get_user(request)
-
-        self.assertEquals(str(cm.exception),
-                          "OIDC_CLIENT_SECRETS must be set in server config.")
+            assert str(cm.value) == "OIDC_CLIENT_SECRETS must be set in server config."
 
     @patch('module_build_service.auth._get_token_info')
     @patch('module_build_service.auth._get_user_info')
@@ -145,12 +138,10 @@ class TestAuthModule(unittest.TestCase):
             request.headers.__setitem__.side_effect = headers.__setitem__
             request.headers.__contains__.side_effect = headers.__contains__
 
-            with self.assertRaises(module_build_service.errors.Unauthorized) as cm:
+            with pytest.raises(module_build_service.errors.Unauthorized) as cm:
                 module_build_service.auth.get_user(request)
-
-            self.assertEquals(str(cm.exception),
-                              "Required OIDC scope 'mbs-scope' not present: "
-                              "['openid', 'https://id.fedoraproject.org/scope/groups']")
+                assert str(cm.value) == ("Required OIDC scope 'mbs-scope' not present: "
+                                         "['openid', 'https://id.fedoraproject.org/scope/groups']")
 
     @patch('module_build_service.auth._get_token_info')
     @patch('module_build_service.auth._get_user_info')
@@ -174,11 +165,9 @@ class TestAuthModule(unittest.TestCase):
             request.headers.__setitem__.side_effect = headers.__setitem__
             request.headers.__contains__.side_effect = headers.__contains__
 
-            with self.assertRaises(module_build_service.errors.Forbidden) as cm:
+            with pytest.raises(module_build_service.errors.Forbidden) as cm:
                 module_build_service.auth.get_user(request)
-
-            self.assertEquals(str(cm.exception),
-                              "OIDC_REQUIRED_SCOPE must be set in server config.")
+                assert str(cm.value) == "OIDC_REQUIRED_SCOPE must be set in server config."
 
 
 class KerberosMockConfig(object):
@@ -229,7 +218,7 @@ class KerberosMockConfig(object):
         self.kerberos_http_host_p.stop()
 
 
-class TestAuthModuleKerberos(unittest.TestCase):
+class TestAuthModuleKerberos:
     @patch('kerberos.authGSSServerInit', return_value=(kerberos.AUTH_GSS_COMPLETE, object()))
     @patch('kerberos.authGSSServerStep', return_value=kerberos.AUTH_GSS_COMPLETE)
     @patch('kerberos.authGSSServerResponse', return_value='STOKEN')
diff --git a/tests/test_build/test_build.py b/tests/test_build/test_build.py
index c5261757..0bf2c375 100644
--- a/tests/test_build/test_build.py
+++ b/tests/test_build/test_build.py
@@ -20,7 +20,6 @@
 #
 # Written by Jan Kaluza <jkaluza@redhat.com>
 
-import unittest
 import koji
 import vcr
 import os
@@ -37,6 +36,7 @@ import module_build_service.scheduler.handlers.repos
 import module_build_service.utils
 from module_build_service.errors import Forbidden
 from module_build_service import db, models, conf, build_logs
+from tests import get_vcr_path
 
 from mock import patch, PropertyMock, Mock
 import kobo
@@ -51,7 +51,6 @@ import module_build_service.scheduler.consumer
 from module_build_service.messaging import MBSModule
 
 base_dir = dirname(dirname(__file__))
-cassette_dir = base_dir + '/vcr-request-data/'
 
 user = ('Homer J. Simpson', set(['packager']))
 
@@ -302,21 +301,19 @@ def cleanup_moksha():
                 'info', 'bzip2', 'grep', 'redhat-rpm-config',
                 'diffutils', 'make', 'patch', 'shadow-utils',
                 'coreutils', 'which', 'rpm-build', 'gzip', 'gcc-c++'])})
-class TestBuild(unittest.TestCase):
-
+class TestBuild:
     # Global variable used for tests if needed
     _global_var = None
 
-    def setUp(self):
+    def setup_method(self, test_method):
         GenericBuilder.register_backend_class(FakeModuleBuilder)
         self.client = app.test_client()
         clean_database()
 
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         FakeModuleBuilder.reset()
         cleanup_moksha()
         self.vcr.__exit__()
@@ -350,7 +347,7 @@ class TestBuild(unittest.TestCase):
         tag_groups.append(set(['tangerine-1-1']))
 
         def on_tag_artifacts_cb(cls, artifacts, dest_tag=True):
-            self.assertEqual(tag_groups.pop(0), set(artifacts))
+            assert tag_groups.pop(0) == set(artifacts)
 
         FakeModuleBuilder.on_tag_artifacts_cb = on_tag_artifacts_cb
 
@@ -362,7 +359,7 @@ class TestBuild(unittest.TestCase):
         buildroot_groups.append(set(['tangerine-1-1']))
 
         def on_buildroot_add_artifacts_cb(cls, artifacts, install):
-            self.assertEqual(buildroot_groups.pop(0), set(artifacts))
+            assert buildroot_groups.pop(0) == set(artifacts)
 
         FakeModuleBuilder.on_buildroot_add_artifacts_cb = on_buildroot_add_artifacts_cb
 
@@ -373,20 +370,20 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
-                                                         models.BUILD_STATES["ready"]])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES["done"],
+                                                models.BUILD_STATES["ready"]]
 
         # All components has to be tagged, so tag_groups and buildroot_groups are empty...
-        self.assertEqual(tag_groups, [])
-        self.assertEqual(buildroot_groups, [])
+        assert tag_groups == []
+        assert buildroot_groups == []
         module_build = models.ModuleBuild.query.get(module_build_id)
-        self.assertEqual(module_build.module_builds_trace[0].state, models.BUILD_STATES['init'])
-        self.assertEqual(module_build.module_builds_trace[1].state, models.BUILD_STATES['wait'])
-        self.assertEqual(module_build.module_builds_trace[2].state, models.BUILD_STATES['build'])
-        self.assertEqual(module_build.module_builds_trace[3].state, models.BUILD_STATES['done'])
-        self.assertEqual(module_build.module_builds_trace[4].state, models.BUILD_STATES['ready'])
-        self.assertEqual(len(module_build.module_builds_trace), 5)
+        assert module_build.module_builds_trace[0].state == models.BUILD_STATES['init']
+        assert module_build.module_builds_trace[1].state == models.BUILD_STATES['wait']
+        assert module_build.module_builds_trace[2].state == models.BUILD_STATES['build']
+        assert module_build.module_builds_trace[3].state == models.BUILD_STATES['done']
+        assert module_build.module_builds_trace[4].state == models.BUILD_STATES['ready']
+        assert len(module_build.module_builds_trace) == 5
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -411,9 +408,9 @@ class TestBuild(unittest.TestCase):
 
         module_build = models.ModuleBuild.query.filter_by(id=module_build_id).one()
         # Make sure no component builds were registered
-        self.assertEqual(len(module_build.component_builds), 0)
+        assert len(module_build.component_builds) == 0
         # Make sure the build is done
-        self.assertEqual(module_build.state, models.BUILD_STATES['ready'])
+        assert module_build.state == models.BUILD_STATES['ready']
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -432,8 +429,8 @@ class TestBuild(unittest.TestCase):
                                   content_type='multipart/form-data',
                                   data={'yaml': (testmodule, yaml)})
             data = json.loads(rv.data)
-            self.assertEqual(data['status'], 403)
-            self.assertEqual(data['message'], 'YAML submission is not enabled')
+            assert data['status'] == 403
+            assert data['message'] == 'YAML submission is not enabled'
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -451,7 +448,7 @@ class TestBuild(unittest.TestCase):
                                   content_type='multipart/form-data',
                                   data={'yaml': (testmodule, yaml)})
             data = json.loads(rv.data)
-            self.assertEqual(data['id'], 1)
+            assert data['id'] == 1
 
         msgs = []
         stop = module_build_service.scheduler.make_simple_stop_condition(db.session)
@@ -468,12 +465,12 @@ class TestBuild(unittest.TestCase):
             return json.loads(rv.data)
 
         data = submit(dict(params.items() + {"not_existing_param": "foo"}.items()))
-        self.assertIn("The request contains unspecified parameters:", data["message"])
-        self.assertIn("not_existing_param", data["message"])
-        self.assertEqual(data["status"], 400)
+        assert "The request contains unspecified parameters:" in data["message"]
+        assert "not_existing_param" in data["message"]
+        assert data["status"] == 400
 
         data = submit(dict(params.items() + {"copr_owner": "foo"}.items()))
-        self.assertIn("The request contains parameters specific to Copr builder", data["message"])
+        assert "The request contains parameters specific to Copr builder" in data["message"]
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -518,14 +515,14 @@ class TestBuild(unittest.TestCase):
         # module build, all components and even the module itself should be in
         # failed state with state_reason se to cancellation message.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['FAILED'])
-            self.assertEqual(build.state_reason, "Canceled by Homer J. Simpson.")
-            self.assertEqual(build.module_build.state, models.BUILD_STATES["failed"])
-            self.assertEqual(build.module_build.state_reason, "Canceled by Homer J. Simpson.")
+            assert build.state == koji.BUILD_STATES['FAILED']
+            assert build.state_reason == "Canceled by Homer J. Simpson."
+            assert build.module_build.state == models.BUILD_STATES["failed"]
+            assert build.module_build.state_reason == "Canceled by Homer J. Simpson."
 
             # Check that cancel_build has been called for this build
             if build.task_id:
-                self.assertTrue(build.task_id in cancelled_tasks)
+                assert build.task_id in cancelled_tasks
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -553,9 +550,9 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
-                                                         models.BUILD_STATES["ready"]])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES["done"],
+                                                models.BUILD_STATES["ready"]]
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -596,11 +593,11 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
             # When this fails, it can mean that num_concurrent_builds
             # threshold has been met.
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
-                                                         models.BUILD_STATES["ready"]])
+            assert build.module_build.state in [models.BUILD_STATES["done"],
+                                                models.BUILD_STATES["ready"]]
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -652,7 +649,7 @@ class TestBuild(unittest.TestCase):
         # If we are building single component more often, num_concurrent_builds
         # does not work correctly.
         num_builds = [k for k, g in itertools.groupby(TestBuild._global_var)]
-        self.assertEqual(num_builds.count(1), 2)
+        assert num_builds.count(1) == 2
 
     @timed(60)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -697,22 +694,22 @@ class TestBuild(unittest.TestCase):
         for c in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
             # perl-Tangerine is expected to fail as configured in on_build_cb.
             if c.package == "perl-Tangerine":
-                self.assertEqual(c.state, koji.BUILD_STATES['FAILED'])
+                assert c.state == koji.BUILD_STATES['FAILED']
             # tangerine is expected to fail, because it is in batch 3, but
             # we had a failing component in batch 2.
             elif c.package == "tangerine":
-                self.assertEqual(c.state, koji.BUILD_STATES['FAILED'])
-                self.assertEqual(c.state_reason, "Some components failed to build.")
+                assert c.state == koji.BUILD_STATES['FAILED']
+                assert c.state_reason == "Some components failed to build."
             else:
-                self.assertEqual(c.state, koji.BUILD_STATES['COMPLETE'])
+                assert c.state == koji.BUILD_STATES['COMPLETE']
 
             # Whole module should be failed.
-            self.assertEqual(c.module_build.state, models.BUILD_STATES['failed'])
-            self.assertEqual(c.module_build.state_reason, "Some components failed to build.")
+            assert c.module_build.state == models.BUILD_STATES['failed']
+            assert c.module_build.state_reason == "Some components failed to build."
 
             # We should end up with batch 2 and never start batch 3, because
             # there were failed components in batch 2.
-            self.assertEqual(c.module_build.batch, 2)
+            assert c.module_build.batch == 2
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -750,17 +747,17 @@ class TestBuild(unittest.TestCase):
         for c in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
             # perl-Tangerine is expected to fail as configured in on_build_cb.
             if c.package == "module-build-macros":
-                self.assertEqual(c.state, koji.BUILD_STATES['COMPLETE'])
+                assert c.state == koji.BUILD_STATES['COMPLETE']
             else:
-                self.assertEqual(c.state, koji.BUILD_STATES['FAILED'])
+                assert c.state == koji.BUILD_STATES['FAILED']
 
             # Whole module should be failed.
-            self.assertEqual(c.module_build.state, models.BUILD_STATES['failed'])
-            self.assertEqual(c.module_build.state_reason, "Some components failed to build.")
+            assert c.module_build.state == models.BUILD_STATES['failed']
+            assert c.module_build.state_reason == "Some components failed to build."
 
             # We should end up with batch 2 and never start batch 3, because
             # there were failed components in batch 2.
-            self.assertEqual(c.module_build.batch, 2)
+            assert c.module_build.batch == 2
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -786,7 +783,7 @@ class TestBuild(unittest.TestCase):
 
         def on_tag_artifacts_cb(cls, artifacts, dest_tag=True):
             if dest_tag is True:
-                self.assertEqual(tag_groups.pop(0), set(artifacts))
+                assert tag_groups.pop(0) == set(artifacts)
         FakeModuleBuilder.on_tag_artifacts_cb = on_tag_artifacts_cb
 
         buildtag_groups = []
@@ -796,7 +793,7 @@ class TestBuild(unittest.TestCase):
              'tangerine-0.22-3.module+0+814cfa39']))
 
         def on_buildroot_add_artifacts_cb(cls, artifacts, install):
-            self.assertEqual(buildtag_groups.pop(0), set(artifacts))
+            assert buildtag_groups.pop(0) == set(artifacts)
         FakeModuleBuilder.on_buildroot_add_artifacts_cb = on_buildroot_add_artifacts_cb
 
         msgs = [MBSModule("local module build", 2, 1)]
@@ -809,12 +806,10 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=2).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
-                                                         models.BUILD_STATES["ready"]])
-
-            self.assertEqual(build.reused_component_id,
-                             reused_component_ids[build.package])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES["done"],
+                                                models.BUILD_STATES["ready"]]
+            assert build.reused_component_id == reused_component_ids[build.package]
 
     @timed(30)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -828,8 +823,7 @@ class TestBuild(unittest.TestCase):
         test_reuse_component_init_data()
 
         models.ComponentBuild.query.filter_by(package="module-build-macros").delete()
-        self.assertEqual(len(models.ComponentBuild.query.filter_by(
-            package="module-build-macros").all()), 0)
+        assert len(models.ComponentBuild.query.filter_by(package="module-build-macros").all()) == 0
 
         db.session.commit()
 
@@ -846,7 +840,7 @@ class TestBuild(unittest.TestCase):
 
         def on_tag_artifacts_cb(cls, artifacts, dest_tag=True):
             if dest_tag is True:
-                self.assertEqual(tag_groups.pop(0), set(artifacts))
+                assert tag_groups.pop(0) == set(artifacts)
         FakeModuleBuilder.on_tag_artifacts_cb = on_tag_artifacts_cb
 
         buildtag_groups = []
@@ -856,7 +850,7 @@ class TestBuild(unittest.TestCase):
              'tangerine-0.22-3.module+0+814cfa39']))
 
         def on_buildroot_add_artifacts_cb(cls, artifacts, install):
-            self.assertEqual(buildtag_groups.pop(0), set(artifacts))
+            assert buildtag_groups.pop(0) == set(artifacts)
         FakeModuleBuilder.on_buildroot_add_artifacts_cb = on_buildroot_add_artifacts_cb
 
         msgs = [MBSModule("local module build", 2, 1)]
@@ -866,10 +860,10 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=2).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
-                                                         models.BUILD_STATES["ready"]])
-            self.assertNotEqual(build.package, "module-build-macros")
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES["done"],
+                                                models.BUILD_STATES["ready"]]
+            assert build.package != "module-build-macros"
 
     @timed(60)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -973,10 +967,10 @@ class TestBuild(unittest.TestCase):
         components = models.ComponentBuild.query.filter_by(
             module_id=module_build_id, batch=2).order_by(models.ComponentBuild.id).all()
         # Make sure the build went from failed to wait
-        self.assertEqual(module_build.state, models.BUILD_STATES['wait'])
-        self.assertEqual(module_build.state_reason, 'Resubmitted by Homer J. Simpson')
+        assert module_build.state == models.BUILD_STATES['wait']
+        assert module_build.state_reason == 'Resubmitted by Homer J. Simpson'
         # Make sure the state was reset on the failed component
-        self.assertIsNone(components[1].state)
+        assert components[1].state is None
         db.session.expire_all()
 
         # Run the backend
@@ -987,9 +981,9 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES['done'],
-                                                         models.BUILD_STATES['ready']])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES['done'],
+                                                models.BUILD_STATES['ready']]
 
     @timed(60)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -1084,11 +1078,11 @@ class TestBuild(unittest.TestCase):
         module_build_id = data['id']
         module_build = models.ModuleBuild.query.filter_by(id=module_build_id).one()
         # Make sure the build went from failed to wait
-        self.assertEqual(module_build.state, models.BUILD_STATES['wait'])
-        self.assertEqual(module_build.state_reason, 'Resubmitted by Homer J. Simpson')
+        assert module_build.state == models.BUILD_STATES['wait']
+        assert module_build.state_reason == 'Resubmitted by Homer J. Simpson'
         # Make sure the state was reset on the failed component
         for c in module_build.component_builds:
-            self.assertIsNone(c.state)
+            assert c.state is None
         db.session.expire_all()
 
         # Run the backend
@@ -1099,9 +1093,9 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES['done'],
-                                                         models.BUILD_STATES['ready']])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES['done'],
+                                                models.BUILD_STATES['ready']]
 
     @timed(60)
     @patch('module_build_service.auth.get_user', return_value=user)
@@ -1125,12 +1119,11 @@ class TestBuild(unittest.TestCase):
 
         module_build_id = json.loads(rv.data)['id']
         module_build = models.ModuleBuild.query.filter_by(id=module_build_id).one()
-        self.assertEqual(module_build.state, models.BUILD_STATES['failed'])
-        self.assertEqual(
-            module_build.state_reason, 'Custom component repositories aren\'t allowed.')
-        self.assertEqual(len(module_build.module_builds_trace), 2)
-        self.assertEqual(module_build.module_builds_trace[0].state, models.BUILD_STATES['init'])
-        self.assertEqual(module_build.module_builds_trace[1].state, models.BUILD_STATES['failed'])
+        assert module_build.state == models.BUILD_STATES['failed']
+        assert module_build.state_reason == 'Custom component repositories aren\'t allowed.'
+        assert len(module_build.module_builds_trace) == 2
+        assert module_build.module_builds_trace[0].state == models.BUILD_STATES['init']
+        assert module_build.module_builds_trace[1].state == models.BUILD_STATES['failed']
 
         # Resubmit the failed module
         rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
@@ -1141,10 +1134,10 @@ class TestBuild(unittest.TestCase):
         components = models.ComponentBuild.query.filter_by(
             module_id=module_build_id, batch=2).order_by(models.ComponentBuild.id).all()
         # Make sure the build went from failed to init
-        self.assertEqual(module_build.state, models.BUILD_STATES['init'])
-        self.assertEqual(module_build.state_reason, 'Resubmitted by Homer J. Simpson')
+        assert module_build.state == models.BUILD_STATES['init']
+        assert module_build.state_reason == 'Resubmitted by Homer J. Simpson'
         # Make sure there are no components
-        self.assertEqual(components, [])
+        assert components == []
         db.session.expire_all()
 
         # Run the backend again
@@ -1153,9 +1146,9 @@ class TestBuild(unittest.TestCase):
         # All components should be built and module itself should be in "done"
         # or "ready" state.
         for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
-            self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-            self.assertTrue(build.module_build.state in [models.BUILD_STATES['done'],
-                                                         models.BUILD_STATES['ready']])
+            assert build.state == koji.BUILD_STATES['COMPLETE']
+            assert build.module_build.state in [models.BUILD_STATES['done'],
+                                                models.BUILD_STATES['ready']]
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -1169,7 +1162,7 @@ class TestBuild(unittest.TestCase):
         rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
             {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                 'testmodule.git?#68932c90de214d9d13feefbd35246a81b6cb8d49'}))
-        self.assertEqual(rv.status_code, 201)
+        assert rv.status_code == 201
         # Run the backend
         stop = module_build_service.scheduler.make_simple_stop_condition(db.session)
         module_build_service.scheduler.main([], stop)
@@ -1184,25 +1177,24 @@ class TestBuild(unittest.TestCase):
                         'failed build is allowed.'),
             'status': 409
         }
-        self.assertEqual(data, expected)
+        assert data == expected
 
 
 @patch("module_build_service.config.Config.system",
        new_callable=PropertyMock, return_value="testlocal")
-class TestLocalBuild(unittest.TestCase):
+class TestLocalBuild:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         FakeModuleBuilder.on_build_cb = None
         FakeModuleBuilder.backend = 'testlocal'
         GenericBuilder.register_backend_class(FakeModuleBuilder)
         self.client = app.test_client()
         clean_database()
 
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         FakeModuleBuilder.reset()
         cleanup_moksha()
         self.vcr.__exit__()
@@ -1254,6 +1246,6 @@ class TestLocalBuild(unittest.TestCase):
             # or "ready" state.
             for build in models.ComponentBuild.query.filter_by(
                     module_id=module_build_id).all():
-                self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
-                self.assertTrue(build.module_build.state in [
-                    models.BUILD_STATES["done"], models.BUILD_STATES["ready"]])
+                assert build.state == koji.BUILD_STATES['COMPLETE']
+                assert build.module_build.state in [models.BUILD_STATES["done"],
+                                                    models.BUILD_STATES["ready"]]
diff --git a/tests/test_builder/test_base.py b/tests/test_builder/test_base.py
index d0244f67..8f037197 100644
--- a/tests/test_builder/test_base.py
+++ b/tests/test_builder/test_base.py
@@ -21,7 +21,6 @@
 # Written by Jan Kaluza <jkaluza@redhat.com>
 
 import mock
-import unittest
 
 import module_build_service.models
 import module_build_service.builder
@@ -32,9 +31,9 @@ from module_build_service.builder import GenericBuilder
 from mock import patch
 
 
-class TestGenericBuilder(unittest.TestCase):
+class TestGenericBuilder:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         init_data()
         self.module = module_build_service.models.ModuleBuild.query.filter_by(id=1).one()
 
@@ -58,23 +57,23 @@ class TestGenericBuilder(unittest.TestCase):
 
         # Call default_buildroot_groups, the result should be cached.
         ret = GenericBuilder.default_buildroot_groups(db.session, self.module)
-        self.assertEqual(ret, expected_groups)
+        assert ret == expected_groups
         resolver.resolve_profiles.assert_called_once()
         resolver.resolve_profiles.reset_mock()
 
         # Now try calling it again to verify resolve_profiles is not called,
         # because it is cached.
         ret = GenericBuilder.default_buildroot_groups(db.session, self.module)
-        self.assertEqual(ret, expected_groups)
+        assert ret == expected_groups
         resolver.resolve_profiles.assert_not_called()
         resolver.resolve_profiles.reset_mock()
 
         # And now try clearing the cache and call it again.
         GenericBuilder.clear_cache(self.module)
         ret = GenericBuilder.default_buildroot_groups(db.session, self.module)
-        self.assertEqual(ret, expected_groups)
+        assert ret == expected_groups
         resolver.resolve_profiles.assert_called_once()
 
     def test_get_build_weights(self):
         weights = GenericBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
+        assert weights == {"httpd": 1.5, "apr": 1.5}
diff --git a/tests/test_builder/test_builder_utils.py b/tests/test_builder/test_builder_utils.py
index 112fa2bc..6aa56d8c 100644
--- a/tests/test_builder/test_builder_utils.py
+++ b/tests/test_builder/test_builder_utils.py
@@ -20,7 +20,6 @@
 #
 # Written by Matt Prahl <mprahl@redhat.com>
 
-import unittest
 import tempfile
 import shutil
 
@@ -30,7 +29,7 @@ from module_build_service.builder import utils
 from tests import conf
 
 
-class TestBuilderUtils(unittest.TestCase):
+class TestBuilderUtils:
 
     @patch('requests.get')
     @patch('koji.ClientSession')
@@ -137,5 +136,5 @@ class TestBuilderUtils(unittest.TestCase):
             call(url_three, stream=True, timeout=60)
         ]
         for expected_call in expected_calls:
-            self.assertIn(expected_call, mock_get.call_args_list)
-        self.assertEqual(len(mock_get.call_args_list), len(expected_calls))
+            assert expected_call in mock_get.call_args_list
+        assert len(mock_get.call_args_list) == len(expected_calls)
diff --git a/tests/test_builder/test_copr.py b/tests/test_builder/test_copr.py
index 557b683c..f846a311 100644
--- a/tests/test_builder/test_copr.py
+++ b/tests/test_builder/test_copr.py
@@ -22,8 +22,8 @@
 
 
 import os
-import unittest
 import mock
+import pytest
 import module_build_service.models
 import module_build_service.builder
 from munch import Munch
@@ -33,10 +33,11 @@ from copr import CoprClient
 from copr.exceptions import CoprRequestException
 
 
-@unittest.skip("We need not yet released version of python-copr. Let's skip this for some time")
-class TestCoprBuilder(unittest.TestCase):
+@pytest.mark.skip(
+    reason="We need not yet released version of python-copr. Let's skip this for some time")
+class TestCoprBuilder:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         self.config = mock.Mock()
         self.config.copr_config = None
 
@@ -53,16 +54,15 @@ class TestCoprBuilder(unittest.TestCase):
 
         repo = module_build_service.builder.GenericBuilder.tag_to_repo(
             "copr", self.config, "foo-module-name-0.25-9", None)
-        self.assertEquals(repo,
-                          "http://copr-be-instance/results/@copr/foo-module-name-0.25-9/modules")
+        assert repo == "http://copr-be-instance/results/@copr/foo-module-name-0.25-9/modules"
 
     @mock.patch("copr.CoprClient.get_module_repo")
     def test_non_existing_tag_to_repo(self, get_module_repo):
         # Let's pretend that CoprClient.get_module_repo couldn't find the project on Copr instance
         get_module_repo.return_value = ResponseMock({"output": "notok", "error": "some error"})
-        self.assertRaises(ValueError,
-                          lambda: module_build_service.builder.GenericBuilder.tag_to_repo(
-                              "copr", self.config, None, None))
+        with pytest.raises(ValueError):
+            lambda: module_build_service.builder.GenericBuilder.tag_to_repo(
+                "copr", self.config, None, None)
 
 
 class ResponseMock(object):
@@ -97,9 +97,9 @@ class FakeCoprAPI(object):
 COPR_MODULE_BUILDER = "module_build_service.builder.CoprModuleBuilder.CoprModuleBuilder"
 
 
-class TestCoprModuleBuilder(unittest.TestCase):
+class TestCoprModuleBuilder:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         init_data()
         self.config = mock.Mock()
         self.config.koji_profile = conf.koji_profile
@@ -132,8 +132,8 @@ class TestCoprModuleBuilder(unittest.TestCase):
         args, kwargs = make_module.call_args
         make_module.assert_called_with(username="myself", projectname="someproject",
                                        modulemd=mock.ANY, create=False, build=True)
-        self.assertIsInstance(kwargs["modulemd"], str)
-        self.assertTrue(os.path.isabs(kwargs["modulemd"]))
+        assert isinstance(kwargs["modulemd"], str)
+        assert os.path.isabs(kwargs["modulemd"]) is True
 
     ###############################################################################################
     #                                                                                             #
@@ -142,7 +142,7 @@ class TestCoprModuleBuilder(unittest.TestCase):
     #                                                                                             #
     ###############################################################################################
 
-    @unittest.skip("Tests fail since PR 765")
+    @pytest.mark.skip("Tests fail since PR 765")
     @mock.patch(COPR_MODULE_BUILDER + "._update_chroot")
     @mock.patch(COPR_MODULE_BUILDER + "._get_copr_safe")
     @mock.patch(COPR_MODULE_BUILDER + "._create_module_safe")
@@ -151,10 +151,10 @@ class TestCoprModuleBuilder(unittest.TestCase):
         groups = {"build": {"pkgname1", "pkgname2", "pkgname3"}}
         builder.buildroot_connect(groups)
         args, kwargs = update_chroot.call_args
-        self.assertEquals(set(kwargs["packages"]), {"pkgname1", "pkgname2", "pkgname3"})
-        self.assertEqual(builder._CoprModuleBuilder__prep, True)
+        assert set(kwargs["packages"]) == {"pkgname1", "pkgname2", "pkgname3"}
+        assert builder._CoprModuleBuilder__prep is True
 
-    @unittest.skip("Tests fail since PR 765")
+    @pytest.mark.skip("Tests fail since PR 765")
     @mock.patch(COPR_MODULE_BUILDER + "._get_copr")
     @mock.patch(COPR_MODULE_BUILDER + "._create_copr")
     @mock.patch(COPR_MODULE_BUILDER + "._create_chroot_safe")
@@ -174,14 +174,14 @@ class TestCoprModuleBuilder(unittest.TestCase):
         builder._get_copr_safe()
         get_copr.assert_called_with(ownername=self.module.owner, projectname="module-nginx-1.2")
         create_copr.assert_called_with(ownername=self.module.owner, projectname="module-nginx-1.2")
-        self.assertEqual(get_copr.call_count, 2)
+        assert get_copr.call_count == 2
 
     @mock.patch("copr.client.CoprClient._fetch", return_value=FakeCoprAPI.get_project_details())
     def test_get_copr(self, get_project_details):
         builder = self.create_builder()
         copr = builder._get_copr("myself", "someproject")
-        self.assertEqual(copr.username, "myself")
-        self.assertEqual(copr.projectname, "someproject")
+        assert copr.username == "myself"
+        assert copr.projectname == "someproject"
 
     @mock.patch("copr.client.CoprClient.create_project")
     def test_create_copr(self, create_project):
@@ -196,12 +196,12 @@ class TestCoprModuleBuilder(unittest.TestCase):
         make_module.assert_called_with(username=self.module.owner, projectname="module-nginx-1.2",
                                        modulemd=mock.ANY, create=True, build=False)
         args, kwargs = make_module.call_args
-        self.assertIsInstance(kwargs["modulemd"], str)
-        self.assertTrue(os.path.isabs(kwargs["modulemd"]))
+        assert isinstance(kwargs["modulemd"], str)
+        assert os.path.isabs(kwargs["modulemd"]) is True
 
     def test_buildroot_ready(self):
         builder = self.create_builder()
-        self.assertTrue(builder.buildroot_ready(artifacts=["a1", "a2", "a3"]))
+        assert builder.buildroot_ready(artifacts=["a1", "a2", "a3"]) is True
 
     ##############################################################################################
     #                                                                                            #
@@ -221,37 +221,37 @@ class TestCoprModuleBuilder(unittest.TestCase):
         edit_chroot.assert_called_with("someproject", "custom-1-x86_64", ownername="myself",
                                        repos=mock.ANY, packages=mock.ANY)
         args, kwargs = edit_chroot.call_args
-        self.assertEqual(set(kwargs["packages"].split()), {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"})
-        self.assertEqual(set(kwargs["repos"].split()), {"http://repo1.ex/", "http://repo2.ex/"})
+        assert set(kwargs["packages"].split()) == {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"}
+        assert set(kwargs["repos"].split()) == {"http://repo1.ex/", "http://repo2.ex/"}
 
         # Update buildroot repos
         builder._update_chroot(repos=["http://repo3.ex/"])
         edit_chroot.assert_called_with("someproject", "custom-1-x86_64", ownername="myself",
                                        repos=mock.ANY, packages=mock.ANY)
         args, kwargs = edit_chroot.call_args
-        self.assertEqual(set(kwargs["packages"].split()), {"pkg1", "pkg2", "pkg3"})
-        self.assertEqual(set(kwargs["repos"].split()), {"http://repo1.ex/", "http://repo2.ex/",
-                                                        "http://repo3.ex/"})
+        assert set(kwargs["packages"].split()) == {"pkg1", "pkg2", "pkg3"}
+        assert set(kwargs["repos"].split()) == {"http://repo1.ex/", "http://repo2.ex/",
+                                                "http://repo3.ex/"}
 
         # Update multiple buildroot options at the same time
         builder._update_chroot(packages=["pkg4", "pkg5"], repos=["http://repo3.ex/"])
         edit_chroot.assert_called_with("someproject", "custom-1-x86_64", ownername="myself",
                                        repos=mock.ANY, packages=mock.ANY)
         args, kwargs = edit_chroot.call_args
-        self.assertEqual(set(kwargs["packages"].split()), {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"})
-        self.assertEqual(set(kwargs["repos"].split()), {"http://repo1.ex/", "http://repo2.ex/",
-                                                        "http://repo3.ex/"})
+        assert set(kwargs["packages"].split()) == {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"}
+        assert set(kwargs["repos"].split()) == {"http://repo1.ex/", "http://repo2.ex/",
+                                                "http://repo3.ex/"}
 
     def test_buildroot_add_artifacts(self):
         pass
 
-    @unittest.skip("Tests fail since PR 765")
+    @pytest.mark.skip("Tests fail since PR 765")
     @mock.patch(COPR_MODULE_BUILDER + "._update_chroot")
     def test_buildroot_add_repos(self, update_chroot):
         builder = self.create_builder()
         builder.buildroot_add_repos(["foo", "bar", "baz"])
         args, kwargs = update_chroot.call_args
-        self.assertEquals(set(kwargs["repos"]), {
+        assert set(kwargs["repos"]) == {
             conf.koji_repository_url + "/foo/latest/x86_64",
             conf.koji_repository_url + "/bar/latest/x86_64",
             conf.koji_repository_url + "/baz/latest/x86_64",
@@ -259,7 +259,7 @@ class TestCoprModuleBuilder(unittest.TestCase):
             # We always add this repo as a workaround, see the code for details
             ("https://kojipkgs.fedoraproject.org/compose"
              "/latest-Fedora-Modular-26/compose/Server/x86_64/os/"),
-        })
+        }
 
     ##############################################################################################
     #                                                                                            #
diff --git a/tests/test_builder/test_koji.py b/tests/test_builder/test_koji.py
index 1b2a60a7..518d39dc 100644
--- a/tests/test_builder/test_koji.py
+++ b/tests/test_builder/test_koji.py
@@ -20,7 +20,6 @@
 #
 # Written by Jan Kaluza <jkaluza@redhat.com>
 
-import unittest
 import mock
 import koji
 import xmlrpclib
@@ -30,6 +29,7 @@ import module_build_service.scheduler.handlers.repos
 import module_build_service.models
 import module_build_service.builder
 
+import pytest
 from mock import patch, MagicMock
 
 from tests import conf, init_data
@@ -52,9 +52,9 @@ class FakeKojiModuleBuilder(KojiModuleBuilder):
         return koji_session
 
 
-class TestKojiBuilder(unittest.TestCase):
+class TestKojiBuilder:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         init_data()
         self.config = mock.Mock()
         self.config.koji_profile = conf.koji_profile
@@ -69,8 +69,8 @@ class TestKojiBuilder(unittest.TestCase):
             "koji", self.config,
             "module-base-runtime-0.25-9",
             "x86_64")
-        self.assertEquals(repo, "https://kojipkgs.stg.fedoraproject.org/repos"
-                          "/module-base-runtime-0.25-9/latest/x86_64")
+        assert repo == ("https://kojipkgs.stg.fedoraproject.org/repos"
+                        "/module-base-runtime-0.25-9/latest/x86_64")
 
     def test_recover_orphaned_artifact_when_tagged(self):
         """ Test recover_orphaned_artifact when the artifact is found and tagged in both tags
@@ -95,25 +95,25 @@ class TestKojiBuilder(unittest.TestCase):
         component_build.nvr = None
 
         actual = builder.recover_orphaned_artifact(component_build)
-        self.assertEqual(len(actual), 3)
-        self.assertEquals(type(actual[0]), module_build_service.messaging.KojiBuildChange)
-        self.assertEquals(actual[0].build_id, 91)
-        self.assertEquals(actual[0].task_id, 12345)
-        self.assertEquals(actual[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
-        self.assertEquals(actual[0].build_name, 'rubygem-rails')
-        self.assertEquals(actual[0].build_version, '1.0')
-        self.assertEquals(actual[0].build_release, '1.module+e0095747')
-        self.assertEquals(actual[0].module_build_id, 30)
-        self.assertEquals(type(actual[1]), module_build_service.messaging.KojiTagChange)
-        self.assertEquals(actual[1].tag, 'module-foo-build')
-        self.assertEquals(actual[1].artifact, 'rubygem-rails')
-        self.assertEquals(type(actual[2]), module_build_service.messaging.KojiTagChange)
-        self.assertEquals(actual[2].tag, 'module-foo')
-        self.assertEquals(actual[2].artifact, 'rubygem-rails')
-        self.assertEqual(component_build.state, koji.BUILD_STATES['COMPLETE'])
-        self.assertEqual(component_build.task_id, 12345)
-        self.assertEqual(component_build.state_reason, 'Found existing build')
-        self.assertEquals(builder.koji_session.tagBuild.call_count, 0)
+        assert len(actual) == 3
+        assert type(actual[0]) == module_build_service.messaging.KojiBuildChange
+        assert actual[0].build_id == 91
+        assert actual[0].task_id == 12345
+        assert actual[0].build_new_state == koji.BUILD_STATES['COMPLETE']
+        assert actual[0].build_name == 'rubygem-rails'
+        assert actual[0].build_version == '1.0'
+        assert actual[0].build_release == '1.module+e0095747'
+        assert actual[0].module_build_id == 30
+        assert type(actual[1]) == module_build_service.messaging.KojiTagChange
+        assert actual[1].tag == 'module-foo-build'
+        assert actual[1].artifact == 'rubygem-rails'
+        assert type(actual[2]) == module_build_service.messaging.KojiTagChange
+        assert actual[2].tag == 'module-foo'
+        assert actual[2].artifact == 'rubygem-rails'
+        assert component_build.state == koji.BUILD_STATES['COMPLETE']
+        assert component_build.task_id == 12345
+        assert component_build.state_reason == 'Found existing build'
+        assert builder.koji_session.tagBuild.call_count == 0
 
     def test_recover_orphaned_artifact_when_untagged(self):
         """ Tests recover_orphaned_artifact when the build is found but untagged
@@ -149,19 +149,18 @@ class TestKojiBuilder(unittest.TestCase):
         component_build.state = None
 
         actual = builder.recover_orphaned_artifact(component_build)
-        self.assertEqual(len(actual), 1)
-        self.assertEquals(type(actual[0]), module_build_service.messaging.KojiBuildChange)
-        self.assertEquals(actual[0].build_id, 91)
-        self.assertEquals(actual[0].task_id, 12345)
-        self.assertEquals(actual[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
-        self.assertEquals(actual[0].build_name, 'rubygem-rails')
-        self.assertEquals(actual[0].build_version, '1.0')
-        self.assertEquals(
-            actual[0].build_release, '1.{0}'.format(dist_tag))
-        self.assertEquals(actual[0].module_build_id, 30)
-        self.assertEqual(component_build.state, koji.BUILD_STATES['COMPLETE'])
-        self.assertEqual(component_build.task_id, 12345)
-        self.assertEqual(component_build.state_reason, 'Found existing build')
+        assert len(actual) == 1
+        assert type(actual[0]) == module_build_service.messaging.KojiBuildChange
+        assert actual[0].build_id == 91
+        assert actual[0].task_id == 12345
+        assert actual[0].build_new_state == koji.BUILD_STATES['COMPLETE']
+        assert actual[0].build_name == 'rubygem-rails'
+        assert actual[0].build_version == '1.0'
+        assert actual[0].build_release == '1.{0}'.format(dist_tag)
+        assert actual[0].module_build_id == 30
+        assert component_build.state == koji.BUILD_STATES['COMPLETE']
+        assert component_build.task_id == 12345
+        assert component_build.state_reason == 'Found existing build'
         builder.koji_session.tagBuild.assert_called_once_with(2, 'foo-1.0-1.{0}'.format(dist_tag))
 
     def test_recover_orphaned_artifact_when_nothing_exists(self):
@@ -191,9 +190,9 @@ class TestKojiBuilder(unittest.TestCase):
         component_build.state = None
 
         actual = builder.recover_orphaned_artifact(component_build)
-        self.assertEqual(actual, [])
+        assert actual == []
         # Make sure nothing erroneous gets tag
-        self.assertEquals(builder.koji_session.tagBuild.call_count, 0)
+        assert builder.koji_session.tagBuild.call_count == 0
 
     @patch('koji.util')
     def test_buildroot_ready(self, mocked_kojiutil):
@@ -208,9 +207,9 @@ class TestKojiBuilder(unittest.TestCase):
                                          components=[])
         fake_kmb.module_target = {'build_tag': 'module-fake_tag'}
 
-        with self.assertRaises(IOError):
+        with pytest.raises(IOError):
             fake_kmb.buildroot_ready()
-        self.assertEquals(mocked_kojiutil.checkForBuilds.call_count, 3)
+        assert mocked_kojiutil.checkForBuilds.call_count == 3
 
     def test_tagging_already_tagged_artifacts(self):
         """
@@ -261,9 +260,9 @@ class TestKojiBuilder(unittest.TestCase):
             components=[])
 
         builder.untag_artifacts(['foo', 'bar'])
-        self.assertEqual(mock_session.untagBuild.call_count, 3)
+        assert mock_session.untagBuild.call_count == 3
         expected_calls = [mock.call(1, 'foo'), mock.call(2, 'foo'), mock.call(1, 'bar')]
-        self.assertEqual(mock_session.untagBuild.mock_calls, expected_calls)
+        assert mock_session.untagBuild.mock_calls == expected_calls
 
     @patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
     def test_get_build_weights(self, get_session):
@@ -281,10 +280,10 @@ class TestKojiBuilder(unittest.TestCase):
         get_session.return_value = session
 
         weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 2, "apr": 2})
+        assert weights == {"httpd": 2, "apr": 2}
 
         expected_calls = [mock.call(456), mock.call(789)]
-        self.assertEqual(session.getTaskDescendents.mock_calls, expected_calls)
+        assert session.getTaskDescendents.mock_calls == expected_calls
 
     @patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
     def test_get_build_weights_no_task_id(self, get_session):
@@ -301,10 +300,10 @@ class TestKojiBuilder(unittest.TestCase):
         get_session.return_value = session
 
         weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 2, "apr": 1.5})
+        assert weights == {"httpd": 2, "apr": 1.5}
 
         expected_calls = [mock.call(456)]
-        self.assertEqual(session.getTaskDescendents.mock_calls, expected_calls)
+        assert session.getTaskDescendents.mock_calls == expected_calls
 
     @patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
     def test_get_build_weights_no_build(self, get_session):
@@ -321,10 +320,10 @@ class TestKojiBuilder(unittest.TestCase):
         get_session.return_value = session
 
         weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 2, "apr": 1.5})
+        assert weights == {"httpd": 2, "apr": 1.5}
 
         expected_calls = [mock.call(456)]
-        self.assertEqual(session.getTaskDescendents.mock_calls, expected_calls)
+        assert session.getTaskDescendents.mock_calls == expected_calls
 
     @patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
     def test_get_build_weights_listBuilds_failed(self, get_session):
@@ -334,13 +333,13 @@ class TestKojiBuilder(unittest.TestCase):
         get_session.return_value = session
 
         weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
+        assert weights == {"httpd": 1.5, "apr": 1.5}
 
         expected_calls = [mock.call(packageID=1, userID=123, state=1,
                                     queryOpts={'limit': 1, 'order': '-build_id'}),
                           mock.call(packageID=2, userID=123, state=1,
                                     queryOpts={'limit': 1, 'order': '-build_id'})]
-        self.assertEqual(session.listBuilds.mock_calls, expected_calls)
+        assert session.listBuilds.mock_calls == expected_calls
 
     @patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
     def test_get_build_weights_getPackageID_failed(self, get_session):
@@ -350,12 +349,12 @@ class TestKojiBuilder(unittest.TestCase):
         get_session.return_value = session
 
         weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
+        assert weights == {"httpd": 1.5, "apr": 1.5}
 
         expected_calls = [mock.call("httpd"), mock.call("apr")]
-        self.assertEqual(session.getPackageID.mock_calls, expected_calls)
+        assert session.getPackageID.mock_calls == expected_calls
 
     @patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
     def test_get_build_weights_getLoggedInUser_failed(self, get_session):
         weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
-        self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
+        assert weights == {"httpd": 1.5, "apr": 1.5}
diff --git a/tests/test_builder/test_mock.py b/tests/test_builder/test_mock.py
index 89ca4cee..51480a8a 100644
--- a/tests/test_builder/test_mock.py
+++ b/tests/test_builder/test_mock.py
@@ -1,5 +1,4 @@
 import os
-import unittest
 import mock
 import koji
 import tempfile
@@ -10,17 +9,16 @@ import kobo.rpmlib
 from module_build_service import conf
 from module_build_service.models import ModuleBuild, ComponentBuild, make_session
 from module_build_service.builder.MockModuleBuilder import MockModuleBuilder
-from tests import db, init_data
+from tests import init_data, clean_database
 
 
-class TestMockModuleBuilder(unittest.TestCase):
+class TestMockModuleBuilder:
 
-    def setUp(self):
-        db.drop_all()
-        db.create_all()
+    def setup_method(self, test_method):
+        clean_database()
         self.resultdir = tempfile.mkdtemp()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         init_data()
         shutil.rmtree(self.resultdir)
 
diff --git a/tests/test_config.py b/tests/test_config.py
index 4e3c8691..d1f8765f 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -20,18 +20,17 @@
 #
 # Written by Jan Kaluza <jkaluza@redhat.com>
 
-import unittest
 import os.path
 
 from module_build_service import conf
 
 
-class TestConfig(unittest.TestCase):
+class TestConfig:
     def test_path_expanduser(self):
         test_dir = "~/modulebuild/builds"
         conf.mock_resultsdir = test_dir
-        self.assertEqual(conf.mock_resultsdir, os.path.expanduser(test_dir))
+        assert conf.mock_resultsdir == os.path.expanduser(test_dir)
 
         test_dir = "~/modulebuild/builds"
         conf.cache_dir = test_dir
-        self.assertEqual(conf.cache_dir, os.path.expanduser(test_dir))
+        assert conf.cache_dir == os.path.expanduser(test_dir)
diff --git a/tests/test_content_generator.py b/tests/test_content_generator.py
index ad56d2d4..273a1d9e 100644
--- a/tests/test_content_generator.py
+++ b/tests/test_content_generator.py
@@ -20,13 +20,11 @@
 #
 # Written by Stanislav Ochotnicky <sochotnicky@redhat.com>
 
-import unittest
 import json
 import vcr
 
 import os
 from os import path
-from os.path import dirname
 
 import module_build_service.messaging
 import module_build_service.scheduler.handlers.repos # noqa
@@ -34,7 +32,7 @@ from module_build_service import models, conf, build_logs
 
 from mock import patch, Mock, MagicMock, call
 
-from tests import init_data
+from tests import init_data, get_vcr_path
 
 from module_build_service.builder.KojiContentGenerator import KojiContentGenerator
 
@@ -45,33 +43,27 @@ GET_USER_RV = {
     "status": 0,
     "usertype": 0
 }
-base_dir = dirname(dirname(__file__))
-cassette_dir = base_dir + '/vcr-request-data/'
 
 
-class TestBuild(unittest.TestCase):
+class TestBuild:
 
-    # Global variable used for tests if needed
-    _global_var = None
-
-    def setUp(self):
+    def setup_method(self, test_method):
         init_data()
         module = models.ModuleBuild.query.filter_by(id=1).one()
         module.cg_build_koji_tag = "f27-module-candidate"
         self.cg = KojiContentGenerator(module, conf)
 
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
         # Ensure that there is no build log from other tests
         try:
-            path = build_logs.path(self.cg.module)
-            os.remove(path)
+            file_path = build_logs.path(self.cg.module)
+            os.remove(file_path)
         except OSError:
             pass
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         # Necessary to restart the twisted reactor for the next test.
         import sys
         del sys.modules['twisted.internet.reactor']
@@ -80,8 +72,8 @@ class TestBuild(unittest.TestCase):
         import moksha.hub.reactor # noqa
         self.vcr.__exit__()
         try:
-            path = build_logs.path(self.cg.module)
-            os.remove(path)
+            file_path = build_logs.path(self.cg.module)
+            os.remove(file_path)
         except OSError:
             pass
 
@@ -98,7 +90,6 @@ class TestBuild(unittest.TestCase):
         koji_session.getUser.return_value = GET_USER_RV
         get_session.return_value = koji_session
         distro.return_value = ("Fedora", "25", "Twenty Five")
-        self.maxDiff = None
         machine.return_value = "i686"
         pkg_res.return_value = Mock()
         pkg_res.return_value.version = "current-tested-version"
@@ -128,7 +119,7 @@ class TestBuild(unittest.TestCase):
         file_dir = self.cg._prepare_file_directory()
         ret = self.cg._get_content_generator_metadata(file_dir)
         rpms_in_tag.assert_called_once()
-        self.assertEqual(expected_output, ret)
+        assert expected_output == ret
 
     @patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
     @patch("subprocess.Popen")
@@ -168,13 +159,13 @@ class TestBuild(unittest.TestCase):
         file_dir = self.cg._prepare_file_directory()
         ret = self.cg._get_content_generator_metadata(file_dir)
         rpms_in_tag.assert_called_once()
-        self.assertEqual(expected_output, ret)
+        assert expected_output == ret
 
     def test_prepare_file_directory(self):
         """ Test preparation of directory with output files """
         dir_path = self.cg._prepare_file_directory()
         with open(path.join(dir_path, "modulemd.txt")) as mmd:
-            self.assertEqual(len(mmd.read()), 1134)
+            assert len(mmd.read()) == 1134
 
     @patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
     def test_tag_cg_build(self, get_session):
@@ -199,9 +190,9 @@ class TestBuild(unittest.TestCase):
 
         self.cg._tag_cg_build()
 
-        self.assertEqual(koji_session.getTag.mock_calls,
-                         [call(self.cg.module.cg_build_koji_tag),
-                          call(conf.koji_cg_default_build_tag)])
+        assert koji_session.getTag.mock_calls == [
+            call(self.cg.module.cg_build_koji_tag),
+            call(conf.koji_cg_default_build_tag)]
         koji_session.tagBuild.assert_called_once_with(123, "nginx-1-2.00000000")
 
     @patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
diff --git a/tests/test_logger.py b/tests/test_logger.py
index 618d8c19..2d9f3101 100644
--- a/tests/test_logger.py
+++ b/tests/test_logger.py
@@ -22,9 +22,9 @@
 
 
 import os
+from os import path
 import shutil
 import tempfile
-import unittest
 
 from module_build_service import log, models
 from module_build_service.logger import ModuleBuildLogs
@@ -32,16 +32,20 @@ from module_build_service.scheduler.consumer import MBSConsumer
 from tests import init_data
 
 
-class TestLogger(unittest.TestCase):
+class TestLogger:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         init_data()
-        self.base = tempfile.mkdtemp(prefix='mbs-', suffix='-%s' % self.id())
+        test_id = '.'.join([
+            path.splitext(path.basename(__file__))[0],
+            test_method.im_class.__name__,
+            test_method.im_func.__name__])
+        self.base = tempfile.mkdtemp(prefix='mbs-', suffix='-%s' % test_id)
         self.name_format = "build-{id}.log"
         print("Storing build logs in %r" % self.base)
         self.build_log = ModuleBuildLogs(self.base, self.name_format)
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         MBSConsumer.current_module_build_id = None
         shutil.rmtree(self.base)
 
@@ -55,7 +59,7 @@ class TestLogger(unittest.TestCase):
         # ensure we are not using some garbage from previous failed test.
         self.build_log.start(build)
         path = self.build_log.path(build)
-        self.assertEqual(path[len(self.base):], "/build-1.log")
+        assert path[len(self.base):] == "/build-1.log"
         if os.path.exists(path):
             os.unlink(path)
 
@@ -66,7 +70,7 @@ class TestLogger(unittest.TestCase):
         log.warn("ignore this test msg")
         log.error("ignore this test msg")
         self.build_log.stop(build)
-        self.assertTrue(not os.path.exists(path))
+        assert not os.path.exists(path)
 
         # Try logging with current_module_build_id set to 1 and then to 2.
         # Only messages with current_module_build_id set to 1 should appear in
@@ -85,12 +89,12 @@ class TestLogger(unittest.TestCase):
         log.error("ignore this test msg2")
 
         self.build_log.stop(build)
-        self.assertTrue(os.path.exists(path))
+        assert os.path.exists(path)
         with open(path, "r") as f:
             data = f.read()
             # Note that DEBUG is not present unless configured server-wide.
             for level in ["INFO", "WARNING", "ERROR"]:
-                self.assertTrue(data.find("%s - ignore this test msg1" % level) != -1)
+                assert data.find("%s - ignore this test msg1" % level) != -1
 
         # Try to log more messages when build_log for module 1 is stopped.
         # New messages should not appear in a log.
@@ -102,15 +106,15 @@ class TestLogger(unittest.TestCase):
         self.build_log.stop(build)
         with open(path, "r") as f:
             data = f.read()
-            self.assertTrue(data.find("ignore this test msg3") == -1)
+            assert data.find("ignore this test msg3") == -1
 
     def test_module_build_logs_name_format(self):
         build = models.ModuleBuild.query.filter_by(id=1).one()
 
         log1 = ModuleBuildLogs("/some/path", "build-{id}.log")
-        self.assertEquals(log1.name(build), "build-1.log")
-        self.assertEquals(log1.path(build), "/some/path/build-1.log")
+        assert log1.name(build) == "build-1.log"
+        assert log1.path(build) == "/some/path/build-1.log"
 
         log2 = ModuleBuildLogs("/some/path", "build-{name}-{stream}-{version}.log")
-        self.assertEquals(log2.name(build), "build-nginx-1-2.log")
-        self.assertEquals(log2.path(build), "/some/path/build-nginx-1-2.log")
+        assert log2.name(build) == "build-nginx-1-2.log"
+        assert log2.path(build) == "/some/path/build-nginx-1-2.log"
diff --git a/tests/test_messaging.py b/tests/test_messaging.py
index ad5e1f0f..f8dc1203 100644
--- a/tests/test_messaging.py
+++ b/tests/test_messaging.py
@@ -21,13 +21,12 @@
 # Written by Jakub Kadlcik <jkadlcik@redhat.com>
 
 
-import unittest
 from module_build_service import messaging
 from module_build_service.messaging import KojiRepoChange # noqa
 from mock import patch, PropertyMock
 
 
-class TestFedmsgMessaging(unittest.TestCase):
+class TestFedmsgMessaging:
 
     def test_buildsys_state_change(self):
         # https://fedora-fedmsg.readthedocs.io/en/latest/topics.html#id134
@@ -51,8 +50,8 @@ class TestFedmsgMessaging(unittest.TestCase):
 
         msg = messaging.FedmsgMessageParser().parse(buildsys_state_change_msg)
 
-        self.assertEqual(msg.build_id, 614503)
-        self.assertEqual(msg.build_new_state, 1)
+        assert msg.build_id == 614503
+        assert msg.build_new_state == 1
 
     @patch("module_build_service.config.Config.system",
            new_callable=PropertyMock, return_value="copr")
@@ -80,17 +79,16 @@ class TestFedmsgMessaging(unittest.TestCase):
         }
 
         msg = messaging.FedmsgMessageParser().parse(copr_build_end_msg)
-        self.assertIsInstance(msg, messaging.KojiBuildChange)
-        self.assertEqual(msg.msg_id, '2013-b05a323d-37ee-4396-9635-7b5dfaf5441b')
-        self.assertEqual(msg.build_id, 100)
-        self.assertEqual(msg.task_id, 100)
-        self.assertEqual(msg.build_new_state, 1)
-        self.assertEqual(msg.build_name, 'mutt-kz')
-        self.assertEqual(msg.build_version, '1.5.23.1')
-        self.assertEqual(msg.build_release, '1.20150203.git.c8504a8a.fc21')
-        self.assertEqual(msg.state_reason,
-                         ('build end: user:fatka copr:mutt-kz build:100 ip:172.16.3.3  '
-                          'pid:12010 status:1'))
+        assert isinstance(msg, messaging.KojiBuildChange)
+        assert msg.msg_id == '2013-b05a323d-37ee-4396-9635-7b5dfaf5441b'
+        assert msg.build_id == 100
+        assert msg.task_id == 100
+        assert msg.build_new_state == 1
+        assert msg.build_name == 'mutt-kz'
+        assert msg.build_version == '1.5.23.1'
+        assert msg.build_release == '1.20150203.git.c8504a8a.fc21'
+        assert msg.state_reason == ('build end: user:fatka copr:mutt-kz build:100 ip:172.16.3.3  '
+                                    'pid:12010 status:1')
 
     def test_buildsys_tag(self):
         # https://fedora-fedmsg.readthedocs.io/en/latest/topics.html#id134
@@ -113,8 +111,8 @@ class TestFedmsgMessaging(unittest.TestCase):
 
         msg = messaging.FedmsgMessageParser().parse(buildsys_tag_msg)
 
-        self.assertEqual(msg.tag, "module-debugging-tools-master-20170405115403-build")
-        self.assertEqual(msg.artifact, "module-build-macros")
+        assert msg.tag == "module-debugging-tools-master-20170405115403-build"
+        assert msg.artifact == "module-build-macros"
 
     def test_buildsys_repo_done(self):
         # https://fedora-fedmsg.readthedocs.io/en/latest/topics.html#id134
@@ -132,4 +130,4 @@ class TestFedmsgMessaging(unittest.TestCase):
 
         msg = messaging.FedmsgMessageParser().parse(buildsys_tag_msg)
 
-        self.assertEqual(msg.repo_tag, "module-f0f7e44f3c6cccab-build")
+        assert msg.repo_tag == "module-f0f7e44f3c6cccab-build"
diff --git a/tests/test_models/test_models.py b/tests/test_models/test_models.py
index c4fba4b6..88072f8e 100644
--- a/tests/test_models/test_models.py
+++ b/tests/test_models/test_models.py
@@ -21,7 +21,6 @@
 # Written by Ralph Bean <rbean@redhat.com>
 
 import os
-import unittest
 
 import modulemd
 
@@ -30,8 +29,8 @@ from module_build_service import conf
 from module_build_service.models import ComponentBuild, ModuleBuild, make_session
 
 
-class TestModels(unittest.TestCase):
-    def setUp(self):
+class TestModels:
+    def setup_method(self, test_method):
         init_data()
 
     def test_app_sqlalchemy_events(self):
@@ -54,11 +53,11 @@ class TestModels(unittest.TestCase):
 
         with make_session(conf) as session:
             c = session.query(ComponentBuild).filter(ComponentBuild.id == 1).one()
-            self.assertEquals(c.component_builds_trace[0].id, 1)
-            self.assertEquals(c.component_builds_trace[0].component_id, 1)
-            self.assertEquals(c.component_builds_trace[0].state, 1)
-            self.assertEquals(c.component_builds_trace[0].state_reason, None)
-            self.assertEquals(c.component_builds_trace[0].task_id, 999999999)
+            assert c.component_builds_trace[0].id == 1
+            assert c.component_builds_trace[0].component_id == 1
+            assert c.component_builds_trace[0].state == 1
+            assert c.component_builds_trace[0].state_reason is None
+            assert c.component_builds_trace[0].task_id == 999999999
 
     def test_context_functions(self):
         """ Test that the build_context, runtime_context, and context hashes are correctly
@@ -70,6 +69,6 @@ class TestModels(unittest.TestCase):
         mmd.load(yaml_path)
         build.modulemd = mmd.dumps()
         build.build_context, build.runtime_context = ModuleBuild.contexts_from_mmd(build.modulemd)
-        self.assertEqual(build.build_context, 'f6e2aeec7576196241b9afa0b6b22acf2b6873d7')
-        self.assertEqual(build.runtime_context, '1739827b08388842fc90ccc0b6070c59b7d856fc')
-        self.assertEqual(build.context, 'e7a3d35e')
+        assert build.build_context == 'f6e2aeec7576196241b9afa0b6b22acf2b6873d7'
+        assert build.runtime_context == '1739827b08388842fc90ccc0b6070c59b7d856fc'
+        assert build.context == 'e7a3d35e'
diff --git a/tests/test_resolver/test_pdc.py b/tests/test_resolver/test_pdc.py
index 8fbfc228..a0b93c8d 100644
--- a/tests/test_resolver/test_pdc.py
+++ b/tests/test_resolver/test_pdc.py
@@ -22,7 +22,6 @@
 
 import os
 
-import unittest
 from mock import patch, PropertyMock
 
 import vcr
@@ -30,25 +29,24 @@ import module_build_service.resolver as mbs_resolver
 import module_build_service.utils
 import module_build_service.models
 from module_build_service import app, db
+from tests import get_vcr_path
 
 import tests
 import modulemd
 
 
 base_dir = os.path.join(os.path.dirname(__file__), "..")
-cassette_dir = base_dir + '/vcr-request-data/'
 
 
-class TestPDCModule(unittest.TestCase):
+class TestPDCModule:
 
-    def setUp(self):
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+    def setup_method(self, test_method):
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
         self.resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='pdc')
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         self.vcr.__exit__()
 
     def test_get_variant_dict_module_dict_active(self):
@@ -67,7 +65,7 @@ class TestPDCModule(unittest.TestCase):
         }
 
         variant_dict = self.resolver._get_variant_dict(dep)
-        self.assertEqual(variant_dict, expected)
+        assert variant_dict == expected
 
     def test_get_module_simple_as_dict(self):
         query = {'name': 'testmodule', 'version': 'master'}
@@ -90,7 +88,7 @@ class TestPDCModule(unittest.TestCase):
         expected = [
             u'module-bootstrap-rawhide',
         ]
-        self.assertEqual(set(result), set(expected))
+        assert set(result) == set(expected)
 
     def test_get_module_build_dependencies_single_level(self):
         """
@@ -107,7 +105,7 @@ class TestPDCModule(unittest.TestCase):
         expected = [
             u'module-base-runtime-master-20170315134803',
         ]
-        self.assertEqual(set(result), set(expected))
+        assert set(result) == set(expected)
 
     @patch("module_build_service.config.Config.system",
            new_callable=PropertyMock, return_value="test")
@@ -138,7 +136,7 @@ class TestPDCModule(unittest.TestCase):
                     local_path,
                     'module-parent-master-20170816080815/results'),
             ]
-            self.assertEqual(set(result), set(expected))
+            assert set(result) == set(expected)
 
     def test_resolve_profiles(self):
         yaml_path = os.path.join(
@@ -158,7 +156,7 @@ class TestPDCModule(unittest.TestCase):
                      'fedora-modular-release', 'fedpkg-minimal', 'gnupg2',
                      'bash'])
         }
-        self.assertEqual(result, expected)
+        assert result == expected
 
     @patch("module_build_service.config.Config.system",
            new_callable=PropertyMock, return_value="test")
@@ -180,4 +178,4 @@ class TestPDCModule(unittest.TestCase):
                 'srpm-buildroot':
                     set(['bar'])
             }
-            self.assertEqual(result, expected)
+            assert result == expected
diff --git a/tests/test_scheduler/test_consumer.py b/tests/test_scheduler/test_consumer.py
index 0f47612e..13d50943 100644
--- a/tests/test_scheduler/test_consumer.py
+++ b/tests/test_scheduler/test_consumer.py
@@ -18,13 +18,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
 from mock import patch, MagicMock
 from module_build_service.scheduler.consumer import MBSConsumer
 from module_build_service.messaging import KojiTagChange, KojiRepoChange
 
 
-class TestConsumer(unittest.TestCase):
+class TestConsumer:
 
     @patch('module_build_service.messaging.conf.messaging', new='fedmsg')
     def test_get_abstracted_msg_fedmsg(self):
@@ -57,10 +56,10 @@ class TestConsumer(unittest.TestCase):
             }
         }
         msg_obj = consumer.get_abstracted_msg(msg)
-        self.assertIsInstance(msg_obj, KojiTagChange)
-        self.assertEqual(msg_obj.msg_id, msg['msg_id'])
-        self.assertEqual(msg_obj.tag, msg['msg']['tag'])
-        self.assertEqual(msg_obj.artifact, msg['msg']['name'])
+        assert isinstance(msg_obj, KojiTagChange)
+        assert msg_obj.msg_id == msg['msg_id']
+        assert msg_obj.tag == msg['msg']['tag']
+        assert msg_obj.artifact == msg['msg']['name']
 
     @patch('module_build_service.scheduler.consumer.models')
     @patch.object(MBSConsumer, 'process_message')
@@ -94,8 +93,8 @@ class TestConsumer(unittest.TestCase):
             }
         }
         consumer.consume(msg)
-        self.assertEqual(process_message.call_count, 1)
+        assert process_message.call_count == 1
         msg_obj = process_message.call_args[0][1]
-        self.assertIsInstance(msg_obj, KojiRepoChange)
-        self.assertEqual(msg_obj.msg_id, msg['body']['msg_id'])
-        self.assertEqual(msg_obj.repo_tag, msg['body']['msg']['tag'])
+        assert isinstance(msg_obj, KojiRepoChange)
+        assert msg_obj.msg_id == msg['body']['msg_id']
+        assert msg_obj.repo_tag == msg['body']['msg']['tag']
diff --git a/tests/test_scheduler/test_module_init.py b/tests/test_scheduler/test_module_init.py
index 96597ec5..086024dd 100644
--- a/tests/test_scheduler/test_module_init.py
+++ b/tests/test_scheduler/test_module_init.py
@@ -20,24 +20,21 @@
 #
 
 import os
-import unittest
 
 from mock import patch, PropertyMock
 import vcr
 
-from tests import conf, clean_database
+from tests import conf, clean_database, get_vcr_path
 from tests.test_views.test_views import FakeSCM
 import module_build_service.messaging
 import module_build_service.scheduler.handlers.modules
 from module_build_service import build_logs
 from module_build_service.models import make_session, ModuleBuild, ComponentBuild
 
-CASSETTE_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'vcr-request-data/')
 
+class TestModuleInit:
 
-class TestModuleInit(unittest.TestCase):
-
-    def setUp(self):
+    def setup_method(self, test_method):
         self.fn = module_build_service.scheduler.handlers.modules.init
         self.staged_data_dir = os.path.join(
             os.path.dirname(__file__), '../', 'staged_data')
@@ -51,11 +48,10 @@ class TestModuleInit(unittest.TestCase):
             ModuleBuild.create(
                 session, conf, 'testmodule', '1', 3, yaml, scmurl, 'mprahl')
 
-        filename = os.path.join(CASSETTE_DIR, self.id())
-        self.vcr = vcr.use_cassette(filename)
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         self.vcr.__exit__()
         try:
             path = build_logs.path(1)
diff --git a/tests/test_scheduler/test_module_wait.py b/tests/test_scheduler/test_module_wait.py
index 4ec29e6f..574ab526 100644
--- a/tests/test_scheduler/test_module_wait.py
+++ b/tests/test_scheduler/test_module_wait.py
@@ -20,7 +20,6 @@
 #
 # Written by Ralph Bean <rbean@redhat.com>
 
-import unittest
 import mock
 from mock import patch
 import module_build_service.messaging
@@ -29,26 +28,23 @@ import modulemd as _modulemd
 import os
 import vcr
 import koji
-from tests import conf, db, app, scheduler_init_data
+from tests import conf, db, app, scheduler_init_data, get_vcr_path
 from module_build_service import build_logs
 from module_build_service.models import ComponentBuild, ModuleBuild
 
 base_dir = os.path.dirname(os.path.dirname(__file__))
-cassette_dir = base_dir + '/vcr-request-data/'
 
 
-class TestModuleWait(unittest.TestCase):
-
-    def setUp(self):
+class TestModuleWait:
+    def setup_method(self, test_method):
         self.config = conf
         self.session = mock.Mock()
         self.fn = module_build_service.scheduler.handlers.modules.wait
 
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         self.vcr.__exit__()
         try:
             path = build_logs.path(1)
@@ -131,7 +127,7 @@ class TestModuleWait(unittest.TestCase):
             # once in database.
             builds_count = db.session.query(ComponentBuild).filter_by(
                 package="module-build-macros", module_id=1).count()
-            self.assertEqual(builds_count, 1)
+            assert builds_count == 1
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -167,7 +163,7 @@ class TestModuleWait(unittest.TestCase):
                                                            module_build_state='some state')
             module_build_service.scheduler.handlers.modules.wait(
                 config=conf, session=db.session, msg=msg)
-            self.assertTrue(koji_session.newRepo.called)
+            assert koji_session.newRepo.called
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -210,7 +206,7 @@ class TestModuleWait(unittest.TestCase):
             module_build_service.scheduler.handlers.modules.wait(
                 config=conf, session=db.session, msg=msg)
             module_build = ModuleBuild.query.filter_by(id=1).one()
-            self.assertEqual(module_build.cg_build_koji_tag, "modular-updates-candidate")
+            assert module_build.cg_build_koji_tag == "modular-updates-candidate"
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -255,5 +251,4 @@ class TestModuleWait(unittest.TestCase):
             module_build_service.scheduler.handlers.modules.wait(
                 config=conf, session=db.session, msg=msg)
             module_build = ModuleBuild.query.filter_by(id=1).one()
-            self.assertEqual(module_build.cg_build_koji_tag,
-                             "f27-modular-updates-candidate")
+            assert module_build.cg_build_koji_tag == "f27-modular-updates-candidate"
diff --git a/tests/test_scheduler/test_poller.py b/tests/test_scheduler/test_poller.py
index cb5e35be..dc5df932 100644
--- a/tests/test_scheduler/test_poller.py
+++ b/tests/test_scheduler/test_poller.py
@@ -18,7 +18,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
 from os import path
 from mock import patch
 from module_build_service import models, conf
@@ -39,12 +38,12 @@ CASSETTES_DIR = path.join(
 @patch("module_build_service.scheduler.consumer.get_global_consumer")
 @patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
 @patch("module_build_service.builder.GenericBuilder.create_from_module")
-class TestPoller(unittest.TestCase):
+class TestPoller:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         test_reuse_component_init_data()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         init_data()
 
     @patch('module_build_service.utils.start_build_component')
@@ -82,8 +81,8 @@ class TestPoller(unittest.TestCase):
         # Components should be in BUILDING state now.
         components = module_build.current_batch()
         for component in components:
-            self.assertEqual(component.state, koji.BUILD_STATES["BUILDING"])
-        self.assertEqual(len(start_build_component.mock_calls), 2)
+            assert component.state == koji.BUILD_STATES["BUILDING"]
+        assert len(start_build_component.mock_calls) == 2
 
     def test_trigger_new_repo_when_failed(self, create_builder,
                                           koji_get_session, global_consumer,
@@ -154,8 +153,8 @@ class TestPoller(unittest.TestCase):
         module_build = models.ModuleBuild.query.filter_by(id=2).one()
         db.session.refresh(module_build)
 
-        self.assertTrue(not koji_session.newRepo.called)
-        self.assertEqual(module_build.new_repo_task_id, 0)
+        assert not koji_session.newRepo.called
+        assert module_build.new_repo_task_id == 0
 
     def test_process_paused_module_builds_waiting_for_repo(
             self, create_builder, koji_get_session, global_consumer, dbg):
@@ -192,7 +191,7 @@ class TestPoller(unittest.TestCase):
         # Components should not be in building state
         components = module_build.current_batch()
         for component in components:
-            self.assertEqual(component.state, None)
+            assert component.state is None
 
     def test_delete_old_koji_targets(
             self, create_builder, koji_get_session, global_consumer, dbg):
@@ -237,7 +236,7 @@ class TestPoller(unittest.TestCase):
 
             # deleteBuildTarget should not be called, because time_completed is
             # set to "now".
-            self.assertTrue(not koji_session.deleteBuildTarget.called)
+            assert not koji_session.deleteBuildTarget.called
 
             # Try removing non-modular target - should not happen
             db.session.refresh(module_build)
@@ -245,7 +244,7 @@ class TestPoller(unittest.TestCase):
             module_build.time_completed = datetime.utcnow() - timedelta(hours=25)
             db.session.commit()
             poller.delete_old_koji_targets(conf, db.session)
-            self.assertTrue(not koji_session.deleteBuildTarget.called)
+            assert not koji_session.deleteBuildTarget.called
 
             # Refresh our module_build object and set time_completed 25 hours ago
             db.session.refresh(module_build)
@@ -279,15 +278,15 @@ class TestPoller(unittest.TestCase):
         db.session.refresh(module_build)
 
         # Ensure the queue is empty before we start.
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
 
         # Poll :)
         poller.process_waiting_module_builds(db.session)
 
-        self.assertEquals(consumer.incoming.qsize(), 1)
+        assert consumer.incoming.qsize() == 1
         module_build = models.ModuleBuild.query.filter_by(id=2).one()
         # ensure the time_modified was changed.
-        self.assertGreater(module_build.time_modified, original)
+        assert module_build.time_modified > original
 
     def test_process_waiting_module_build_not_old_enough(self, create_builder, koji_get_session,
                                                          global_consumer, dbg):
@@ -310,13 +309,13 @@ class TestPoller(unittest.TestCase):
         db.session.refresh(module_build)
 
         # Ensure the queue is empty before we start.
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
 
         # Poll :)
         poller.process_waiting_module_builds(db.session)
 
         # Ensure we did *not* process the 9 minute-old build.
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
 
     def test_process_waiting_module_build_none_found(self, create_builder, koji_get_session,
                                                      global_consumer, dbg):
@@ -330,13 +329,13 @@ class TestPoller(unittest.TestCase):
         poller = MBSProducer(hub)
 
         # Ensure the queue is empty before we start.
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
 
         # Poll :)
         poller.process_waiting_module_builds(db.session)
 
         # Ensure we did *not* process any of the non-waiting builds.
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
 
     def test_cleanup_stale_failed_builds(self, create_builder, koji_get_session,
                                          global_consumer, dbg):
@@ -369,20 +368,20 @@ class TestPoller(unittest.TestCase):
         poller = MBSProducer(hub)
 
         # Ensure the queue is empty before we start
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
         poller.cleanup_stale_failed_builds(conf, db.session)
         db.session.refresh(module_build_two)
         # Make sure module_build_one was transitioned to garbage
-        self.assertEqual(module_build_one.state, models.BUILD_STATES['garbage'])
+        assert module_build_one.state == models.BUILD_STATES['garbage']
         state_reason = ('The module was garbage collected since it has failed over {0} day(s) ago'
                         .format(conf.cleanup_failed_builds_time))
-        self.assertEqual(module_build_one.state_reason, state_reason)
+        assert module_build_one.state_reason == state_reason
         # Make sure all the components are marked as untagged in the database
         for component in module_build_one.component_builds:
-            self.assertFalse(component.tagged)
-            self.assertFalse(component.tagged_in_final)
+            assert not component.tagged
+            assert not component.tagged_in_final
         # Make sure module_build_two stayed the same
-        self.assertEqual(module_build_two.state, models.BUILD_STATES['failed'])
+        assert module_build_two.state == models.BUILD_STATES['failed']
         # Make sure the builds were untagged
         builder.untag_artifacts.assert_called_once_with([
             'perl-Tangerine-0.23-1.module+0+814cfa39',
@@ -419,15 +418,15 @@ class TestPoller(unittest.TestCase):
         poller = MBSProducer(hub)
 
         # Ensure the queue is empty before we start
-        self.assertEquals(consumer.incoming.qsize(), 0)
+        assert consumer.incoming.qsize() == 0
         poller.cleanup_stale_failed_builds(conf, db.session)
         db.session.refresh(module_build_two)
         # Make sure module_build_two was transitioned to garbage
-        self.assertEqual(module_build_two.state, models.BUILD_STATES['garbage'])
+        assert module_build_two.state == models.BUILD_STATES['garbage']
         state_reason = ('The module was garbage collected since it has failed over {0} day(s) ago'
                         .format(conf.cleanup_failed_builds_time))
-        self.assertEqual(module_build_two.state_reason, state_reason)
+        assert module_build_two.state_reason == state_reason
         # Make sure module_build_one stayed the same
-        self.assertEqual(module_build_one.state, models.BUILD_STATES['failed'])
+        assert module_build_one.state == models.BUILD_STATES['failed']
         # Make sure that the builder was never instantiated
         create_builder.assert_not_called()
diff --git a/tests/test_scheduler/test_repo_done.py b/tests/test_scheduler/test_repo_done.py
index 17e2c842..3ce8649b 100644
--- a/tests/test_scheduler/test_repo_done.py
+++ b/tests/test_scheduler/test_repo_done.py
@@ -21,30 +21,26 @@
 # Written by Ralph Bean <rbean@redhat.com>
 
 from os.path import dirname
-import unittest
 import mock
 import vcr
 
 import module_build_service.messaging
 import module_build_service.scheduler.handlers.repos
 import module_build_service.models
-from tests import scheduler_init_data
-from tests import conf, db, app
+from tests import conf, db, app, scheduler_init_data, get_vcr_path
 
 base_dir = dirname(dirname(__file__))
-cassette_dir = base_dir + '/vcr-request-data/'
 
 
-class TestRepoDone(unittest.TestCase):
+class TestRepoDone:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         scheduler_init_data()
 
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+        self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
         self.vcr.__enter__()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         self.vcr.__exit__()
 
     @mock.patch('module_build_service.models.ModuleBuild.from_repo_done_event')
@@ -124,8 +120,7 @@ class TestRepoDone(unittest.TestCase):
                     '?#da95886c8a443b36a9ce31abda1f9bed22f2f9c2'))
         component_build = module_build_service.models.ComponentBuild.query\
             .filter_by(package='communicator').one()
-        self.assertEquals(component_build.state_reason,
-                          'Failed to submit artifact communicator to Koji')
+        assert component_build.state_reason == 'Failed to submit artifact communicator to Koji'
 
     @mock.patch('module_build_service.scheduler.handlers.repos.log.info')
     def test_erroneous_regen_repo_received(self, mock_log_info):
@@ -146,7 +141,7 @@ class TestRepoDone(unittest.TestCase):
             'Ignoring repo regen, because not all components are tagged.')
         module_build = module_build_service.models.ModuleBuild.query.get(1)
         # Make sure the module build didn't transition since all the components weren't tagged
-        self.assertEqual(module_build.state, module_build_service.models.BUILD_STATES['build'])
+        assert module_build.state == module_build_service.models.BUILD_STATES['build']
 
     @mock.patch('module_build_service.builder.KojiModuleBuilder.'
                 'KojiModuleBuilder.list_tasks_for_components',
@@ -177,5 +172,4 @@ class TestRepoDone(unittest.TestCase):
             module_build = module_build_service.models.ModuleBuild.query\
                 .filter_by(name='starcommand').one()
 
-            self.assertEquals(module_build.state,
-                              module_build_service.models.BUILD_STATES["failed"])
+            assert module_build.state == module_build_service.models.BUILD_STATES["failed"]
diff --git a/tests/test_scheduler/test_tag_tagged.py b/tests/test_scheduler/test_tag_tagged.py
index ac45f3ef..ec25b549 100644
--- a/tests/test_scheduler/test_tag_tagged.py
+++ b/tests/test_scheduler/test_tag_tagged.py
@@ -20,7 +20,6 @@
 #
 # Written by Jan Kaluza <jkaluza@redhat.com>
 
-import unittest
 import mock
 
 from mock import patch
@@ -34,14 +33,11 @@ from tests import conf, db
 import koji
 
 
-class TestTagTagged(unittest.TestCase):
+class TestTagTagged:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         test_reuse_component_init_data()
 
-    def tearDown(self):
-        pass
-
     @mock.patch('module_build_service.models.ModuleBuild.from_tag_change_event')
     def test_no_matching_module(self, from_tag_change_event):
         """ Test that when a tag msg hits us and we have no match,
@@ -109,7 +105,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo should not be called, because there are still components
         # to tag.
-        self.assertTrue(not koji_session.newRepo.called)
+        assert not koji_session.newRepo.called
 
         # Tag the second component to the buildroot.
         msg = module_build_service.messaging.KojiTagChange(
@@ -119,7 +115,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo should not be called, because the component has not been
         # tagged to final tag so far.
-        self.assertTrue(not koji_session.newRepo.called)
+        assert not koji_session.newRepo.called
 
         # Tag the first component to the final tag.
         msg = module_build_service.messaging.KojiTagChange(
@@ -136,7 +132,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo task_id should be stored in database, so we can check its
         # status later in poller.
-        self.assertEqual(module_build.new_repo_task_id, 123456)
+        assert module_build.new_repo_task_id == 123456
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -178,7 +174,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo should not be called, because perl-List-Compare has not been
         # built yet.
-        self.assertTrue(not koji_session.newRepo.called)
+        assert not koji_session.newRepo.called
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -239,7 +235,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo task_id should be stored in database, so we can check its
         # status later in poller.
-        self.assertEqual(module_build.new_repo_task_id, 123456)
+        assert module_build.new_repo_task_id == 123456
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -287,7 +283,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo should not be called, because there are still components
         # to tag.
-        self.assertTrue(not koji_session.newRepo.called)
+        assert not koji_session.newRepo.called
 
         # Tag the second component to the buildroot.
         msg = module_build_service.messaging.KojiTagChange(
@@ -302,7 +298,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo should not be called, because there are still components
         # to tag.
-        self.assertTrue(not koji_session.newRepo.called)
+        assert not koji_session.newRepo.called
 
         # Tag the component from first batch to final tag.
         msg = module_build_service.messaging.KojiTagChange(
@@ -324,7 +320,7 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo task_id should be stored in database, so we can check its
         # status later in poller.
-        self.assertEqual(module_build.new_repo_task_id, 123456)
+        assert module_build.new_repo_task_id == 123456
 
     @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
            return_value={'build': [], 'srpm-build': []})
@@ -373,7 +369,7 @@ class TestTagTagged(unittest.TestCase):
             'id', 'module-testmodule-build', "perl-Tangerine")
         module_build_service.scheduler.handlers.tags.tagged(
             config=conf, session=db.session, msg=msg)
-        self.assertTrue(not koji_session.newRepo.called)
+        assert not koji_session.newRepo.called
         # Tag the perl-List-Compare component to the buildroot.
         msg = module_build_service.messaging.KojiTagChange(
             'id', 'module-testmodule-build', "perl-List-Compare")
@@ -395,4 +391,4 @@ class TestTagTagged(unittest.TestCase):
 
         # newRepo task_id should be stored in database, so we can check its
         # status later in poller.
-        self.assertEqual(module_build.new_repo_task_id, 123456)
+        assert module_build.new_repo_task_id == 123456
diff --git a/tests/test_scm.py b/tests/test_scm.py
index 5f89a0b4..52fce294 100644
--- a/tests/test_scm.py
+++ b/tests/test_scm.py
@@ -24,7 +24,6 @@ import os
 import shutil
 import tempfile
 
-import unittest
 from mock import patch
 from nose.tools import raises
 
@@ -34,13 +33,13 @@ from module_build_service.errors import ValidationError, UnprocessableEntity
 repo_path = 'file://' + os.path.dirname(__file__) + "/scm_data/testrepo"
 
 
-class TestSCMModule(unittest.TestCase):
+class TestSCMModule:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         self.tempdir = tempfile.mkdtemp()
         self.repodir = self.tempdir + '/testrepo'
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         if os.path.exists(self.tempdir):
             shutil.rmtree(self.tempdir)
 
@@ -152,4 +151,4 @@ class TestSCMModule(unittest.TestCase):
         mock_run.return_value = (0, output, '')
         scm = module_build_service.scm.SCM(repo_path)
         commit = scm.get_latest(None)
-        self.assertEquals(commit, '58379ef7887cbc91b215bacd32430628c92bc869')
+        assert commit == '58379ef7887cbc91b215bacd32430628c92bc869'
diff --git a/tests/test_utils/test_utils.py b/tests/test_utils/test_utils.py
index a48871d4..81daee27 100644
--- a/tests/test_utils/test_utils.py
+++ b/tests/test_utils/test_utils.py
@@ -18,7 +18,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
 import tempfile
 from os import path, mkdir
 from shutil import copyfile, rmtree
@@ -36,6 +35,7 @@ from tests import (test_reuse_component_init_data, init_data, db,
                    clean_database)
 import mock
 import koji
+import pytest
 import module_build_service.scheduler.handlers.components
 from module_build_service.builder.base import GenericBuilder
 from module_build_service.builder.KojiModuleBuilder import KojiModuleBuilder
@@ -79,10 +79,9 @@ class FakeSCM(object):
         return path.join(self.sourcedir, self.name + ".yaml")
 
 
-class TestUtils(unittest.TestCase):
-    maxDiff = None
+class TestUtils:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         self.filtered_rpms = [
             u'sqlite-tcl-0:3.17.0-2.module_5ccf9229',
             u'sqlite-analyzer-0:3.17.0-2.module_5ccf9229',
@@ -229,7 +228,7 @@ class TestUtils(unittest.TestCase):
             u'iproute-tc-0:4.11.0-1.module_d6de39f1'
         ]
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         init_data()
 
     @vcr.use_cassette(
@@ -260,9 +259,9 @@ class TestUtils(unittest.TestCase):
 
         # Make sure that original refs are not changed.
         mmd_pkg_refs = [pkg.ref for pkg in mmd.components.rpms.values()]
-        self.assertEqual(set(mmd_pkg_refs), set(original_refs))
+        assert set(mmd_pkg_refs) == set(original_refs)
 
-        self.assertEqual(mmd.buildrequires, {'base-runtime': 'master'})
+        assert mmd.buildrequires == {'base-runtime': 'master'}
         xmd = {
             'mbs': {
                 'commit': '620ec77321b2ea7b0d67d82992dda3e1d67055b4',
@@ -286,7 +285,7 @@ class TestUtils(unittest.TestCase):
             }
         }
 
-        self.assertEqual(mmd.xmd, xmd)
+        assert mmd.xmd == xmd
 
     @vcr.use_cassette(
         path.join(CASSETTES_DIR, 'tests.test_utils.TestUtils.test_format_mmd'))
@@ -329,14 +328,14 @@ class TestUtils(unittest.TestCase):
                 'scmurl': None,
             }
         }
-        self.assertEqual(mmd.xmd, xmd)
+        assert mmd.xmd == xmd
 
     def test_get_reusable_component_same(self):
         test_reuse_component_init_data()
         new_module = models.ModuleBuild.query.filter_by(id=2).one()
         rv = module_build_service.utils.get_reusable_component(
             db.session, new_module, 'tangerine')
-        self.assertEqual(rv.package, 'tangerine')
+        assert rv.package == 'tangerine'
 
     def test_get_reusable_component_different_perl_tangerine(self):
         test_reuse_component_init_data()
@@ -355,18 +354,18 @@ class TestUtils(unittest.TestCase):
         # none)
         plc_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-List-Compare')
-        self.assertEqual(plc_rv.package, 'perl-List-Compare')
+        assert plc_rv.package == 'perl-List-Compare'
 
         # perl-Tangerine has a different commit hash
         pt_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-Tangerine')
-        self.assertEqual(pt_rv, None)
+        assert pt_rv is None
 
         # tangerine is the same but its in a build order that is after the
         # different perl-Tangerine, so it can't be reused
         tangerine_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'tangerine')
-        self.assertEqual(tangerine_rv, None)
+        assert tangerine_rv is None
 
     def test_get_reusable_component_different_rpm_macros(self):
         test_reuse_component_init_data()
@@ -378,12 +377,12 @@ class TestUtils(unittest.TestCase):
 
         plc_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-List-Compare')
-        self.assertEqual(plc_rv, None)
+        assert plc_rv is None
 
         # perl-Tangerine has a different commit hash
         pt_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-Tangerine')
-        self.assertEqual(pt_rv, None)
+        assert pt_rv is None
 
     def test_get_reusable_component_different_buildrequires_hash(self):
         test_reuse_component_init_data()
@@ -397,18 +396,18 @@ class TestUtils(unittest.TestCase):
 
         plc_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-List-Compare')
-        self.assertEqual(plc_rv, None)
+        assert plc_rv is None
 
         # perl-Tangerine has a different commit hash
         pt_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-Tangerine')
-        self.assertEqual(pt_rv, None)
+        assert pt_rv is None
 
         # tangerine is the same but its in a build order that is after the
         # different perl-Tangerine, so it can't be reused
         tangerine_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'tangerine')
-        self.assertEqual(tangerine_rv, None)
+        assert tangerine_rv is None
 
     def test_get_reusable_component_different_buildrequires(self):
         test_reuse_component_init_data()
@@ -428,18 +427,18 @@ class TestUtils(unittest.TestCase):
 
         plc_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-List-Compare')
-        self.assertEqual(plc_rv, None)
+        assert plc_rv is None
 
         # perl-Tangerine has a different commit hash
         pt_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'perl-Tangerine')
-        self.assertEqual(pt_rv, None)
+        assert pt_rv is None
 
         # tangerine is the same but its in a build order that is after the
         # different perl-Tangerine, so it can't be reused
         tangerine_rv = module_build_service.utils.get_reusable_component(
             db.session, second_module_build, 'tangerine')
-        self.assertEqual(tangerine_rv, None)
+        assert tangerine_rv is None
 
     def test_get_reusable_component_shared_userspace_ordering(self):
         """
@@ -452,7 +451,7 @@ class TestUtils(unittest.TestCase):
         new_module = models.ModuleBuild.query.filter_by(id=2).one()
         rv = module_build_service.utils.get_reusable_component(
             db.session, new_module, 'llvm')
-        self.assertEqual(rv.package, 'llvm')
+        assert rv.package == 'llvm'
 
     def test_validate_koji_tag_wrong_tag_arg_during_programming(self):
         """ Test that we fail on a wrong param name (non-existing one) due to
@@ -462,7 +461,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_programming_error(good_tag_arg, other_arg):
             pass
 
-        with self.assertRaises(ProgrammingError):
+        with pytest.raises(ProgrammingError):
             validate_koji_tag_programming_error('dummy', 'other_val')
 
     def test_validate_koji_tag_bad_tag_value(self):
@@ -472,7 +471,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_bad_tag_value(tag_arg):
             pass
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             validate_koji_tag_bad_tag_value('forbiddentagprefix-foo')
 
     def test_validate_koji_tag_bad_tag_value_in_list(self):
@@ -482,7 +481,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_bad_tag_value_in_list(tag_arg):
             pass
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             validate_koji_tag_bad_tag_value_in_list([
                 'module-foo', 'forbiddentagprefix-bar'])
 
@@ -493,8 +492,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_good_tag_value(tag_arg):
             return True
 
-        self.assertEquals(
-            validate_koji_tag_good_tag_value('module-foo'), True)
+        assert validate_koji_tag_good_tag_value('module-foo') is True
 
     def test_validate_koji_tag_good_tag_values_in_list(self):
         """ Test that we pass on a list of good tag values. """
@@ -503,9 +501,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_good_tag_values_in_list(tag_arg):
             return True
 
-        self.assertEquals(
-            validate_koji_tag_good_tag_values_in_list(['module-foo',
-                                                       'module-bar']), True)
+        assert validate_koji_tag_good_tag_values_in_list(['module-foo', 'module-bar']) is True
 
     def test_validate_koji_tag_good_tag_value_in_dict(self):
         """ Test that we pass on a dict arg with default key
@@ -515,8 +511,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_good_tag_value_in_dict(tag_arg):
             return True
 
-        self.assertEquals(
-            validate_koji_tag_good_tag_value_in_dict({'name': 'module-foo'}), True)
+        assert validate_koji_tag_good_tag_value_in_dict({'name': 'module-foo'}) is True
 
     def test_validate_koji_tag_good_tag_value_in_dict_nondefault_key(self):
         """ Test that we pass on a dict arg with non-default key
@@ -527,9 +522,8 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_good_tag_value_in_dict_nondefault_key(tag_arg):
             return True
 
-        self.assertEquals(
-            validate_koji_tag_good_tag_value_in_dict_nondefault_key(
-                {'nondefault': 'module-foo'}), True)
+        assert validate_koji_tag_good_tag_value_in_dict_nondefault_key(
+            {'nondefault': 'module-foo'}) is True
 
     def test_validate_koji_tag_double_trouble_good(self):
         """ Test that we pass on a list of tags that are good. """
@@ -541,7 +535,7 @@ class TestUtils(unittest.TestCase):
             return expected
 
         actual = validate_koji_tag_double_trouble('module-1', 'module-2')
-        self.assertEquals(actual, expected)
+        assert actual == expected
 
     def test_validate_koji_tag_double_trouble_bad(self):
         """ Test that we fail on a list of tags that are bad. """
@@ -550,7 +544,7 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_double_trouble(tag_arg1, tag_arg2):
             pass
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             validate_koji_tag_double_trouble('module-1', 'BADNEWS-2')
 
     def test_validate_koji_tag_is_None(self):
@@ -560,10 +554,9 @@ class TestUtils(unittest.TestCase):
         def validate_koji_tag_is_None(tag_arg):
             pass
 
-        with self.assertRaises(ValidationError) as cm:
+        with pytest.raises(ValidationError) as cm:
             validate_koji_tag_is_None(None)
-
-        self.assertTrue(str(cm.exception).endswith(' No value provided.'))
+            assert str(cm.value).endswith(' No value provided.') is True
 
     @vcr.use_cassette(
         path.join(CASSETTES_DIR, 'tests.test_utils.TestUtils.test_format_mmd'))
@@ -611,13 +604,13 @@ class TestUtils(unittest.TestCase):
                 "Tom Brady", 'git://pkgs.stg.fedoraproject.org/modules/testmodule.git?#8fea453',
                 'master')
 
-            self.assertEqual(module_build.state, models.BUILD_STATES['wait'])
-            self.assertEqual(module_build.batch, 0)
-            self.assertEqual(module_build.state_reason, "Resubmitted by Tom Brady")
-            self.assertEqual(complete_component.state, koji.BUILD_STATES['COMPLETE'])
+            assert module_build.state == models.BUILD_STATES['wait']
+            assert module_build.batch == 0
+            assert module_build.state_reason == "Resubmitted by Tom Brady"
+            assert complete_component.state == koji.BUILD_STATES['COMPLETE']
             # The failed/cancelled components are now stateless
-            self.assertIsNone(failed_component.state)
-            self.assertIsNone(canceled_component.state)
+            assert failed_component.state is None
+            assert canceled_component.state is None
 
     @vcr.use_cassette(
         path.join(CASSETTES_DIR, ('tests.test_utils.TestUtils.'
@@ -651,12 +644,10 @@ class TestUtils(unittest.TestCase):
             error_msg = (
                 'The included module "testmodule-variant" in "testmodule" have '
                 'the following conflicting components: perl-List-Compare')
-            try:
+            with pytest.raises(UnprocessableEntity) as e:
                 module_build_service.utils.record_component_builds(
                     testmodule_variant_mmd, module_build, main_mmd=mmd)
-                assert False, 'A UnprocessableEntity was expected but was not raised'
-            except UnprocessableEntity as e:
-                self.assertEqual(e.message, error_msg)
+                assert str(e.value) == error_msg
 
     @patch("module_build_service.utils.submit_module_build")
     def test_submit_module_build_from_yaml_with_skiptests(self, mock_submit):
@@ -725,10 +716,10 @@ class TestUtils(unittest.TestCase):
             module_build_service.utils.record_component_builds(
                 mmd, module_build)
 
-            self.assertEqual(module_build.state, models.BUILD_STATES['init'])
+            assert module_build.state == models.BUILD_STATES['init']
             db.session.refresh(module_build)
             for c in module_build.component_builds:
-                self.assertEqual(c.weight, 1.5)
+                assert c.weight == 1.5
 
 
 class DummyModuleBuilder(GenericBuilder):
@@ -798,13 +789,13 @@ class DummyModuleBuilder(GenericBuilder):
 
 @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
        return_value={'build': [], 'srpm-build': []})
-class TestBatches(unittest.TestCase):
+class TestBatches:
 
-    def setUp(self):
+    def setup_method(self, test_method):
         test_reuse_component_init_data()
         GenericBuilder.register_backend_class(DummyModuleBuilder)
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         init_data()
         DummyModuleBuilder.TAGGED_COMPONENTS = []
         GenericBuilder.register_backend_class(KojiModuleBuilder)
@@ -827,7 +818,7 @@ class TestBatches(unittest.TestCase):
             conf, module_build, db.session, builder)
 
         # Batch number should increase.
-        self.assertEqual(module_build.batch, 2)
+        assert module_build.batch == 2
 
         # KojiBuildChange messages in further_work should have build_new_state
         # set to COMPLETE, but the current component build state should be set
@@ -835,9 +826,9 @@ class TestBatches(unittest.TestCase):
         # properly.
         for msg in further_work:
             if type(msg) == module_build_service.messaging.KojiBuildChange:
-                self.assertEqual(msg.build_new_state, koji.BUILD_STATES['COMPLETE'])
+                assert msg.build_new_state == koji.BUILD_STATES['COMPLETE']
                 component_build = models.ComponentBuild.from_component_event(db.session, msg)
-                self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
+                assert component_build.state == koji.BUILD_STATES['BUILDING']
 
         # When we handle these KojiBuildChange messages, MBS should tag all
         # the components just once.
@@ -848,10 +839,10 @@ class TestBatches(unittest.TestCase):
 
         # Since we have reused all the components in the batch, there should
         # be fake KojiRepoChange message.
-        self.assertEqual(type(further_work[-1]), module_build_service.messaging.KojiRepoChange)
+        assert type(further_work[-1]) == module_build_service.messaging.KojiRepoChange
 
         # Check that packages have been tagged just once.
-        self.assertEqual(len(DummyModuleBuilder.TAGGED_COMPONENTS), 2)
+        assert len(DummyModuleBuilder.TAGGED_COMPONENTS) == 2
 
     @patch('module_build_service.utils.start_build_component')
     def test_start_next_batch_build_reuse_some(self, mock_sbc, default_buildroot_groups):
@@ -876,22 +867,22 @@ class TestBatches(unittest.TestCase):
             conf, module_build, db.session, builder)
 
         # Batch number should increase.
-        self.assertEqual(module_build.batch, 2)
+        assert module_build.batch == 2
 
         # Make sure we only have one message returned for the one reused component
-        self.assertEqual(len(further_work), 1)
+        assert len(further_work) == 1
         # The KojiBuildChange message in further_work should have build_new_state
         # set to COMPLETE, but the current component build state in the DB should be set
         # to BUILDING, so KojiBuildChange message handler handles the change
         # properly.
-        self.assertEqual(further_work[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
+        assert further_work[0].build_new_state == koji.BUILD_STATES['COMPLETE']
         component_build = models.ComponentBuild.from_component_event(db.session, further_work[0])
-        self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
-        self.assertEqual(component_build.package, 'perl-Tangerine')
-        self.assertIsNotNone(component_build.reused_component_id)
+        assert component_build.state == koji.BUILD_STATES['BUILDING']
+        assert component_build.package == 'perl-Tangerine'
+        assert component_build.reused_component_id is not None
         # Make sure perl-List-Compare is set to the build state as well but not reused
-        self.assertEqual(plc_component.state, koji.BUILD_STATES['BUILDING'])
-        self.assertIsNone(plc_component.reused_component_id)
+        assert plc_component.state == koji.BUILD_STATES['BUILDING']
+        assert plc_component.reused_component_id is None
         mock_sbc.assert_called_once()
 
     @patch('module_build_service.utils.start_build_component')
@@ -913,11 +904,11 @@ class TestBatches(unittest.TestCase):
             conf, module_build, db.session, builder)
 
         # Batch number should increase.
-        self.assertEqual(module_build.batch, 2)
+        assert module_build.batch == 2
         # No component reuse messages should be returned
-        self.assertEqual(len(further_work), 0)
+        assert len(further_work) == 0
         # Make sure that both components in the batch were submitted
-        self.assertEqual(len(mock_sbc.mock_calls), 2)
+        assert len(mock_sbc.mock_calls) == 2
 
     @patch('module_build_service.utils.start_build_component')
     @patch('module_build_service.config.Config.rebuild_strategy',
@@ -944,22 +935,22 @@ class TestBatches(unittest.TestCase):
             conf, module_build, db.session, builder)
 
         # Batch number should increase
-        self.assertEqual(module_build.batch, 2)
+        assert module_build.batch == 2
 
         # Make sure we only have one message returned for the one reused component
-        self.assertEqual(len(further_work), 1)
+        assert len(further_work) == 1
         # The KojiBuildChange message in further_work should have build_new_state
         # set to COMPLETE, but the current component build state in the DB should be set
         # to BUILDING, so KojiBuildChange message handler handles the change
         # properly.
-        self.assertEqual(further_work[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
+        assert further_work[0].build_new_state == koji.BUILD_STATES['COMPLETE']
         component_build = models.ComponentBuild.from_component_event(db.session, further_work[0])
-        self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
-        self.assertEqual(component_build.package, 'perl-Tangerine')
-        self.assertIsNotNone(component_build.reused_component_id)
+        assert component_build.state == koji.BUILD_STATES['BUILDING']
+        assert component_build.package == 'perl-Tangerine'
+        assert component_build.reused_component_id is not None
         # Make sure perl-List-Compare is set to the build state as well but not reused
-        self.assertEqual(plc_component.state, koji.BUILD_STATES['BUILDING'])
-        self.assertIsNone(plc_component.reused_component_id)
+        assert plc_component.state == koji.BUILD_STATES['BUILDING']
+        assert plc_component.reused_component_id is None
         mock_sbc.assert_called_once()
         mock_sbc.reset_mock()
 
@@ -973,14 +964,14 @@ class TestBatches(unittest.TestCase):
         further_work = module_build_service.utils.start_next_batch_build(
             conf, module_build, db.session, builder)
         # Batch number should increase
-        self.assertEqual(module_build.batch, 3)
+        assert module_build.batch == 3
         # Verify that tangerine was reused even though perl-Tangerine was rebuilt in the previous
         # batch
-        self.assertEqual(further_work[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
+        assert further_work[0].build_new_state == koji.BUILD_STATES['COMPLETE']
         component_build = models.ComponentBuild.from_component_event(db.session, further_work[0])
-        self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
-        self.assertEqual(component_build.package, 'tangerine')
-        self.assertIsNotNone(component_build.reused_component_id)
+        assert component_build.state == koji.BUILD_STATES['BUILDING']
+        assert component_build.package == 'tangerine'
+        assert component_build.reused_component_id is not None
         mock_sbc.assert_not_called()
 
     @patch('module_build_service.utils.start_build_component')
@@ -1008,18 +999,18 @@ class TestBatches(unittest.TestCase):
             conf, module_build, db.session, builder)
 
         # Batch number should increase.
-        self.assertEqual(module_build.batch, 2)
+        assert module_build.batch == 2
 
         # Make sure we don't have any messages returned since no components should be reused
-        self.assertEqual(len(further_work), 0)
+        assert len(further_work) == 0
         # Make sure both components are set to the build state but not reused
-        self.assertEqual(pt_component.state, koji.BUILD_STATES['BUILDING'])
-        self.assertIsNone(pt_component.reused_component_id)
-        self.assertEqual(plc_component.state, koji.BUILD_STATES['BUILDING'])
-        self.assertIsNone(plc_component.reused_component_id)
+        assert pt_component.state == koji.BUILD_STATES['BUILDING']
+        assert pt_component.reused_component_id is None
+        assert plc_component.state == koji.BUILD_STATES['BUILDING']
+        assert plc_component.reused_component_id is None
         # Test the order of the scheduling
         expected_calls = [mock.call(builder, plc_component), mock.call(builder, pt_component)]
-        self.assertEqual(mock_sbc.mock_calls, expected_calls)
+        assert mock_sbc.mock_calls == expected_calls
 
     @patch('module_build_service.utils.start_build_component')
     def test_start_next_batch_continue(self, mock_sbc, default_buildroot_groups):
@@ -1041,11 +1032,11 @@ class TestBatches(unittest.TestCase):
             conf, module_build, db.session, builder)
 
         # Batch number should not increase.
-        self.assertEqual(module_build.batch, 2)
+        assert module_build.batch == 2
         # Make sure start build was called for the second component which wasn't reused
         mock_sbc.assert_called_once()
         # No further work should be returned
-        self.assertEqual(len(further_work), 0)
+        assert len(further_work) == 0
 
     def test_start_next_batch_build_repo_building(self, default_buildroot_groups):
         """
@@ -1059,7 +1050,7 @@ class TestBatches(unittest.TestCase):
         builder.buildroot_ready.return_value = False
 
         # Batch number should not increase.
-        self.assertEqual(module_build.batch, 1)
+        assert module_build.batch == 1
 
 
 @patch("module_build_service.config.Config.mock_resultsdir",
@@ -1068,12 +1059,12 @@ class TestBatches(unittest.TestCase):
            BASE_DIR, '..', 'staged_data', "local_builds"))
 @patch("module_build_service.config.Config.system",
        new_callable=mock.PropertyMock, return_value="mock")
-class TestLocalBuilds(unittest.TestCase):
+class TestLocalBuilds:
 
-    def setUp(self):
+    def setup_method(self):
         init_data()
 
-    def tearDown(self):
+    def teardown_method(self):
         init_data()
 
     def test_load_local_builds_name(self, conf_system, conf_resultsdir):
@@ -1081,9 +1072,9 @@ class TestLocalBuilds(unittest.TestCase):
             module_build_service.utils.load_local_builds("testmodule")
             local_modules = models.ModuleBuild.local_modules(db.session)
 
-            self.assertEqual(len(local_modules), 1)
-            self.assertTrue(local_modules[0].koji_tag.endswith(
-                "/module-testmodule-master-20170816080816/results"))
+            assert len(local_modules) == 1
+            assert local_modules[0].koji_tag.endswith(
+                "/module-testmodule-master-20170816080816/results")
 
     def test_load_local_builds_name_stream(
             self, conf_system, conf_resultsdir):
@@ -1091,14 +1082,14 @@ class TestLocalBuilds(unittest.TestCase):
             module_build_service.utils.load_local_builds("testmodule:master")
             local_modules = models.ModuleBuild.local_modules(db.session)
 
-            self.assertEqual(len(local_modules), 1)
-            self.assertTrue(local_modules[0].koji_tag.endswith(
-                "/module-testmodule-master-20170816080816/results"))
+            assert len(local_modules) == 1
+            assert local_modules[0].koji_tag.endswith(
+                "/module-testmodule-master-20170816080816/results")
 
     def test_load_local_builds_name_stream_non_existing(
             self, conf_system, conf_resultsdir):
         with app.app_context():
-            with self.assertRaises(RuntimeError):
+            with pytest.raises(RuntimeError):
                 module_build_service.utils.load_local_builds("testmodule:x")
                 models.ModuleBuild.local_modules(db.session)
 
@@ -1108,14 +1099,14 @@ class TestLocalBuilds(unittest.TestCase):
             module_build_service.utils.load_local_builds("testmodule:master:20170816080815")
             local_modules = models.ModuleBuild.local_modules(db.session)
 
-            self.assertEqual(len(local_modules), 1)
-            self.assertTrue(local_modules[0].koji_tag.endswith(
-                "/module-testmodule-master-20170816080815/results"))
+            assert len(local_modules) == 1
+            assert local_modules[0].koji_tag.endswith(
+                "/module-testmodule-master-20170816080815/results")
 
     def test_load_local_builds_name_stream_version_non_existing(
             self, conf_system, conf_resultsdir):
         with app.app_context():
-            with self.assertRaises(RuntimeError):
+            with pytest.raises(RuntimeError):
                 module_build_service.utils.load_local_builds("testmodule:master:123")
                 models.ModuleBuild.local_modules(db.session)
 
@@ -1125,9 +1116,9 @@ class TestLocalBuilds(unittest.TestCase):
             module_build_service.utils.load_local_builds("base-runtime")
             local_modules = models.ModuleBuild.local_modules(db.session)
 
-            self.assertEqual(len(local_modules), 1)
-            self.assertTrue(local_modules[0].koji_tag.endswith(
-                "/module-base-runtime-master-20170816080815/results"))
+            assert len(local_modules) == 1
+            assert local_modules[0].koji_tag.endswith(
+                "/module-base-runtime-master-20170816080815/results")
 
     def test_load_local_builds_base_runtime_master(
             self, conf_system, conf_resultsdir):
@@ -1135,6 +1126,6 @@ class TestLocalBuilds(unittest.TestCase):
             module_build_service.utils.load_local_builds("base-runtime:master")
             local_modules = models.ModuleBuild.local_modules(db.session)
 
-            self.assertEqual(len(local_modules), 1)
-            self.assertTrue(local_modules[0].koji_tag.endswith(
-                "/module-base-runtime-master-20170816080815/results"))
+            assert len(local_modules) == 1
+            assert local_modules[0].koji_tag.endswith(
+                "/module-base-runtime-master-20170816080815/results")
diff --git a/tests/test_views/test_views.py b/tests/test_views/test_views.py
index 2e924a6b..759b3b52 100644
--- a/tests/test_views/test_views.py
+++ b/tests/test_views/test_views.py
@@ -18,9 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 #
-# Written by Matt Prahl <mprahl@redhat.com
+# Written by Matt Prahl <mprahl@redhat.com>
 
-import unittest
 import json
 import vcr
 
@@ -112,31 +111,32 @@ class FakeSCM(object):
         return path.join(self.sourcedir, self.name + ".yaml")
 
 
-class TestViews(unittest.TestCase):
-    maxDiff = None
-
-    def setUp(self):
+class TestViews:
+    def setup_method(self, test_method):
         self.client = app.test_client()
         init_data()
 
-        filename = cassette_dir + self.id()
-        self.vcr = vcr.use_cassette(filename)
+        filename = '.'.join([
+            path.splitext(path.basename(__file__))[0],
+            test_method.im_class.__name__,
+            test_method.im_func.__name__])
+        self.vcr = vcr.use_cassette(path.join(cassette_dir, filename))
         self.vcr.__enter__()
 
-    def tearDown(self):
+    def teardown_method(self, test_method):
         self.vcr.__exit__()
 
     def test_query_build(self):
         rv = self.client.get('/module-build-service/1/module-builds/1')
         data = json.loads(rv.data)
-        self.assertEquals(data['id'], 1)
-        self.assertEquals(data['context'], '00000000')
-        self.assertEquals(data['name'], 'nginx')
-        self.assertEquals(data['owner'], 'Moe Szyslak')
-        self.assertEquals(data['stream'], '1')
-        self.assertEquals(data['state'], 3)
-        self.assertEquals(data['state_reason'], None)
-        self.assertDictEqual(data['tasks'], {
+        assert data['id'] == 1
+        assert data['context'] == '00000000'
+        assert data['name'] == 'nginx'
+        assert data['owner'] == 'Moe Szyslak'
+        assert data['stream'] == '1'
+        assert data['state'] == 3
+        assert data['state_reason'] is None
+        assert data['tasks'] == {
             'rpms': {
                 'module-build-macros': {
                     'task_id': 12312321,
@@ -151,49 +151,48 @@ class TestViews(unittest.TestCase):
                     'nvr': 'nginx-1.10.1-2.module+1+b8661ee4',
                 },
             },
-        })
-        self.assertEquals(data['time_completed'], '2016-09-03T11:25:32Z')
-        self.assertEquals(data['time_modified'], '2016-09-03T11:25:32Z')
-        self.assertEquals(data['time_submitted'], '2016-09-03T11:23:20Z')
-        self.assertEqual(data['rebuild_strategy'], 'changed-and-after')
-        self.assertEquals(data['version'], '2')
+        }
+        assert data['time_completed'] == '2016-09-03T11:25:32Z'
+        assert data['time_modified'] == '2016-09-03T11:25:32Z'
+        assert data['time_submitted'] == '2016-09-03T11:23:20Z'
+        assert data['rebuild_strategy'] == 'changed-and-after'
+        assert data['version'] == '2'
 
     def test_query_build_short(self):
         rv = self.client.get('/module-build-service/1/module-builds/1?short=True')
         data = json.loads(rv.data)
-        self.assertEquals(data['id'], 1)
-        self.assertEquals(data['context'], '00000000')
-        self.assertEquals(data['name'], 'nginx')
-        self.assertEquals(data['state'], 3)
-        self.assertEquals(data['state_name'], 'done')
-        self.assertEquals(data['stream'], '1')
-        self.assertEquals(data['version'], '2')
+        assert data['id'] == 1
+        assert data['context'] == '00000000'
+        assert data['name'] == 'nginx'
+        assert data['state'] == 3
+        assert data['state_name'] == 'done'
+        assert data['stream'] == '1'
+        assert data['version'] == '2'
 
     def test_query_build_with_verbose_mode(self):
         rv = self.client.get('/module-build-service/1/module-builds/1?verbose=true')
         data = json.loads(rv.data)
-        self.assertEquals(data['component_builds'], [1, 2])
-        self.assertEquals(data['context'], '00000000')
+        assert data['component_builds'] == [1, 2]
+        assert data['context'] == '00000000'
         # There is no xmd information on this module, so these values should be null
-        self.assertIsNone(data['build_context'])
-        self.assertIsNone(data['runtime_context'])
-        self.assertEquals(data['id'], 1)
+        assert data['build_context'] is None
+        assert data['runtime_context'] is None
+        assert data['id'] == 1
         with open(path.join(base_dir, "staged_data", "nginx_mmd.yaml")) as mmd:
-            self.assertEquals(data['modulemd'], mmd.read())
-        self.assertEquals(data['name'], 'nginx')
-        self.assertEquals(data['owner'], 'Moe Szyslak')
-        self.assertEquals(data['scmurl'],
-                          ('git://pkgs.domain.local/modules/nginx'
-                           '?#ba95886c7a443b36a9ce31abda1f9bef22f2f8c9'))
-        self.assertEquals(data['state'], 3)
-        self.assertEquals(data['state_name'], 'done')
-        self.assertEquals(data['state_reason'], None)
+            assert data['modulemd'] == mmd.read()
+        assert data['name'] == 'nginx'
+        assert data['owner'] == 'Moe Szyslak'
+        assert data['scmurl'] == ('git://pkgs.domain.local/modules/nginx'
+                                  '?#ba95886c7a443b36a9ce31abda1f9bef22f2f8c9')
+        assert data['state'] == 3
+        assert data['state_name'] == 'done'
+        assert data['state_reason'] is None
         # State trace is empty because we directly created these builds and didn't have them
         # transition, which creates these entries
-        self.assertEquals(data['state_trace'], [])
-        self.assertEquals(data['state_url'], '/module-build-service/1/module-builds/1')
-        self.assertEquals(data['stream'], '1')
-        self.assertDictEqual(data['tasks'], {
+        assert data['state_trace'] == []
+        assert data['state_url'] == '/module-build-service/1/module-builds/1'
+        assert data['stream'] == '1'
+        assert data['tasks'] == {
             'rpms': {
                 'module-build-macros': {
                     'task_id': 12312321,
@@ -208,39 +207,35 @@ class TestViews(unittest.TestCase):
                     'nvr': 'nginx-1.10.1-2.module+1+b8661ee4',
                 },
             },
-        })
-        self.assertEquals(data['time_completed'], u'2016-09-03T11:25:32Z')
-        self.assertEquals(data['time_modified'], u'2016-09-03T11:25:32Z')
-        self.assertEquals(data['time_submitted'], u'2016-09-03T11:23:20Z')
-        self.assertEquals(data['version'], '2')
-        self.assertEqual(data['rebuild_strategy'], 'changed-and-after')
+        }
+        assert data['time_completed'] == u'2016-09-03T11:25:32Z'
+        assert data['time_modified'] == u'2016-09-03T11:25:32Z'
+        assert data['time_submitted'] == u'2016-09-03T11:23:20Z'
+        assert data['version'] == '2'
+        assert data['rebuild_strategy'] == 'changed-and-after'
 
     def test_pagination_metadata(self):
         rv = self.client.get('/module-build-service/1/module-builds/?per_page=8&page=2')
         meta_data = json.loads(rv.data)['meta']
-        self.assertIn(
-            meta_data['prev'].split('?', 1)[1], ['per_page=8&page=1', 'page=1&per_page=8'])
-        self.assertIn(
-            meta_data['next'].split('?', 1)[1], ['per_page=8&page=3', 'page=3&per_page=8'])
-        self.assertIn(
-            meta_data['last'].split('?', 1)[1], ['per_page=8&page=4', 'page=4&per_page=8'])
-        self.assertIn(
-            meta_data['first'].split('?', 1)[1], ['per_page=8&page=1', 'page=1&per_page=8'])
-        self.assertEquals(meta_data['total'], 30)
-        self.assertEquals(meta_data['per_page'], 8)
-        self.assertEquals(meta_data['pages'], 4)
-        self.assertEquals(meta_data['page'], 2)
+        assert meta_data['prev'].split('?', 1)[1] in ['per_page=8&page=1', 'page=1&per_page=8']
+        assert meta_data['next'].split('?', 1)[1] in ['per_page=8&page=3', 'page=3&per_page=8']
+        assert meta_data['last'].split('?', 1)[1] in ['per_page=8&page=4', 'page=4&per_page=8']
+        assert meta_data['first'].split('?', 1)[1] in ['per_page=8&page=1', 'page=1&per_page=8']
+        assert meta_data['total'] == 30
+        assert meta_data['per_page'] == 8
+        assert meta_data['pages'] == 4
+        assert meta_data['page'] == 2
 
     def test_pagination_metadata_with_args(self):
         rv = self.client.get('/module-build-service/1/module-builds/?per_page=8&page=2&order_by=id')
         meta_data = json.loads(rv.data)['meta']
         for link in [meta_data['prev'], meta_data['next'], meta_data['last'], meta_data['first']]:
-            self.assertIn('order_by=id', link)
-            self.assertIn('per_page=8', link)
-        self.assertEquals(meta_data['total'], 30)
-        self.assertEquals(meta_data['per_page'], 8)
-        self.assertEquals(meta_data['pages'], 4)
-        self.assertEquals(meta_data['page'], 2)
+            assert 'order_by=id' in link
+            assert 'per_page=8' in link
+        assert meta_data['total'] == 30
+        assert meta_data['per_page'] == 8
+        assert meta_data['pages'] == 4
+        assert meta_data['page'] == 2
 
     def test_query_builds(self):
         rv = self.client.get('/module-build-service/1/module-builds/?per_page=2')
@@ -315,7 +310,7 @@ class TestViews(unittest.TestCase):
                 'version': '2'
             }
         ]
-        self.assertEquals(items, expected)
+        assert items == expected
 
     def test_query_builds_with_id_error(self):
         rv = self.client.get('/module-build-service/1/module-builds/?id=1')
@@ -327,142 +322,140 @@ class TestViews(unittest.TestCase):
             'message': msg,
             "status": 400
         }
-        self.assertEqual(actual, expected)
+        assert actual == expected
 
     def test_query_component_build(self):
         rv = self.client.get('/module-build-service/1/component-builds/1')
         data = json.loads(rv.data)
-        self.assertEquals(data['id'], 1)
-        self.assertEquals(data['format'], 'rpms')
-        self.assertEquals(data['module_build'], 1)
-        self.assertEquals(data['package'], 'nginx')
-        self.assertEquals(data['state'], 1)
-        self.assertEquals(data['state_name'], 'COMPLETE')
-        self.assertEquals(data['state_reason'], None)
-        self.assertEquals(data['task_id'], 12312345)
+        assert data['id'] == 1
+        assert data['format'] == 'rpms'
+        assert data['module_build'] == 1
+        assert data['package'] == 'nginx'
+        assert data['state'] == 1
+        assert data['state_name'] == 'COMPLETE'
+        assert data['state_reason'] is None
+        assert data['task_id'] == 12312345
 
     def test_query_component_build_short(self):
         rv = self.client.get('/module-build-service/1/component-builds/1?short=True')
         data = json.loads(rv.data)
-        self.assertEquals(data['id'], 1)
-        self.assertEquals(data['format'], 'rpms')
-        self.assertEquals(data['module_build'], 1)
-        self.assertEquals(data['package'], 'nginx')
-        self.assertEquals(data['state'], 1)
-        self.assertEquals(data['state_name'], 'COMPLETE')
-        self.assertEquals(data['state_reason'], None)
-        self.assertEquals(data['task_id'], 12312345)
+        assert data['id'] == 1
+        assert data['format'] == 'rpms'
+        assert data['module_build'] == 1
+        assert data['package'] == 'nginx'
+        assert data['state'] == 1
+        assert data['state_name'] == 'COMPLETE'
+        assert data['state_reason'] is None
+        assert data['task_id'] == 12312345
 
     def test_query_component_build_verbose(self):
         rv = self.client.get('/module-build-service/1/component-builds/3?verbose=true')
         data = json.loads(rv.data)
-        self.assertEquals(data['id'], 3)
-        self.assertEquals(data['format'], 'rpms')
-        self.assertEquals(data['module_build'], 2)
-        self.assertEquals(data['package'], 'postgresql')
-        self.assertEquals(data['state'], 1)
-        self.assertEquals(data['state_name'], 'COMPLETE')
-        self.assertEquals(data['state_reason'], None)
-        self.assertEquals(data['task_id'], 2433433)
-        self.assertEquals(data['state_trace'][0]['reason'], None)
-        self.assertTrue(data['state_trace'][0]['time'] is not None)
-        self.assertEquals(data['state_trace'][0]['state'], 1)
-        self.assertEquals(data['state_trace'][0]['state_name'], 'wait')
-        self.assertEquals(data['state_url'], '/module-build-service/1/component-builds/3')
-
-    component_builds_filters = ['tagged', 'ref', 'format']
+        assert data['id'] == 3
+        assert data['format'] == 'rpms'
+        assert data['module_build'] == 2
+        assert data['package'] == 'postgresql'
+        assert data['state'] == 1
+        assert data['state_name'] == 'COMPLETE'
+        assert data['state_reason'] is None
+        assert data['task_id'] == 2433433
+        assert data['state_trace'][0]['reason'] is None
+        assert data['state_trace'][0]['time'] is not None
+        assert data['state_trace'][0]['state'] == 1
+        assert data['state_trace'][0]['state_name'] == 'wait'
+        assert data['state_url'], '/module-build-service/1/component-builds/3'
 
     def test_query_component_builds_filter_format(self):
         rv = self.client.get('/module-build-service/1/component-builds/'
                              '?format=rpms')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 60)
+        assert data['meta']['total'] == 60
 
     def test_query_component_builds_filter_ref(self):
         rv = self.client.get('/module-build-service/1/component-builds/'
                              '?ref=this-filter-query-should-return-zero-items')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 0)
+        assert data['meta']['total'] == 0
 
     def test_query_component_builds_filter_tagged(self):
         rv = self.client.get('/module-build-service/1/component-builds/?tagged=true')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 40)
+        assert data['meta']['total'] == 40
 
     def test_query_component_builds_filter_nvr(self):
         rv = self.client.get('/module-build-service/1/component-builds/?nvr=nginx-1.10.1-2.'
                              'module%2B1%2Bb8661ee4')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 1)
+        assert data['meta']['total'] == 1
 
     def test_query_component_builds_filter_task_id(self):
         rv = self.client.get('/module-build-service/1/component-builds/?task_id=12312346')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 1)
+        assert data['meta']['total'] == 1
 
     def test_query_builds_filter_name(self):
         rv = self.client.get('/module-build-service/1/module-builds/?name=nginx')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 10)
+        assert data['meta']['total'] == 10
 
     def test_query_builds_filter_koji_tag(self):
         rv = self.client.get('/module-build-service/1/module-builds/?koji_tag=module-nginx-1.2')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 10)
+        assert data['meta']['total'] == 10
 
     def test_query_builds_filter_completed_before(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?completed_before=2016-09-03T11:30:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 2)
+        assert data['meta']['total'] == 2
 
     def test_query_builds_filter_completed_after(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?completed_after=2016-09-03T12:25:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 8)
+        assert data['meta']['total'] == 8
 
     def test_query_builds_filter_submitted_before(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?submitted_before=2016-09-03T12:25:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 7)
+        assert data['meta']['total'] == 7
 
     def test_query_builds_filter_submitted_after(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?submitted_after=2016-09-03T12:25:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 23)
+        assert data['meta']['total'] == 23
 
     def test_query_builds_filter_modified_before(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?modified_before=2016-09-03T12:25:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 6)
+        assert data['meta']['total'] == 6
 
     def test_query_builds_filter_modified_after(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?modified_after=2016-09-03T12:25:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 24)
+        assert data['meta']['total'] == 24
 
     def test_query_builds_filter_owner(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?owner=Moe%20Szyslak')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 10)
+        assert data['meta']['total'] == 10
 
     def test_query_builds_filter_state(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?state=3')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 20)
+        assert data['meta']['total'] == 20
 
     def test_query_builds_two_filters(self):
         rv = self.client.get('/module-build-service/1/module-builds/?owner=Moe%20Szyslak'
                              '&modified_after=2016-09-03T12:25:00Z')
         data = json.loads(rv.data)
-        self.assertEquals(data['meta']['total'], 4)
+        assert data['meta']['total'] == 4
 
     def test_query_builds_filter_nsv(self):
         rv = self.client.get(
@@ -470,19 +463,19 @@ class TestViews(unittest.TestCase):
         data = json.loads(rv.data)
         # TODO: The nsv should really be unique in the test data
         for item in data['items']:
-            self.assertEqual(item['name'], 'postgressql')
-            self.assertEqual(item['stream'], '1')
-            self.assertEqual(item['version'], '2')
-        self.assertEquals(data['meta']['total'], 10)
+            assert item['name'] == 'postgressql'
+            assert item['stream'] == '1'
+            assert item['version'] == '2'
+        assert data['meta']['total'] == 10
 
     def test_query_builds_filter_invalid_date(self):
         rv = self.client.get(
             '/module-build-service/1/module-builds/?modified_after=2016-09-03T12:25:00-05:00')
         data = json.loads(rv.data)
-        self.assertEquals(data['error'], 'Bad Request')
-        self.assertEquals(data['message'], 'An invalid Zulu ISO 8601 timestamp'
-                          ' was provided for the \"modified_after\" parameter')
-        self.assertEquals(data['status'], 400)
+        assert data['error'] == 'Bad Request'
+        assert data['message'] == ('An invalid Zulu ISO 8601 timestamp was '
+                                   'provided for the \"modified_after\" parameter')
+        assert data['status'] == 400
 
     def test_query_builds_order_by(self):
         build = db.session.query(module_build_service.models.ModuleBuild).filter_by(id=2).one()
@@ -492,8 +485,8 @@ class TestViews(unittest.TestCase):
         rv = self.client.get('/module-build-service/1/module-builds/?'
                              'per_page=10&order_by=name')
         items = json.loads(rv.data)['items']
-        self.assertEqual(items[0]['name'], 'candy')
-        self.assertEqual(items[1]['name'], 'nginx')
+        assert items[0]['name'] == 'candy'
+        assert items[1]['name'] == 'nginx'
 
     def test_query_builds_order_desc_by(self):
         rv = self.client.get('/module-build-service/1/module-builds/?'
@@ -501,7 +494,7 @@ class TestViews(unittest.TestCase):
         items = json.loads(rv.data)['items']
         # Check that the id is items[0]["id"], items[0]["id"] - 1, ...
         for idx, item in enumerate(items):
-            self.assertEquals(item["id"], items[0]["id"] - idx)
+            assert item["id"] == items[0]["id"] - idx
 
     def test_query_builds_order_by_order_desc_by(self):
         """
@@ -513,17 +506,15 @@ class TestViews(unittest.TestCase):
         items = json.loads(rv.data)['items']
         # Check that the id is items[0]["id"], items[0]["id"] - 1, ...
         for idx, item in enumerate(items):
-            self.assertEquals(item["id"], items[0]["id"] - idx)
+            assert item["id"] == items[0]["id"] - idx
 
     def test_query_builds_order_by_wrong_key(self):
         rv = self.client.get('/module-build-service/1/module-builds/?'
                              'per_page=10&order_by=unknown')
         data = json.loads(rv.data)
-        self.assertEquals(data['status'], 400)
-        self.assertEquals(data['error'], 'Bad Request')
-        self.assertEquals(
-            data['message'], 'An invalid order_by or order_desc_by key '
-            'was supplied')
+        assert data['status'] == 400
+        assert data['error'] == 'Bad Request'
+        assert data['message'] == 'An invalid order_by or order_desc_by key was supplied'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -537,24 +528,23 @@ class TestViews(unittest.TestCase):
         data = json.loads(rv.data)
 
         assert 'component_builds' in data, data
-        self.assertEquals(data['component_builds'], [])
-        self.assertEquals(data['name'], 'testmodule')
-        self.assertEquals(data['scmurl'],
-                          ('git://pkgs.stg.fedoraproject.org/modules/testmodule'
-                          '.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'))
-        self.assertEquals(data['version'], '1')
-        self.assertTrue(data['time_submitted'] is not None)
-        self.assertTrue(data['time_modified'] is not None)
-        self.assertEquals(data['time_completed'], None)
-        self.assertEquals(data['stream'], 'master')
-        self.assertEquals(data['owner'], 'Homer J. Simpson')
-        self.assertEquals(data['id'], 31)
-        self.assertEquals(data['rebuild_strategy'], 'changed-and-after')
-        self.assertEquals(data['state_name'], 'init')
-        self.assertEquals(data['state_url'], '/module-build-service/1/module-builds/31')
-        self.assertEquals(len(data['state_trace']), 1)
-        self.assertEquals(data['state_trace'][0]['state'], 0)
-        self.assertDictEqual(data['tasks'], {})
+        assert data['component_builds'] == []
+        assert data['name'] == 'testmodule'
+        assert data['scmurl'] == ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git'
+                                  '?#68931c90de214d9d13feefbd35246a81b6cb8d49')
+        assert data['version'] == '1'
+        assert data['time_submitted'] is not None
+        assert data['time_modified'] is not None
+        assert data['time_completed'] is None
+        assert data['stream'] == 'master'
+        assert data['owner'] == 'Homer J. Simpson'
+        assert data['id'] == 31
+        assert data['rebuild_strategy'] == 'changed-and-after'
+        assert data['state_name'] == 'init'
+        assert data['state_url'] == '/module-build-service/1/module-builds/31'
+        assert len(data['state_trace']) == 1
+        assert data['state_trace'][0]['state'] == 0
+        assert data['tasks'] == {}
         mmd = _modulemd.ModuleMetadata()
         mmd.loads(data["modulemd"])
 
@@ -571,7 +561,7 @@ class TestViews(unittest.TestCase):
              'scmurl': ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git?'
                         '#68931c90de214d9d13feefbd35246a81b6cb8d49')}))
         data = json.loads(rv.data)
-        self.assertEquals(data['rebuild_strategy'], 'only-changed')
+        assert data['rebuild_strategy'] == 'only-changed'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -589,13 +579,13 @@ class TestViews(unittest.TestCase):
              'scmurl': ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git?'
                         '#68931c90de214d9d13feefbd35246a81b6cb8d49')}))
         data = json.loads(rv.data)
-        self.assertEqual(rv.status_code, 400)
+        assert rv.status_code == 400
         expected_error = {
             'error': 'Bad Request',
             'message': ('The rebuild method of "only-changed" is not allowed. Choose from: all.'),
             'status': 400
         }
-        self.assertEqual(data, expected_error)
+        assert data == expected_error
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -608,14 +598,14 @@ class TestViews(unittest.TestCase):
              'scmurl': ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git?'
                         '#68931c90de214d9d13feefbd35246a81b6cb8d49')}))
         data = json.loads(rv.data)
-        self.assertEqual(rv.status_code, 400)
+        assert rv.status_code == 400
         expected_error = {
             'error': 'Bad Request',
             'message': ('The request contains the "rebuild_strategy" parameter but overriding '
                         'the default isn\'t allowed'),
             'status': 400
         }
-        self.assertEqual(data, expected_error)
+        assert data == expected_error
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -628,20 +618,19 @@ class TestViews(unittest.TestCase):
                 'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['component_builds'], [])
-        self.assertEquals(data['name'], 'fakemodule')
-        self.assertEquals(data['scmurl'],
-                          ('git://pkgs.stg.fedoraproject.org/modules/testmodule'
-                          '.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'))
-        self.assertEquals(data['version'], '1')
-        self.assertTrue(data['time_submitted'] is not None)
-        self.assertTrue(data['time_modified'] is not None)
-        self.assertEquals(data['time_completed'], None)
-        self.assertEquals(data['stream'], 'master')
-        self.assertEquals(data['owner'], 'Homer J. Simpson')
-        self.assertEquals(data['id'], 31)
-        self.assertEquals(data['state_name'], 'init')
-        self.assertEquals(data['rebuild_strategy'], 'changed-and-after')
+        assert data['component_builds'] == []
+        assert data['name'] == 'fakemodule'
+        assert data['scmurl'] == ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git'
+                                  '?#68931c90de214d9d13feefbd35246a81b6cb8d49')
+        assert data['version'] == '1'
+        assert data['time_submitted'] is not None
+        assert data['time_modified'] is not None
+        assert data['time_completed'] is None
+        assert data['stream'] == 'master'
+        assert data['owner'] == 'Homer J. Simpson'
+        assert data['id'] == 31
+        assert data['state_name'] == 'init'
+        assert data['rebuild_strategy'] == 'changed-and-after'
 
     def test_submit_build_auth_error(self):
         base_dir = path.abspath(path.dirname(__file__))
@@ -651,22 +640,18 @@ class TestViews(unittest.TestCase):
                 {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                     'testmodule.git?#48931b90de214d9d13feefbd35246a81b6cb8d49'}))
             data = json.loads(rv.data)
-            self.assertEquals(
-                data['message'],
-                "No 'authorization' header found."
-            )
-            self.assertEquals(data['status'], 401)
-            self.assertEquals(data['error'], 'Unauthorized')
+            assert data['message'] == "No 'authorization' header found."
+            assert data['status'] == 401
+            assert data['error'] == 'Unauthorized'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     def test_submit_build_scm_url_error(self, mocked_get_user):
         rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
             {'branch': 'master', 'scmurl': 'git://badurl.com'}))
         data = json.loads(rv.data)
-        self.assertEquals(data['message'], 'The submitted scmurl '
-                          'git://badurl.com is not allowed')
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['message'] == 'The submitted scmurl git://badurl.com is not allowed'
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     def test_submit_build_scm_url_without_hash(self, mocked_get_user):
@@ -674,11 +659,10 @@ class TestViews(unittest.TestCase):
             {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                 'testmodule.git'}))
         data = json.loads(rv.data)
-        self.assertEquals(data['message'], 'The submitted scmurl '
-                          'git://pkgs.stg.fedoraproject.org/modules/testmodule.git '
-                          'is not valid')
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['message'] == ('The submitted scmurl git://pkgs.stg.fedoraproject.org'
+                                   '/modules/testmodule.git is not valid')
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -689,9 +673,9 @@ class TestViews(unittest.TestCase):
             {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                 'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
         data = json.loads(rv.data)
-        self.assertTrue(data['message'].startswith('Invalid modulemd:'))
-        self.assertEquals(data['status'], 422)
-        self.assertEquals(data['error'], 'Unprocessable Entity')
+        assert data['message'].startswith('Invalid modulemd:') is True
+        assert data['status'] == 422
+        assert data['error'] == 'Unprocessable Entity'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -704,8 +688,8 @@ class TestViews(unittest.TestCase):
                 'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=other_user)
     def test_cancel_build(self, mocked_get_user):
@@ -713,8 +697,8 @@ class TestViews(unittest.TestCase):
                                data=json.dumps({'state': 'failed'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['state'], 4)
-        self.assertEquals(data['state_reason'], 'Canceled by some_other_user.')
+        assert data['state'] == 4
+        assert data['state_reason'] == 'Canceled by some_other_user.'
 
     @patch('module_build_service.auth.get_user', return_value=other_user)
     def test_cancel_build_already_failed(self, mocked_get_user):
@@ -726,8 +710,8 @@ class TestViews(unittest.TestCase):
                                data=json.dumps({'state': 'failed'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=('sammy', set()))
     def test_cancel_build_unauthorized_no_groups(self, mocked_get_user):
@@ -735,8 +719,8 @@ class TestViews(unittest.TestCase):
                                data=json.dumps({'state': 'failed'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=('sammy', set(["packager"])))
     def test_cancel_build_unauthorized_not_owner(self, mocked_get_user):
@@ -744,8 +728,8 @@ class TestViews(unittest.TestCase):
                                data=json.dumps({'state': 'failed'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user',
            return_value=('sammy', set(["packager", "mbs-admin"])))
@@ -756,8 +740,8 @@ class TestViews(unittest.TestCase):
                                    data=json.dumps({'state': 'failed'}))
             data = json.loads(rv.data)
 
-            self.assertEquals(data['state'], 4)
-            self.assertEquals(data['state_reason'], 'Canceled by sammy.')
+            assert data['state'] == 4
+            assert data['state_reason'] == 'Canceled by sammy.'
 
     @patch('module_build_service.auth.get_user',
            return_value=('sammy', set(["packager"])))
@@ -768,8 +752,8 @@ class TestViews(unittest.TestCase):
                                    data=json.dumps({'state': 'failed'}))
             data = json.loads(rv.data)
 
-            self.assertEquals(data['status'], 403)
-            self.assertEquals(data['error'], 'Forbidden')
+            assert data['status'] == 403
+            assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=other_user)
     def test_cancel_build_wrong_param(self, mocked_get_user):
@@ -777,10 +761,9 @@ class TestViews(unittest.TestCase):
                                data=json.dumps({'some_param': 'value'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['status'], 400)
-        self.assertEquals(data['error'], 'Bad Request')
-        self.assertEquals(
-            data['message'], 'Invalid JSON submitted')
+        assert data['status'] == 400
+        assert data['error'] == 'Bad Request'
+        assert data['message'] == 'Invalid JSON submitted'
 
     @patch('module_build_service.auth.get_user', return_value=other_user)
     def test_cancel_build_wrong_state(self, mocked_get_user):
@@ -788,10 +771,9 @@ class TestViews(unittest.TestCase):
                                data=json.dumps({'state': 'some_state'}))
         data = json.loads(rv.data)
 
-        self.assertEquals(data['status'], 400)
-        self.assertEquals(data['error'], 'Bad Request')
-        self.assertEquals(
-            data['message'], 'The provided state change is not supported')
+        assert data['status'] == 400
+        assert data['error'] == 'Bad Request'
+        assert data['message'] == 'The provided state change is not supported'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     def test_submit_build_unsupported_scm_scheme(self, mocked_get_user):
@@ -800,14 +782,10 @@ class TestViews(unittest.TestCase):
         rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
             {'branch': 'master', 'scmurl': scmurl}))
         data = json.loads(rv.data)
-        self.assertIn(
-            data['message'], (
-                "The submitted scmurl {} is not allowed".format(scmurl),
-                "The submitted scmurl {} is not valid".format(scmurl),
-            )
-        )
-        self.assertEquals(data['status'], 403)
-        self.assertEquals(data['error'], 'Forbidden')
+        assert data['message'] in ("The submitted scmurl {} is not allowed".format(scmurl),
+                                   "The submitted scmurl {} is not valid".format(scmurl))
+        assert data['status'] == 403
+        assert data['error'] == 'Forbidden'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -819,13 +797,11 @@ class TestViews(unittest.TestCase):
             {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                 'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
         data = json.loads(rv.data)
-        self.assertEquals(data['status'], 400)
-        self.assertEquals(
-            data['message'],
-            'The version "123456789" is already defined in the modulemd but '
-            'it shouldn\'t be since the version is generated based on the '
-            'commit time')
-        self.assertEquals(data['error'], 'Bad Request')
+        assert data['status'] == 400
+        assert data['message'] == ('The version "123456789" is already defined in the modulemd '
+                                   'but it shouldn\'t be since the version is generated based on '
+                                   'the commit time')
+        assert data['error'] == 'Bad Request'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -837,12 +813,10 @@ class TestViews(unittest.TestCase):
             {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                 'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
         data = json.loads(rv.data)
-        self.assertEquals(data['status'], 400)
-        self.assertEquals(
-            data['message'],
-            'The stream "wrong_stream" that is stored in the modulemd does not '
-            'match the branch "master"')
-        self.assertEquals(data['error'], 'Bad Request')
+        assert data['status'] == 400
+        assert data['message'] == ('The stream "wrong_stream" that is stored in the modulemd '
+                                   'does not match the branch "master"')
+        assert data['error'] == 'Bad Request'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     def test_submit_build_set_owner(self, mocked_get_user):
@@ -854,8 +828,8 @@ class TestViews(unittest.TestCase):
         }
         rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(data))
         result = json.loads(rv.data)
-        self.assertEquals(result['status'], 400)
-        self.assertIn("The request contains 'owner' parameter", result['message'])
+        assert result['status'] == 400
+        assert "The request contains 'owner' parameter" in result['message']
 
     @patch('module_build_service.auth.get_user', return_value=anonymous_user)
     @patch('module_build_service.scm.SCM')
@@ -875,7 +849,7 @@ class TestViews(unittest.TestCase):
         result = json.loads(rv.data)
 
         build = ModuleBuild.query.filter(ModuleBuild.id == result['id']).one()
-        self.assertTrue(build.owner == result['owner'] == 'foo')
+        assert (build.owner == result['owner'] == 'foo') is True
 
     @patch('module_build_service.auth.get_user', return_value=anonymous_user)
     @patch('module_build_service.scm.SCM')
@@ -896,15 +870,15 @@ class TestViews(unittest.TestCase):
 
         url = '/module-build-service/1/module-builds/' + str(r1['id'])
         r2 = self.client.patch(url, data=json.dumps({'state': 'failed'}))
-        self.assertEquals(r2.status_code, 403)
+        assert r2.status_code == 403
 
         r3 = self.client.patch(url, data=json.dumps({'state': 'failed', 'owner': 'foo'}))
-        self.assertEquals(r3.status_code, 200)
+        assert r3.status_code == 200
 
         mocked_no_auth.return_value = False
         r3 = self.client.patch(url, data=json.dumps({'state': 'failed', 'owner': 'foo'}))
-        self.assertEquals(r3.status_code, 400)
-        self.assertIn("The request contains 'owner' parameter", json.loads(r3.data)['message'])
+        assert r3.status_code == 400
+        assert "The request contains 'owner' parameter" in json.loads(r3.data)['message']
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -916,12 +890,10 @@ class TestViews(unittest.TestCase):
             {'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
                 'testmodule.git?#7035bd33614972ac66559ac1fdd019ff6027ad22'}))
         data = json.loads(rv.data)
-        self.assertIn("The requested commit hash was not found within the repository.",
-                      data['message'])
-        self.assertIn("Perhaps you forgot to push. The original message was: ",
-                      data['message'])
-        self.assertEquals(data['status'], 422)
-        self.assertEquals(data['error'], 'Unprocessable Entity')
+        assert "The requested commit hash was not found within the repository." in data['message']
+        assert "Perhaps you forgot to push. The original message was: " in data['message']
+        assert data['status'] == 422
+        assert data['error'] == 'Unprocessable Entity'
 
     @patch('module_build_service.auth.get_user', return_value=user)
     @patch('module_build_service.scm.SCM')
@@ -937,26 +909,26 @@ class TestViews(unittest.TestCase):
         allow_custom_scmurls.return_value = False
         res1 = submit('git://some.custom.url.org/modules/testmodule.git?#68931c9')
         data = json.loads(res1.data)
-        self.assertEquals(data['status'], 403)
-        self.assertTrue(data['message'].startswith('The submitted scmurl'))
-        self.assertTrue(data['message'].endswith('is not allowed'))
+        assert data['status'] == 403
+        assert data['message'].startswith('The submitted scmurl') is True
+        assert data['message'].endswith('is not allowed') is True
 
         allow_custom_scmurls.return_value = True
         res2 = submit('git://some.custom.url.org/modules/testmodule.git?#68931c9')
-        self.assertEquals(res2.status_code, 201)
+        assert res2.status_code == 201
 
     def test_about(self):
         with patch.object(mbs_config.Config, 'auth_method', new_callable=PropertyMock) as auth:
             auth.return_value = 'kerberos'
             rv = self.client.get('/module-build-service/1/about/')
         data = json.loads(rv.data)
-        self.assertEqual(rv.status_code, 200)
-        self.assertEquals(data, {'auth_method': 'kerberos', 'version': version})
+        assert rv.status_code == 200
+        assert data == {'auth_method': 'kerberos', 'version': version}
 
     def test_rebuild_strategy_api(self):
         rv = self.client.get('/module-build-service/1/rebuild-strategies/')
         data = json.loads(rv.data)
-        self.assertEqual(rv.status_code, 200)
+        assert rv.status_code == 200
         expected = {
             'items': [
                 {
@@ -980,14 +952,14 @@ class TestViews(unittest.TestCase):
                 }
             ]
         }
-        self.assertEquals(data, expected)
+        assert data == expected
 
     def test_rebuild_strategy_api_only_changed_default(self):
         with patch.object(mbs_config.Config, 'rebuild_strategy', new_callable=PropertyMock) as r_s:
             r_s.return_value = 'only-changed'
             rv = self.client.get('/module-build-service/1/rebuild-strategies/')
         data = json.loads(rv.data)
-        self.assertEqual(rv.status_code, 200)
+        assert rv.status_code == 200
         expected = {
             'items': [
                 {
@@ -1011,7 +983,7 @@ class TestViews(unittest.TestCase):
                 }
             ]
         }
-        self.assertEquals(data, expected)
+        assert data == expected
 
     def test_rebuild_strategy_api_override_allowed(self):
         with patch.object(mbs_config.Config, 'rebuild_strategy_allow_override',
@@ -1019,7 +991,7 @@ class TestViews(unittest.TestCase):
             rsao.return_value = True
             rv = self.client.get('/module-build-service/1/rebuild-strategies/')
         data = json.loads(rv.data)
-        self.assertEqual(rv.status_code, 200)
+        assert rv.status_code == 200
         expected = {
             'items': [
                 {
@@ -1043,8 +1015,8 @@ class TestViews(unittest.TestCase):
                 }
             ]
         }
-        self.assertEquals(data, expected)
+        assert data == expected
 
     def test_cors_header_decorator(self):
         rv = self.client.get('/module-build-service/1/module-builds/')
-        self.assertEquals(rv.headers['Access-Control-Allow-Origin'], '*')
+        assert rv.headers['Access-Control-Allow-Origin'] == '*'