Merge ~adam-collard/maas:less-testtools into maas:master

[Adam Collard]

refactor(pserv/*): replace testtools' expectThat with unittest

refactor(pserv/drivers/hardware): replace testtools with unittest

[Anton Troyanov (troyanov)]

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b less-testtools lp:~adam-collard/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas-tester/4199/console
COMMIT: ceddd187e1b20f2590eb5ba1dc87046584d1a02e

review: Needs Fixing

[MAAS Lander (maas-lander)]

UNIT TESTS
-b less-testtools lp:~adam-collard/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 4e7ad7e674ecf182a46a255f26dca354a87e0757

review: Approve

diff --git a/src/provisioningserver/drivers/hardware/tests/test_seamicro.py b/src/provisioningserver/drivers/hardware/tests/test_seamicro.py
index f06111c..0907960 100644
--- a/src/provisioningserver/drivers/hardware/tests/test_seamicro.py
+++ b/src/provisioningserver/drivers/hardware/tests/test_seamicro.py
@@ -14,11 +14,6 @@ from twisted.internet.threads import deferToThread
 
 from maastesting import get_testing_timeout
 from maastesting.factory import factory
-from maastesting.matchers import (
-    MockCalledOnceWith,
-    MockCalledWith,
-    MockCallsMatch,
-)
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from provisioningserver.drivers.hardware import seamicro
 from provisioningserver.drivers.hardware.seamicro import (
@@ -39,9 +34,9 @@ from provisioningserver.utils.twisted import asynchronous
 class FakeResponse:
     def __init__(self, response_code, response, is_json=False):
         self.response_code = response_code
-        self.response = response
         if is_json:
-            self.response = json.dumps(response)
+            response = json.dumps(response)
+        self.response = response
 
     def getcode(self):
         return self.response_code
@@ -163,7 +158,7 @@ class TestSeaMicroAPIV09(MAASTestCase):
     def assert_put_power_called(self, mock, idx, new_status, *params):
         location = "servers/%d" % idx
         params = ["action=%s" % new_status] + list(params)
-        self.assertThat(mock, MockCalledOnceWith(location, params=params))
+        mock.assert_called_once_with(location, params=params)
 
     def test_put_server_power_on_using_pxe(self):
         token = factory.make_string()
@@ -251,12 +246,11 @@ class TestSeaMicro(MAASTestCase):
             password,
             "ipmi",
         )
-        self.assertThat(
-            mock,
-            MockCallsMatch(
+        mock.assert_has_calls(
+            [
                 call("v2.0", ip, username, password),
                 call("v0.9", ip, username, password),
-            ),
+            ]
         )
 
     def test_find_seamicro15k_servers_restapi(self):
@@ -269,9 +263,7 @@ class TestSeaMicro(MAASTestCase):
             password,
             "restapi",
         )
-        self.assertThat(
-            mock, MockCalledOnceWith("v0.9", ip, username, password)
-        )
+        mock.assert_called_once_with("v0.9", ip, username, password)
 
     def test_find_seamicro15k_servers_restapi2(self):
         mock, ip, username, password = self.configure_get_seamicro15k_api()
@@ -283,9 +275,7 @@ class TestSeaMicro(MAASTestCase):
             password,
             "restapi2",
         )
-        self.assertThat(
-            mock, MockCalledOnceWith("v2.0", ip, username, password)
-        )
+        mock.assert_called_once_with("v2.0", ip, username, password)
 
     def configure_api_v09_login(self, token=None):
         token = token or factory.make_string()
@@ -349,17 +339,14 @@ class TestSeaMicro(MAASTestCase):
             "power_pass": password,
             "power_user": username,
         }
-        self.expectThat(
-            mock_create_node,
-            MockCalledWith(
-                last["serverMacAddr"],
-                "amd64",
-                "sm15k",
-                power_params,
-                domain=domain,
-            ),
+        mock_create_node.assert_called_with(
+            last["serverMacAddr"],
+            "amd64",
+            "sm15k",
+            power_params,
+            domain=domain,
         )
-        self.expectThat(mock_commission_node, MockCalledWith(system_id, user))
+        mock_commission_node.assert_called_with(system_id, user)
 
     def test_power_control_seamicro15k_v09(self):
         self.configure_api_v09_login()
@@ -369,9 +356,7 @@ class TestSeaMicro(MAASTestCase):
         mock = self.patch(SeaMicroAPIV09, "power_server")
 
         power_control_seamicro15k_v09(ip, username, password, "25", "on")
-        self.assertThat(
-            mock, MockCalledOnceWith("25/0", POWER_STATUS.ON, do_pxe=True)
-        )
+        mock.assert_called_once_with("25/0", POWER_STATUS.ON, do_pxe=True)
 
     def test_power_control_seamicro15k_v09_retry_failure(self):
         self.configure_api_v09_login()
@@ -439,9 +424,8 @@ class TestSeaMicro(MAASTestCase):
         )
         self.assertEqual(2, mock_create_node.call_count)
 
-        self.expectThat(
-            mock_create_node,
-            MockCallsMatch(
+        mock_create_node.assert_has_calls(
+            [
                 call(
                     fake_server_0.get_fake_macs(),
                     "amd64",
@@ -468,9 +452,9 @@ class TestSeaMicro(MAASTestCase):
                     },
                     domain=None,
                 ),
-            ),
+            ]
         )
-        self.expectThat(mock_commission_node, MockCalledWith(system_id, user))
+        mock_commission_node.assert_called_with(system_id, user)
 
     def test_power_control_seamicro15k_v2(self):
         ip = factory.make_ipv4_address()
@@ -487,7 +471,7 @@ class TestSeaMicro(MAASTestCase):
         mock_get_api.return_value = fake_client
 
         power_control_seamicro15k_v2(ip, username, password, "0", "on")
-        self.assertThat(mock_power_on, MockCalledOnceWith(using_pxe=True))
+        mock_power_on.assert_called_once_with(using_pxe=True)
 
     def test_power_control_seamicro15k_v2_raises_error_when_api_None(self):
         ip = factory.make_ipv4_address()
diff --git a/src/provisioningserver/drivers/hardware/tests/test_ucsm.py b/src/provisioningserver/drivers/hardware/tests/test_ucsm.py
index ebac33b..87f6a16 100644
--- a/src/provisioningserver/drivers/hardware/tests/test_ucsm.py
+++ b/src/provisioningserver/drivers/hardware/tests/test_ucsm.py
@@ -10,17 +10,11 @@ import urllib.parse
 import urllib.request
 
 from lxml.etree import Element, SubElement, XML
-from testtools.matchers import Equals
 from twisted.internet.defer import inlineCallbacks
 from twisted.internet.threads import deferToThread
 
 from maastesting import get_testing_timeout
 from maastesting.factory import factory
-from maastesting.matchers import (
-    MockCalledOnceWith,
-    MockCallsMatch,
-    MockNotCalled,
-)
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from provisioningserver.drivers.hardware import ucsm
 from provisioningserver.drivers.hardware.ucsm import (
@@ -142,7 +136,7 @@ class TestLogin(MAASTestCase):
         api, mock = make_api_patch_call(self, user=user, password=password)
         api.login()
         fields = {"inName": user, "inPassword": password}
-        self.assertThat(mock, MockCalledOnceWith("aaaLogin", fields))
+        mock.assert_called_once_with("aaaLogin", fields)
 
 
 class TestLogout(MAASTestCase):
@@ -157,7 +151,7 @@ class TestLogout(MAASTestCase):
         cookie = api.cookie
         api.logout()
         fields = {"inCookie": cookie}
-        self.assertThat(mock, MockCalledOnceWith("aaaLogout", fields))
+        mock.assert_called_once_with("aaaLogout", fields)
 
 
 class TestConfigResolveClass(MAASTestCase):
@@ -166,9 +160,7 @@ class TestConfigResolveClass(MAASTestCase):
         api, mock = make_api_patch_call(self)
         api.config_resolve_class(class_id)
         fields = {"cookie": api.cookie, "classId": class_id}
-        self.assertThat(
-            mock, MockCalledOnceWith("configResolveClass", fields, ANY)
-        )
+        mock.assert_called_once_with("configResolveClass", fields, ANY)
 
     def test_with_filters(self):
         class_id = make_class()
@@ -192,18 +184,14 @@ class TestConfigResolveChildren(MAASTestCase):
         api, mock = make_api_patch_call(self)
         api.config_resolve_children(dn, class_id)
         fields = {"inDn": dn, "classId": class_id, "cookie": api.cookie}
-        self.assertThat(
-            mock, MockCalledOnceWith("configResolveChildren", fields)
-        )
+        mock.assert_called_once_with("configResolveChildren", fields)
 
     def test_no_class_id(self):
         dn = make_dn()
         api, mock = make_api_patch_call(self)
         api.config_resolve_children(dn)
         fields = {"inDn": dn, "cookie": api.cookie}
-        self.assertThat(
-            mock, MockCalledOnceWith("configResolveChildren", fields)
-        )
+        mock.assert_called_once_with("configResolveChildren", fields)
 
     def test_return_response(self):
         api, mock = make_api_patch_call(self)
@@ -219,7 +207,7 @@ class TestConfigConfMo(MAASTestCase):
         api, mock = make_api_patch_call(self)
         api.config_conf_mo(dn, config_items)
         fields = {"dn": dn, "cookie": api.cookie}
-        self.assertThat(mock, MockCalledOnceWith("configConfMo", fields, ANY))
+        mock.assert_called_once_with("configConfMo", fields, ANY)
         in_configs = mock.call_args[0][2]
         self.assertEqual(config_items, in_configs[0][:])
 
@@ -240,10 +228,8 @@ class TestCall(MAASTestCase):
         mock_send_request.return_value = response
 
         api._call(name, fields, children)
-        self.assertThat(
-            mock_make_request_data, MockCalledOnceWith(name, fields, children)
-        )
-        self.assertThat(mock_send_request, MockCalledOnceWith(request))
+        mock_make_request_data.assert_called_once_with(name, fields, children)
+        mock_send_request.assert_called_once_with(request)
 
 
 class TestSendRequest(MAASTestCase):
@@ -266,7 +252,7 @@ class TestConfigResolveDn(MAASTestCase):
         test_dn = make_dn()
         fields = {"cookie": api.cookie, "dn": test_dn}
         api.config_resolve_dn(test_dn)
-        self.assertThat(mock, MockCalledOnceWith("configResolveDn", fields))
+        mock.assert_called_once_with("configResolveDn", fields)
 
 
 class TestGetServers(MAASTestCase):
@@ -292,7 +278,7 @@ class TestGetServers(MAASTestCase):
         api = make_api()
         mock = self.patch(api, "config_resolve_class")
         get_servers(api, uuid)
-        self.assertThat(mock, MockCalledOnceWith("computeItem", ANY))
+        mock.assert_called_once_with("computeItem", ANY)
 
 
 class TestProbeLanBootOptions(MAASTestCase):
@@ -309,16 +295,11 @@ class TestProbeLanBootOptions(MAASTestCase):
         )
         mock_config_resolve_children.return_value = fake_result
         self.assertEqual(1, len(probe_lan_boot_options(api, server)))
-        self.assertThat(
-            mock_config_resolve_children,
-            MockCalledOnceWith(sentinel.profile_get),
-        )
-        self.assertThat(
-            mock_service_profile.get, MockCalledOnceWith("operBootPolicyName")
-        )
-        self.assertThat(
-            mock_get_service_profile, MockCalledOnceWith(api, server)
+        mock_config_resolve_children.assert_called_once_with(
+            sentinel.profile_get
         )
+        mock_service_profile.get.assert_called_once_with("operBootPolicyName")
+        mock_get_service_profile.assert_called_once_with(api, server)
 
 
 class TestGetChildren(MAASTestCase):
@@ -340,7 +321,7 @@ class TestGetChildren(MAASTestCase):
         in_element = Element("test", {"dn": parent_dn})
         class_id = search_class
         get_children(api, in_element, class_id)
-        self.assertThat(mock, MockCalledOnceWith(parent_dn, search_class))
+        mock.assert_called_once_with(parent_dn, search_class)
 
 
 class TestGetMacs(MAASTestCase):
@@ -359,12 +340,11 @@ class TestGetMacs(MAASTestCase):
 
         mock.side_effect = fake_get_children
         macs = get_macs(api, server)
-        self.assertThat(
-            mock,
-            MockCallsMatch(
+        mock.assert_has_calls(
+            [
                 call(api, server, "adaptorUnit"),
                 call(api, adaptor, "adaptorHostEthIf"),
-            ),
+            ]
         )
         self.assertEqual([mac], macs)
 
@@ -374,7 +354,7 @@ class TestProbeServers(MAASTestCase):
         api = make_api()
         mock = self.patch(ucsm, "get_servers")
         probe_servers(api)
-        self.assertThat(mock, MockCalledOnceWith(api))
+        mock.assert_called_once_with(api)
 
     def test_returns_results(self):
         servers = [{"uuid": factory.make_UUID()}]
@@ -415,7 +395,7 @@ class TestGetServerPowerControl(MAASTestCase):
         dn = make_dn()
         server = Element("computeItem", {"assignedToDn": dn})
         power_control = get_server_power_control(api, server)
-        self.assertThat(mock, MockCalledOnceWith(dn, "lsPower"))
+        mock.assert_called_once_with(dn, "lsPower")
         self.assertEqual("lsPower", power_control.tag)
 
 
@@ -427,7 +407,7 @@ class TestSetServerPowerControl(MAASTestCase):
         config_conf_mo_mock = self.patch(api, "config_conf_mo")
         state = "state"
         set_server_power_control(api, power_control, state)
-        self.assertThat(config_conf_mo_mock, MockCalledOnceWith(power_dn, ANY))
+        config_conf_mo_mock.assert_called_once_with(power_dn, ANY)
         power_change = config_conf_mo_mock.call_args[0][1][0]
         self.assertEqual(power_change.tag, "lsPower")
         self.assertEqual({"state": state, "dn": power_dn}, power_change.attrib)
@@ -443,9 +423,9 @@ class TestLoggedIn(MAASTestCase):
 
         with logged_in(url, username, password) as api:
             self.assertEqual(mock.return_value, api)
-            self.assertThat(api.login, MockCalledOnceWith())
+            api.login()
 
-        self.assertThat(mock.return_value.logout, MockCalledOnceWith())
+        mock.return_value.logout.assert_called_once_with()
 
 
 class TestValidGetPowerCommand(MAASTestCase):
@@ -498,10 +478,9 @@ class TestPowerControlUCSM(MAASTestCase):
             ucsm, "set_server_power_control"
         )
         power_control_ucsm("url", "username", "password", uuid, "off")
-        self.assertThat(get_servers_mock, MockCalledOnceWith(api, uuid))
-        self.assertThat(
-            set_server_power_control_mock,
-            MockCalledOnceWith(api, power_control, state),
+        get_servers_mock.assert_called_once_with(api, uuid)
+        set_server_power_control_mock.assert_called_once_with(
+            api, power_control, state
         )
 
 
@@ -517,8 +496,8 @@ class TestUCSMPowerState(MAASTestCase):
         get_servers_mock.return_value = [make_server("off")]
 
         power_state = power_state_ucsm(url, username, password, uuid)
-        self.expectThat(get_servers_mock, MockCalledOnceWith(api, uuid))
-        self.expectThat(power_state, Equals("off"))
+        get_servers_mock.assert_called_once_with(api, uuid)
+        self.assertEqual(power_state, "off")
 
     def test_power_state_get_on(self):
         url = factory.make_name("url")
@@ -531,8 +510,8 @@ class TestUCSMPowerState(MAASTestCase):
         get_servers_mock.return_value = [make_server("on")]
 
         power_state = power_state_ucsm(url, username, password, uuid)
-        self.expectThat(get_servers_mock, MockCalledOnceWith(api, uuid))
-        self.expectThat(power_state, Equals("on"))
+        get_servers_mock.assert_called_once_with(api, uuid)
+        self.assertEqual(power_state, "on")
 
     def test_power_state_error_on_unknown_state(self):
         url = factory.make_name("url")
@@ -576,23 +555,18 @@ class TestProbeAndEnlistUCSM(MAASTestCase):
         yield deferToThread(
             probe_and_enlist_ucsm, user, url, username, password, True, domain
         )
-        self.expectThat(
-            set_lan_boot_default_mock, MockCalledOnceWith(api, server_element)
-        )
-        self.expectThat(probe_servers_mock, MockCalledOnceWith(api))
+        set_lan_boot_default_mock.assert_called_once_with(api, server_element)
+        probe_servers_mock.assert_called_once_with(api)
         params = {
             "power_address": url,
             "power_user": username,
             "power_pass": password,
             "uuid": server[0]["uuid"],
         }
-        self.expectThat(
-            create_node_mock,
-            MockCalledOnceWith(server[1], "amd64", "ucsm", params, domain),
-        )
-        self.expectThat(
-            commission_node_mock, MockCalledOnceWith(system_id, user)
+        create_node_mock.assert_called_once_with(
+            server[1], "amd64", "ucsm", params, domain
         )
+        commission_node_mock.assert_called_once_with(system_id, user)
 
 
 class TestGetServiceProfile(MAASTestCase):
@@ -605,7 +579,7 @@ class TestGetServiceProfile(MAASTestCase):
             "configResolveDn", "lsServer", "outConfig"
         )
         service_profile = get_service_profile(api, server)
-        self.assertThat(mock, MockCalledOnceWith(test_dn))
+        mock.assert_called_once_with(test_dn)
         self.assertEqual(mock.return_value[0], service_profile)
 
 
@@ -646,7 +620,7 @@ class TestsForStripRoKeys(MAASTestCase):
         attributes = {key: "DC" for key in RO_KEYS}
 
         elements = [
-            Element("Element%d" % i, attributes)
+            Element(f"Element{i}", attributes)
             for i in range(random.randint(0, 10))
         ]
 
@@ -667,7 +641,7 @@ class TestMakePolicyChange(MAASTestCase):
         mock.return_value = boot_profile_response[0]
         change = make_policy_change(boot_profile_response)
         self.assertIsNone(change)
-        self.assertThat(mock, MockCalledOnceWith(boot_profile_response))
+        mock.assert_called_once_with(boot_profile_response)
 
     def test_change_lan_to_top_priority(self):
         boot_profile_response = Element("outConfigs")
@@ -694,7 +668,7 @@ class TestSetLanBootDefault(MAASTestCase):
         self.patch(ucsm, "make_policy_change").return_value = None
         config_conf_mo = self.patch(api, "config_conf_mo")
         set_lan_boot_default(api, server)
-        self.assertThat(config_conf_mo, MockNotCalled())
+        config_conf_mo.assert_not_called()
 
     def test_with_change(self):
         api = make_api()
@@ -707,6 +681,4 @@ class TestSetLanBootDefault(MAASTestCase):
         self.patch(ucsm, "make_policy_change").return_value = test_change
         config_conf_mo = self.patch(api, "config_conf_mo")
         set_lan_boot_default(api, server)
-        self.assertThat(
-            config_conf_mo, MockCalledOnceWith(test_dn, [test_change])
-        )
+        config_conf_mo.assert_called_once_with(test_dn, [test_change])
diff --git a/src/provisioningserver/drivers/hardware/tests/test_virsh.py b/src/provisioningserver/drivers/hardware/tests/test_virsh.py
index 0711efa..5c124a0 100644
--- a/src/provisioningserver/drivers/hardware/tests/test_virsh.py
+++ b/src/provisioningserver/drivers/hardware/tests/test_virsh.py
@@ -11,13 +11,11 @@ from unittest.mock import call
 
 from lxml import etree
 import pexpect
-from testtools.testcase import ExpectedException
 from twisted.internet.defer import inlineCallbacks
 from twisted.internet.threads import deferToThread
 
 from maastesting import get_testing_timeout
 from maastesting.factory import factory
-from maastesting.matchers import MockCalledOnceWith, MockCallsMatch
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from provisioningserver.drivers.hardware import virsh
 from provisioningserver.utils.arch import KERNEL_TO_DEBIAN_ARCHITECTURES
@@ -130,7 +128,7 @@ class TestVirshSSH(MAASTestCase):
         conn = self.configure_virshssh_pexpect(virsh_outputs)
         mock_sendline = self.patch(conn, "sendline")
         conn.login(poweraddr=None)
-        self.assertThat(mock_sendline, MockCalledOnceWith("yes"))
+        mock_sendline.assert_called_once_with("yes")
 
     def test_login_with_password(self):
         virsh_outputs = [
@@ -140,7 +138,7 @@ class TestVirshSSH(MAASTestCase):
         fake_password = factory.make_name("password")
         mock_sendline = self.patch(conn, "sendline")
         conn.login(poweraddr=None, password=fake_password)
-        self.assertThat(mock_sendline, MockCalledOnceWith(fake_password))
+        mock_sendline.assert_called_once_with(fake_password)
 
     def test_login_missing_password(self):
         virsh_outputs = [
@@ -149,22 +147,22 @@ class TestVirshSSH(MAASTestCase):
         conn = self.configure_virshssh_pexpect(virsh_outputs)
         mock_close = self.patch(conn, "close")
         self.assertFalse(conn.login(poweraddr=None, password=None))
-        self.assertThat(mock_close, MockCalledOnceWith())
+        mock_close.assert_called_once_with()
 
     def test_login_invalid(self):
         virsh_outputs = [factory.make_string()]
         conn = self.configure_virshssh_pexpect(virsh_outputs)
         mock_close = self.patch(conn, "close")
         self.assertFalse(conn.login(poweraddr=None))
-        self.assertThat(mock_close, MockCalledOnceWith())
+        mock_close.assert_called_once_with()
 
     def test_logout(self):
         conn = self.configure_virshssh_pexpect()
         mock_sendline = self.patch(conn, "sendline")
         mock_close = self.patch(conn, "close")
         conn.logout()
-        self.assertThat(mock_sendline, MockCalledOnceWith("quit"))
-        self.assertThat(mock_close, MockCalledOnceWith())
+        mock_sendline.assert_called_once_with("quit")
+        mock_close.assert_called_once_with()
 
     def test_prompt(self):
         virsh_outputs = ["virsh # "]
@@ -185,8 +183,8 @@ class TestVirshSSH(MAASTestCase):
         mock_sendline = self.patch(conn, "sendline")
         mock_prompt = self.patch(conn, "prompt")
         output = conn.run(cmd)
-        self.assertThat(mock_sendline, MockCalledOnceWith(expected))
-        self.assertThat(mock_prompt, MockCalledOnceWith())
+        mock_sendline.assert_called_once_with(expected)
+        mock_prompt.assert_called_once_with()
         self.assertEqual("\n".join(names), output)
 
     def test_list(self):
@@ -242,11 +240,8 @@ class TestVirshSSH(MAASTestCase):
         c_utf8_environment = get_env_with_locale()
         mock_spawn = self.patch(pexpect.spawn, "__init__")
         self.configure_virshssh("")
-        self.assertThat(
-            mock_spawn,
-            MockCalledOnceWith(
-                None, timeout=30, maxread=2000, env=c_utf8_environment
-            ),
+        mock_spawn.assert_called_once_with(
+            None, timeout=30, maxread=2000, env=c_utf8_environment
         )
 
 
@@ -359,15 +354,12 @@ class TestVirsh(MAASTestCase):
 
         # Check that login was called with the provided poweraddr and
         # password.
-        self.expectThat(
-            mock_login, MockCalledOnceWith(poweraddr, fake_password)
-        )
+        mock_login.assert_called_once_with(poweraddr, fake_password)
 
         # Check that the create command had the correct parameters for
         # each machine.
-        self.expectThat(
-            mock_create_node,
-            MockCallsMatch(
+        mock_create_node.assert_has_calls(
+            [
                 call(
                     fake_macs[0],
                     fake_arch,
@@ -408,24 +400,25 @@ class TestVirsh(MAASTestCase):
                     domain,
                     machines[4],
                 ),
-            ),
+            ]
         )
 
         # The first and last machine should have poweroff called on it, as it
         # was initial in the on state.
-        self.expectThat(
-            mock_poweroff, MockCallsMatch(call(machines[0]), call(machines[3]))
-        )
+        mock_poweroff.assert_has_calls([call(machines[0]), call(machines[3])])
 
-        self.assertThat(mock_logout, MockCalledOnceWith())
-        self.expectThat(
-            mock_commission_node,
-            MockCallsMatch(
+        mock_logout.assert_called_once_with()
+        mock_commission_node.assert_has_calls(
+            [
                 call(system_id, user),
+                call().wait(30),
                 call(system_id, user),
+                call().wait(30),
                 call(system_id, user),
+                call().wait(30),
                 call(system_id, user),
-            ),
+                call().wait(30),
+            ]
         )
 
     @inlineCallbacks
@@ -434,7 +427,9 @@ class TestVirsh(MAASTestCase):
         poweraddr = factory.make_name("poweraddr")
         mock_login = self.patch(virsh.VirshSSH, "login")
         mock_login.return_value = False
-        with ExpectedException(virsh.VirshError):
+        with self.assertRaisesRegex(
+            virsh.VirshError, r"^Failed to login to virsh console\.$"
+        ):
             yield deferToThread(
                 virsh.probe_virsh_and_enlist,
                 user,
@@ -469,9 +464,9 @@ class TestVirshPowerControl(MAASTestCase):
         machine = factory.make_name("machine")
         virsh.power_control_virsh(poweraddr, machine, "on")
 
-        self.assertThat(mock_login, MockCalledOnceWith(poweraddr, None))
-        self.assertThat(mock_state, MockCalledOnceWith(machine))
-        self.assertThat(mock_poweron, MockCalledOnceWith(machine))
+        mock_login.assert_called_once_with(poweraddr, None)
+        mock_state.assert_called_once_with(machine)
+        mock_poweron.assert_called_once_with(machine)
 
     def test_power_control_off(self):
         mock_login = self.patch(virsh.VirshSSH, "login")
@@ -484,9 +479,9 @@ class TestVirshPowerControl(MAASTestCase):
         machine = factory.make_name("machine")
         virsh.power_control_virsh(poweraddr, machine, "off")
 
-        self.assertThat(mock_login, MockCalledOnceWith(poweraddr, None))
-        self.assertThat(mock_state, MockCalledOnceWith(machine))
-        self.assertThat(mock_poweroff, MockCalledOnceWith(machine))
+        mock_login.assert_called_once_with(poweraddr, None)
+        mock_state.assert_called_once_with(machine)
+        mock_poweroff.assert_called_once_with(machine)
 
     def test_power_control_bad_domain(self):
         mock_login = self.patch(virsh.VirshSSH, "login")
diff --git a/src/provisioningserver/drivers/hardware/tests/test_vmware.py b/src/provisioningserver/drivers/hardware/tests/test_vmware.py
index 433b452..a52a93e 100644
--- a/src/provisioningserver/drivers/hardware/tests/test_vmware.py
+++ b/src/provisioningserver/drivers/hardware/tests/test_vmware.py
@@ -7,8 +7,6 @@
 
 import random
 
-from testtools import ExpectedException
-from testtools.matchers import Equals, Is, IsInstance, Not
 from twisted.internet.defer import inlineCallbacks
 from twisted.internet.threads import deferToThread
 
@@ -16,10 +14,6 @@ from maastesting import get_testing_timeout
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from provisioningserver.drivers.hardware import vmware
-from provisioningserver.drivers.hardware.vmware import (
-    VMwarePyvmomiAPI,
-    VMwareVMNotFound,
-)
 from provisioningserver.utils.twisted import asynchronous
 
 
@@ -53,8 +47,7 @@ class FakeVmomiVMRuntime:
 
 
 class FakeVmomiVMConfigHardwareDevice:
-    def __init__(self):
-        pass
+    pass
 
 
 class FakeVmomiNic(FakeVmomiVMConfigHardwareDevice):
@@ -246,35 +239,36 @@ class TestVMwarePyvmomi(MAASTestCase):
 
     def test_api_connection(self):
         mock_vmomi_api = self.configure_vmomi_api(servers=0)
-        api = VMwarePyvmomiAPI(
+        api = vmware.VMwarePyvmomiAPI(
             factory.make_hostname(),
             factory.make_username(),
             factory.make_username(),
         )
         api.connect()
-        self.expectThat(
-            api.service_instance, IsInstance(FakeVmomiServiceInstance)
-        )
-        self.expectThat(api.is_connected(), Equals(True))
+        self.assertIsInstance(api.service_instance, FakeVmomiServiceInstance)
+        self.assertTrue(api.is_connected())
         api.disconnect()
-        self.expectThat(mock_vmomi_api.SmartConnect.called, Equals(True))
-        self.expectThat(mock_vmomi_api.Disconnect.called, Equals(True))
+        self.assertTrue(mock_vmomi_api.SmartConnect.called)
+        self.assertTrue(mock_vmomi_api.Disconnect.called)
 
     def test_api_failed_connection(self):
         mock_vmomi_api = self.patch(vmware, "vmomi_api")
         mock_vmomi_api.SmartConnect.return_value = None
-        api = VMwarePyvmomiAPI(
+        api = vmware.VMwarePyvmomiAPI(
             factory.make_hostname(),
             factory.make_username(),
             factory.make_username(),
         )
-        with ExpectedException(vmware.VMwareAPIConnectionFailed):
+        with self.assertRaisesRegex(
+            vmware.VMwareAPIConnectionFailed,
+            "^Could not connect to VMware service API$",
+        ):
             api.connect()
-        self.expectThat(api.service_instance, Is(None))
-        self.expectThat(api.is_connected(), Equals(False))
+        self.assertIsNone(api.service_instance)
+        self.assertFalse(api.is_connected())
         api.disconnect()
-        self.expectThat(mock_vmomi_api.SmartConnect.called, Equals(True))
-        self.expectThat(mock_vmomi_api.Disconnect.called, Equals(True))
+        self.assertTrue(mock_vmomi_api.SmartConnect.called)
+        self.assertTrue(mock_vmomi_api.Disconnect.called)
 
     def test_get_vmware_servers_empty(self):
         self.configure_vmomi_api(servers=0)
@@ -285,7 +279,7 @@ class TestVMwarePyvmomi(MAASTestCase):
             port=8443,
             protocol="https",
         )
-        self.expectThat(servers, Equals({}))
+        self.assertEqual(servers, {})
 
     def test_get_vmware_servers(self):
         self.configure_vmomi_api(servers=10)
@@ -294,7 +288,7 @@ class TestVMwarePyvmomi(MAASTestCase):
             factory.make_username(),
             factory.make_username(),
         )
-        self.expectThat(servers, Not(Equals({})))
+        self.assertNotEqual(servers, {})
 
     def test_get_server_by_instance_uuid(self):
         mock_vmomi_api = self.configure_vmomi_api(
@@ -336,7 +330,10 @@ class TestVMwarePyvmomi(MAASTestCase):
         mock_vmomi_api = self.configure_vmomi_api(
             servers=1, has_instance_uuid=True, has_uuid=True
         )
-        with ExpectedException(VMwareVMNotFound):
+        with self.assertRaisesRegex(
+            vmware.VMwareVMNotFound,
+            "^Failed to find VM; need a UUID or a VM name for power control$",
+        ):
             vmware._find_vm_by_uuid_or_name(mock_vmomi_api, None, None)
 
     def test_power_control_missing_server_raises_VMwareVMNotFound(self):
@@ -346,7 +343,10 @@ class TestVMwarePyvmomi(MAASTestCase):
         host = factory.make_hostname()
         username = factory.make_username()
         password = factory.make_username()
-        with ExpectedException(VMwareVMNotFound):
+        with self.assertRaisesRegex(
+            vmware.VMwareVMNotFound,
+            "^Failed to find VM; need a UUID or a VM name for power control$",
+        ):
             vmware.power_control_vmware(
                 host, username, password, None, None, "on"
             )
@@ -358,7 +358,10 @@ class TestVMwarePyvmomi(MAASTestCase):
         host = factory.make_hostname()
         username = factory.make_username()
         password = factory.make_username()
-        with ExpectedException(VMwareVMNotFound):
+        with self.assertRaisesRegex(
+            vmware.VMwareVMNotFound,
+            "^Failed to find VM; need a UUID or a VM name for power control$",
+        ):
             vmware.power_query_vmware(host, username, password, None, None)
 
     def test_power_control(self):
@@ -399,7 +402,7 @@ class TestVMwarePyvmomi(MAASTestCase):
             state = vmware.power_query_vmware(
                 host, username, password, vm_name, uuid
             )
-            self.expectThat(state, Equals("on"))
+            self.assertEqual(state, "on")
 
         # turn off a set of VMs, then verify they are off
         for uuid in instance_uuids:
@@ -410,9 +413,9 @@ class TestVMwarePyvmomi(MAASTestCase):
             state = vmware.power_query_vmware(
                 host, username, password, vm_name, uuid
             )
-            self.expectThat(state, Equals("off"))
+            self.assertEqual(state, "off")
 
-        self.expectThat(servers, Not(Equals({})))
+        self.assertNotEqual(servers, {})
 
     @inlineCallbacks
     def test_probe_and_enlist(self):
diff --git a/src/provisioningserver/drivers/osystem/tests/test_centos.py b/src/provisioningserver/drivers/osystem/tests/test_centos.py
index aabc7f9..ccc1b4d 100644
--- a/src/provisioningserver/drivers/osystem/tests/test_centos.py
+++ b/src/provisioningserver/drivers/osystem/tests/test_centos.py
@@ -6,8 +6,6 @@
 
 from itertools import product
 
-from testtools.matchers import Equals
-
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
 from provisioningserver.drivers.osystem.centos import (
@@ -53,4 +51,4 @@ class TestCentOS(MAASTestCase):
         }
         osystem = CentOS()
         for name, title in name_titles.items():
-            self.expectThat(osystem.get_release_title(name), Equals(title))
+            self.assertEqual(osystem.get_release_title(name), title)
diff --git a/src/provisioningserver/drivers/osystem/tests/test_esxi.py b/src/provisioningserver/drivers/osystem/tests/test_esxi.py
index 8b60360..cea57d1 100644
--- a/src/provisioningserver/drivers/osystem/tests/test_esxi.py
+++ b/src/provisioningserver/drivers/osystem/tests/test_esxi.py
@@ -6,8 +6,6 @@
 
 from itertools import product
 
-from testtools.matchers import Equals
-
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
 from provisioningserver.drivers.osystem import BOOT_IMAGE_PURPOSE
@@ -47,4 +45,4 @@ class TestESXi(MAASTestCase):
         }
         osystem = ESXi()
         for name, title in name_titles.items():
-            self.expectThat(osystem.get_release_title(name), Equals(title))
+            self.assertEqual(osystem.get_release_title(name), title)
diff --git a/src/provisioningserver/drivers/osystem/tests/test_rhel.py b/src/provisioningserver/drivers/osystem/tests/test_rhel.py
index 709aee9..fc2acd7 100644
--- a/src/provisioningserver/drivers/osystem/tests/test_rhel.py
+++ b/src/provisioningserver/drivers/osystem/tests/test_rhel.py
@@ -6,8 +6,6 @@
 
 from itertools import product
 
-from testtools.matchers import Equals
-
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
 from provisioningserver.drivers.osystem.rhel import (
@@ -51,4 +49,4 @@ class TestRHEL(MAASTestCase):
         }
         osystem = RHELOS()
         for name, title in name_titles.items():
-            self.expectThat(osystem.get_release_title(name), Equals(title))
+            self.assertEqual(osystem.get_release_title(name), title)
diff --git a/src/provisioningserver/tests/test_monkey.py b/src/provisioningserver/tests/test_monkey.py
index 3c38d49..7ddc0ff 100644
--- a/src/provisioningserver/tests/test_monkey.py
+++ b/src/provisioningserver/tests/test_monkey.py
@@ -5,7 +5,6 @@
 
 
 from testtools.deferredruntest import assert_fails_with
-from testtools.matchers import Equals
 from twisted.internet.defer import Deferred
 from twisted.internet.threads import deferToThread
 
@@ -38,58 +37,62 @@ class TestAugmentDeferToThreadPool(MAASTestCase):
 
 class TestPatchedURI(MAASTestCase):
     def test_parses_URL_with_hostname(self):
-        hostname = factory.make_name("host").encode("ascii")
-        path = factory.make_name("path").encode("ascii")
-        uri = get_patched_URI().fromBytes(b"http://%s/%s" % (hostname, path))
-        self.expectThat(uri.host, Equals(hostname))
-        self.expectThat(uri.path, Equals(b"/%s" % path))
-        self.expectThat(uri.port, Equals(80))
+        hostname = factory.make_name("host")
+        path = factory.make_name("path")
+        uri = get_patched_URI().fromBytes(
+            f"http://{hostname}/{path}".encode("utf-8")
+        )
+        self.assertEqual(uri.host, hostname.encode("utf-8"))
+        self.assertEqual(uri.path, f"/{path}".encode("utf-8"))
+        self.assertEqual(uri.port, 80)
 
     def test_parses_URL_with_hostname_and_port(self):
-        hostname = factory.make_name("host").encode("ascii")
+        hostname = factory.make_name("host")
         port = factory.pick_port()
-        path = factory.make_name("path").encode("ascii")
+        path = factory.make_name("path")
         uri = get_patched_URI().fromBytes(
-            b"http://%s:%d/%s" % (hostname, port, path)
+            f"http://{hostname}:{port}/{path}".encode("utf-8")
         )
-        self.expectThat(uri.host, Equals(hostname))
-        self.expectThat(uri.path, Equals(b"/%s" % path))
-        self.expectThat(uri.port, Equals(port))
+        self.assertEqual(uri.host, hostname.encode("utf-8"))
+        self.assertEqual(uri.path, f"/{path}".encode("utf-8"))
+        self.assertEqual(uri.port, port)
 
     def test_parses_URL_with_IPv4_address(self):
-        ip = factory.make_ipv4_address().encode("ascii")
+        ip = factory.make_ipv4_address()
         path = factory.make_name("path").encode("ascii")
-        uri = get_patched_URI().fromBytes(b"http://%s/%s" % (ip, path))
-        self.expectThat(uri.host, Equals(ip))
-        self.expectThat(uri.path, Equals(b"/%s" % path))
-        self.expectThat(uri.port, Equals(80))
+        uri = get_patched_URI().fromBytes(
+            f"http://{ip}/{path}".encode("utf-8")
+        )
+        self.assertEqual(uri.host, ip.encode("utf-8"))
+        self.assertEqual(uri.path, f"/{path}".encode("utf-8"))
+        self.assertEqual(uri.port, 80)
 
     def test_parses_URL_with_IPv4_address_and_port(self):
-        ip = factory.make_ipv4_address().encode("ascii")
+        ip = factory.make_ipv4_address()
         port = factory.pick_port()
-        path = factory.make_name("path").encode("ascii")
+        path = factory.make_name("path")
         uri = get_patched_URI().fromBytes(
-            b"http://%s:%d/%s" % (ip, port, path)
+            f"http://{ip}:{port}/{path}".encode("utf-8")
         )
-        self.expectThat(uri.host, Equals(ip))
-        self.expectThat(uri.path, Equals(b"/%s" % path))
-        self.expectThat(uri.port, Equals(port))
+        self.assertEqual(uri.host, ip.encode("utf-8"))
+        self.assertEqual(uri.path, f"/{path}".encode("utf-8"))
+        self.assertEqual(uri.port, port)
 
     def test_parses_URL_with_IPv6_address(self):
-        ip = factory.make_ipv6_address().encode("ascii")
-        path = factory.make_name("path").encode("ascii")
-        uri = get_patched_URI().fromBytes(b"http://[%s]/%s" % (ip, path))
-        self.expectThat(uri.host, Equals(b"%s" % ip))
-        self.expectThat(uri.path, Equals(b"/%s" % path))
-        self.expectThat(uri.port, Equals(80))
+        ip = factory.make_ipv6_address()
+        path = factory.make_name("path")
+        uri = get_patched_URI().fromBytes(f"http://[{ip}]/{path}".encode())
+        self.assertEqual(uri.host, ip.encode("utf-8"))
+        self.assertEqual(uri.path, f"/{path}".encode("utf-8"))
+        self.assertEqual(uri.port, 80)
 
     def test_parses_URL_with_IPv6_address_and_port(self):
-        ip = factory.make_ipv6_address().encode("ascii")
+        ip = factory.make_ipv6_address()
         port = factory.pick_port()
-        path = factory.make_name("path").encode("ascii")
+        path = factory.make_name("path")
         uri = get_patched_URI().fromBytes(
-            b"http://[%s]:%d/%s" % (ip, port, path)
+            f"http://[{ip}]:{port}/{path}".encode()
         )
-        self.expectThat(uri.host, Equals(b"%s" % ip))
-        self.expectThat(uri.path, Equals(b"/%s" % path))
-        self.expectThat(uri.port, Equals(port))
+        self.assertEqual(uri.host, ip.encode("utf-8"))
+        self.assertEqual(uri.path, f"/{path}".encode("utf-8"))
+        self.assertEqual(uri.port, port)
diff --git a/src/provisioningserver/utils/tests/test_events.py b/src/provisioningserver/utils/tests/test_events.py
index c9a677f..c3c64bb 100644
--- a/src/provisioningserver/utils/tests/test_events.py
+++ b/src/provisioningserver/utils/tests/test_events.py
@@ -6,8 +6,6 @@
 
 from unittest.mock import MagicMock, sentinel
 
-from testtools.matchers import IsInstance
-
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
 from provisioningserver.utils.events import Event, EventGroup
@@ -64,4 +62,4 @@ class TestEventGroup(MAASTestCase):
         events = [factory.make_name("event") for _ in range(3)]
         group = EventGroup(*events)
         for event in events:
-            self.expectThat(getattr(group, event), IsInstance(Event))
+            self.assertIsInstance(getattr(group, event), Event)
diff --git a/src/provisioningserver/utils/tests/test_text.py b/src/provisioningserver/utils/tests/test_text.py
index 5e6f949..c585619 100644
--- a/src/provisioningserver/utils/tests/test_text.py
+++ b/src/provisioningserver/utils/tests/test_text.py
@@ -8,7 +8,6 @@ from itertools import repeat
 import string
 
 import hypothesis.strategies
-from testtools.matchers import Equals
 
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
@@ -111,9 +110,9 @@ class TestNormalizeToCommaListScenarios(MAASTestCase):
 
     def test_scenarios(self):
         unquoted = normalise_to_comma_list(self.test_input)
-        self.expectThat(unquoted, Equals(self.unquoted))
+        self.assertEqual(unquoted, self.unquoted)
         quoted = normalise_to_comma_list(self.test_input, quoted=True)
-        self.expectThat(quoted, Equals(self.quoted))
+        self.assertEqual(quoted, self.quoted)
 
 
 class TestSplitStringList(MAASTestCase):