diff --git a/requirements-test.txt b/requirements-test.txt
index beeb8e9..5fc11d5 100644
--- a/requirements-test.txt
+++ b/requirements-test.txt
@@ -4,6 +4,7 @@ mock==1.3.0
 pytest==3.0.1
 pytest-pep8==1.0.5
 pytest-cov==2.2.1
+pytest-mock==1.5.0
 cov-core==1.15.0
 unittest2==1.1.0; python_version < '2.7'
 bandit
diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/test/test_app.py b/test/test_app.py
index c25399e..2fb3606 100644
--- a/test/test_app.py
+++ b/test/test_app.py
@@ -1,19 +1,8 @@
-import os
-from puppetboard import app
-import unittest
+import pytest
 import tempfile
 
-
-class AppTestCase(unittest.TestCase):
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-    def test_first_test(self):
-        self.assertTrue(True)
+from puppetboard import app
 
 
-if __name__ == '__main__':
-    unittest.main()
+def test_first_test():
+    assert app is not None, ("%s" % reg.app)
diff --git a/test/test_docker_settings.py b/test/test_docker_settings.py
index b9dbb61..e9db63e 100644
--- a/test/test_docker_settings.py
+++ b/test/test_docker_settings.py
@@ -1,7 +1,7 @@
+import pytest
 import os
 from puppetboard import docker_settings
-import unittest
-import tempfile
+
 try:
     import future.utils
 except:
@@ -13,80 +13,87 @@ except:
     pass
 
 
-class DockerTestCase(unittest.TestCase):
-    def setUp(self):
-        for env_var in dir(docker_settings):
-            if (env_var.startswith('__') or env_var.startswith('_') or
-                    env_var.islower()):
-                continue
+@pytest.fixture(scope='function')
+def cleanUpEnv(request):
+    for env_var in dir(docker_settings):
+        if (env_var.startswith('__') or env_var.startswith('_') or
+                env_var.islower()):
+            continue
 
