Merge ~woutervb/snapstore-client:move_to_pytest into snapstore-client:master

[Wouter van Bommel]

Convert the testing to pytest

This will simplify changes in the future and resulted in a big cleanup.
The test_cli.py has been removed, as the cli will be replaced by click and has to be done completely.

Convert the testing to pytest

This will simplify changes in the future and resulted in a big cleanup.
The test_cli.py has been removed, as the cli will be replaced by click and has to be done completely.

[Maximiliano Bertacchini (maxiberta)]

Looks great to me, thanks. But, I think it'd be wise to announce this migration publicly to the team, given the relative backlash in December's monthly meeting. That said, I'm +1! But please first check comments below.

[Wouter van Bommel (woutervb)]

Thanks for the feedback, will work on the comments.
Won't hide it for broader public, but it at least made me realize that we need some kind of styleguide on how / where to define fixtures

[Jonathan Hartley (tartley)]

review: Approve

[Jonathan Hartley (tartley)]

Bravely fought, tackling this churn!

I have one minor superficial FYI in the diffs, and one here. Ignore them if they are not today's problem:

Just FYI, when I run these test on a focal lxc, I get deprecation warnings from the use of 'responses' in test_login.py. I don't think this is due to your edits, but thought I'd mention it just in case you weren't aware and wanted to know:

