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

[Adam Collard]

refactor(pserver/boot): 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: SUCCESS
COMMIT: 467a88fab56ba249e0ad8e19ad9a2a616c2bd32c

review: Approve

[MAAS Lander (maas-lander)]

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

STATUS: FAILED BUILD
LOG: http://maas-ci.internal:8080/job/maas-tester/4176/console

[MAAS Lander (maas-lander)]

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

STATUS: FAILED BUILD
LOG: http://maas-ci.internal:8080/job/maas-tester/4177/console

f396ae1... by Adam Collard on 2023-12-04

fix(api/test_partitions): avoid creating disks in partition tests

Missing partitions shouldn't rely on happening to not find a partition
id that exists.

diff --git a/src/maasserver/api/tests/test_partitions.py b/src/maasserver/api/tests/test_partitions.py
index 8962259..fdd51a3 100644
--- a/src/maasserver/api/tests/test_partitions.py
+++ b/src/maasserver/api/tests/test_partitions.py
@@ -375,7 +375,9 @@ class TestPartitions(APITestCase.ForUser):
 
     def test_format_missing_partition(self):
         self.become_admin()
-        node = factory.make_Node(status=NODE_STATUS.READY)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, with_boot_disk=False
+        )
         device = factory.make_PhysicalBlockDevice(
             node=node,
             size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE,
@@ -491,7 +493,9 @@ class TestPartitions(APITestCase.ForUser):
 
     def test_unformat_missing_partition(self):
         self.become_admin()
-        node = factory.make_Node(status=NODE_STATUS.READY)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, with_boot_disk=False
+        )
         device = factory.make_PhysicalBlockDevice(
             node=node,
             size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE,
diff --git a/src/provisioningserver/boot/tests/test_boot.py b/src/provisioningserver/boot/tests/test_boot.py
index f3568a6..ef6b51c 100644
--- a/src/provisioningserver/boot/tests/test_boot.py
+++ b/src/provisioningserver/boot/tests/test_boot.py
@@ -15,7 +15,6 @@ from twisted.python import context
 
 from maastesting import get_testing_timeout
 from maastesting.factory import factory
-from maastesting.matchers import MockCalledOnce, MockCalledOnceWith
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from provisioningserver import boot
 from provisioningserver.boot import (
@@ -71,7 +70,7 @@ class TestBootMethod(MAASTestCase):
 
         mock_find = self.patch(boot, "find_mac_via_arp")
         yield context.call(call_context, get_remote_mac)
-        self.assertThat(mock_find, MockCalledOnceWith(remote_host))
+        mock_find.assert_called_once_with(remote_host)
 
     def test_gen_template_filenames(self):
         purpose = factory.make_name("purpose")
@@ -132,7 +131,7 @@ class TestBootMethod(MAASTestCase):
             method.get_template,
             *factory.make_names("purpose", "arch", "subarch"),
         )
-        self.assertThat(mock_try_send_rack_event, MockCalledOnce())
+        mock_try_send_rack_event.assert_called_once()
 
     def test_get_templates_only_suppresses_ENOENT(self):
         # The IOError arising from trying to load a template that doesn't
@@ -183,8 +182,8 @@ class TestBootMethod(MAASTestCase):
 
             method.link_bootloader(tmp)
 
-            self.assertThat(mock_maaslog, MockCalledOnce())
-            self.assertThat(mock_try_send_rack_event, MockCalledOnce())
+            mock_maaslog.assert_called_once()
+            mock_try_send_rack_event.assert_called_once()
 
     def test_link_bootloader_copies_previous_downloaded_files(self):
         method = FakeBootMethod()
@@ -237,8 +236,8 @@ class TestBootMethod(MAASTestCase):
 
             method.link_bootloader(new_dir)
 
-            self.assertThat(mock_maaslog, MockCalledOnce())
-            self.assertThat(mock_try_send_rack_event, MockCalledOnce())
+            mock_maaslog.assert_called_once()
+            mock_try_send_rack_event.assert_called_once()
 
     def test_compose_template_namespace(self):
         kernel_params = make_kernel_parameters()
diff --git a/src/provisioningserver/boot/tests/test_grub.py b/src/provisioningserver/boot/tests/test_grub.py
index ce7064d..2dbc405 100644
--- a/src/provisioningserver/boot/tests/test_grub.py
+++ b/src/provisioningserver/boot/tests/test_grub.py
@@ -8,15 +8,7 @@ import os
 import random
 import re
 
-from testtools.matchers import (
-    ContainsAll,
-    MatchesAll,
-    MatchesRegex,
-    StartsWith,
-)
-
 from maastesting.factory import factory
-from maastesting.matchers import FileContains, MockAnyCall, MockCalledOnce
 from maastesting.testcase import MAASTestCase
 from provisioningserver import boot
 from provisioningserver.boot import BytesReader
@@ -77,8 +69,8 @@ class TestUEFIAMD64BootMethodRender(MAASTestCase):
         # correctly rendered.
         method = UEFIAMD64BootMethod()
         params = make_kernel_parameters(arch="amd64", purpose="xinstall")
-        fs_host = "(http,%s:5248)/images" % (
-            convert_host_to_uri_str(params.fs_host)
+        fs_host = re.escape(
+            "(http,%s:5248)/images" % (convert_host_to_uri_str(params.fs_host))
         )
         output = method.get_reader(
             backend=None, kernel_params=params, protocol="tftp"
@@ -88,44 +80,24 @@ class TestUEFIAMD64BootMethodRender(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. UEFI configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith('set default="0"'))
+        self.assertTrue(output.startswith('set default="0"'))
         # The UEFI parameters are all set according to the options.
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
 
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*\s+lin.*cc:\\{\'datasource_list\':"
-                    r" \[\'MAAS\'\]\\}end_cc.*",
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+linux  %s/%s/%s .+?$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.kernel,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+initrd %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.initrd,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-            ),
-        )
+        for regex in [
+            r"(?ms).*\s+lin.*cc:\\{\'datasource_list\': \[\'MAAS\'\]\\}end_cc.*",
+            rf"(?ms).*^\s+linux  {fs_host}/{image_dir}/{params.kernel} .+?$",
+            rf"(?ms).*^\s+initrd {fs_host}/{image_dir}/{params.initrd}$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_http(self):
         # Given the right configuration options, the UEFI configuration is
@@ -140,7 +112,7 @@ class TestUEFIAMD64BootMethodRender(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. UEFI configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith('set default="0"'))
+        self.assertTrue(output.startswith('set default="0"'))
         # The UEFI parameters are all set according to the options.
         image_dir = compose_image_path(
             osystem=params.kernel_osystem,
@@ -150,32 +122,12 @@ class TestUEFIAMD64BootMethodRender(MAASTestCase):
             label=params.kernel_label,
         )
 
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*\s+lin.*cc:\\{\'datasource_list\':"
-                    r" \[\'MAAS\'\]\\}end_cc.*",
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+linux  /images/%s/%s .+?$"
-                    % (
-                        re.escape(image_dir),
-                        params.kernel,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+initrd /images/%s/%s$"
-                    % (
-                        re.escape(image_dir),
-                        params.initrd,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-            ),
-        )
+        for regex in [
+            r"(?ms).*\s+lin.*cc:\\{\'datasource_list\': \[\'MAAS\'\]\\}end_cc.*",
+            rf"(?ms).*^\s+linux  /images/{image_dir}/{params.kernel} .+?$",
+            rf"(?ms).*^\s+initrd /images/{image_dir}/{params.initrd}$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_with_extra_arguments_does_not_affect_output(self):
         # get_reader() allows any keyword arguments as a safety valve.
@@ -225,16 +177,12 @@ class TestUEFIAMD64BootMethodRender(MAASTestCase):
             "protocol": random.choice(["tftp", "http"]),
         }
         output = method.get_reader(**options).read(10000).decode("utf-8")
-        self.assertThat(
-            output,
-            ContainsAll(
-                [
-                    "menuentry 'Ephemeral'",
-                    f"{params.osystem}/{params.arch}/{params.subarch}",
-                    params.kernel,
-                ]
-            ),
-        )
+        for needle in [
+            "menuentry 'Ephemeral'",
+            f"{params.osystem}/{params.arch}/{params.subarch}",
+            params.kernel,
+        ]:
+            self.assertIn(needle, output)
 
     def test_get_reader_with_commissioning_purpose(self):
         # If purpose is "commissioning", the config.commissioning.template
@@ -247,16 +195,12 @@ class TestUEFIAMD64BootMethodRender(MAASTestCase):
             "protocol": random.choice(["tftp", "http"]),
         }
         output = method.get_reader(**options).read(10000).decode("utf-8")
-        self.assertThat(
-            output,
-            ContainsAll(
-                [
-                    "menuentry 'Ephemeral'",
-                    f"{params.osystem}/{params.arch}/{params.subarch}",
-                    params.kernel,
-                ]
-            ),
-        )
+        for needle in [
+            "menuentry 'Ephemeral'",
+            f"{params.osystem}/{params.arch}/{params.subarch}",
+            params.kernel,
+        ]:
+            self.assertIn(needle, output)
 
 
 class TestUEFIAMD64BootMethodRegex(MAASTestCase):
@@ -459,7 +403,9 @@ class TestUEFIAMD64BootMethod(MAASTestCase):
                 bootloader_file_path = os.path.join(tmp, bootloader_file)
                 self.assertTrue(os.path.islink(bootloader_file_path))
             grub_file_path = os.path.join(tmp, "grub", "grub.cfg")
-            self.assertTrue(grub_file_path, FileContains(CONFIG_FILE))
+            with open(grub_file_path, "r") as fh:
+                contents = fh.read()
+        self.assertIn(CONFIG_FILE, contents)
 
     def test_link_bootloader_copies_previous_downloaded_files(self):
         method = UEFIAMD64BootMethod()
@@ -501,19 +447,13 @@ class TestUEFIAMD64BootMethod(MAASTestCase):
 
         method._find_and_copy_bootloaders(bootloader_dir)
 
-        self.assertThat(
-            mock_atomic_symlink,
-            MockAnyCall(
-                "/usr/lib/shim/shim.efi.signed",
-                os.path.join(bootloader_dir, "bootx64.efi"),
-            ),
+        mock_atomic_symlink.assert_any_call(
+            "/usr/lib/shim/shim.efi.signed",
+            os.path.join(bootloader_dir, "bootx64.efi"),
         )
-        self.assertThat(
-            mock_atomic_symlink,
-            MockAnyCall(
-                "/usr/lib/grub/x86_64-efi-signed/grubnetx64.efi.signed",
-                os.path.join(bootloader_dir, "grubx64.efi"),
-            ),
+        mock_atomic_symlink.assert_any_call(
+            "/usr/lib/grub/x86_64-efi-signed/grubnetx64.efi.signed",
+            os.path.join(bootloader_dir, "grubx64.efi"),
         )
 
     def test_link_bootloader_logs_missing_bootloader_files(self):
@@ -524,4 +464,4 @@ class TestUEFIAMD64BootMethod(MAASTestCase):
             "snapshot"
         )
         method._find_and_copy_bootloaders(bootloader_dir)
-        self.assertThat(mock_maaslog, MockCalledOnce())
+        mock_maaslog.assert_called_once()
diff --git a/src/provisioningserver/boot/tests/test_ipxe.py b/src/provisioningserver/boot/tests/test_ipxe.py
index c36f97a..0e12406 100644
--- a/src/provisioningserver/boot/tests/test_ipxe.py
+++ b/src/provisioningserver/boot/tests/test_ipxe.py
@@ -7,7 +7,6 @@
 import os
 import re
 
-from testtools.matchers import MatchesAll, MatchesRegex, Not, StartsWith
 from twisted.python.filepath import FilePath
 
 from maastesting.factory import factory
@@ -56,9 +55,8 @@ class TestIPXEBootMethod(MAASTestCase):
     def test_compose_config_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root().asBytesMode()
         mac = factory.make_mac_address()
-        self.assertThat(
-            compose_config_path(mac), Not(StartsWith(tftproot.path))
-        )
+        config_path = compose_config_path(mac)
+        self.assertFalse(config_path.startswith(tftproot.path))
 
     def test_bootloader_path(self):
         method = IPXEBootMethod()
@@ -67,7 +65,7 @@ class TestIPXEBootMethod(MAASTestCase):
     def test_bootloader_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root()
         method = IPXEBootMethod()
-        self.assertThat(method.bootloader_path, Not(StartsWith(tftproot.path)))
+        self.assertFalse(method.bootloader_path.startswith(tftproot.path))
 
     def test_name(self):
         method = IPXEBootMethod()
@@ -102,8 +100,8 @@ class TestIPXEBootMethodRender(MAASTestCase):
         # correctly rendered.
         method = IPXEBootMethod()
         params = make_kernel_parameters(self, purpose="xinstall")
-        fs_host = "http://%s:5248/images" % (
-            convert_host_to_uri_str(params.fs_host)
+        fs_host = re.escape(
+            "http://%s:5248/images" % (convert_host_to_uri_str(params.fs_host))
         )
         output = method.get_reader(backend=None, kernel_params=params)
         # The output is a BytesReader.
@@ -111,39 +109,23 @@ class TestIPXEBootMethodRender(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. iPXE configurations
         # start with #ipxe.
-        self.assertThat(output, StartsWith("#!ipxe"))
+        self.assertTrue(output.startswith("#!ipxe"))
         # The iPXE parameters are all set according to the options.
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
-        )
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s*kernel %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.kernel,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s*initrd %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.initrd,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s*imgargs .+?$", re.MULTILINE | re.DOTALL),
-            ),
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
+        for regex in [
+            rf"(?ms).*^\s*kernel {fs_host}/{image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s*initrd {fs_host}/{image_dir}/{params.initrd}$",
+            r"(?ms).*^\s*imgargs .+?$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_with_local_purpose(self):
         # If purpose is "local", the config.localboot.template should be
@@ -213,7 +195,7 @@ class TestIPXEBootMethodRegex(MAASTestCase):
         mac = b"aa:bb:cc:dd:ee:ff"
         match = re_config_file.match(b"ipxe.cfg-%s" % mac)
         self.assertIsNotNone(match)
-        self.assertDictEqual(
+        self.assertEqual(
             {"mac": mac, "arch": None, "subarch": None}, match.groupdict()
         )
 
@@ -221,7 +203,7 @@ class TestIPXEBootMethodRegex(MAASTestCase):
         mac = b"aa:bb:cc:dd:ee:ff"
         match = re_config_file.match(b"/ipxe.cfg-%s" % mac)
         self.assertIsNotNone(match)
-        self.assertDictEqual(
+        self.assertEqual(
             {"mac": mac, "arch": None, "subarch": None}, match.groupdict()
         )
 
@@ -235,7 +217,7 @@ class TestIPXEBootMethodRegex(MAASTestCase):
         arch = factory.make_name("arch", sep="").encode("ascii")
         match = re_config_file.match(b"ipxe.cfg-default-%s" % arch)
         self.assertIsNotNone(match)
-        self.assertDictEqual(
+        self.assertEqual(
             {"mac": None, "arch": arch, "subarch": None}, match.groupdict()
         )
 
@@ -246,6 +228,6 @@ class TestIPXEBootMethodRegex(MAASTestCase):
             b"ipxe.cfg-default-%s-%s" % (arch, subarch)
         )
         self.assertIsNotNone(match)
-        self.assertDictEqual(
+        self.assertEqual(
             {"mac": None, "arch": arch, "subarch": subarch}, match.groupdict()
         )
diff --git a/src/provisioningserver/boot/tests/test_powernv.py b/src/provisioningserver/boot/tests/test_powernv.py
index 869784a..421a48f 100644
--- a/src/provisioningserver/boot/tests/test_powernv.py
+++ b/src/provisioningserver/boot/tests/test_powernv.py
@@ -7,7 +7,6 @@
 import re
 from unittest.mock import Mock
 
-from testtools.matchers import MatchesAll, MatchesRegex, Not, StartsWith
 from twisted.python.filepath import FilePath
 
 from maastesting.factory import factory
@@ -75,9 +74,8 @@ class TestPowerNVBootMethod(MAASTestCase):
     def test_compose_config_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root().asBytesMode()
         mac = factory.make_mac_address("-")
-        self.assertThat(
-            compose_config_path(mac), Not(StartsWith(tftproot.path))
-        )
+        config_path = compose_config_path(mac)
+        self.assertFalse(config_path.startswith(tftproot.path))
 
     def test_bootloader_path(self):
         method = PowerNVBootMethod()
@@ -86,7 +84,7 @@ class TestPowerNVBootMethod(MAASTestCase):
     def test_bootloader_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root()
         method = PowerNVBootMethod()
-        self.assertThat(method.bootloader_path, Not(StartsWith(tftproot.path)))
+        self.assertFalse(method.bootloader_path.startswith(tftproot.path))
 
     def test_name(self):
         method = PowerNVBootMethod()
@@ -153,8 +151,8 @@ class TestPowerNVBootMethodRenderConfig(MAASTestCase):
         params = make_kernel_parameters(
             self, arch="ppc64el", purpose="xinstall"
         )
-        fs_host = "http://%s:5248/images" % (
-            convert_host_to_uri_str(params.fs_host)
+        fs_host = re.escape(
+            "http://%s:5248/images" % (convert_host_to_uri_str(params.fs_host))
         )
         output = method.get_reader(backend=None, kernel_params=params)
         # The output is a BytesReader.
@@ -162,39 +160,23 @@ class TestPowerNVBootMethodRenderConfig(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. PXELINUX configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith("DEFAULT "))
+        self.assertTrue(output.startswith("DEFAULT "))
         # The PXE parameters are all set according to the options.
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
-        )
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+KERNEL %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.kernel,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+INITRD %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.initrd,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s+APPEND .+?$", re.MULTILINE | re.DOTALL),
-            ),
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
+        for regex in [
+            rf"(?ms).*^\s+KERNEL {fs_host}/{image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+INITRD {fs_host}/{image_dir}/{params.initrd}$",
+            r"(?ms).*^\s+APPEND .+?$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_with_extra_arguments_does_not_affect_output(self):
         # get_reader() allows any keyword arguments as a safety valve.
diff --git a/src/provisioningserver/boot/tests/test_pxe.py b/src/provisioningserver/boot/tests/test_pxe.py
index cdd8c8c..6a8b6a4 100644
--- a/src/provisioningserver/boot/tests/test_pxe.py
+++ b/src/provisioningserver/boot/tests/test_pxe.py
@@ -8,17 +8,9 @@ from collections import OrderedDict
 import os
 import re
 
-from testtools.matchers import (
-    ContainsAll,
-    MatchesAll,
-    MatchesRegex,
-    Not,
-    StartsWith,
-)
 from twisted.python.filepath import FilePath
 
 from maastesting.factory import factory
-from maastesting.matchers import MockAnyCall, MockNotCalled
 from maastesting.testcase import MAASTestCase
 from provisioningserver import kernel_opts
 from provisioningserver.boot import BytesReader
@@ -86,9 +78,8 @@ class TestPXEBootMethod(MAASTestCase):
     def test_compose_config_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root().asBytesMode()
         mac = factory.make_mac_address("-")
-        self.assertThat(
-            compose_config_path(mac), Not(StartsWith(tftproot.path))
-        )
+        config_path = compose_config_path(mac)
+        self.assertFalse(config_path.startswith(tftproot.path))
 
     def test_bootloader_path(self):
         method = PXEBootMethod()
@@ -97,7 +88,7 @@ class TestPXEBootMethod(MAASTestCase):
     def test_bootloader_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root()
         method = PXEBootMethod()
-        self.assertThat(method.bootloader_path, Not(StartsWith(tftproot.path)))
+        self.assertFalse(method.bootloader_path.startswith(tftproot.path))
 
     def test_name(self):
         method = PXEBootMethod()
@@ -198,23 +189,17 @@ class TestPXEBootMethod(MAASTestCase):
 
         method.link_bootloader(bootloader_dir)
 
-        self.assertThat(mock_atomic_copy, MockNotCalled())
-        self.assertThat(mock_shutil_copy, MockNotCalled())
+        mock_atomic_copy.assert_not_called()
+        mock_shutil_copy.assert_not_called()
         for bootloader_file in method.bootloader_files:
             bootloader_src = os.path.join(
                 "/usr/lib/syslinux/modules/bios", bootloader_file
             )
             bootloader_dst = os.path.join(bootloader_dir, bootloader_file)
-            self.assertThat(
-                mock_atomic_symlink,
-                MockAnyCall(bootloader_src, bootloader_dst),
-            )
-        self.assertThat(
-            mock_atomic_symlink,
-            MockAnyCall(
-                "/usr/lib/syslinux/modules/bios",
-                os.path.join(bootloader_dir, "syslinux"),
-            ),
+            mock_atomic_symlink.assert_any_call(bootloader_src, bootloader_dst)
+        mock_atomic_symlink.assert_any_call(
+            "/usr/lib/syslinux/modules/bios",
+            os.path.join(bootloader_dir, "syslinux"),
         )
 
     def test_link_bootloader_logs_missing_files(self):
@@ -281,8 +266,8 @@ class TestPXEBootMethodRender(MAASTestCase):
         # correctly rendered.
         method = PXEBootMethod()
         params = make_kernel_parameters(self, purpose="xinstall")
-        fs_host = "http://%s:5248/images" % (
-            convert_host_to_uri_str(params.fs_host)
+        fs_host = re.escape(
+            "http://%s:5248/images" % (convert_host_to_uri_str(params.fs_host))
         )
         output = method.get_reader(backend=None, kernel_params=params)
         # The output is a BytesReader.
@@ -290,40 +275,25 @@ class TestPXEBootMethodRender(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. PXELINUX configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith("DEFAULT "))
+        self.assertTrue(output.startswith("DEFAULT "))
         # The PXE parameters are all set according to the options.
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
-        )
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+KERNEL %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.kernel,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+INITRD %s/%s/%s$"
-                    % (
-                        re.escape(fs_host),
-                        re.escape(image_dir),
-                        params.initrd,
-                    ),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s+APPEND .+?$", re.MULTILINE | re.DOTALL),
-            ),
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
 
+        for regex in [
+            rf"(?ms).*^\s+KERNEL {fs_host}/{image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+INITRD {fs_host}/{image_dir}/{params.initrd}$",
+            r"(?ms).*^\s+APPEND .+?$",
+        ]:
+            self.assertRegex(output, regex)
+
     def test_get_reader_install_mustang_dtb(self):
         # Architecture specific test.
         # Given the right configuration options, the PXE configuration is
@@ -342,7 +312,7 @@ class TestPXEBootMethodRender(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. PXELINUX configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith("DEFAULT "))
+        self.assertTrue(output.startswith("DEFAULT "))
         # The PXE parameters are all set according to the options.
         image_dir = compose_image_path(
             osystem=params.kernel_osystem,
@@ -351,27 +321,13 @@ class TestPXEBootMethodRender(MAASTestCase):
             release=params.kernel_release,
             label=params.kernel_label,
         )
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+KERNEL %s/%s$"
-                    % (re.escape(image_dir), params.kernel),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+INITRD %s/%s$"
-                    % (re.escape(image_dir), params.initrd),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+FDT %s/%s$"
-                    % (re.escape(image_dir), params.boot_dtb),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s+APPEND .+?$", re.MULTILINE | re.DOTALL),
-            ),
-        )
+        for regex in [
+            rf"(?ms).*^\s+KERNEL {image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+INITRD {image_dir}/{params.initrd}$",
+            rf"(?ms).*^\s+FDT {image_dir}/{params.boot_dtb}$",
+            r"(?ms).*^\s+APPEND .+?$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_xinstall_mustang_dtb(self):
         # Architecture specific test.
@@ -391,7 +347,7 @@ class TestPXEBootMethodRender(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. PXELINUX configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith("DEFAULT "))
+        self.assertTrue(output.startswith("DEFAULT "))
         # The PXE parameters are all set according to the options.
         image_dir = compose_image_path(
             osystem=params.kernel_osystem,
@@ -400,27 +356,13 @@ class TestPXEBootMethodRender(MAASTestCase):
             release=params.kernel_release,
             label=params.kernel_label,
         )
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+KERNEL %s/%s$"
-                    % (re.escape(image_dir), params.kernel),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+INITRD %s/%s$"
-                    % (re.escape(image_dir), params.initrd),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+FDT %s/%s$"
-                    % (re.escape(image_dir), params.boot_dtb),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s+APPEND .+?$", re.MULTILINE | re.DOTALL),
-            ),
-        )
+        for regex in [
+            rf"(?ms).*^\s+KERNEL {image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+INITRD {image_dir}/{params.initrd}$",
+            rf"(?ms).*^\s+FDT {image_dir}/{params.boot_dtb}$",
+            r"(?ms).*^\s+APPEND .+?$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_with_extra_arguments_does_not_affect_output(self):
         # get_reader() allows any keyword arguments as a safety valve.
@@ -517,11 +459,16 @@ class TestPXEBootMethodRenderConfigScenarios(MAASTestCase):
         self.assertIn(default_section_label, config)
         default_section = dict(config[default_section_label])
 
-        contains_arch_path = StartsWith(
-            f"{fs_host}/{osystem}/{arch}/{subarch}"
+        self.assertTrue(
+            default_section["KERNEL"].startswith(
+                f"{fs_host}/{osystem}/{arch}/{subarch}"
+            )
+        )
+        self.assertTrue(
+            default_section["INITRD"].startswith(
+                f"{fs_host}/{osystem}/{arch}/{subarch}"
+            )
         )
-        self.assertThat(default_section["KERNEL"], contains_arch_path)
-        self.assertThat(default_section["INITRD"], contains_arch_path)
         self.assertEqual("2", default_section["IPAPPEND"])
 
 
@@ -565,20 +512,27 @@ class TestPXEBootMethodRenderConfigScenariosEnlist(MAASTestCase):
             ["amd64", "--", "i386"], default_section["APPEND"].split()
         )
         # Both "i386" and "amd64" sections exist.
-        self.assertThat(config, ContainsAll(("i386", "amd64")))
+        self.assertIn("i386", config)
+        self.assertIn("amd64", config)
+
         # Each section defines KERNEL, INITRD, and APPEND settings.  The
         # KERNEL and INITRD ones contain paths referring to their
         # architectures.
         for section_label in ("i386", "amd64"):
             section = config[section_label]
-            self.assertThat(
-                section, ContainsAll(("KERNEL", "INITRD", "APPEND"))
+            self.assertGreaterEqual(
+                section.keys(), {"KERNEL", "INITRD", "APPEND"}
+            )
+            self.assertTrue(
+                section["KERNEL"].startswith(
+                    f"{fs_host}/{osystem}/{section_label}"
+                )
             )
-            contains_arch_path = StartsWith(
-                f"{fs_host}/{osystem}/{section_label}/"
+            self.assertTrue(
+                section["INITRD"].startswith(
+                    f"{fs_host}/{osystem}/{section_label}"
+                )
             )
-            self.assertThat(section["KERNEL"], contains_arch_path)
-            self.assertThat(section["INITRD"], contains_arch_path)
             self.assertIn("APPEND", section)
 
 
diff --git a/src/provisioningserver/boot/tests/test_s390x.py b/src/provisioningserver/boot/tests/test_s390x.py
index 4b4d522..63e05fa 100644
--- a/src/provisioningserver/boot/tests/test_s390x.py
+++ b/src/provisioningserver/boot/tests/test_s390x.py
@@ -7,7 +7,6 @@
 import re
 from unittest.mock import Mock
 
-from testtools.matchers import MatchesAll, MatchesRegex, Not, StartsWith
 from twisted.python.filepath import FilePath
 
 from maastesting.factory import factory
@@ -74,9 +73,8 @@ class TestS390XBootMethod(MAASTestCase):
     def test_compose_config_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root().asBytesMode()
         mac = factory.make_mac_address("-")
-        self.assertThat(
-            compose_config_path(mac), Not(StartsWith(tftproot.path))
-        )
+        config_path = compose_config_path(mac)
+        self.assertFalse(config_path.startswith(tftproot.path))
 
     def test_bootloader_path(self):
         method = S390XBootMethod()
@@ -85,7 +83,7 @@ class TestS390XBootMethod(MAASTestCase):
     def test_bootloader_path_does_not_include_tftp_root(self):
         tftproot = self.make_tftp_root()
         method = S390XBootMethod()
-        self.assertThat(method.bootloader_path, Not(StartsWith(tftproot.path)))
+        self.assertFalse(method.bootloader_path.startswith(tftproot.path))
 
     def test_name(self):
         method = S390XBootMethod()
@@ -156,31 +154,23 @@ class TestS390XBootMethodRenderConfig(MAASTestCase):
         output = output.read(10000).decode("utf-8")
         # The template has rendered without error. PXELINUX configurations
         # typically start with a DEFAULT line.
-        self.assertThat(output, StartsWith("DEFAULT "))
+        self.assertTrue(output.startswith("DEFAULT "))
         # The PXE parameters are all set according to the options.
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
-        )
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+KERNEL %s/%s$"
-                    % (re.escape(image_dir), params.kernel),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+INITRD %s/%s$"
-                    % (re.escape(image_dir), params.initrd),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s+APPEND .+?$", re.MULTILINE | re.DOTALL),
-            ),
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
+        for regex in [
+            rf"(?ms).*^\s+KERNEL {image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+INITRD {image_dir}/{params.initrd}$",
+            r"(?ms).*^\s+APPEND .+?$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_with_extra_arguments_does_not_affect_output(self):
         # get_reader() allows any keyword arguments as a safety valve.
diff --git a/src/provisioningserver/boot/tests/test_s390x_partition.py b/src/provisioningserver/boot/tests/test_s390x_partition.py
index 790d29f..102d6ae 100644
--- a/src/provisioningserver/boot/tests/test_s390x_partition.py
+++ b/src/provisioningserver/boot/tests/test_s390x_partition.py
@@ -7,8 +7,6 @@
 import random
 import re
 
-from testtools.matchers import MatchesAll, MatchesRegex
-
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
 from provisioningserver.boot import s390x_partition as s390x_partition_module
@@ -69,33 +67,22 @@ class TestS390XPartitionBootMethod(MAASTestCase):
 
         output = s390x_partition.get_reader(None, params, mac)
         output = output.read(output.size).decode()
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
 
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+kernel=%s/%s$"
-                    % (re.escape(image_dir), params.kernel),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+initrd=%s/%s$"
-                    % (re.escape(image_dir), params.initrd),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+append=.*BOOTIF=%s$" % format_bootif(mac),
-                    re.MULTILINE | re.DOTALL,
-                ),
-            ),
-        )
+        for regex in [
+            rf"(?ms).*^\s+kernel={image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+initrd={image_dir}/{params.initrd}$",
+            rf"(?ms).*^\s+append=.*BOOTIF={format_bootif(mac)}+?$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_ephemeral_no_mac(self):
         s390x_partition = S390XPartitionBootMethod()
@@ -109,30 +96,21 @@ class TestS390XPartitionBootMethod(MAASTestCase):
 
         output = s390x_partition.get_reader(None, params)
         output = output.read(output.size).decode()
-        image_dir = compose_image_path(
-            osystem=params.kernel_osystem,
-            arch=params.arch,
-            subarch=params.subarch,
-            release=params.kernel_release,
-            label=params.kernel_label,
-        )
-
-        self.assertThat(
-            output,
-            MatchesAll(
-                MatchesRegex(
-                    r".*^\s+kernel=%s/%s$"
-                    % (re.escape(image_dir), params.kernel),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(
-                    r".*^\s+initrd=%s/%s$"
-                    % (re.escape(image_dir), params.initrd),
-                    re.MULTILINE | re.DOTALL,
-                ),
-                MatchesRegex(r".*^\s+append=.*$", re.MULTILINE | re.DOTALL),
-            ),
+        image_dir = re.escape(
+            compose_image_path(
+                osystem=params.kernel_osystem,
+                arch=params.arch,
+                subarch=params.subarch,
+                release=params.kernel_release,
+                label=params.kernel_label,
+            )
         )
+        for regex in [
+            rf"(?ms).*^\s+kernel={image_dir}/{params.kernel}$",
+            rf"(?ms).*^\s+initrd={image_dir}/{params.initrd}$",
+            r"(?ms).*^\s+append=.*$",
+        ]:
+            self.assertRegex(output, regex)
 
     def test_get_reader_poweroff(self):
         s390x_partition = S390XPartitionBootMethod()
diff --git a/src/provisioningserver/boot/tests/test_tftppath.py b/src/provisioningserver/boot/tests/test_tftppath.py
index d14069b..dd3f57d 100644
--- a/src/provisioningserver/boot/tests/test_tftppath.py
+++ b/src/provisioningserver/boot/tests/test_tftppath.py
@@ -8,9 +8,6 @@ import errno
 import os.path
 from unittest.mock import Mock
 
-from testtools.matchers import Not, StartsWith
-from testtools.testcase import ExpectedException
-
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
 from provisioningserver.boot import tftppath
@@ -116,10 +113,8 @@ class TestTFTPPath(MAASTestCase):
         subarch = factory.make_name("subarch")
         release = factory.make_name("release")
         label = factory.make_name("label")
-        self.assertThat(
-            compose_image_path(osystem, arch, subarch, release, label),
-            Not(StartsWith(self.tftproot)),
-        )
+        image_path = compose_image_path(osystem, arch, subarch, release, label)
+        self.assertFalse(image_path.startswith(self.tftproot))
 
     def test_list_boot_images_copes_with_missing_directory(self):
         self.assertEqual([], list_boot_images(factory.make_string()))
@@ -129,7 +124,9 @@ class TestTFTPPath(MAASTestCase):
         # PermissionError. It's a subclass of OSError.
         error = OSError(errno.EACCES, "Deliberate error for testing.")
         self.patch(tftppath, "list_subdirs", Mock(side_effect=error))
-        with ExpectedException(PermissionError):
+        with self.assertRaisesRegex(
+            PermissionError, "Deliberate error for testing."
+        ):
             list_boot_images(factory.make_string())
 
     def test_list_boot_images_copes_with_empty_directory(self):
diff --git a/src/provisioningserver/boot/tests/test_windows.py b/src/provisioningserver/boot/tests/test_windows.py
index a82cebf..2db5890 100644
--- a/src/provisioningserver/boot/tests/test_windows.py
+++ b/src/provisioningserver/boot/tests/test_windows.py
@@ -17,7 +17,6 @@ from twisted.internet.defer import inlineCallbacks
 
 from maastesting import get_testing_timeout
 from maastesting.factory import factory
-from maastesting.matchers import MockCalledOnceWith
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from maastesting.twisted import (
     always_fail_with,
@@ -76,10 +75,9 @@ class TestBcd(MAASTestCase):
         bcd.hive.value_multiple_strings.return_value = [mock_string]
 
         response = bcd._get_loader(bootmgr_elems)
-        self.assertThat(bcd.hive.node_values, MockCalledOnceWith(mock_elem))
-        self.assertThat(
-            bcd.hive.value_multiple_strings,
-            MockCalledOnceWith(mock_node_value),
+        bcd.hive.node_values.assert_called_once_with(mock_elem)
+        bcd.hive.value_multiple_strings.assert_called_once_with(
+            mock_node_value
         )
         self.assertEqual(mock_string, response)
 
@@ -94,8 +92,8 @@ class TestBcd(MAASTestCase):
         bcd.hive.node_name.return_value = mock_name
 
         response = bcd._get_loader_elems()
-        self.assertThat(bcd.hive.node_children, MockCalledOnceWith(mock_uid_1))
-        self.assertThat(bcd.hive.node_name, MockCalledOnceWith(mock_child))
+        bcd.hive.node_children.assert_called_once_with(mock_uid_1)
+        bcd.hive.node_name.assert_called_once_with(mock_child)
         self.assertEqual(response, {mock_name: mock_child})
 
     def test_get_load_options_key(self):
@@ -109,10 +107,8 @@ class TestBcd(MAASTestCase):
         mock_get_loader_elems.return_value = mock_load_elem
 
         response = bcd._get_load_options_key()
-        self.assertThat(mock_get_loader_elems, MockCalledOnceWith())
-        self.assertThat(
-            mock_load_elem.get, MockCalledOnceWith(bcd.LOAD_OPTIONS, None)
-        )
+        mock_get_loader_elems.assert_called_once_with()
+        mock_load_elem.get.assert_called_once_with(bcd.LOAD_OPTIONS, None)
         self.assertEqual(response, fake_load_elem)
 
     def test_set_load_options(self):
@@ -133,15 +129,12 @@ class TestBcd(MAASTestCase):
             "key": "Element",
             "value": fake_value.decode("utf-8").encode("utf-16le"),
         }
-        self.assertThat(mock_get_load_options_key, MockCalledOnceWith())
-        self.assertThat(
-            bcd.hive.node_add_child,
-            MockCalledOnceWith(mock_uid_1, bcd.LOAD_OPTIONS),
-        )
-        self.assertThat(
-            bcd.hive.node_set_value, MockCalledOnceWith(fake_child, compare)
+        mock_get_load_options_key.assert_called_once_with()
+        bcd.hive.node_add_child.assert_called_once_with(
+            mock_uid_1, bcd.LOAD_OPTIONS
         )
-        self.assertThat(bcd.hive.commit, MockCalledOnceWith(None))
+        bcd.hive.node_set_value.assert_called_once_with(fake_child, compare)
+        bcd.hive.commit.assert_called_once_with(None)
 
 
 class TestRequestNodeInfoByMACAddress(MAASTestCase):
@@ -163,11 +156,8 @@ class TestRequestNodeInfoByMACAddress(MAASTestCase):
         client.side_effect = always_succeed_with(sentinel.node_info)
         d = windows_module.request_node_info_by_mac_address(sentinel.mac)
         self.assertIs(extract_result(d), sentinel.node_info)
-        self.assertThat(
-            client,
-            MockCalledOnceWith(
-                RequestNodeInfoByMACAddress, mac_address=sentinel.mac
-            ),
+        client.assert_called_once_with(
+            RequestNodeInfoByMACAddress, mac_address=sentinel.mac
         )
 
 
@@ -200,7 +190,7 @@ class TestWindowsPXEBootMethod(MAASTestCase):
             windows_module, "request_node_info_by_mac_address"
         )
         method.get_node_info()
-        self.assertThat(mock_request_node_info, MockCalledOnceWith(mac))
+        mock_request_node_info.assert_called_once_with(mac)
 
     @inlineCallbacks
     def test_match_path_pxelinux(self):
@@ -377,9 +367,7 @@ class TestWindowsPXEBootMethod(MAASTestCase):
         method.get_reader(
             None, kernel_params, path="bcd", local_host=local_host
         )
-        self.assertThat(
-            mock_compose_bcd, MockCalledOnceWith(kernel_params, local_host)
-        )
+        mock_compose_bcd.assert_called_once_with(kernel_params, local_host)
 
     def test_get_reader_static_file(self):
         method = WindowsPXEBootMethod()
@@ -388,9 +376,7 @@ class TestWindowsPXEBootMethod(MAASTestCase):
         kernel_params = make_kernel_parameters(osystem="windows")
 
         method.get_reader(None, kernel_params, path=mock_path)
-        self.assertThat(
-            mock_output_static, MockCalledOnceWith(kernel_params, mock_path)
-        )
+        mock_output_static.assert_called_once_with(kernel_params, mock_path)
 
     def test_compose_preseed_url(self):
         url = "http://localhost/MAAS"
@@ -414,7 +400,7 @@ class TestWindowsPXEBootMethod(MAASTestCase):
         self.patch(windows_module, "open")
         windows_module.open.return_value = io.BytesIO(fake_output)
         output = method.compose_bcd(kernel_params, local_host)
-        self.assertThat(windows_module.open, MockCalledOnceWith(ANY, "rb"))
+        windows_module.open.assert_called_once_with(ANY, "rb")
 
         self.assertIsInstance(output, BytesReader)
         self.assertEqual(fake_output, output.read(-1))