-            if env_var in os.environ:
-                del os.environ[env_var]
-        reload(docker_settings)
-
-    def test_default_host_port(self):
-        self.assertEqual(docker_settings.PUPPETDB_HOST, 'puppetdb')
-        self.assertEqual(docker_settings.PUPPETDB_PORT, 8080)
-
-    def test_set_host_port(self):
-        os.environ['PUPPETDB_HOST'] = 'puppetdb'
-        os.environ['PUPPETDB_PORT'] = '9081'
-        reload(docker_settings)
-        self.assertEqual(docker_settings.PUPPETDB_HOST, 'puppetdb')
-        self.assertEqual(docker_settings.PUPPETDB_PORT, 9081)
-
-    def test_cert_true_test(self):
-        os.environ['PUPPETDB_SSL_VERIFY'] = 'True'
-        reload(docker_settings)
-        self.assertTrue(docker_settings.PUPPETDB_SSL_VERIFY)
-        os.environ['PUPPETDB_SSL_VERIFY'] = 'true'
-        reload(docker_settings)
-        self.assertTrue(docker_settings.PUPPETDB_SSL_VERIFY)
-
-    def test_cert_false_test(self):
-        os.environ['PUPPETDB_SSL_VERIFY'] = 'False'
-        reload(docker_settings)
-        self.assertFalse(docker_settings.PUPPETDB_SSL_VERIFY)
-        os.environ['PUPPETDB_SSL_VERIFY'] = 'false'
-        reload(docker_settings)
-        self.assertFalse(docker_settings.PUPPETDB_SSL_VERIFY)
-
-    def test_cert_path(self):
-        ca_file = '/usr/ssl/path/ca.pem'
-        os.environ['PUPPETDB_SSL_VERIFY'] = ca_file
-        reload(docker_settings)
-        self.assertEqual(docker_settings.PUPPETDB_SSL_VERIFY, ca_file)
-
-    def validate_facts(self, facts):
-        self.assertEqual(type(facts), type([]))
-        self.assertTrue(len(facts) > 0)
-        for map in facts:
-            self.assertEqual(type(map), type(()))
-            self.assertTrue(len(map) == 2)
-
-    def test_inventory_facts_default(self):
-        self.validate_facts(docker_settings.INVENTORY_FACTS)
-
-    def test_invtory_facts_custom(self):
-        os.environ['INVENTORY_FACTS'] = "A, B, C, D"
-        reload(docker_settings)
-        self.validate_facts(docker_settings.INVENTORY_FACTS)
-
-    def test_graph_facts_defautl(self):
-        facts = docker_settings.GRAPH_FACTS
-        self.assertEqual(type(facts), type([]))
-        self.assertTrue('puppetversion' in facts)
-
-    def test_graph_facts_custom(self):
-        os.environ['GRAPH_FACTS'] = "architecture, puppetversion, extra"
-        reload(docker_settings)
-        facts = docker_settings.GRAPH_FACTS
-        self.assertEqual(type(facts), type([]))
-        self.assertEqual(len(facts), 3)
-        self.assertTrue('puppetversion' in facts)
-        self.assertTrue('architecture' in facts)
-        self.assertTrue('extra' in facts)
+        if env_var in os.environ:
+            del os.environ[env_var]
+    reload(docker_settings)
+    return
 
 
-if __name__ == '__main__':
-    unittest.main()
+def test_default_host_port(cleanUpEnv):
+    assert docker_settings.PUPPETDB_HOST == 'puppetdb'
+    assert docker_settings.PUPPETDB_PORT == 8080
+
+
+def test_set_host_port(cleanUpEnv):
+    os.environ['PUPPETDB_HOST'] = 'puppetdb2'
+    os.environ['PUPPETDB_PORT'] = '9081'
+    reload(docker_settings)
+    assert docker_settings.PUPPETDB_HOST == 'puppetdb2'
+    assert docker_settings.PUPPETDB_PORT == 9081
+
+
+def test_cert_true_test(cleanUpEnv):
+    os.environ['PUPPETDB_SSL_VERIFY'] = 'True'
+    reload(docker_settings)
+    assert docker_settings.PUPPETDB_SSL_VERIFY is True
+    os.environ['PUPPETDB_SSL_VERIFY'] = 'true'
+    reload(docker_settings)
+    assert docker_settings.PUPPETDB_SSL_VERIFY is True
+
+
+def test_cert_false_test(cleanUpEnv):
+    os.environ['PUPPETDB_SSL_VERIFY'] = 'False'
+    reload(docker_settings)
+    assert docker_settings.PUPPETDB_SSL_VERIFY is False
+    os.environ['PUPPETDB_SSL_VERIFY'] = 'false'
+    reload(docker_settings)
+    assert docker_settings.PUPPETDB_SSL_VERIFY is False
+
+
+def test_cert_path(cleanUpEnv):
+    ca_file = '/usr/ssl/path/ca.pem'
+    os.environ['PUPPETDB_SSL_VERIFY'] = ca_file
+    reload(docker_settings)
+    assert docker_settings.PUPPETDB_SSL_VERIFY == ca_file
+
+
+def validate_facts(facts):
+    assert isinstance(facts, list)
+    assert len(facts) > 0
+    for map in facts:
+        assert isinstance(map, tuple)
+        assert len(map) == 2
+
+
+def test_inventory_facts_default(cleanUpEnv):
+    validate_facts(docker_settings.INVENTORY_FACTS)
+
+
+def test_invtory_facts_custom(cleanUpEnv):
+    os.environ['INVENTORY_FACTS'] = "A, B, C, D"
+    reload(docker_settings)
+    validate_facts(docker_settings.INVENTORY_FACTS)
+
+
+def test_graph_facts_defautl(cleanUpEnv):
+    facts = docker_settings.GRAPH_FACTS
+    assert isinstance(facts, list)
+    assert 'puppetversion' in facts
+
+
+def test_graph_facts_custom(cleanUpEnv):
+    os.environ['GRAPH_FACTS'] = "architecture, puppetversion, extra"
+    reload(docker_settings)
+    facts = docker_settings.GRAPH_FACTS
+    assert isinstance(facts, list)
+    assert len(facts) == 3
+    assert 'puppetversion' in facts
+    assert 'architecture' in facts
+    assert 'extra' in facts
diff --git a/test/test_utils.py b/test/test_utils.py
index 7a82f48..2db74c2 100644
--- a/test/test_utils.py
+++ b/test/test_utils.py
@@ -1,8 +1,4 @@
-try:
-    import unittest2 as unittest
-except ImportError:
-    import unittest
-
+import pytest
 import sys
 import json
 import mock