=============================== warnings summary ===============================
snapstore_client/logic/tests/test_login.py: 16 warnings
  /home/jhartley/src/snapstore-client/env/lib/python3.8/site-packages/responses/__init__.py:334: DeprecationWarning: Argument 'match_querystring' is deprecated. Use 'responses.matchers.query_param_matcher' or 'responses.matchers.query_string_matcher'
    warn(

-- Docs: https://docs.pytest.org/en/stable/warnings.html

review: Approve

[Jonathan Hartley (tartley)]

Another thought...

[Maximiliano Bertacchini (maxiberta)]

+1 awesome. Check a couple of non-blocking comments below. Thanks!

review: Approve

[Wouter van Bommel (woutervb)]

Thanks for the responses, will update (most) things you both found.

diff --git a/Makefile b/Makefile
index 76ddd0a..be1be80 100644
--- a/Makefile
+++ b/Makefile
@@ -28,7 +28,7 @@ snap:
 	snapcraft
 
 test: $(ENV)/dev
-	$(PYTHON3) -m unittest $(TESTS) 2>&1
+	$(PYTHON3) -m pytest
 	$(MAKE) --silent lint
 
 /snap/bin/documentation-builder:
@@ -39,7 +39,7 @@ docs: /snap/bin/documentation-builder
 
 
 lint: $(ENV)/dev
-	$(FLAKE8) $(SERVICE_PACKAGE)
+	$(FLAKE8) $(SERVICE_PACKAGE) conftest.py
 	$(BLACK) --check .
 
 black: $(ENV)/dev
@@ -47,8 +47,9 @@ black: $(ENV)/dev
 
 coverage: $(ENV)/dev
 	$(PYTHON3) -m coverage erase
-	$(PYTHON3) -m coverage run --include "$(SERVICE_PACKAGE)*" -m unittest $(TESTS)
+	$(PYTHON3) -m coverage run --include "$(SERVICE_PACKAGE)*" -m pytest
 	$(PYTHON3) -m coverage html
+	$(PYTHON3) -m coverage report
 
 clean:
 	rm -rf $(TMPDIR)
diff --git a/conftest.py b/conftest.py
new file mode 100644
index 0000000..06c7ca0
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,70 @@
+import os.path
+import tempfile
+from unittest import mock
+from unittest.mock import patch
+
+from pymacaroons import Macaroon
+import pytest
+
+from snapstore_client.config import Config
+
+
[e-mail](scope="function")
+def ftmpdir(tmpdir):
+    """Takes the tmpdir, but add a random path per function invocation"""
+    with tempfile.TemporaryDirectory(dir=tmpdir) as new_tmpdir:
+        yield new_tmpdir
+
+
[e-mail]
+def mocked_xdgconfig(ftmpdir):
+    with patch("xdg.BaseDirectory.xdg_config_home", ftmpdir), patch(
+        "xdg.BaseDirectory.xdg_config_dirs", [ftmpdir]
+    ):
+        yield ftmpdir
+
+
[e-mail]
+def mocked_config(mocked_xdgconfig):
+    app_config_path = os.path.join(mocked_xdgconfig, "snap-store-proxy-client")
+    os.makedirs(app_config_path)
+    root = Macaroon(key="random-key")
+    root.add_third_party_caveat("login.example.com", "sso-key", "payload")
+    unbound_discharge = Macaroon(
+        location="login.example.com", identifier="payload", key="sso-key"
+    )
+    with open(os.path.join(app_config_path, "config.ini"), "w") as f:
+        f.write(
+            (
+                "[store:default]\n"
+                "gw_url = {gw_url}\n"
+                "sso_url = {sso_url}\n"
+                "root = {root}\n"
+                "unbound_discharge = {unbound_discharge}\n"
+            ).format(
+                gw_url="http://store.local/",
+                sso_url="http://sso.local/",
+                root=root.serialize(),
+                unbound_discharge=unbound_discharge.serialize(),
+            )
+        )
+
+    yield Config()
+
+
[e-mail]
+def mocked_empty_config(mocked_xdgconfig):
+    app_config_path = os.path.join(mocked_xdgconfig, "snap-store-proxy-client")
+    os.makedirs(app_config_path)
+
+
[e-mail]
+def mock_input():
+    with mock.patch("builtins.input") as input:
+        yield input
+
+
[e-mail]
+def mock_getpass():
+    with mock.patch("getpass.getpass") as getpass:
+        yield getpass
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 72daeb2..d9285a2 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,8 +1,7 @@
 acceptable>=0.9
 coverage
-fixtures
 flake8
 responses
-testscenarios
-testtools
 black
+pytest
+testtools
\ No newline at end of file
diff --git a/snapstore_client/logic/tests/test_login.py b/snapstore_client/logic/tests/test_login.py
index d61ac1b..7dbfea1 100644
--- a/snapstore_client/logic/tests/test_login.py
+++ b/snapstore_client/logic/tests/test_login.py
@@ -1,13 +1,13 @@
 # Copyright 2017 Canonical Ltd.
 
+import pytest
 import json
 from unittest import mock
 from urllib.parse import urljoin, urlparse
 
-import fixtures
+
 from pymacaroons import Macaroon
 import responses
-from testtools import TestCase
 from testtools.matchers import (
     ContainsDict,
     Equals,
@@ -22,23 +22,11 @@ from snapstore_client.logic.login import login
 from snapstore_client.tests import factory
 
 
-class LoginTests(TestCase):
-    def setUp(self):
-        super().setUp()
-        self.default_gw_url = "http://store.local/"
-        self.default_sso_url = "https://login.staging.ubuntu.com/"
-        self.logger = self.useFixture(fixtures.FakeLogger())
-        self.config_path = self.useFixture(fixtures.TempDir()).path
-        self.useFixture(
-            fixtures.MonkeyPatch("xdg.BaseDirectory.xdg_config_home", self.config_path)
-        )
-        self.useFixture(
-            fixtures.MonkeyPatch(
-                "xdg.BaseDirectory.xdg_config_dirs", [self.config_path]
-            )
-        )
-        self.mock_input = self.useFixture(fixtures.MockPatch("builtins.input")).mock
-        self.mock_getpass = self.useFixture(fixtures.MockPatch("getpass.getpass")).mock
[e-mail]("mocked_config")
+class TestLogin:
+
+    default_gw_url = "http://store.local/"
+    default_sso_url = "https://login.staging.ubuntu.com/"
 
     def make_responses_callback(self, response_templates):
         full_responses = []
@@ -86,21 +74,21 @@ class LoginTests(TestCase):
         return macaroon.serialize()
 
     @responses.activate
-    def test_login_sso_mismatch(self):
-        self.mock_input.return_value = "[e-mail]"
-        self.mock_getpass.return_value = "secret"
+    def test_login_sso_mismatch(self, mock_input, mock_getpass):
+        mock_input.return_value = "[e-mail]"
+        mock_getpass.returnvalue = "secret"
         macaroon = Macaroon()
         macaroon.add_third_party_caveat("another.example.com", "", "")
         self.add_issue_store_admin_response(
             {"status": 200, "json": {"macaroon": macaroon.serialize()}}
         )
         self.add_get_sso_discharge_response({"status": 401})
-        self.assertRaises(exceptions.StoreMacaroonSSOMismatch, login, self.make_args())
+        pytest.raises(exceptions.StoreMacaroonSSOMismatch, login, self.make_args())
 
     @responses.activate
-    def test_login_sso_bad_email(self):
-        self.mock_input.return_value = ""
-        self.mock_getpass.return_value = ""
+    def test_login_sso_bad_email(self, mock_input, mock_getpass, caplog):
+        mock_input.return_value = ""
+        mock_getpass.return_value = ""
         self.add_issue_store_admin_response(
             {"status": 200, "json": {"macaroon": self.make_root_macaroon()}}
         )
@@ -111,19 +99,17 @@ class LoginTests(TestCase):
         self.add_get_sso_discharge_response(
             {"status": 401, "json": {"error_list": [auth_error]}}
         )
-        self.assertEqual(1, login(self.make_args()))
-        self.assertEqual(
-            "Enter your Ubuntu One SSO credentials.\n"
-            "Login failed.\n"
-            "Authentication error: Invalid request data\n"
-            "email: Enter a valid email address.\n",
-            self.logger.output,
-        )
+        assert 1 == login(self.make_args())
+        assert [
+            "Login failed.",
+            "Authentication error: Invalid request data",
+            "email: Enter a valid email address.",
+        ] == caplog.messages
 
     @responses.activate
-    def test_login_sso_unauthorized(self):
-        self.mock_input.return_value = "[e-mail]"
-        self.mock_getpass.return_value = "secret"
+    def test_login_sso_unauthorized(self, mock_input, mock_getpass, caplog):
+        mock_input.return_value = "[e-mail]"
+        mock_getpass.return_value = "secret"
         self.add_issue_store_admin_response(
             {"status": 200, "json": {"macaroon": self.make_root_macaroon()}}
         )
@@ -131,51 +117,41 @@ class LoginTests(TestCase):
         self.add_get_sso_discharge_response(
             {"status": 401, "json": {"error_list": [auth_error]}}
         )
-        self.assertEqual(1, login(self.make_args()))
-        self.assertEqual(
-            "Enter your Ubuntu One SSO credentials.\n"
-            "Login failed.\n"
-            "Authentication error: Provided email/password is not correct.\n",
-            self.logger.output,
-        )
+        assert 1 == login(self.make_args())
+        assert [
+            "Login failed.",
+            "Authentication error: Provided email/password is not correct.",
+        ] == caplog.messages
 
     @responses.activate
-    def test_login_twofactor_required(self):
-        self.mock_input.side_effect = ("[e-mail]", "123456")
-        self.mock_getpass.return_value = "secret"
+    def test_login_twofactor_required(self, mock_input, mock_getpass):
+        mock_input.side_effect = ("[e-mail]", "123456")
+        mock_getpass.return_value = "secret"
         root = self.make_root_macaroon()
         self.add_issue_store_admin_response({"status": 200, "json": {"macaroon": root}})
         self.add_get_sso_discharge_response(
             {"status": 401, "json": {"error_list": [{"code": "twofactor-required"}]}},
             {"status": 200, "json": {"discharge_macaroon": "dummy"}},
         )
-        self.assertEqual(0, login(self.make_args()))
+        assert 0 == login(self.make_args())
 
-        self.assertIn("Enter your Ubuntu One SSO credentials.", self.logger.output)
-        self.mock_input.assert_has_calls(
+        mock_input.assert_has_calls(
             [mock.call("Email: "), mock.call("Second-factor auth: ")]
         )
-        self.mock_getpass.assert_called_once_with("Password: ")
-        self.assertEqual(3, len(responses.calls))
-        self.assertEqual(
-            {
-                "email": "[e-mail]",
-                "password": "secret",
-                "caveat_id": "payload",
-            },
-            json.loads(responses.calls[1].request.body.decode()),
-        )
-        self.assertEqual(
-            {
-                "email": "[e-mail]",
-                "password": "secret",
-                "caveat_id": "payload",
-                "otp": "123456",
-            },
-            json.loads(responses.calls[2].request.body.decode()),
-        )
-        self.assertThat(
-            config.Config().parser,
+        mock_getpass.assert_called_once_with("Password: ")
+        assert 3 == len(responses.calls)
+        assert {
+            "email": "[e-mail]",
+            "password": "secret",
+            "caveat_id": "payload",
+        } == json.loads(responses.calls[1].request.body.decode())
+        assert {
+            "email": "[e-mail]",
+            "password": "secret",
+            "caveat_id": "payload",
+            "otp": "123456",
+        } == json.loads(responses.calls[2].request.body.decode())
+        assert (
             ContainsDict(
                 {
                     "store:default": MatchesDict(
@@ -188,13 +164,14 @@ class LoginTests(TestCase):
                         }
                     ),
                 }
-            ),
+            ).match(config.Config().parser)
+            is None
         )
 
     @responses.activate
-    def test_login_twofactor_not_required(self):
-        self.mock_input.return_value = "[e-mail]"
-        self.mock_getpass.return_value = "secret"
+    def test_login_twofactor_not_required(self, mock_input, mock_getpass):
+        mock_input.return_value = "[e-mail]"
+        mock_getpass.return_value = "secret"
         root = self.make_root_macaroon()
         self.add_issue_store_admin_response({"status": 200, "json": {"macaroon": root}})
         self.add_get_sso_discharge_response(
@@ -202,20 +179,15 @@ class LoginTests(TestCase):
         )
         login(self.make_args())
 
-        self.assertIn("Enter your Ubuntu One SSO credentials.", self.logger.output)
-        self.mock_input.assert_called_once_with("Email: ")
-        self.mock_getpass.assert_called_once_with("Password: ")
-        self.assertEqual(2, len(responses.calls))
-        self.assertEqual(
-            {
-                "email": "[e-mail]",
-                "password": "secret",
-                "caveat_id": "payload",
-            },
-            json.loads(responses.calls[1].request.body.decode()),
-        )
-        self.assertThat(
-            config.Config().parser,
+        mock_input.assert_called_once_with("Email: ")
+        mock_getpass.assert_called_once_with("Password: ")
+        assert 2 == len(responses.calls)
+        assert {
+            "email": "[e-mail]",
+            "password": "secret",
+            "caveat_id": "payload",
+        } == json.loads(responses.calls[1].request.body.decode())
+        assert (
             ContainsDict(
                 {
                     "store:default": MatchesDict(
@@ -228,13 +200,14 @@ class LoginTests(TestCase):
                         }
                     ),
                 }
-            ),
+            ).match(config.Config().parser)
+            is None
         )
 
     @responses.activate
-    def test_login_with_email(self):
-        self.mock_input.side_effect = Exception("shouldn't be called")
-        self.mock_getpass.return_value = "secret"
+    def test_login_with_email(self, mock_input, mock_getpass):
+        mock_input.side_effect = Exception("shouldn't be called")
+        mock_getpass.return_value = "secret"
         root = self.make_root_macaroon()
         self.add_issue_store_admin_response({"status": 200, "json": {"macaroon": root}})
         self.add_get_sso_discharge_response(
@@ -242,20 +215,15 @@ class LoginTests(TestCase):
         )
         login(self.make_args(email="[e-mail]"))
 
-        self.assertIn("Enter your Ubuntu One SSO credentials.", self.logger.output)
-        self.mock_input.assert_not_called()
-        self.mock_getpass.assert_called_once_with("Password: ")
-        self.assertEqual(2, len(responses.calls))
-        self.assertEqual(
-            {
-                "email": "[e-mail]",
-                "password": "secret",
-                "caveat_id": "payload",
-            },
-            json.loads(responses.calls[1].request.body.decode()),
-        )
-        self.assertThat(
-            config.Config().parser,
+        mock_input.assert_not_called()
+        mock_getpass.assert_called_once_with("Password: ")
+        assert 2 == len(responses.calls)
+        assert {
+            "email": "[e-mail]",
+            "password": "secret",
+            "caveat_id": "payload",
+        } == json.loads(responses.calls[1].request.body.decode())
+        assert (
             ContainsDict(
                 {
                     "store:default": MatchesDict(
@@ -268,15 +236,16 @@ class LoginTests(TestCase):
                         }
                     ),
                 }
-            ),
+            ).match(config.Config().parser)
+            is None
         )
 
     @responses.activate
-    def test_store_url(self):
+    def test_store_url(self, mock_input, mock_getpass):
         gw_url = "http://otherstore.local:1234/"
 
-        self.mock_input.return_value = "[e-mail]"
-        self.mock_getpass.return_value = "secret"
+        mock_input.return_value = "[e-mail]"
+        mock_getpass.return_value = "secret"
         root = self.make_root_macaroon()
         self.add_issue_store_admin_response(
             {"status": 200, "json": {"macaroon": root}}, gw_url=gw_url
@@ -286,11 +255,10 @@ class LoginTests(TestCase):
         )
         login(self.make_args(store_url=gw_url))
 
-        self.assertEqual(2, len(responses.calls))
-        self.assertEqual(responses.calls[0].request.url[: len(gw_url)], gw_url)
-        self.assertTrue(responses.calls[1].request.url.startswith(self.default_sso_url))
-        self.assertThat(
-            config.Config().parser,
+        assert 2 == len(responses.calls)
+        assert responses.calls[0].request.url[: len(gw_url)] == gw_url
+        assert responses.calls[1].request.url.startswith(self.default_sso_url)
+        assert (
             ContainsDict(
                 {
                     "store:default": ContainsDict(
@@ -300,15 +268,16 @@ class LoginTests(TestCase):
                         }
                     ),
                 }
-            ),
+            ).match(config.Config().parser)
+            is None
         )
 
     @responses.activate
-    def test_sso_url(self):
+    def test_sso_url(self, mock_input, mock_getpass):
         sso_url = "https://othersso.local:1234/"
 
-        self.mock_input.return_value = "[e-mail]"
-        self.mock_getpass.return_value = "secret"
+        mock_input.return_value = "[e-mail]"
+        mock_getpass.return_value = "secret"
         root = self.make_root_macaroon(sso_url=sso_url)
         self.add_issue_store_admin_response({"status": 200, "json": {"macaroon": root}})
         self.add_get_sso_discharge_response(
@@ -316,11 +285,10 @@ class LoginTests(TestCase):
         )
         login(self.make_args(sso_url=sso_url))
 
-        self.assertEqual(2, len(responses.calls))
-        self.assertTrue(responses.calls[0].request.url.startswith(self.default_gw_url))
-        self.assertEqual(responses.calls[1].request.url[: len(sso_url)], sso_url)
-        self.assertThat(
-            config.Config().parser,
+        assert 2 == len(responses.calls)
+        assert responses.calls[0].request.url.startswith(self.default_gw_url)
+        assert responses.calls[1].request.url[: len(sso_url)] == sso_url
+        assert (
             ContainsDict(
                 {
                     "store:default": ContainsDict(
@@ -330,5 +298,6 @@ class LoginTests(TestCase):
                         }
                     ),
                 }
-            ),
+            ).match(config.Config().parser)
+            is None
         )
diff --git a/snapstore_client/logic/tests/test_overrides.py b/snapstore_client/logic/tests/test_overrides.py
index 591b55d..c628810 100644
--- a/snapstore_client/logic/tests/test_overrides.py
+++ b/snapstore_client/logic/tests/test_overrides.py
@@ -1,11 +1,11 @@
 # Copyright 2017 Canonical Ltd.
 
 import json
+import logging
 from urllib.parse import urljoin
 
-import fixtures
 import responses
-from testtools import TestCase
+import pytest
 
 from snapstore_client import config
 from snapstore_client.logic.overrides import (
@@ -15,26 +15,23 @@ from snapstore_client.logic.overrides import (
 )
 from snapstore_client.tests import (
     factory,
-    testfixtures,
 )
 
 
-class OverridesTests(TestCase):
-    def test_list_overrides_no_store_config(self):
-        self.useFixture(testfixtures.ConfigFixture(empty=True))
-        logger = self.useFixture(fixtures.FakeLogger())
+class TestOverrides:
+    @pytest.mark.usefixtures("mocked_empty_config")
+    def test_list_overrides_no_store_config(self, caplog):
         rc = list_overrides(factory.Args(snap_name="some-snap", series="16"))
-        self.assertEqual(rc, 1)
-        self.assertEqual(
-            logger.output,
+        assert rc == 1
+        assert [
             "No store configuration found. "
-            'Have you run "snap-store-proxy-client login"?\n',
-        )
+            'Have you run "snap-store-proxy-client login"?'
+        ] == caplog.messages
 
+    @pytest.mark.usefixtures("mocked_config")
     @responses.activate
-    def test_list_overrides_online(self):
-        self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_list_overrides_online(self, caplog):
+        caplog.set_level(logging.DEBUG)
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
@@ -56,18 +53,17 @@ class OverridesTests(TestCase):
         responses.add("GET", overrides_url, status=200, json={"overrides": overrides})
 
         list_overrides(factory.Args(snap_name="mysnap", series="16", password=False))
-        self.assertEqual(
-            "mysnap stable amd64 1 (upstream 2)\n"
-            "mysnap foo/stable i386 3 (upstream 4)\n",
-            logger.output,
-        )
+        assert [
+            "mysnap stable amd64 1 (upstream 2)",
+            "mysnap foo/stable i386 3 (upstream 4)",
+        ] == caplog.messages
         # We shouldn't have Basic Authorization headers, but Macaroon
-        self.assertNotIn("Basic", responses.calls[0].request.headers["Authorization"])
+        assert "Basic" not in responses.calls[0].request.headers["Authorization"]
 
+    @pytest.mark.usefixtures("mocked_config")
     @responses.activate
-    def test_list_overrides_offline(self):
-        self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_list_overrides_offline(self, caplog):
+        caplog.set_level(logging.DEBUG)
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
@@ -89,19 +85,17 @@ class OverridesTests(TestCase):
         responses.add("GET", overrides_url, status=200, json={"overrides": overrides})
 
         list_overrides(factory.Args(snap_name="mysnap", series="16", password="test"))
-        self.assertEqual(
-            "mysnap stable amd64 1 (upstream 2)\n"
-            "mysnap foo/stable i386 3 (upstream 4)\n",
-            logger.output,
-        )
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            responses.calls[0].request.headers["Authorization"],
+        assert [
+            "mysnap stable amd64 1 (upstream 2)",
+            "mysnap foo/stable i386 3 (upstream 4)",
+        ] == caplog.messages
+        assert (
+            "Basic YWRtaW46dGVzdA=="
+            == responses.calls[0].request.headers["Authorization"]
         )
 
-    def test_override_no_store_config(self):
-        self.useFixture(testfixtures.ConfigFixture(empty=True))
-        logger = self.useFixture(fixtures.FakeLogger())
+    @pytest.mark.usefixtures("mocked_empty_config")
+    def test_override_no_store_config(self, caplog):
         rc = override(
             factory.Args(
                 snap_name="some-snap",
@@ -110,17 +104,16 @@ class OverridesTests(TestCase):
                 password=False,
             )
         )
-        self.assertEqual(rc, 1)
-        self.assertEqual(
-            logger.output,
+        assert rc == 1
+        assert [
             "No store configuration found. "
-            'Have you run "snap-store-proxy-client login"?\n',
-        )
+            'Have you run "snap-store-proxy-client login"?'
+        ] == caplog.messages
 
+    @pytest.mark.usefixtures("mocked_config")
     @responses.activate
-    def test_override_online(self):
-        self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_override_online(self, caplog):
+        caplog.set_level(logging.DEBUG)
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
@@ -149,35 +142,32 @@ class OverridesTests(TestCase):
                 password=False,
             )
         )