@@ -22,137 +18,130 @@ from puppetboard.app import NoContent
 import logging
 
 
-class UtilsTestCase(unittest.TestCase):
-    def setUp(self):
-        pass
+def test_json_format():
+    demo = [{'foo': 'bar'}, {'bar': 'foo'}]
+    sample = json.dumps(demo, indent=2, separators=(',', ': '))
 
-    def teadDown(self):
-        pass
-
-    def test_json_format(self):
-        demo = [{'foo': 'bar'}, {'bar': 'foo'}]
-        sample = json.dumps(demo, indent=2, separators=(',', ': '))
-
-        self.assertEqual(sample, utils.jsonprint(demo),
-                         "Json formatting has changed")
-
-    def test_format_val_str(self):
-        x = "some string"
-        self.assertEqual(x, utils.formatvalue(x),
-                         "Should return same value")
-
-    def test_format_val_array(self):
-        x = ['a', 'b', 'c']
-        self.assertEqual("a, b, c", utils.formatvalue(x),
-                         "Should return comma seperated string")
-
-    def test_format_val_dict_one_layer(self):
-        x = {'a': 'b'}
-        self.assertEqual("a => b,<br/>", utils.formatvalue(x),
-                         "Should return stringified value")
-
-    def test_format_val_tuple(self):
-        x = ('a', 'b')
-        self.assertEqual(str(x), utils.formatvalue(x))
+    assert sample == utils.jsonprint(demo), "Json formatting has changed"
 
 
-@mock.patch('logging.log')
-class GetOrAbortTesting(unittest.TestCase):
-
-    def test_get(self, mock_log):
-        x = "hello world"
-
-        def test_get_or_abort():
-            return x
-
-        self.assertEqual(x, utils.get_or_abort(test_get_or_abort))
-
-    def test_http_error(self, mock_log):
-        err = "NotFound"
-
-        def raise_http_error():
-            x = Response()
-            x.status_code = 404
-            x.reason = err
-            raise HTTPError(err, response=x)
-
-        with self.assertRaises(NotFound) as error:
-            utils.get_or_abort(raise_http_error)
-            mock_log.error.assert_called_with(err)
-
-    def test_http_connection_error(self, mock_log):
-        err = "ConnectionError"
-
-        def connection_error():
-            x = Response()
-            x.status_code = 500
-            x.reason = err
-            raise ConnectionError(err, response=x)
-
-        with self.assertRaises(InternalServerError) as error:
-            utils.get_or_abort(connection_error)
-            mock_log.error.assert_called_with(err)
-
-    @mock.patch('flask.abort')
-    def test_http_empty(self, mock_log, flask_abort):
-        err = "Empty Response"
-
-        def connection_error():
-            raise EmptyResponseError(err)
-
-        with self.assertRaises(NoContent) as error:
-            utils.get_or_abort(connection_error)
-            mock_log.error.assert_called_with(err)
-            flask_abort.assert_called_with('204')
+def test_format_val_str():
+    x = "some string"
+    assert x == utils.formatvalue(x), "Should return same value"
 
 
-class yieldOrStop(unittest.TestCase):
-
-    def test_iter(self):
-        test_list = (0, 1, 2, 3)
-
-        def my_generator():
-            for i in test_list:
-                yield i
-
-        gen = utils.yield_or_stop(my_generator())
-        self.assertIsInstance(gen, GeneratorType)
-
-        i = 0
-        for val in gen:
-            self.assertEqual(i, val)
-            i = i + 1
-
-    def test_stop_empty(self):
-        def my_generator():
-            yield 1
-            raise EmptyResponseError
-            yield 2
-
-        gen = utils.yield_or_stop(my_generator())
-        for val in gen:
-            self.assertEqual(1, val)
-
-    def test_stop_conn_error(self):
-        def my_generator():
-            yield 1
-            raise ConnectionError
-            yield 2
-
-        gen = utils.yield_or_stop(my_generator())
-        for val in gen:
-            self.assertEqual(1, val)
-
-    def test_stop_http_error(self):
-        def my_generator():
-            yield 1
-            raise HTTPError
-            yield 2
-
-        gen = utils.yield_or_stop(my_generator())
-        for val in gen:
-            self.assertEqual(1, val)
+def test_format_val_array():
+    x = ['a', 'b', 'c']
+    assert "a, b, c" == utils.formatvalue(x)
 
 
-if __name__ == '__main__':
-    unittest.main()
+def test_format_val_dict_one_layer():
+    x = {'a': 'b'}
+    assert "a => b,<br/>" == utils.formatvalue(x)
+
+
+def test_format_val_tuple():
+    x = ('a', 'b')
+    assert str(x) == utils.formatvalue(x)
+
+
+def test_get():
+    x = "hello world"
+
+    def test_get_or_abort():
+        return x
+
+    assert x == utils.get_or_abort(test_get_or_abort)
+
+
+@pytest.fixture
+def mock_log(mocker):
+    return mocker.patch('logging.log')
+
+
+def test_http_error(mock_log):
+    err = "NotFound"
+
+    def raise_http_error():
+        x = Response()
+        x.status_code = 404
+        x.reason = err
+        raise HTTPError(err, response=x)
+
+    with pytest.raises(NotFound):
+        utils.get_or_abort(raise_http_error)
+        mock_log.error.assert_called_once_with(err)
+
+
+def test_http_connection_error(mock_log):
+    err = "ConnectionError"
+
+    def connection_error():
+        x = Response()
+        x.status_code = 500
+        x.reason = err
+        raise ConnectionError(err, response=x)
+
+    with pytest.raises(InternalServerError):
+        utils.get_or_abort(connection_error)
+        mock_log.error.assert_called_with(err)
+
+
+def test_http_empty(mock_log, mocker):
+    err = "Empty Response"
+
+    def connection_error():
+        raise EmptyResponseError(err)
+
+    flask_abort = mocker.patch('flask.abort')
+    with pytest.raises(NoContent):
+        utils.get_or_abort(connection_error)
+        mock_log.error.assert_called_with(err)
+        flask_abort.assert_called_with('204')
+
+
+def test_iter():
+    test_list = (0, 1, 2, 3)
+
+    def my_generator():
+        for i in test_list:
+            yield i
+
+    gen = utils.yield_or_stop(my_generator())
+    assert isinstance(gen, GeneratorType)
+
+    i = 0
+    for val in gen:
+        assert i == val
+        i = i + 1
+
+
+def test_stop_empty():
+    def my_generator():
+        yield 1
+        raise EmptyResponseError
+        yield 2
+
+    gen = utils.yield_or_stop(my_generator())
+    for val in gen:
+        assert 1 == val
+
+
+def test_stop_conn_error():
+    def my_generator():
+        yield 1
+        raise ConnectionError
+        yield 2
+    gen = utils.yield_or_stop(my_generator())
+    for val in gen:
+        assert 1 == val
+
+
+def test_stop_http_error():
+    def my_generator():
+        yield 1
+        raise HTTPError
+        yield 2
+    gen = utils.yield_or_stop(my_generator())
+    for val in gen:
+        assert 1 == val