-        self.assertEqual(
-            [
-                {
-                    "snap_name": "mysnap",
-                    "revision": 1,
-                    "channel": "stable",
-                    "series": "16",
-                },
-                {
-                    "snap_name": "mysnap",
-                    "revision": 3,
-                    "channel": "foo/stable",
-                    "series": "16",
-                },
-            ],
-            json.loads(responses.calls[0].request.body.decode()),
-        )
-        self.assertEqual(
-            "mysnap stable amd64 1 (upstream 2)\n"
-            "mysnap foo/stable i386 3 (upstream 4)\n",
-            logger.output,
-        )
+        assert [
+            {
+                "snap_name": "mysnap",
+                "revision": 1,
+                "channel": "stable",
+                "series": "16",
+            },
+            {
+                "snap_name": "mysnap",
+                "revision": 3,
+                "channel": "foo/stable",
+                "series": "16",
+            },
+        ] == json.loads(responses.calls[0].request.body.decode())
+        assert [
+            "mysnap stable amd64 1 (upstream 2)",
+            "mysnap foo/stable i386 3 (upstream 4)",
+        ] == caplog.messages
+
         # We shouldn't have Basic Authorization headers, but Macaroon
-        self.assertNotIn("Basic", responses.calls[0].request.headers["Authorization"])
+        assert "Basic" not in responses.calls[0].request.headers["Authorization"]
 
+    @pytest.mark.usefixtures("mocked_config")
     @responses.activate
-    def test_override_offline(self):
-        self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_override_offline(self, caplog):
+        caplog.set_level(logging.DEBUG)
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
@@ -206,52 +196,46 @@ class OverridesTests(TestCase):
                 password="test",
             )
         )
-        self.assertEqual(
-            [
-                {
-                    "snap_name": "mysnap",
-                    "revision": 1,
-                    "channel": "stable",
-                    "series": "16",
-                },
-                {
-                    "snap_name": "mysnap",
-                    "revision": 3,
-                    "channel": "foo/stable",
-                    "series": "16",
-                },
-            ],
-            json.loads(responses.calls[0].request.body.decode()),
-        )
-        self.assertEqual(
-            "mysnap stable amd64 1 (upstream 2)\n"
-            "mysnap foo/stable i386 3 (upstream 4)\n",
-            logger.output,
-        )
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            responses.calls[0].request.headers["Authorization"],
+        assert [
+            {
+                "snap_name": "mysnap",
+                "revision": 1,
+                "channel": "stable",
+                "series": "16",
+            },
+            {
+                "snap_name": "mysnap",
+                "revision": 3,
+                "channel": "foo/stable",
+                "series": "16",
+            },
+        ] == json.loads(responses.calls[0].request.body.decode())
+        assert [
+            "mysnap stable amd64 1 (upstream 2)",
+            "mysnap foo/stable i386 3 (upstream 4)",
+        ] == caplog.messages
+        assert (
+            "Basic YWRtaW46dGVzdA=="
+            == responses.calls[0].request.headers["Authorization"]
         )
 
-    def test_delete_override_no_store_config(self):
-        self.useFixture(testfixtures.ConfigFixture(empty=True))
-        logger = self.useFixture(fixtures.FakeLogger())
+    @pytest.mark.usefixtures("mocked_empty_config")
+    def test_delete_override_no_store_config(self, caplog):
         rc = delete_override(
             factory.Args(
                 snap_name="some-snap", channels=["stable"], series="16", password=False
             )
         )
-        self.assertEqual(rc, 1)
-        self.assertEqual(
-            logger.output,
+        assert rc == 1
+        assert [
             "No store configuration found. "
-            'Have you run "snap-store-proxy-client login"?\n',
-        )
+            'Have you run "snap-store-proxy-client login"?'
+        ] == caplog.messages
 
+    @pytest.mark.usefixtures("mocked_config")
     @responses.activate
-    def test_delete_override_online(self):
-        self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_delete_override_online(self, caplog):
+        caplog.set_level(logging.DEBUG)
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(
@@ -282,35 +266,31 @@ class OverridesTests(TestCase):
                 password=False,
             )
         )
-        self.assertEqual(
-            [
-                {
-                    "snap_name": "mysnap",
-                    "revision": None,
-                    "channel": "stable",
-                    "series": "16",
-                },
-                {
-                    "snap_name": "mysnap",
-                    "revision": None,
-                    "channel": "foo/stable",
-                    "series": "16",
-                },
-            ],
-            json.loads(responses.calls[0].request.body.decode()),
-        )
-        self.assertEqual(
-            "mysnap stable amd64 is tracking upstream (revision 2)\n"
-            "mysnap foo/stable i386 is tracking upstream (revision 4)\n",
-            logger.output,
-        )
+        assert [
+            {
+                "snap_name": "mysnap",
+                "revision": None,
+                "channel": "stable",
+                "series": "16",
+            },
+            {
+                "snap_name": "mysnap",
+                "revision": None,
+                "channel": "foo/stable",
+                "series": "16",
+            },
+        ] == json.loads(responses.calls[0].request.body.decode())
+        assert [
+            "mysnap stable amd64 is tracking upstream (revision 2)",
+            "mysnap foo/stable i386 is tracking upstream (revision 4)",
+        ] == caplog.messages
         # We shouldn't have Basic Authorization headers, but Macaroon
-        self.assertNotIn("Basic", responses.calls[0].request.headers["Authorization"])
+        assert "Basic" not in responses.calls[0].request.headers["Authorization"]
 
+    @pytest.mark.usefixtures("mocked_config")
     @responses.activate
-    def test_delete_override_offline(self):
-        self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_delete_override_offline(self, caplog):
+        caplog.set_level(logging.DEBUG)
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(
@@ -341,29 +321,25 @@ class OverridesTests(TestCase):
                 password="test",
             )
         )
-        self.assertEqual(
-            [
-                {
-                    "snap_name": "mysnap",
-                    "revision": None,
-                    "channel": "stable",
-                    "series": "16",
-                },
-                {
-                    "snap_name": "mysnap",
-                    "revision": None,
-                    "channel": "foo/stable",
-                    "series": "16",
-                },
-            ],
-            json.loads(responses.calls[0].request.body.decode()),
-        )
-        self.assertEqual(
-            "mysnap stable amd64 is tracking upstream (revision 2)\n"
-            "mysnap foo/stable i386 is tracking upstream (revision 4)\n",
-            logger.output,
-        )
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            responses.calls[0].request.headers["Authorization"],
+        assert [
+            {
+                "snap_name": "mysnap",
+                "revision": None,
+                "channel": "stable",
+                "series": "16",
+            },
+            {
+                "snap_name": "mysnap",
+                "revision": None,
+                "channel": "foo/stable",
+                "series": "16",
+            },
+        ] == json.loads(responses.calls[0].request.body.decode())
+        assert [
+            "mysnap stable amd64 is tracking upstream (revision 2)",
+            "mysnap foo/stable i386 is tracking upstream (revision 4)",
+        ] == caplog.messages
+        assert (
+            "Basic YWRtaW46dGVzdA=="
+            == responses.calls[0].request.headers["Authorization"]
         )
diff --git a/snapstore_client/logic/tests/test_push.py b/snapstore_client/logic/tests/test_push.py
index e96088f..05b4cee 100644
--- a/snapstore_client/logic/tests/test_push.py
+++ b/snapstore_client/logic/tests/test_push.py
@@ -1,10 +1,9 @@
+import pytest
 import json
 from pathlib import Path
 from urllib.parse import urljoin
 
-import fixtures
 import responses
-from testtools import TestCase
 
 from snapstore_client.logic.push import (
     ChannelMapExistsException,
@@ -17,11 +16,9 @@ from snapstore_client.logic.push import (
 )
 
 
-class pushTests(TestCase):
-    def setUp(self):
-        super().setUp()
+class Testpush:
+    def setup_method(self):
         self.default_gw_url = "http://store.local"
-        self.logger = self.useFixture(fixtures.FakeLogger())
         current_path = Path(__file__).resolve().parent
         with (current_path / "test-snap-map.json").open() as fh:
             self.snap_map = json.load(fh)
@@ -39,21 +36,15 @@ class pushTests(TestCase):
         request = responses.calls[0].request
         payload = json.loads(request.body.decode("utf-8"))
 
-        self.assertEqual(
-            payload["snaps"][0]["package_type"],
-            "snap",
-        )
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            request.headers["Authorization"],
-        )
+        assert payload["snaps"][0]["package_type"] == "snap"
+        assert "Basic YWRtaW46dGVzdA==" == request.headers["Authorization"]
 
     @responses.activate
     def test_push_ident_failed(self):
         ident_url = urljoin(self.default_gw_url, "/snaps/update")
         responses.add("POST", ident_url, status=500)
 
-        self.assertRaises(pushException, _push_ident, self.store, "test", self.snap_map)
+        pytest.raises(pushException, _push_ident, self.store, "test", self.snap_map)
 
     @responses.activate
     def test_push_revs(self):
@@ -65,25 +56,22 @@ class pushTests(TestCase):
         request = responses.calls[0].request
         payload = json.loads(request.body.decode("utf-8"))
 
-        self.assertEqual(payload[0]["package_type"], "snap")
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            request.headers["Authorization"],
-        )
+        assert payload[0]["package_type"] == "snap"
+        assert "Basic YWRtaW46dGVzdA==" == request.headers["Authorization"]
 
     @responses.activate
     def test_push_revs_unexpected_status_code(self):
         revs_url = urljoin(self.default_gw_url, "/revisions/create")
         responses.add("POST", revs_url, status=302)
 
-        self.assertRaises(pushException, _push_revs, self.store, "test", self.snap_map)
+        pytest.raises(pushException, _push_revs, self.store, "test", self.snap_map)
 
     @responses.activate
     def test_push_revs_failed(self):
         revs_url = urljoin(self.default_gw_url, "/revisions/create")
         responses.add("POST", revs_url, status=500)
 
-        self.assertRaises(pushException, _push_revs, self.store, "test", self.snap_map)
+        pytest.raises(pushException, _push_revs, self.store, "test", self.snap_map)
 
     @responses.activate
     def test_push_map(self):
@@ -96,29 +84,20 @@ class pushTests(TestCase):
 
         filter_request = responses.calls[0].request
         filter_payload = json.loads(filter_request.body.decode("utf-8"))
-        self.assertEqual(
-            filter_payload["filters"],
-            [
-                {
-                    "series": "16",
-                    "package_type": "snap",
-                    "snap_id": self.snap_map["snap-id"],
-                },
-            ],
-        )
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            filter_request.headers["Authorization"],
-        )
+        assert filter_payload["filters"] == [
+            {
+                "series": "16",
+                "package_type": "snap",
+                "snap_id": self.snap_map["snap-id"],
+            },
+        ]
+        assert "Basic YWRtaW46dGVzdA==" == filter_request.headers["Authorization"]
 
         chanmap_update_request = responses.calls[1].request
         chanmap_update_payload = json.loads(
             chanmap_update_request.body.decode("utf-8"),
         )
-        self.assertEqual(
-            chanmap_update_payload["release_requests"][0]["package_type"],
-            "snap",
-        )
+        assert chanmap_update_payload["release_requests"][0]["package_type"] == "snap"
 
     @responses.activate
     def test_push_map_failed(self):
@@ -127,7 +106,7 @@ class pushTests(TestCase):
         responses.add("POST", filter_url, status=200, json={})
         responses.add("POST", update_url, status=500)
 
-        self.assertRaises(
+        pytest.raises(
             pushException, _push_channelmap, self.store, "test", self.snap_map
         )
 
@@ -139,7 +118,7 @@ class pushTests(TestCase):
         responses.add("POST", filter_url, status=200, json=exists)
         responses.add("POST", update_url, status=200)
 
-        self.assertRaises(
+        pytest.raises(
             ChannelMapExistsException,
             _push_channelmap,
             self.store,
@@ -157,9 +136,9 @@ class pushTests(TestCase):
 
         _push_channelmap(self.store, "test", self.snap_map, True)
 
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            responses.calls[0].request.headers["Authorization"],
+        assert (
+            "Basic YWRtaW46dGVzdA=="
+            == responses.calls[0].request.headers["Authorization"]
         )
 
     def test_split_assertions(self):
@@ -180,13 +159,12 @@ class pushTests(TestCase):
         split_assertions = _split_assertions(self.snap_assert)
         _add_assertion_to_service(self.store, "test", split_assertions)
 
-        self.assertIn(
-            "display-name: Tom Wardill (Ω)",
-            responses.calls[0].request.body.decode("utf-8"),
-        )
-        self.assertEqual(
-            "Basic YWRtaW46dGVzdA==",
-            responses.calls[0].request.headers["Authorization"],
+        assert "display-name: Tom Wardill (Ω)" in responses.calls[
+            0
+        ].request.body.decode("utf-8")
+        assert (
+            "Basic YWRtaW46dGVzdA=="
+            == responses.calls[0].request.headers["Authorization"]
         )
 
     @responses.activate
@@ -195,7 +173,7 @@ class pushTests(TestCase):
         responses.add("POST", assert_url, status=302)
 
         split_assertions = _split_assertions(self.snap_assert)
-        self.assertRaises(
+        pytest.raises(
             pushException,
             _add_assertion_to_service,
             self.store,
@@ -209,7 +187,7 @@ class pushTests(TestCase):
         responses.add("POST", assert_url, status=500)
 
         split_assertions = _split_assertions(self.snap_assert)
-        self.assertRaises(
+        pytest.raises(
             pushException,
             _add_assertion_to_service,
             self.store,
diff --git a/snapstore_client/tests/test_cli.py b/snapstore_client/tests/test_cli.py
deleted file mode 100644
index 3ba9dc9..0000000
--- a/snapstore_client/tests/test_cli.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright 2017 Canonical Ltd.  This software is licensed under the
-# GNU General Public License version 3 (see the file LICENSE).
-
-import logging
-
-import fixtures
-from testtools import TestCase
-
-from snapstore_client import cli
-
-
-class ConfigureLoggingTests(TestCase):
-    def setUp(self):
-        super().setUp()
-        self.logger = logging.getLogger(__name__)
-        self.addCleanup(
-            self._restoreLogger,
-            self.logger,
-            self.logger.level,
-            list(self.logger.handlers),
-        )
-        self.stdout = self.useFixture(fixtures.StringStream("stdout")).stream
-        self.stdout.fileno = lambda: 1
-        self.useFixture(fixtures.MonkeyPatch("sys.stdout", self.stdout))
-        self.stderr = self.useFixture(fixtures.StringStream("stderr")).stream
-        self.useFixture(fixtures.MonkeyPatch("sys.stderr", self.stderr))
-
-    @staticmethod
-    def _restoreLogger(logger, level, handlers):
-        logger.setLevel(logger.level)
-        for handler in list(logger.handlers):
-            logger.removeHandler(handler)
-        for handler in handlers:
-            logger.addHandler(handler)
-
-    def test_log_levels(self):
-        self.useFixture(fixtures.MonkeyPatch("os.isatty", lambda fd: True))
-        cli.configure_logging(__name__)
-        self.assertEqual(logging.INFO, self.logger.level)
-        self.logger.debug("Debug")
-        self.logger.info("Info")
-        self.logger.warning("Warning: %s", "smoke")
-        self.logger.error("Error: %s", "fire")
-        self.stdout.seek(0)
-        self.assertEqual("Info\nWarning: smoke\n", self.stdout.read())
-        self.stderr.seek(0)
-        self.assertEqual("\033[0;31mError: fire\033[0m\n", self.stderr.read())
-
-    def test_requests_log_level_default(self):
-        cli.configure_logging(__name__)
-        self.assertEqual(logging.WARNING, logging.getLogger("requests").level)
-
-    def test_requests_log_level_debug(self):
-        cli.configure_logging(__name__, logging.DEBUG)
-        self.assertEqual(logging.DEBUG, logging.getLogger("requests").level)
-
-    def test_requests_log_level_error(self):
-        cli.configure_logging(__name__, logging.ERROR)
-        self.assertEqual(logging.ERROR, logging.getLogger("requests").level)
-
-    def test_no_tty(self):
-        self.useFixture(fixtures.MonkeyPatch("os.isatty", lambda fd: False))
-        self.useFixture(fixtures.EnvironmentVariable("TERM", "xterm"))
-        cli.configure_logging(__name__)
-        self.logger.error("Error: %s", "fire")
-        self.stderr.seek(0)
-        self.assertEqual("Error: fire\n", self.stderr.read())
diff --git a/snapstore_client/tests/test_config.py b/snapstore_client/tests/test_config.py
index 7243554..c2cca69 100644
--- a/snapstore_client/tests/test_config.py
+++ b/snapstore_client/tests/test_config.py
@@ -1,81 +1,57 @@
 # Copyright 2017 Canonical Ltd.  This software is licensed under the
 # GNU General Public License version 3 (see the file LICENSE).
+import os
 
-import os.path
-from textwrap import dedent
+from snapstore_client.config import Config
 
-from testtools import TestCase
 
-from snapstore_client.config import Config
-from snapstore_client.tests.testfixtures import (
-    ConfigFixture,
-    XDGConfigDirFixture,
-)
-
-
-class ConfigTests(TestCase):
-    def test_no_config(self):
-        xdg_path = self.useFixture(XDGConfigDirFixture()).path
-        config_ini = os.path.join(xdg_path, Config.xdg_name, "config.ini")
-        self.assertFalse(os.path.exists(config_ini))
-        Config()
-
-    def test_init_loads(self):
-        self.useFixture(ConfigFixture())
-        cfg = Config()
-        self.assertIsNotNone(cfg.get("store:default", "gw_url"))
-
-    def test_save(self):
-        xdg_path = self.useFixture(XDGConfigDirFixture()).path
-        config_ini = os.path.join(xdg_path, "snap-store-proxy-client", "config.ini")
-        self.assertFalse(os.path.exists(config_ini))
-
-        cfg = Config()
-        cfg.set("s", "k", "v")
-        cfg.save()
-
-        self.assertTrue(os.path.exists(config_ini))
-        with open(config_ini) as f:
-            content = f.read()
-        self.assertEqual(
-            content,
-            dedent(
-                """\
-            [s]
-            k = v
-
-        """
-            ),
-        )
-
-    def test_get_missing(self):
-        self.useFixture(XDGConfigDirFixture())
-        cfg = Config()
-        self.assertIsNone(cfg.get("s", "k"))
-
-    def test_get(self):
-        self.useFixture(XDGConfigDirFixture())
-        cfg = Config()
-        cfg.set("s", "k", "v")
-        self.assertEqual(cfg.get("s", "k"), "v")
-
-    def test_section(self):
-        self.useFixture(XDGConfigDirFixture())
-        cfg = Config()
-        s = cfg.section("s")
-        s.set("k", "v")
-        self.assertEqual(s.get("k"), "v")
-        self.assertEqual(cfg.get("s", "k"), "v")
-
-    def test_store_section(self):
-        self.useFixture(XDGConfigDirFixture())
-        cfg = Config()
-        store = cfg.store_section("foo")
-        store.set("k", "v")
-        self.assertEqual(cfg.get("store:foo", "k"), "v")
-
-
-def test_suite():
-    from unittest import TestLoader
-
-    return TestLoader().loadTestsFromName(__name__)
+def test_no_config(mocked_xdgconfig):
+    config_ini = os.path.join(mocked_xdgconfig, Config.xdg_name, "config.ini")
+    assert not os.path.exists(config_ini)
+    Config()
+
+
+def test_init_loads(mocked_config):
+    cfg = Config()
+    assert cfg.get("store:default", "gw_url")
+
+
+def test_save(mocked_xdgconfig):
+    config_ini = os.path.join(mocked_xdgconfig, "snap-store-proxy-client", "config.ini")
+    assert not os.path.exists(config_ini)
+
+    cfg = Config()
+    cfg.set("s", "k", "v")
+    cfg.save()
+
+    assert os.path.exists(config_ini)
+
+    with open(config_ini) as f:
+        content = f.read()
+    assert content == ("[s]\n" "k = v\n" "\n")
+
+
+def test_get_missing(mocked_xdgconfig):
+    cfg = Config()
+    assert not cfg.get("s", "k")
+
+
+def test_get(mocked_xdgconfig):
+    cfg = Config()
+    cfg.set("s", "k", "v")
+    assert cfg.get("s", "k") == "v"
+
+
+def test_section(mocked_xdgconfig):
+    cfg = Config()
+    s = cfg.section("s")
+    s.set("k", "v")
+    assert s.get("k") == "v"
+    assert cfg.get("s", "k") == "v"
+
+
+def test_store_section(mocked_xdgconfig):
+    cfg = Config()
+    store = cfg.store_section("foo")
+    store.set("k", "v")
+    assert cfg.get("store:foo", "k") == "v"
diff --git a/snapstore_client/tests/test_presentation_helpers.py b/snapstore_client/tests/test_presentation_helpers.py
index 7399f91..e58e9e9 100644
--- a/snapstore_client/tests/test_presentation_helpers.py
+++ b/snapstore_client/tests/test_presentation_helpers.py
@@ -1,7 +1,6 @@
 # Copyright 2017 Canonical Ltd.
 
-from testtools import TestCase
-from testscenarios import WithScenarios
+import pytest
 
 from snapstore_client.presentation_helpers import (
     channel_map_string_to_tuple,
@@ -9,129 +8,93 @@ from snapstore_client.presentation_helpers import (
 )
 
 
-class ChannelMapStringToTupleScenarioTests(WithScenarios, TestCase):
-
-    scenarios = [
-        (
-            "with risk",
-            {
-                "channel_map": "stable=1",
-                "terms": ("stable", 1),
-            },
-        ),
-        (
-            "with track and risk",
-            {
-                "channel_map": "2.1/stable=2",
-                "terms": ("2.1/stable", 2),
-            },
-        ),
-        (
-            "with risk and branch",
-            {
-                "channel_map": "stable/hot-fix=42",
-                "terms": ("stable/hot-fix", 42),
-            },
-        ),
-        (
-            "with track, risk and branch",
-            {
-                "channel_map": "2.1/stable/hot-fix=123",
-                "terms": ("2.1/stable/hot-fix", 123),
-            },
-        ),
-    ]
-
-    def test_run_scenario(self):
-        self.assertEqual(self.terms, channel_map_string_to_tuple(self.channel_map))
-
-
-class ChannelMapStringToTupleErrorTests(WithScenarios, TestCase):
-
-    scenarios = [
-        (
-            "missing revision",
-            {
-                "channel_map": "stable",
-                "error_message": "Invalid channel map string: 'stable'",
-            },
-        ),
-        (
-            "non-integer revision",
-            {
-                "channel_map": "stable=nonsense",
-                "error_message": "Invalid revision string: 'nonsense'",
-            },
-        ),
-    ]
[e-mail](
+    "channel_map,terms",
+    [
+        ("stable=1", ("stable", 1)),
+        ("2.1/stable=2", ("2.1/stable", 2)),
+        ("stable/hot-fix=42", ("stable/hot-fix", 42)),
+        ("2.1/stable/hot-fix=123", ("2.1/stable/hot-fix", 123)),
+    ],
+    ids=[
+        "with risk",
+        "with track and risk",
+        "with risk and branch",
+        "with track, risk and branch",
+    ],
+)
+def test_channel_map_string_to_tuple(channel_map, terms):
+    assert terms == channel_map_string_to_tuple(channel_map)
 
-    def test_run_scenario(self):
-        error = self.assertRaises(
-            ValueError, channel_map_string_to_tuple, self.channel_map
-        )
-        self.assertEqual(self.error_message, str(error))
 
[e-mail](
+    "channel_map,error_message",
+    [
+        ("stable", "Invalid channel map string: 'stable'"),
+        ("stable=nonsense", "Invalid revision string: 'nonsense'"),
+    ],
+    ids=["missing revision", "non-integer revision"],
+)
+def test_channel_map_string_to_tuple_exceptions(channel_map, error_message):
+    with pytest.raises(ValueError) as error:
+        channel_map_string_to_tuple(channel_map)
+    assert error_message == str(error.value)
 
-class OverrideToStringTests(WithScenarios, TestCase):
 
-    scenarios = [
[e-mail](
+    "override,string",
+    [
         (
-            "without revision or upstream revision",
             {
-                "override": {
-                    "snap_id": "dummy",
-                    "snap_name": "mysnap",
-                    "revision": None,
-                    "upstream_revision": None,
-                    "channel": "stable",
-                    "architecture": "amd64",
-                },
-                "string": "mysnap stable amd64 is tracking upstream",
+                "snap_id": "dummy",
+                "snap_name": "mysnap",
+                "revision": None,
+                "upstream_revision": None,
+                "channel": "stable",
+                "architecture": "amd64",
             },
+            "mysnap stable amd64 is tracking upstream",
         ),
         (
-            "without revision but with upstream revision",
             {
-                "override": {
-                    "snap_id": "dummy",
-                    "snap_name": "mysnap",
-                    "revision": None,
-                    "upstream_revision": 2,
-                    "channel": "stable",
-                    "architecture": "amd64",
-                },
-                "string": "mysnap stable amd64 is tracking upstream (revision 2)",
+                "snap_id": "dummy",
+                "snap_name": "mysnap",
+                "revision": None,
+                "upstream_revision": 2,
+                "channel": "stable",
+                "architecture": "amd64",
             },
+            "mysnap stable amd64 is tracking upstream (revision 2)",
         ),
         (
-            "with revision but without upstream revision",
             {
-                "override": {
-                    "snap_id": "dummy",
-                    "snap_name": "mysnap",
-                    "revision": 1,
-                    "upstream_revision": None,
-                    "channel": "stable",
-                    "architecture": "amd64",
-                },
-                "string": "mysnap stable amd64 1",
+                "snap_id": "dummy",
+                "snap_name": "mysnap",
+                "revision": 1,
+                "upstream_revision": None,
+                "channel": "stable",
+                "architecture": "amd64",
             },
+            "mysnap stable amd64 1",
         ),
         (
-            "with revision and upstream revision",
             {
-                "override": {
-                    "snap_id": "dummy",
-                    "snap_name": "mysnap",
-                    "revision": 1,
-                    "upstream_revision": 2,
-                    "channel": "stable",
-                    "architecture": "amd64",
-                },
-                "string": "mysnap stable amd64 1 (upstream 2)",
+                "snap_id": "dummy",
+                "snap_name": "mysnap",
+                "revision": 1,
+                "upstream_revision": 2,
+                "channel": "stable",
+                "architecture": "amd64",
             },
+            "mysnap stable amd64 1 (upstream 2)",
         ),
-    ]
-
-    def test_run_scenario(self):
-        self.assertEqual(self.string, override_to_string(self.override))
+    ],
+    ids=[
+        "without revision or upstream revision",
+        "without revision but with upstream revision",
+        "with revision but without upstream revision",
+        "with revision and upstream revision",
+    ],
+)
+def test_override_to_string(override, string):
+    assert string == override_to_string(override)
diff --git a/snapstore_client/tests/test_webservices.py b/snapstore_client/tests/test_webservices.py
index ec2019d..3c667bb 100644
--- a/snapstore_client/tests/test_webservices.py
+++ b/snapstore_client/tests/test_webservices.py
@@ -1,13 +1,12 @@
 # Copyright 2017 Canonical Ltd.
 
+import pytest
 import json
 import sys
 from urllib.parse import urljoin
 
-import fixtures
 from requests.exceptions import HTTPError
 import responses
-from testtools import TestCase
 
 from snapstore_client import (
     config,
@@ -17,18 +16,14 @@ from snapstore_client import (
 from snapstore_client.tests import (
     factory,
     matchers,
-    testfixtures,
 )
 
 if sys.version < "3.6":
     import sha3  # noqa
 
 
-class WebservicesTests(TestCase):
-    def setUp(self):
-        super().setUp()
-        self.config = self.useFixture(testfixtures.ConfigFixture())
-
[e-mail]("mocked_config")
+class TestWebservices:
     @responses.activate
     def test_issue_store_admin_success(self):
         gw_url = "http://store.local/"
@@ -37,11 +32,10 @@ class WebservicesTests(TestCase):
             "POST", issue_store_admin_url, status=200, json={"macaroon": "dummy"}
         )
 
-        self.assertEqual("dummy", webservices.issue_store_admin(gw_url))
+        assert "dummy" == webservices.issue_store_admin(gw_url)
 
     @responses.activate
-    def test_issue_store_admin_error(self):
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_issue_store_admin_error(self, caplog):
         gw_url = "http://store.local/"
         issue_store_admin_url = urljoin(gw_url, "/v2/auth/issue-store-admin")
         responses.add(
@@ -51,11 +45,11 @@ class WebservicesTests(TestCase):
             json=factory.APIError.single("Something went wrong").to_dict(),
         )
 
-        self.assertRaises(HTTPError, webservices.issue_store_admin, gw_url)
-        self.assertEqual(
-            "Failed to issue store_admin macaroon:\nSomething went wrong\n",
-            logger.output,
-        )
+        pytest.raises(HTTPError, webservices.issue_store_admin, gw_url)
+        assert [
+            "Failed to issue store_admin macaroon:",
+            "Something went wrong",
+        ] == caplog.messages
 
     @responses.activate
     def test_get_sso_discharge_success(self):
@@ -65,22 +59,16 @@ class WebservicesTests(TestCase):
             "POST", discharge_url, status=200, json={"discharge_macaroon": "dummy"}
         )
 
-        self.assertEqual(
-            "dummy",
-            webservices.get_sso_discharge(
-                sso_url, "[e-mail]", "secret", "caveat"
-            ),
+        assert "dummy" == webservices.get_sso_discharge(
+            sso_url, "[e-mail]", "secret", "caveat"
         )
         request = responses.calls[0].request
-        self.assertEqual("application/json", request.headers["Content-Type"])
-        self.assertEqual(
-            {
-                "email": "[e-mail]",
-                "password": "secret",
-                "caveat_id": "caveat",
-            },
-            json.loads(request.body.decode()),
-        )
+        assert "application/json" == request.headers["Content-Type"]
+        assert {
+            "email": "[e-mail]",
+            "password": "secret",
+            "caveat_id": "caveat",
+        } == json.loads(request.body.decode())
 
     @responses.activate
     def test_get_sso_discharge_success_with_otp(self):
@@ -90,27 +78,21 @@ class WebservicesTests(TestCase):
             "POST", discharge_url, status=200, json={"discharge_macaroon": "dummy"}
         )
 
-        self.assertEqual(
-            "dummy",
-            webservices.get_sso_discharge(
-                sso_url,
-                "[e-mail]",
-                "secret",
-                "caveat",
-                one_time_password="123456",
-            ),
+        assert "dummy" == webservices.get_sso_discharge(
+            sso_url,
+            "[e-mail]",
+            "secret",
+            "caveat",
+            one_time_password="123456",
         )
         request = responses.calls[0].request
-        self.assertEqual("application/json", request.headers["Content-Type"])
-        self.assertEqual(
-            {
-                "email": "[e-mail]",
-                "password": "secret",
-                "caveat_id": "caveat",
-                "otp": "123456",
-            },
-            json.loads(request.body.decode()),
-        )
+        assert "application/json" == request.headers["Content-Type"]
+        assert {
+            "email": "[e-mail]",
+            "password": "secret",
+            "caveat_id": "caveat",
+            "otp": "123456",
+        } == json.loads(request.body.decode())
 
     @responses.activate
     def test_get_sso_discharge_twofactor_required(self):
@@ -123,7 +105,7 @@ class WebservicesTests(TestCase):
             json={"error_list": [{"code": "twofactor-required"}]},
         )
 
-        self.assertRaises(
+        pytest.raises(
             exceptions.StoreTwoFactorAuthenticationRequired,
             webservices.get_sso_discharge,
             sso_url,
@@ -147,7 +129,7 @@ class WebservicesTests(TestCase):
             },
         )
 
-        e = self.assertRaises(
+        e = pytest.raises(
             exceptions.StoreAuthenticationError,
             webservices.get_sso_discharge,
             sso_url,
@@ -155,16 +137,15 @@ class WebservicesTests(TestCase):
             "secret",
             "caveat",
         )
-        self.assertEqual("Something went wrong", e.message)
+        assert "Authentication error: Something went wrong" == str(e.value)
 
     @responses.activate
-    def test_get_sso_discharge_unstructured_error(self):
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_get_sso_discharge_unstructured_error(self, caplog):
         sso_url = "http://sso.local/"
         discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
         responses.add("POST", discharge_url, status=503, body="Try again later.")
 
-        self.assertRaises(
+        pytest.raises(
             HTTPError,
             webservices.get_sso_discharge,
             sso_url,
@@ -172,17 +153,15 @@ class WebservicesTests(TestCase):
             "secret",
             "caveat",
         )
-        self.assertEqual(
-            "Failed to get SSO discharge:\n"
-            "====================\n"
-            "Try again later.\n"
-            "====================\n",
-            logger.output,
-        )
+        assert [
+            "Failed to get SSO discharge:",
+            "====================",
+            "Try again later.",
+            "====================",
+        ] == caplog.messages
 
     @responses.activate
-    def test_get_overrides_success(self):
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_get_overrides_success(self, caplog):
         overrides = [factory.SnapDeviceGateway.Override()]
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
@@ -190,17 +169,18 @@ class WebservicesTests(TestCase):
         overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides/mysnap")
         responses.add("GET", overrides_url, status=200, json=overrides)
 
-        self.assertEqual(overrides, webservices.get_overrides(store, "mysnap"))
+        assert overrides == webservices.get_overrides(store, "mysnap")
         request = responses.calls[0].request
-        self.assertThat(
-            request.headers["Authorization"],
-            matchers.MacaroonHeaderVerifies(self.config.key),
+        assert (
+            matchers.MacaroonHeaderVerifies("random-key").match(
+                request.headers["Authorization"]
+            )
+            is None
         )
-        self.assertNotIn("Failed to get overrides:", logger.output)
+        assert "Failed to get overrides:" not in caplog.messages
 
     @responses.activate
-    def test_get_overrides_error(self):
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_get_overrides_error(self, caplog):
         store = config.Config().store_section("default")
         overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides/mysnap")
         responses.add(
@@ -210,14 +190,11 @@ class WebservicesTests(TestCase):
             json=factory.APIError.single("Something went wrong").to_dict(),
         )
 
-        self.assertRaises(HTTPError, webservices.get_overrides, store, "mysnap")
-        self.assertEqual(
-            "Failed to get overrides:\nSomething went wrong\n", logger.output
-        )
+        pytest.raises(HTTPError, webservices.get_overrides, store, "mysnap")
+        assert ["Failed to get overrides:", "Something went wrong"] == caplog.messages
 
     @responses.activate
-    def test_set_overrides_success(self):
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_set_overrides_success(self, caplog):
         override = factory.SnapDeviceGateway.Override()
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
@@ -225,26 +202,8 @@ class WebservicesTests(TestCase):
         overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides")
         responses.add("POST", overrides_url, status=200, json=[override])
 
-        self.assertEqual(
-            [override],
-            webservices.set_overrides(
-                store,
-                [
-                    {
-                        "snap_name": override["snap_name"],
-                        "revision": override["revision"],
-                        "channel": override["channel"],
-                        "series": override["series"],
-                    }
-                ],
-            ),
-        )
-        request = responses.calls[0].request
-        self.assertThat(
-            request.headers["Authorization"],
-            matchers.MacaroonHeaderVerifies(self.config.key),
-        )
-        self.assertEqual(
+        assert [override] == webservices.set_overrides(
+            store,
             [
                 {
                     "snap_name": override["snap_name"],
@@ -253,13 +212,27 @@ class WebservicesTests(TestCase):
                     "series": override["series"],
                 }
             ],
-            json.loads(request.body.decode()),
         )
-        self.assertNotIn("Failed to set override:", logger.output)
+        request = responses.calls[0].request
+        assert (
+            matchers.MacaroonHeaderVerifies("random-key").match(
+                request.headers["Authorization"]
+            )
+            is None
+        )
+
+        assert [
+            {
+                "snap_name": override["snap_name"],
+                "revision": override["revision"],
+                "channel": override["channel"],
+                "series": override["series"],
+            }
+        ] == json.loads(request.body.decode())
+        assert "Failed to set override:" not in caplog.messages
 
     @responses.activate
-    def test_set_overrides_error(self):
-        logger = self.useFixture(fixtures.FakeLogger())
+    def test_set_overrides_error(self, caplog):
         override = factory.SnapDeviceGateway.Override()
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
@@ -272,7 +245,7 @@ class WebservicesTests(TestCase):
             json=factory.APIError.single("Something went wrong").to_dict(),
         )
 
-        self.assertRaises(
+        pytest.raises(
             HTTPError,
             lambda: webservices.set_overrides(
                 store,
@@ -284,6 +257,4 @@ class WebservicesTests(TestCase):
                 },
             ),
         )
-        self.assertEqual(
-            "Failed to set override:\nSomething went wrong\n", logger.output
-        )
+        assert ["Failed to set override:", "Something went wrong"] == caplog.messages