Merge ~adam-collard/maas:no-assert-equals into maas:master

[Adam Collard]

s/assertEquals/assertEqual/g

Replace all assertEquals with preferred spelling of assertEqual.

Simple bowler script of:

query = Query().select_method("assertEquals").rename("assertEqual").write()

607f037... by Adam Collard on 2020-11-25

Blacken

[MAAS Lander (maas-lander)]

UNIT TESTS
-b no-assert-equals lp:~adam-collard/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/8756/console
COMMIT: 81aab4f30dacb590efb8cd3b2e300d97c9a685ad

review: Needs Fixing

[MAAS Lander (maas-lander)]

UNIT TESTS
-b no-assert-equals lp:~adam-collard/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 7169f72b1d771b2d4d0bc821dcf4e1c610ff1a32

review: Approve

[Alberto Donato (ack)]

+1.

I think we should also add a script to run as part of `make lint` which checks that we don't reintroduce those (we can later extend it to look for other things that we want to move away from (like dreaded assertThat).
I don't mean to add it to this branch, just a thought.

review: Approve

[Dougal Matthews (d0ugal)]

> (like dreaded assertThat).

We could remove testtools instead, or overwrite it.

def assertThat(self, *args, **kwargs):
    raise SyntaxError("not a chance")

review: Approve

45f24c3... by Adam Collard on 2020-12-15

Remove the triple quotes that were effectively ignoring tests.

diff --git a/src/maascli/actions/tests/test_sshkeys_import.py b/src/maascli/actions/tests/test_sshkeys_import.py
index 540dc30..d8de2b4 100644
--- a/src/maascli/actions/tests/test_sshkeys_import.py
+++ b/src/maascli/actions/tests/test_sshkeys_import.py
@@ -39,14 +39,14 @@ class TestSSHKeysImportAction(MAASTestCase):
         )
         expected_data = ("keysource", ks)
         data = action.name_value_pair(ks)
-        self.assertEquals(data, expected_data)
+        self.assertEqual(data, expected_data)
 
     def test_name_value_pair_returns_sshkey_creds_tuple_for_no_protocol(self):
         action = self.make_sshkeys_import_action()
         ks = factory.make_name("user-id")
         expected_data = ("keysource", ks)
         data = action.name_value_pair(ks)
-        self.assertEquals(data, expected_data)
+        self.assertEqual(data, expected_data)
 
     def test_name_value_pair_returns_sshkey_creds_tuple_for_no_input(self):
         action = self.make_sshkeys_import_action()
diff --git a/src/maascli/tests/test_snappy.py b/src/maascli/tests/test_snappy.py
index 2014071..95458f7 100644
--- a/src/maascli/tests/test_snappy.py
+++ b/src/maascli/tests/test_snappy.py
@@ -257,7 +257,7 @@ class TestSupervisordHelpers(MAASTestCase):
         mock_popen.return_value = mock_process
         snappy.sighup_supervisord()
         self.assertThat(mock_kill, MockCalledOnceWith(pid, signal.SIGHUP))
-        self.assertEquals(2, mock_popen.call_count)
+        self.assertEqual(2, mock_popen.call_count)
 
 
 class TestConfigHelpers(MAASTestCase):
@@ -302,7 +302,7 @@ class TestConfigHelpers(MAASTestCase):
     def test_set_rpc_secret_sets_secret(self):
         secret = factory.make_string()
         snappy.set_rpc_secret(secret)
-        self.assertEquals(secret, snappy.get_rpc_secret())
+        self.assertEqual(secret, snappy.get_rpc_secret())
 
     def test_set_rpc_secret_clears_secret(self):
         secret = factory.make_string()
diff --git a/src/maasserver/api/tests/test_blockdevice.py b/src/maasserver/api/tests/test_blockdevice.py
index 8329df7..e03ecea 100644
--- a/src/maasserver/api/tests/test_blockdevice.py
+++ b/src/maasserver/api/tests/test_blockdevice.py
@@ -1183,51 +1183,66 @@ class TestBlockDeviceAPI(APITestCase.ForUser):
             http.client.CONFLICT, response.status_code, response.content
         )
 
-    """
     def test_set_boot_disk_returns_400_for_virtual_device(self):
         self.become_admin()
-        node = factory.make_Node(owner=self.user)
+        node = factory.make_Node(status=NODE_STATUS.READY, owner=self.user)
         block_device = factory.make_VirtualBlockDevice(node=node)
         uri = get_blockdevice_uri(block_device)
-        response = self.client.post(uri, {
-            'op': "set_boot_disk",
-        })
+        response = self.client.post(
+            uri,
+            {
+                "op": "set_boot_disk",
+            },
+        )
+        self.assertEqual(
+            http.client.BAD_REQUEST, response.status_code, response.content
+        )
         self.assertEqual(
-            httplib.BAD_REQUEST, response.status_code, response.content)
-        self.assertEquals(
-            "Cannot set a virtual block device as the boot disk.",
-            response.content)
+            b"Cannot set a virtual block device as the boot disk.",
+            response.content,
+        )
 
     def test_set_boot_disk_returns_403_for_normal_user(self):
-        node = factory.make_Node(owner=self.user)
+        node = factory.make_Node(status=NODE_STATUS.READY, owner=self.user)
         block_device = factory.make_PhysicalBlockDevice(node=node)
         uri = get_blockdevice_uri(block_device)
-        response = self.client.post(uri, {
-            'op': "set_boot_disk",
-        })
+        response = self.client.post(
+            uri,
+            {
+                "op": "set_boot_disk",
+            },
+        )
         self.assertEqual(
-            httplib.FORBIDDEN, response.status_code, response.content)
+            http.client.FORBIDDEN, response.status_code, response.content
+        )
 
     def test_set_boot_disk_returns_404_for_block_device_not_on_node(self):
         node = factory.make_Node(owner=self.user)
         block_device = factory.make_PhysicalBlockDevice()
         uri = get_blockdevice_uri(block_device, node=node)
-        response = self.client.post(uri, {
-            'op': "set_boot_disk",
-        })
+        response = self.client.post(
+            uri,
+            {
+                "op": "set_boot_disk",
+            },
+        )
         self.assertEqual(
-            httplib.NOT_FOUND, response.status_code, response.content)
+            http.client.NOT_FOUND, response.status_code, response.content
+        )
 
     def test_set_boot_disk_sets_boot_disk_for_admin(self):
         self.become_admin()
-        node = factory.make_Node(owner=self.user)
+        node = factory.make_Node(status=NODE_STATUS.READY, owner=self.user)
         block_device = factory.make_PhysicalBlockDevice(node=node)
         uri = get_blockdevice_uri(block_device)
-        response = self.client.post(uri, {
-            'op': "set_boot_disk",
-        })
+        response = self.client.post(
+            uri,
+            {
+                "op": "set_boot_disk",
+            },
+        )
         self.assertEqual(
-            httplib.OK, response.status_code, response.content)
+            http.client.OK, response.status_code, response.content
+        )
         node = reload_object(node)
-        self.assertEquals(block_device, node.boot_disk)
-    """
+        self.assertEqual(block_device, node.boot_disk)
diff --git a/src/maasserver/api/tests/test_commissioning.py b/src/maasserver/api/tests/test_commissioning.py
index 33310c3..671125f 100644
--- a/src/maasserver/api/tests/test_commissioning.py
+++ b/src/maasserver/api/tests/test_commissioning.py
@@ -65,8 +65,8 @@ class AdminCommissioningScriptsAPITest(APITestCase.ForAdmin):
         self.assertThat(response, HasStatusCode(http.client.OK))
 
         returned_script = json_load_bytes(response.content)
-        self.assertEquals(name, returned_script["name"])
-        self.assertEquals(
+        self.assertEqual(name, returned_script["name"])
+        self.assertEqual(
             content.encode(), b64decode(returned_script["content"])
         )
 
@@ -133,7 +133,7 @@ class AdminCommissioningScriptAPITest(APITestCase.ForAdmin):
             {"content": factory.make_file_upload(content=new_content)},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(rc.ALL_OK.content, response.content)
+        self.assertEqual(rc.ALL_OK.content, response.content)
 
         self.assertEqual(
             new_content.decode("utf-8"), reload_object(script).script.data
@@ -244,7 +244,7 @@ class NodeCommissionResultHandlerAPITest(APITestCase.ForUser):
         for parsed_result in parsed_results:
             if parsed_result["name"] == script_result.name:
                 break
-        self.assertEquals(
+        self.assertEqual(
             node.current_commissioning_script_set.scriptresult_set.count()
             + node.current_testing_script_set.scriptresult_set.count()
             + node.current_installation_script_set.scriptresult_set.count(),
@@ -264,16 +264,16 @@ class NodeCommissionResultHandlerAPITest(APITestCase.ForUser):
             ],
             parsed_result.keys(),
         )
-        self.assertEquals(script_result.id, parsed_result["id"])
-        self.assertEquals(script_result.name, parsed_result["name"])
-        self.assertEquals(
+        self.assertEqual(script_result.id, parsed_result["id"])
+        self.assertEqual(script_result.name, parsed_result["name"])
+        self.assertEqual(
             script_result.exit_status, parsed_result["script_result"]
         )
-        self.assertEquals(script_set.result_type, parsed_result["result_type"])
-        self.assertEquals(
+        self.assertEqual(script_set.result_type, parsed_result["result_type"])
+        self.assertEqual(
             {"system_id": script_set.node.system_id}, parsed_result["node"]
         )
-        self.assertEquals(
+        self.assertEqual(
             script_result.stdout, b64decode(parsed_result["data"])
         )
 
@@ -396,7 +396,7 @@ class NodeCommissionResultHandlerAPITest(APITestCase.ForUser):
         response = self.client.get(url, {"name": script_result.name})
         self.assertThat(response, HasStatusCode(http.client.OK))
         parsed_results = json_load_bytes(response.content)
-        self.assertEquals(script_result.id, parsed_results[0]["id"])
+        self.assertEqual(script_result.id, parsed_results[0]["id"])
 
     def test_list_displays_only_visible_nodes(self):
         node = factory.make_Node(
diff --git a/src/maasserver/api/tests/test_devices.py b/src/maasserver/api/tests/test_devices.py
index bd5ff70..c305d20 100644
--- a/src/maasserver/api/tests/test_devices.py
+++ b/src/maasserver/api/tests/test_devices.py
@@ -56,9 +56,9 @@ class TestDevicesAPI(APITestCase.ForUser):
         device = Device.objects.get(system_id=system_id)
         self.assertEqual(hostname, device.hostname)
         self.assertIsNone(device.parent)
-        self.assertEquals(device.node_type, NODE_TYPE.DEVICE)
-        self.assertEquals(self.user, device.owner)
-        self.assertEquals(
+        self.assertEqual(device.node_type, NODE_TYPE.DEVICE)
+        self.assertEqual(self.user, device.owner)
+        self.assertEqual(
             macs, {nic.mac_address for nic in device.interface_set.all()}
         )
 
@@ -81,8 +81,8 @@ class TestDevicesAPI(APITestCase.ForUser):
         )
         system_id = json_load_bytes(response.content)["system_id"]
         device = Device.objects.get(system_id=system_id)
-        self.assertEquals(hostname, device.hostname)
-        self.assertEquals(parent, device.parent)
+        self.assertEqual(hostname, device.hostname)
+        self.assertEqual(parent, device.parent)
         self.assertEqual(device.node_type, NODE_TYPE.DEVICE)
 
     def test_POST_creates_device_with_default_domain(self):
@@ -99,8 +99,8 @@ class TestDevicesAPI(APITestCase.ForUser):
         )
         system_id = json_load_bytes(response.content)["system_id"]
         device = Device.objects.get(system_id=system_id)
-        self.assertEquals(hostname, device.hostname)
-        self.assertEquals(Domain.objects.get_default_domain(), device.domain)
+        self.assertEqual(hostname, device.hostname)
+        self.assertEqual(Domain.objects.get_default_domain(), device.domain)
         self.assertEqual(device.node_type, NODE_TYPE.DEVICE)
 
     def test_POST_creates_device_with_domain(self):
@@ -122,8 +122,8 @@ class TestDevicesAPI(APITestCase.ForUser):
         )
         system_id = json_load_bytes(response.content)["system_id"]
         device = Device.objects.get(system_id=system_id)
-        self.assertEquals(hostname, device.hostname)
-        self.assertEquals(domain, device.domain)
+        self.assertEqual(hostname, device.hostname)
+        self.assertEqual(domain, device.domain)
         self.assertEqual(device.node_type, NODE_TYPE.DEVICE)
 
     def test_POST_without_macs_raises_appropriate_error(self):
diff --git a/src/maasserver/api/tests/test_dhcpsnippets.py b/src/maasserver/api/tests/test_dhcpsnippets.py
index 21a0e2e..d844daa 100644
--- a/src/maasserver/api/tests/test_dhcpsnippets.py
+++ b/src/maasserver/api/tests/test_dhcpsnippets.py
@@ -198,7 +198,7 @@ class TestDHCPSnippetAPI(APITestCase.ForUser):
             http.client.OK, response.status_code, response.content
         )
         parsed_dhcp_snippet = json.loads(response.content.decode())
-        self.assertEquals(
+        self.assertEqual(
             VersionedTextFile.objects.get(id=textfile_ids[revert_to - 1]).data,
             parsed_dhcp_snippet["value"],
         )
@@ -326,10 +326,10 @@ class TestDHCPSnippetsAPI(APITestCase.ForUser):
             },
         )
         parsed_dhcp_snippet = json.loads(response.content.decode())
-        self.assertEquals(name, parsed_dhcp_snippet["name"])
-        self.assertEquals(value, parsed_dhcp_snippet["value"])
-        self.assertEquals(description, parsed_dhcp_snippet["description"])
-        self.assertEquals(enabled, parsed_dhcp_snippet["enabled"])
+        self.assertEqual(name, parsed_dhcp_snippet["name"])
+        self.assertEqual(value, parsed_dhcp_snippet["value"])
+        self.assertEqual(description, parsed_dhcp_snippet["description"])
+        self.assertEqual(enabled, parsed_dhcp_snippet["enabled"])
 
     def test_create_admin_only(self):
         response = self.client.post(
diff --git a/src/maasserver/api/tests/test_interfaces.py b/src/maasserver/api/tests/test_interfaces.py
index 396b1bb..890f27d 100644
--- a/src/maasserver/api/tests/test_interfaces.py
+++ b/src/maasserver/api/tests/test_interfaces.py
@@ -1104,8 +1104,8 @@ class TestNodeInterfaceAPI(APITransactionTestCase.ForUser):
             http.client.OK, response.status_code, response.content
         )
         parsed_interface = json_load_bytes(response.content)
-        self.assertEquals(new_name, parsed_interface["name"])
-        self.assertEquals(new_vlan.vid, parsed_interface["vlan"]["vid"])
+        self.assertEqual(new_name, parsed_interface["name"])
+        self.assertEqual(new_vlan.vid, parsed_interface["vlan"]["vid"])
 
     def test_update_bond_interface(self):
         self.become_admin()
@@ -1979,7 +1979,7 @@ class TestInterfaceAPIForControllers(APITestCase.ForUser):
             http.client.OK, response.status_code, response.content
         )
         parsed_interface = json_load_bytes(response.content)
-        self.assertEquals(new_vlan.id, parsed_interface["vlan"]["id"])
+        self.assertEqual(new_vlan.id, parsed_interface["vlan"]["id"])
 
     def test_update_only_works_for_vlan_field(self):
         self.become_admin()
@@ -1997,8 +1997,8 @@ class TestInterfaceAPIForControllers(APITestCase.ForUser):
             http.client.OK, response.status_code, response.content
         )
         parsed_interface = json_load_bytes(response.content)
-        self.assertEquals(new_vlan.id, parsed_interface["vlan"]["id"])
-        self.assertEquals(interface.name, parsed_interface["name"])
+        self.assertEqual(new_vlan.id, parsed_interface["vlan"]["id"])
+        self.assertEqual(interface.name, parsed_interface["name"])
 
     def test_update_forbidden_for_vlan_interface(self):
         self.become_admin()
diff --git a/src/maasserver/api/tests/test_machine.py b/src/maasserver/api/tests/test_machine.py
index dd6495c..9450e24 100644
--- a/src/maasserver/api/tests/test_machine.py
+++ b/src/maasserver/api/tests/test_machine.py
@@ -854,7 +854,7 @@ class TestMachineAPI(APITestCase.ForUser):
             http.client.OK, response.status_code, response.content
         )
         response_content = json_load_bytes(response.content)
-        self.assertEquals("virsh", response_content["power_type"])
+        self.assertEqual("virsh", response_content["power_type"])
 
     def test_POST_deploy_allocates_ready_machines(self):
         self.patch(node_module.Node, "_start")
diff --git a/src/maasserver/api/tests/test_machines.py b/src/maasserver/api/tests/test_machines.py
index 0736ffe..8f43d33 100644
--- a/src/maasserver/api/tests/test_machines.py
+++ b/src/maasserver/api/tests/test_machines.py
@@ -247,7 +247,7 @@ class TestMachinesAPI(APITestCase.ForUser):
         validation_errors = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )["power_type"]
-        self.assertEquals(
+        self.assertEqual(
             "Select a valid choice. %s is not one of the "
             "available choices." % power_type,
             validation_errors[0],
@@ -269,7 +269,7 @@ class TestMachinesAPI(APITestCase.ForUser):
             response.content.decode(settings.DEFAULT_CHARSET)
         )["system_id"]
         machine = Machine.objects.get(system_id=system_id)
-        self.assertEquals("", machine.power_type)
+        self.assertEqual("", machine.power_type)
         self.assertEqual({}, machine.power_parameters)
 
     def test_POST_handles_error_when_unable_to_access_bmc(self):
@@ -319,8 +319,8 @@ class TestMachinesAPI(APITestCase.ForUser):
             },
         )
         parsed_result = json.loads(response.content.decode())
-        self.assertEquals(NODE_STATUS.COMMISSIONING, parsed_result["status"])
-        self.assertEquals(description, parsed_result["description"])
+        self.assertEqual(NODE_STATUS.COMMISSIONING, parsed_result["status"])
+        self.assertEqual(description, parsed_result["description"])
 
     def test_POST_starts_commissioning_with_selected_test_scripts(self):
         # Regression test for LP1707562
@@ -342,7 +342,7 @@ class TestMachinesAPI(APITestCase.ForUser):
             },
         )
         parsed_result = json.loads(response.content.decode())
-        self.assertEquals(NODE_STATUS.COMMISSIONING, parsed_result["status"])
+        self.assertEqual(NODE_STATUS.COMMISSIONING, parsed_result["status"])
         script_set = ScriptSet.objects.get(
             id=parsed_result["current_testing_result_id"]
         )
@@ -366,7 +366,7 @@ class TestMachinesAPI(APITestCase.ForUser):
             },
         )
         parsed_result = json.loads(response.content.decode())
-        self.assertEquals(NODE_STATUS.COMMISSIONING, parsed_result["status"])
+        self.assertEqual(NODE_STATUS.COMMISSIONING, parsed_result["status"])
 
     def test_POST_commission_false(self):
         # Regression test for LP:1904398
@@ -382,7 +382,7 @@ class TestMachinesAPI(APITestCase.ForUser):
             },
         )
         parsed_result = json.loads(response.content.decode())
-        self.assertEquals(NODE_STATUS.NEW, parsed_result["status"])
+        self.assertEqual(NODE_STATUS.NEW, parsed_result["status"])
 
     def test_GET_lists_machines(self):
         # The api allows for fetching the list of Machines.
@@ -457,7 +457,7 @@ class TestMachinesAPI(APITestCase.ForUser):
         parsed_result = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertEquals(
+        self.assertEqual(
             {
                 "id": pod.id,
                 "name": pod.name,
diff --git a/src/maasserver/api/tests/test_node.py b/src/maasserver/api/tests/test_node.py
index 295a72f..e8b84f2 100644
--- a/src/maasserver/api/tests/test_node.py
+++ b/src/maasserver/api/tests/test_node.py
@@ -258,59 +258,59 @@ class TestNodeAPI(APITestCase.ForUser):
             return SCRIPT_STATUS_CHOICES[status(s)][1]
 
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(
+        self.assertEqual(
             status(commissioning_script_result),
             parsed_result["commissioning_status"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(commissioning_script_result),
             parsed_result["commissioning_status_name"],
         )
-        self.assertEquals(testing_status, parsed_result["testing_status"])
-        self.assertEquals(
+        self.assertEqual(testing_status, parsed_result["testing_status"])
+        self.assertEqual(
             SCRIPT_STATUS_CHOICES[testing_status][1],
             parsed_result["testing_status_name"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status(cpu_script_result), parsed_result["cpu_test_status"]
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(cpu_script_result),
             parsed_result["cpu_test_status_name"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status(memory_script_result), parsed_result["memory_test_status"]
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(memory_script_result),
             parsed_result["memory_test_status_name"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status(network_script_result), parsed_result["network_test_status"]
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(network_script_result),
             parsed_result["network_test_status_name"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status(storage_script_result), parsed_result["storage_test_status"]
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(storage_script_result),
             parsed_result["storage_test_status_name"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status(node_script_result), parsed_result["other_test_status"]
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(node_script_result),
             parsed_result["other_test_status_name"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status(interface_script_result),
             parsed_result["interface_test_status"],
         )
-        self.assertEquals(
+        self.assertEqual(
             status_name(interface_script_result),
             parsed_result["interface_test_status_name"],
         )
diff --git a/src/maasserver/api/tests/test_pods.py b/src/maasserver/api/tests/test_pods.py
index 5c840e7..33586b5 100644
--- a/src/maasserver/api/tests/test_pods.py
+++ b/src/maasserver/api/tests/test_pods.py
@@ -491,7 +491,7 @@ class TestPodAPIAdmin(PodAPITestForAdmin, PodMixin):
         self.assertEqual(
             http.client.BAD_REQUEST, response.status_code, response.content
         )
-        self.assertEquals(
+        self.assertEqual(
             b"Pod does not support composability.", response.content
         )
 
diff --git a/src/maasserver/api/tests/test_scriptresults.py b/src/maasserver/api/tests/test_scriptresults.py
index c005848..c775ff8 100644
--- a/src/maasserver/api/tests/test_scriptresults.py
+++ b/src/maasserver/api/tests/test_scriptresults.py
@@ -760,7 +760,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
         self.assertThat(response, HasStatusCode(http.client.OK))
         script_set = reload_object(script_set)
         self.assertIsNotNone(script_set)
-        self.assertEquals(script_set.id, script_result.script_set.id)
+        self.assertEqual(script_set.id, script_result.script_set.id)
         script_result = reload_object(script_result)
         self.assertTrue(script_result.suppressed)
         for script_result in script_results:
@@ -792,7 +792,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
         self.assertThat(response, HasStatusCode(http.client.OK))
         script_set = reload_object(script_set)
         self.assertIsNotNone(script_set)
-        self.assertEquals(script_set.id, script_result.script_set.id)
+        self.assertEqual(script_set.id, script_result.script_set.id)
         script_result = reload_object(script_result)
         self.assertTrue(script_result.suppressed)
         for script_result in script_results:
@@ -829,10 +829,10 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
         self.assertThat(response, HasStatusCode(http.client.OK))
         script_set = reload_object(script_set)
         self.assertIsNotNone(script_set)
-        self.assertEquals(script_set.id, script_result.script_set.id)
+        self.assertEqual(script_set.id, script_result.script_set.id)
         script_result = reload_object(script_result)
         self.assertTrue(script_result.suppressed)
-        self.assertEquals(hardware_type, script_result.script.hardware_type)
+        self.assertEqual(hardware_type, script_result.script.hardware_type)
         for script_result in script_results:
             script_result = reload_object(script_result)
             self.assertFalse(script_result.suppressed)
@@ -858,7 +858,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             )
             binary.write(script_result.output)
             binary.write(b"\n")
-        self.assertEquals(binary.getvalue(), response.content)
+        self.assertEqual(binary.getvalue(), response.content)
 
     def test_download_single(self):
         script_set = self.make_scriptset()
@@ -869,7 +869,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             {"op": "download", "filter": script_result.id},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.output, response.content)
+        self.assertEqual(script_result.output, response.content)
 
     def test_download_filetype_txt(self):
         script_set = self.make_scriptset()
@@ -880,7 +880,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             {"op": "download", "filetype": "txt", "filters": script_result.id},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.output, response.content)
+        self.assertEqual(script_result.output, response.content)
 
     def test_download_filetype_tar_xz(self):
         script_set = self.make_scriptset()
@@ -935,7 +935,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             },
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.output, response.content)
+        self.assertEqual(script_result.output, response.content)
 
     def test_download_output_stdout(self):
         script_set = self.make_scriptset()
@@ -946,7 +946,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             {"op": "download", "filter": script_result.id, "output": "stdout"},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.stdout, response.content)
+        self.assertEqual(script_result.stdout, response.content)
 
     def test_download_output_stderr(self):
         script_set = self.make_scriptset()
@@ -957,7 +957,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             {"op": "download", "filter": script_result.id, "output": "stderr"},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.stderr, response.content)
+        self.assertEqual(script_result.stderr, response.content)
 
     def test_download_output_result(self):
         script_set = self.make_scriptset()
@@ -968,7 +968,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             {"op": "download", "filter": script_result.id, "output": "result"},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.result, response.content)
+        self.assertEqual(script_result.result, response.content)
 
     def test_download_output_all(self):
         script_set = self.make_scriptset()
@@ -1002,7 +1002,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
         binary.write(("%s %s %s\n" % (dashes, filename, dashes)).encode())
         binary.write(script_result.result)
         binary.write(b"\n")
-        self.assertEquals(binary.getvalue(), response.content)
+        self.assertEqual(binary.getvalue(), response.content)
 
     def test_download_filters(self):
         scripts = [factory.make_Script() for _ in range(10)]
@@ -1043,9 +1043,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             script_set.id,
         )
         with tarfile.open(mode="r", fileobj=BytesIO(response.content)) as tar:
-            self.assertEquals(
-                len(set(filtered_results)), len(tar.getmembers())
-            )
+            self.assertEqual(len(set(filtered_results)), len(tar.getmembers()))
             for script_result in filtered_results:
                 path = os.path.join(root_dir, script_result.name)
                 member = tar.getmember(path)
@@ -1081,7 +1079,7 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
             },
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script_result.output, response.content)
+        self.assertEqual(script_result.output, response.content)
 
     def test_download_shows_results_from_all_disks(self):
         # Regression test for #LP:1755060
@@ -1192,4 +1190,4 @@ class TestNodeScriptResultAPI(APITestCase.ForUser):
         binary.write(("%s %s %s\n" % (dashes, filename, dashes)).encode())
         binary.write(other_result.result)
         binary.write(b"\n")
-        self.assertEquals(binary.getvalue(), response.content)
+        self.assertEqual(binary.getvalue(), response.content)
diff --git a/src/maasserver/api/tests/test_scripts.py b/src/maasserver/api/tests/test_scripts.py
index c2a0d21..7718c7a 100644
--- a/src/maasserver/api/tests/test_scripts.py
+++ b/src/maasserver/api/tests/test_scripts.py
@@ -77,18 +77,18 @@ class TestScriptsAPI(APITestCase.ForUser):
         parsed_result = json_load_bytes(response.content)
         script = Script.objects.get(id=int(parsed_result["id"]))
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(title, script.title)
-        self.assertEquals(description, script.description)
+        self.assertEqual(name, script.name)
+        self.assertEqual(title, script.title)
+        self.assertEqual(description, script.description)
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(timeout, script.timeout.seconds)
-        self.assertEquals(destructive, script.destructive)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(comment, script.script.comment)
+        self.assertEqual(timeout, script.timeout.seconds)
+        self.assertEqual(destructive, script.destructive)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(comment, script.script.comment)
 
     def test_POST_gets_name_from_filename(self):
         self.become_admin()
@@ -125,18 +125,18 @@ class TestScriptsAPI(APITestCase.ForUser):
         parsed_result = json_load_bytes(response.content)
         script = Script.objects.get(id=int(parsed_result["id"]))
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(title, script.title)
-        self.assertEquals(description, script.description)
+        self.assertEqual(name, script.name)
+        self.assertEqual(title, script.title)
+        self.assertEqual(description, script.description)
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(timeout, script.timeout.seconds)
-        self.assertEquals(destructive, script.destructive)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(comment, script.script.comment)
+        self.assertEqual(timeout, script.timeout.seconds)
+        self.assertEqual(destructive, script.destructive)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(comment, script.script.comment)
 
     def test_POST_requires_admin(self):
         response = self.client.post(self.get_scripts_uri())
@@ -224,7 +224,7 @@ class TestScriptsAPI(APITestCase.ForUser):
         parsed_results = json_load_bytes(response.content)
 
         for result in parsed_results:
-            self.assertEquals(
+            self.assertEqual(
                 scripts[result["name"]].script.data.encode(),
                 b64decode(result["history"][0]["data"].encode()),
             )
@@ -298,7 +298,7 @@ class TestScriptAPI(APITestCase.ForUser):
         for result_rev in history:
             for rev in script.script.previous_versions():
                 if rev.id == result_rev["id"]:
-                    self.assertEquals(
+                    self.assertEqual(
                         {
                             "id": rev.id,
                             "comment": rev.comment,
@@ -354,7 +354,7 @@ class TestScriptAPI(APITestCase.ForUser):
         for result_rev in history:
             for rev in script.script.previous_versions():
                 if rev.id == result_rev["id"]:
-                    self.assertEquals(
+                    self.assertEqual(
                         {
                             "id": rev.id,
                             "comment": rev.comment,
@@ -428,18 +428,18 @@ class TestScriptAPI(APITestCase.ForUser):
         self.assertThat(response, HasStatusCode(http.client.OK))
         script = reload_object(script)
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(title, script.title)
-        self.assertEquals(description, script.description)
+        self.assertEqual(name, script.name)
+        self.assertEqual(title, script.title)
+        self.assertEqual(description, script.description)
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(timeout, script.timeout.seconds)
-        self.assertEquals(destructive, script.destructive)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(comment, script.script.comment)
+        self.assertEqual(timeout, script.timeout.seconds)
+        self.assertEqual(destructive, script.destructive)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(comment, script.script.comment)
         self.assertIsNotNone(script.script.previous_version)
 
     def test_PUT_gets_name_from_filename(self):
@@ -477,17 +477,17 @@ class TestScriptAPI(APITestCase.ForUser):
         self.assertThat(response, HasStatusCode(http.client.OK))
         script = reload_object(script)
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(description, script.description)
+        self.assertEqual(name, script.name)
+        self.assertEqual(description, script.description)
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(timeout, script.timeout.seconds)
-        self.assertEquals(destructive, script.destructive)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(comment, script.script.comment)
+        self.assertEqual(timeout, script.timeout.seconds)
+        self.assertEqual(destructive, script.destructive)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(comment, script.script.comment)
         self.assertIsNotNone(script.script.previous_version)
 
     def test_PUT_admin_only(self):
@@ -503,7 +503,7 @@ class TestScriptAPI(APITestCase.ForUser):
             self.get_script_uri(script), {"op": "download"}
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(script.script.data, response.content.decode())
+        self.assertEqual(script.script.data, response.content.decode())
 
     def test_download_gets_previous_revision(self):
         script = factory.make_Script()
@@ -514,7 +514,7 @@ class TestScriptAPI(APITestCase.ForUser):
             {"op": "download", "revision": script.script.previous_version.id},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(
+        self.assertEqual(
             script.script.previous_version.data, response.content.decode()
         )
 
@@ -527,7 +527,7 @@ class TestScriptAPI(APITestCase.ForUser):
             {"op": "download", "rev": script.script.previous_version.id},
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
-        self.assertEquals(
+        self.assertEqual(
             script.script.previous_version.data, response.content.decode()
         )
 
@@ -555,7 +555,7 @@ class TestScriptAPI(APITestCase.ForUser):
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
         script = reload_object(script)
-        self.assertEquals(
+        self.assertEqual(
             VersionedTextFile.objects.get(id=textfile_ids[revert_to - 1]).data,
             script.script.data,
         )
diff --git a/src/maasserver/api/tests/test_ssl_key.py b/src/maasserver/api/tests/test_ssl_key.py
index 0217420..67af5a6 100644
--- a/src/maasserver/api/tests/test_ssl_key.py
+++ b/src/maasserver/api/tests/test_ssl_key.py
@@ -134,7 +134,7 @@ class TestSSLKeyHandlers(APITestCase.ForUser):
         self.assertEqual(1, len(keys_after))
         self.assertEqual(keys[1].id, keys_after[0].id)
         self.assertIsNotNone(event)
-        self.assertEquals(
+        self.assertEqual(
             event.description, "Deleted SSL key id='%s'." % keys[0].id
         )
 
diff --git a/src/maasserver/api/tests/test_tag.py b/src/maasserver/api/tests/test_tag.py
index 018259e..975b443 100644
--- a/src/maasserver/api/tests/test_tag.py
+++ b/src/maasserver/api/tests/test_tag.py
@@ -209,7 +209,7 @@ class TestTagAPI(APITestCase.ForUser):
         # `default_gateways`, `health_status`, 'special_filesystems' and
         # 'resource_pool' the number of queries is not the same but it is
         # proportional to the number of machines.
-        self.assertEquals(num_queries1, num_queries2 - (3 * 7))
+        self.assertEqual(num_queries1, num_queries2 - (3 * 7))
 
     def test_GET_machines_returns_machines(self):
         tag = factory.make_Tag()
@@ -282,7 +282,7 @@ class TestTagAPI(APITestCase.ForUser):
         # `default_gateways`, `health_status` and 'resource_pool', the number
         # of queries is not the same but it is proportional to the number of
         # machines.
-        self.assertEquals(num_queries1, num_queries2 - (3 * 7))
+        self.assertEqual(num_queries1, num_queries2 - (3 * 7))
 
     def test_GET_devices_returns_devices(self):
         tag = factory.make_Tag()
@@ -345,7 +345,7 @@ class TestTagAPI(APITestCase.ForUser):
                 len(extract_system_ids(parsed_result_2)),
             ],
         )
-        self.assertEquals(num_queries1, num_queries2)
+        self.assertEqual(num_queries1, num_queries2)
 
     def test_GET_rack_controllers_returns_rack_controllers(self):
         self.become_admin()
@@ -413,7 +413,7 @@ class TestTagAPI(APITestCase.ForUser):
                 len(extract_system_ids(parsed_result_2)),
             ],
         )
-        self.assertEquals(num_queries1, num_queries2 - (3 * 3))
+        self.assertEqual(num_queries1, num_queries2 - (3 * 3))
 
     def test_GET_rack_controllers_returns_no_rack_controllers_nonadmin(self):
         tag = factory.make_Tag()
@@ -506,7 +506,7 @@ class TestTagAPI(APITestCase.ForUser):
                 len(extract_system_ids(parsed_result_2)),
             ],
         )
-        self.assertEquals(num_queries1, num_queries2 - 6)
+        self.assertEqual(num_queries1, num_queries2 - 6)
 
     def test_GET_region_controllers_returns_no_controllers_nonadmin(self):
         tag = factory.make_Tag()
diff --git a/src/maasserver/api/tests/test_users.py b/src/maasserver/api/tests/test_users.py
index 9507d2c..7f0e190 100644
--- a/src/maasserver/api/tests/test_users.py
+++ b/src/maasserver/api/tests/test_users.py
@@ -181,7 +181,7 @@ class TestUsers(APITestCase.ForUser):
         )
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Created user '%s'." % username)
+        self.assertEqual(event.description, "Created user '%s'." % username)
 
     def test_POST_creates_audit_event_for_admin(self):
         self.become_admin()
@@ -197,7 +197,7 @@ class TestUsers(APITestCase.ForUser):
         )
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Created admin '%s'." % username)
+        self.assertEqual(event.description, "Created admin '%s'." % username)
 
     def test_POST_password_required_without_external_auth(self):
         self.become_admin()
@@ -552,7 +552,7 @@ class TestUser(APITestCase.ForUser):
         self.client.delete(reverse("user_handler", args=[user.username]))
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(
+        self.assertEqual(
             event.description, "Deleted user '%s'." % user.username
         )
 
@@ -562,6 +562,6 @@ class TestUser(APITestCase.ForUser):
         self.client.delete(reverse("user_handler", args=[user.username]))
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(
+        self.assertEqual(
             event.description, "Deleted admin '%s'." % user.username
         )
diff --git a/src/maasserver/api/tests/test_vmfs_datastores.py b/src/maasserver/api/tests/test_vmfs_datastores.py
index c805b89..2c24dd5 100644
--- a/src/maasserver/api/tests/test_vmfs_datastores.py
+++ b/src/maasserver/api/tests/test_vmfs_datastores.py
@@ -125,9 +125,9 @@ class TestVMFSDatastoresAPI(APITestCase.ForUser):
         )
         self.assertThat(response, HasStatusCode(http.client.OK))
         parsed_results = json_load_bytes(response.content)
-        self.assertEquals(node.system_id, parsed_results["system_id"])
+        self.assertEqual(node.system_id, parsed_results["system_id"])
         # VMFS should be using the 5 devices we listed above.
-        self.assertEquals(5, len(parsed_results["devices"]))
+        self.assertEqual(5, len(parsed_results["devices"]))
         # VMFS should be using all the block devices we created.
         self.assertItemsEqual(
             [bd.id for bd in block_devices] + [block_device.id],
@@ -147,7 +147,7 @@ class TestVMFSDatastoreAPI(APITestCase.ForUser):
     def test_handler_path(self):
         node = factory.make_Machine()
         vmfs = factory.make_VMFS(node=node)
-        self.assertEquals(
+        self.assertEqual(
             "/MAAS/api/2.0/nodes/%s/vmfs-datastore/%s/"
             % (node.system_id, vmfs.id),
             self.get_vmfs_uri(vmfs),
@@ -183,7 +183,7 @@ class TestVMFSDatastoreAPI(APITestCase.ForUser):
                 }
             ),
         )
-        self.assertEquals(
+        self.assertEqual(
             vmfs.filesystems.count(), len(parsed_result["devices"])
         )
 
@@ -242,8 +242,8 @@ class TestVMFSDatastoreAPI(APITestCase.ForUser):
         vmfs = reload_object(vmfs)
         partition_ids.add(new_bd.get_partitiontable().partitions.first().id)
 
-        self.assertEquals(new_name, vmfs.name)
-        self.assertEquals(new_uuid, vmfs.uuid)
+        self.assertEqual(new_name, vmfs.name)
+        self.assertEqual(new_uuid, vmfs.uuid)
         self.assertItemsEqual(
             partition_ids,
             [fs.get_parent().id for fs in vmfs.filesystems.all()],
diff --git a/src/maasserver/api/tests/test_volume_groups.py b/src/maasserver/api/tests/test_volume_groups.py
index db13536..df1ddaf 100644
--- a/src/maasserver/api/tests/test_volume_groups.py
+++ b/src/maasserver/api/tests/test_volume_groups.py
@@ -189,7 +189,7 @@ class TestVolumeGroupAPI(APITestCase.ForUser):
         volume_group = factory.make_FilesystemGroup(
             node=node, group_type=FILESYSTEM_GROUP_TYPE.LVM_VG
         )
-        self.assertEquals(
+        self.assertEqual(
             "/MAAS/api/2.0/nodes/%s/volume-group/%s/"
             % (node.system_id, volume_group.id),
             get_volume_group_uri(volume_group, node, False),
diff --git a/src/maasserver/clusterrpc/tests/test_driver_parameters.py b/src/maasserver/clusterrpc/tests/test_driver_parameters.py
index 950214d..d9c6507 100644
--- a/src/maasserver/clusterrpc/tests/test_driver_parameters.py
+++ b/src/maasserver/clusterrpc/tests/test_driver_parameters.py
@@ -214,7 +214,7 @@ class TestMakeFormField(MAASServerTestCase):
             "default": "some default",
         }
         django_field = make_form_field(json_field)
-        self.assertEquals(json_field["default"], django_field.initial)
+        self.assertEqual(json_field["default"], django_field.initial)
 
 
 class TestMakeSettingField(MAASServerTestCase):
diff --git a/src/maasserver/clusterrpc/tests/test_pods.py b/src/maasserver/clusterrpc/tests/test_pods.py
index 96e8552..bbdff42 100644
--- a/src/maasserver/clusterrpc/tests/test_pods.py
+++ b/src/maasserver/clusterrpc/tests/test_pods.py
@@ -75,7 +75,7 @@ class TestDiscoverPod(MAASTransactionServerTestCase):
 
         self.patch(pods_module, "getAllClients").return_value = clients
         discovered = yield discover_pod(factory.make_name("pod"), {})
-        self.assertEquals(
+        self.assertEqual(
             ({rack_id: pod for rack_id in rack_ids}, {}), discovered
         )
 
@@ -113,7 +113,7 @@ class TestDiscoverPod(MAASTransactionServerTestCase):
 
         self.patch(pods_module, "getAllClients").return_value = clients
         discovered = yield discover_pod(pod_type, {})
-        self.assertEquals(
+        self.assertEqual(
             ({valid_rack_id: pod}, {error_rack_id: exception}), discovered
         )
 
diff --git a/src/maasserver/forms/tests/test_clone.py b/src/maasserver/forms/tests/test_clone.py
index 7868ea8..8133280 100644
--- a/src/maasserver/forms/tests/test_clone.py
+++ b/src/maasserver/forms/tests/test_clone.py
@@ -17,7 +17,7 @@ class TestCloneForm(MAASServerTestCase):
         user = factory.make_admin()
         form = CloneForm(user, data={})
         self.assertFalse(form.is_valid())
-        self.assertEquals(
+        self.assertEqual(
             {
                 "source": ["This field is required."],
                 "destinations": ["This field is required."],
@@ -42,7 +42,7 @@ class TestCloneForm(MAASServerTestCase):
             },
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals(
+        self.assertEqual(
             {
                 "destinations": [
                     "Machine 1 in the array did not validate: "
@@ -76,7 +76,7 @@ class TestCloneForm(MAASServerTestCase):
             },
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals(
+        self.assertEqual(
             {
                 "destinations": [
                     "Machine 1 in the array did not validate: "
@@ -107,7 +107,7 @@ class TestCloneForm(MAASServerTestCase):
             },
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals(
+        self.assertEqual(
             {
                 "destinations": [
                     "Machine 1 in the array did not validate: "
@@ -145,7 +145,7 @@ class TestCloneForm(MAASServerTestCase):
             },
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals(
+        self.assertEqual(
             {
                 "destinations": [
                     "Machine 1 in the array did not validate: "
diff --git a/src/maasserver/forms/tests/test_dhcpsnippet.py b/src/maasserver/forms/tests/test_dhcpsnippet.py
index 2736ee9..2000f04 100644
--- a/src/maasserver/forms/tests/test_dhcpsnippet.py
+++ b/src/maasserver/forms/tests/test_dhcpsnippet.py
@@ -251,7 +251,7 @@ class TestDHCPSnippetForm(MAASServerTestCase):
         request.user = factory.make_User()
         dhcp_snippet = form.save(endpoint, request)
         self.assertIsNone(dhcp_snippet.subnet)
-        self.assertEquals(node, dhcp_snippet.node)
+        self.assertEqual(node, dhcp_snippet.node)
 
     def test_updates_subnet(self):
         dhcp_snippet = factory.make_DHCPSnippet()
@@ -278,7 +278,7 @@ class TestDHCPSnippetForm(MAASServerTestCase):
         request.user = factory.make_User()
         dhcp_snippet = form.save(endpoint, request)
         self.assertIsNone(dhcp_snippet.node)
-        self.assertEquals(subnet, dhcp_snippet.subnet)
+        self.assertEqual(subnet, dhcp_snippet.subnet)
 
     def test_cannot_update_both_node_and_subnet(self):
         dhcp_snippet = factory.make_DHCPSnippet()
@@ -302,7 +302,7 @@ class TestDHCPSnippetForm(MAASServerTestCase):
             },
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals(value, reload_object(dhcp_snippet).value.data)
+        self.assertEqual(value, reload_object(dhcp_snippet).value.data)
 
     def test_update_global_snippet_resets_node(self):
         node = factory.make_Node()
@@ -349,6 +349,6 @@ class TestDHCPSnippetForm(MAASServerTestCase):
             }
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals({"value": [dhcpd_error["error"]]}, form.errors)
+        self.assertEqual({"value": [dhcpd_error["error"]]}, form.errors)
         self.assertItemsEqual([], VersionedTextFile.objects.all())
         self.assertItemsEqual([], DHCPSnippet.objects.all())
diff --git a/src/maasserver/forms/tests/test_interface.py b/src/maasserver/forms/tests/test_interface.py
index 9d93879..52364a3 100644
--- a/src/maasserver/forms/tests/test_interface.py
+++ b/src/maasserver/forms/tests/test_interface.py
@@ -441,7 +441,7 @@ class TestPhysicalInterfaceForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), dict(form.errors))
         interface = form.save()
-        self.assertEquals(vlan, interface.vlan)
+        self.assertEqual(vlan, interface.vlan)
 
     def test_rejects_parents(self):
         parent = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
@@ -1077,7 +1077,7 @@ class BondInterfaceFormTest(MAASServerTestCase):
             data={"name": interface_name, "parents": [parent1.id, parent2.id]},
         )
         self.assertFalse(form.is_valid(), dict(form.errors))
-        self.assertEquals(
+        self.assertEqual(
             "All parents must belong to the same VLAN.",
             form.errors["parents"][0],
         )
diff --git a/src/maasserver/forms/tests/test_machinewithmacaddresses.py b/src/maasserver/forms/tests/test_machinewithmacaddresses.py
index fe96353..ebc8a16 100644
--- a/src/maasserver/forms/tests/test_machinewithmacaddresses.py
+++ b/src/maasserver/forms/tests/test_machinewithmacaddresses.py
@@ -189,7 +189,7 @@ class MachineWithMACAddressesFormTest(MAASServerTestCase):
         node = form.save()
 
         self.assertIsNotNone(node.id)  # The node is persisted.
-        self.assertEquals(NODE_STATUS.NEW, node.status)
+        self.assertEqual(NODE_STATUS.NEW, node.status)
         self.assertItemsEqual(
             macs, [nic.mac_address for nic in node.interface_set.all()]
         )
@@ -226,5 +226,5 @@ class MachineWithMACAddressesFormTest(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         machine = form.save()
-        self.assertEquals(NODE_STATUS.COMMISSIONING, machine.status)
+        self.assertEqual(NODE_STATUS.COMMISSIONING, machine.status)
         self.assertIsNotNone(machine.current_commissioning_script_set)
diff --git a/src/maasserver/forms/tests/test_packagerepository.py b/src/maasserver/forms/tests/test_packagerepository.py
index 1898d89..f96d36b 100644
--- a/src/maasserver/forms/tests/test_packagerepository.py
+++ b/src/maasserver/forms/tests/test_packagerepository.py
@@ -174,7 +174,7 @@ class TestPackageRepositoryForm(MAASServerTestCase):
             data={"url": factory.make_url(scheme="fake")},
         )
         self.assertFalse(form.is_valid())
-        self.assertEquals(url, reload_object(package_repository).url)
+        self.assertEqual(url, reload_object(package_repository).url)
 
     def test_creates_package_repository_defaults_main_arches(self):
         repo = factory.make_PackageRepository(arches=[])
diff --git a/src/maasserver/forms/tests/test_parameters.py b/src/maasserver/forms/tests/test_parameters.py
index ac3eed3..4b41ce3 100644
--- a/src/maasserver/forms/tests/test_parameters.py
+++ b/src/maasserver/forms/tests/test_parameters.py
@@ -324,7 +324,7 @@ class TestParametersForm(MAASServerTestCase):
             data={"runtime": value}, script=script, node=factory.make_Node()
         )
         self.assertTrue(form.is_valid(), form.errors)
-        self.assertEquals(1, len(form.cleaned_data["input"]))
+        self.assertEqual(1, len(form.cleaned_data["input"]))
         self.assertDictEqual(
             {"runtime": {"type": "runtime", "value": value}},
             form.cleaned_data["input"][0],
@@ -336,7 +336,7 @@ class TestParametersForm(MAASServerTestCase):
         )
         form = ParametersForm(data={}, script=script, node=factory.make_Node())
         self.assertTrue(form.is_valid(), form.errors)
-        self.assertEquals(1, len(form.cleaned_data["input"]))
+        self.assertEqual(1, len(form.cleaned_data["input"]))
         self.assertDictEqual(
             {"runtime": {"type": "runtime", "value": script.timeout.seconds}},
             form.cleaned_data["input"][0],
@@ -423,7 +423,7 @@ class TestParametersForm(MAASServerTestCase):
             node=factory.make_Node(with_boot_disk=False),
         )
         self.assertTrue(form.is_valid(), form.errors)
-        self.assertEquals(1, len(form.cleaned_data["input"]))
+        self.assertEqual(1, len(form.cleaned_data["input"]))
         self.assertDictEqual(
             {
                 "runtime": {
@@ -450,12 +450,12 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(node.physicalblockdevice_set.count(), len(input))
+        self.assertEqual(node.physicalblockdevice_set.count(), len(input))
         for bd in node.physicalblockdevice_set:
             for i in input:
                 if bd.name == i["storage"]["value"]["name"]:
                     break
-            self.assertEquals(script.timeout.seconds, i["runtime"]["value"])
+            self.assertEqual(script.timeout.seconds, i["runtime"]["value"])
             self.assertDictEqual(
                 {
                     "name": bd.name,
@@ -485,8 +485,8 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(1, len(input))
-        self.assertEquals(script.timeout.seconds, input[0]["runtime"]["value"])
+        self.assertEqual(1, len(input))
+        self.assertEqual(script.timeout.seconds, input[0]["runtime"]["value"])
         self.assertDictEqual(
             {
                 "name": bd.name,
@@ -544,12 +544,12 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(len(selected_scripts), len(input))
+        self.assertEqual(len(selected_scripts), len(input))
         for bd in selected_scripts.keys():
             for i in input:
                 if bd.name == i["storage"]["value"]["name"]:
                     break
-            self.assertEquals(script.timeout.seconds, i["runtime"]["value"])
+            self.assertEqual(script.timeout.seconds, i["runtime"]["value"])
             self.assertDictEqual(
                 {
                     "name": bd.name,
@@ -609,7 +609,7 @@ class TestParametersForm(MAASServerTestCase):
             data={}, script=script, node=factory.make_Node(interface=False)
         )
         self.assertTrue(form.is_valid(), form.errors)
-        self.assertEquals(1, len(form.cleaned_data["input"]))
+        self.assertEqual(1, len(form.cleaned_data["input"]))
         self.assertDictEqual(
             {"interface": {"type": "interface", "value": "all"}},
             form.cleaned_data["input"][0],
@@ -624,7 +624,7 @@ class TestParametersForm(MAASServerTestCase):
         )
         form = ParametersForm(data={}, script=script, node=node)
         self.assertTrue(form.is_valid(), form.errors)
-        self.assertEquals(1, len(form.cleaned_data["input"]))
+        self.assertEqual(1, len(form.cleaned_data["input"]))
         self.assertDictEqual(
             {
                 "name": node.boot_interface.name,
@@ -657,7 +657,7 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(len(usable_interfaces), len(input))
+        self.assertEqual(len(usable_interfaces), len(input))
         for interface in usable_interfaces:
             for i in input:
                 if i["interface"]["value"]["interface"] == interface:
@@ -690,7 +690,7 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(1, len(input))
+        self.assertEqual(1, len(input))
         self.assertDictEqual(
             {
                 "name": bond.name,
@@ -720,7 +720,7 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(1, len(input))
+        self.assertEqual(1, len(input))
         self.assertDictEqual(
             {
                 "name": interface.name,
@@ -808,7 +808,7 @@ class TestParametersForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         input = form.cleaned_data["input"]
-        self.assertEquals(len(selected_scripts), len(input))
+        self.assertEqual(len(selected_scripts), len(input))
         for nic in selected_scripts.keys():
             for i in input:
                 if (
diff --git a/src/maasserver/forms/tests/test_pods.py b/src/maasserver/forms/tests/test_pods.py
index fe04080..d0cf4f7 100644
--- a/src/maasserver/forms/tests/test_pods.py
+++ b/src/maasserver/forms/tests/test_pods.py
@@ -432,8 +432,8 @@ class TestPodForm(MAASTransactionServerTestCase):
         form = PodForm(data=pod_info, request=self.request)
         self.assertTrue(form.is_valid(), form._errors)
         pod = form.save()
-        self.assertEquals(bmc.id, pod.id)
-        self.assertEquals(BMC_TYPE.POD, reload_object(bmc).bmc_type)
+        self.assertEqual(bmc.id, pod.id)
+        self.assertEqual(BMC_TYPE.POD, reload_object(bmc).bmc_type)
         self.assertThat(mock_post_commit_do, MockCalledOnce())
 
     def test_updates_existing_pod_minimal(self):
@@ -797,7 +797,7 @@ class TestPodForm(MAASTransactionServerTestCase):
         form = PodForm(data=pod_info)
         self.assertTrue(form.is_valid(), form._errors)
         error = self.assertRaises(PodProblem, form.save)
-        self.assertEquals(
+        self.assertEqual(
             "Unable to start the pod discovery process. "
             "No rack controllers connected.",
             str(error),
@@ -816,7 +816,7 @@ class TestPodForm(MAASTransactionServerTestCase):
 
         def validate_error(failure):
             self.assertIsInstance(failure.value, PodProblem)
-            self.assertEquals(
+            self.assertEqual(
                 "Unable to start the pod discovery process. "
                 "No rack controllers connected.",
                 str(failure.value),
@@ -837,7 +837,7 @@ class TestPodForm(MAASTransactionServerTestCase):
         form = PodForm(data=pod_info)
         self.assertTrue(form.is_valid(), form._errors)
         error = self.assertRaises(PodProblem, form.save)
-        self.assertEquals(str(exc), str(error))
+        self.assertEqual(str(exc), str(error))
 
     @wait_for_reactor
     @inlineCallbacks
@@ -854,7 +854,7 @@ class TestPodForm(MAASTransactionServerTestCase):
 
         def validate_error(failure):
             self.assertIsInstance(failure.value, PodProblem)
-            self.assertEquals(str(exc), str(failure.value))
+            self.assertEqual(str(exc), str(failure.value))
 
         d = form.save()
         d.addErrback(validate_error)
@@ -2386,7 +2386,7 @@ class TestComposeMachineForm(MAASTransactionServerTestCase):
         form = ComposeMachineForm(data={}, request=request, pod=pod)
         self.assertTrue(form.is_valid())
         error = self.assertRaises(PodProblem, form.compose)
-        self.assertEquals(
+        self.assertEqual(
             "Unable to compose a machine because '%s' driver timed out "
             "after 120 seconds." % pod.power_type,
             str(error),
diff --git a/src/maasserver/forms/tests/test_script.py b/src/maasserver/forms/tests/test_script.py
index 13df30f..f421660 100644
--- a/src/maasserver/forms/tests/test_script.py
+++ b/src/maasserver/forms/tests/test_script.py
@@ -51,19 +51,19 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(name, script.name)
-        self.assertEquals("", script.title)
-        self.assertEquals("", script.description)
-        self.assertEquals(1, len(script.tags))
-        self.assertEquals(SCRIPT_TYPE.TESTING, script.script_type)
-        self.assertEquals(HARDWARE_TYPE.NODE, script.hardware_type)
-        self.assertEquals(SCRIPT_PARALLEL.DISABLED, script.parallel)
+        self.assertEqual(name, script.name)
+        self.assertEqual("", script.title)
+        self.assertEqual("", script.description)
+        self.assertEqual(1, len(script.tags))
+        self.assertEqual(SCRIPT_TYPE.TESTING, script.script_type)
+        self.assertEqual(HARDWARE_TYPE.NODE, script.hardware_type)
+        self.assertEqual(SCRIPT_PARALLEL.DISABLED, script.parallel)
         self.assertDictEqual({}, script.packages)
         self.assertDictEqual({}, script.results)
         self.assertDictEqual({}, script.parameters)
-        self.assertEquals(timedelta(0), script.timeout)
+        self.assertEqual(timedelta(0), script.timeout)
         self.assertFalse(script.destructive)
-        self.assertEquals(script_content, script.script.data)
+        self.assertEqual(script_content, script.script.data)
         self.assertFalse(script.default)
         self.assertItemsEqual([], script.for_hardware)
         self.assertFalse(script.may_reboot)
@@ -123,24 +123,24 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(title, script.title)
-        self.assertEquals(description, script.description)
+        self.assertEqual(name, script.name)
+        self.assertEqual(title, script.title)
+        self.assertEqual(description, script.description)
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual(packages, script.packages)
         self.assertDictEqual({}, script.results)
         self.assertDictEqual({}, script.parameters)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(timedelta(0, timeout), script.timeout)
-        self.assertEquals(destructive, script.destructive)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(comment, script.script.comment)
-        self.assertEquals(may_reboot, script.may_reboot)
+        self.assertEqual(timedelta(0, timeout), script.timeout)
+        self.assertEqual(destructive, script.destructive)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(comment, script.script.comment)
+        self.assertEqual(may_reboot, script.may_reboot)
         self.assertItemsEqual(for_hardware, script.for_hardware)
-        self.assertEquals(recommission, script.recommission)
+        self.assertEqual(recommission, script.recommission)
         self.assertFalse(script.default)
 
     def test_create_setting_default_has_no_effect(self):
@@ -214,25 +214,25 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(title, script.title)
-        self.assertEquals(description, script.description)
+        self.assertEqual(name, script.name)
+        self.assertEqual(title, script.title)
+        self.assertEqual(description, script.description)
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual({}, script.results)
         self.assertDictEqual({}, script.parameters)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(timedelta(0, timeout), script.timeout)
-        self.assertEquals(destructive, script.destructive)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(comment, script.script.comment)
-        self.assertEquals(
+        self.assertEqual(timedelta(0, timeout), script.timeout)
+        self.assertEqual(destructive, script.destructive)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(comment, script.script.comment)
+        self.assertEqual(
             orig_script_content, script.script.previous_version.data
         )
-        self.assertEquals(None, script.script.previous_version.comment)
-        self.assertEquals(
+        self.assertEqual(None, script.script.previous_version.comment)
+        self.assertEqual(
             apply_configured_networking, script.apply_configured_networking
         )
         self.assertFalse(script.default)
@@ -276,7 +276,7 @@ class TestScriptForm(MAASServerTestCase):
                 value = factory.make_string()
             form = ScriptForm(data={name: value}, instance=script)
             self.assertFalse(form.is_valid())
-            self.assertEquals(1, VersionedTextFile.objects.all().count())
+            self.assertEqual(1, VersionedTextFile.objects.all().count())
 
     def test_update_edit_default_allows_update_of_all_fields(self):
         script = factory.make_Script(default=True)
@@ -321,7 +321,7 @@ class TestScriptForm(MAASServerTestCase):
         script = form.save()
 
         self.assertThat(script.tags, ContainsAll(tags))
-        self.assertEquals(timedelta(0, timeout), script.timeout)
+        self.assertEqual(timedelta(0, timeout), script.timeout)
 
     def test_update_requires_script_with_comment(self):
         script = factory.make_Script()
@@ -362,23 +362,23 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(name, script.name)
-        self.assertEquals(title, script.title)
-        self.assertEquals(description, script.description)
-        self.assertEquals(tags, script.tags)
-        self.assertEquals(script_type, script.script_type)
-        self.assertEquals(hardware_type, script.hardware_type)
+        self.assertEqual(name, script.name)
+        self.assertEqual(title, script.title)
+        self.assertEqual(description, script.description)
+        self.assertEqual(tags, script.tags)
+        self.assertEqual(script_type, script.script_type)
+        self.assertEqual(hardware_type, script.hardware_type)
         self.assertDictEqual(packages, script.packages)
-        self.assertEquals(parallel, script.parallel)
+        self.assertEqual(parallel, script.parallel)
         self.assertDictEqual(results, script.results)
         self.assertDictEqual(parameters, script.parameters)
-        self.assertEquals(timeout, script.timeout)
-        self.assertEquals(destructive, script.destructive)
+        self.assertEqual(timeout, script.timeout)
+        self.assertEqual(destructive, script.destructive)
         self.assertFalse(script.default)
-        self.assertEquals(script_content, script.script.data)
-        self.assertEquals(may_reboot, script.may_reboot)
+        self.assertEqual(script_content, script.script.data)
+        self.assertEqual(may_reboot, script.may_reboot)
         self.assertItemsEqual(for_hardware, script.for_hardware)
-        self.assertEquals(recommission, script.recommission)
+        self.assertEqual(recommission, script.recommission)
 
     def test_yaml_doesnt_update_tags(self):
         script = factory.make_Script()
@@ -410,7 +410,7 @@ class TestScriptForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
-        self.assertEquals(orig_timeout, script.timeout)
+        self.assertEqual(orig_timeout, script.timeout)
 
     def test_can_use_script_type_name(self):
         script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
@@ -424,7 +424,7 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(script_type, script.script_type)
+        self.assertEqual(script_type, script.script_type)
 
     def test_errors_on_invalid_script_type(self):
         form = ScriptForm(
@@ -453,7 +453,7 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(hardware_type, script.hardware_type)
+        self.assertEqual(hardware_type, script.hardware_type)
 
     def test_errors_on_invalid_hardware_type(self):
         form = ScriptForm(
@@ -486,7 +486,7 @@ class TestScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
 
-        self.assertEquals(script_parallel, script.parallel)
+        self.assertEqual(script_parallel, script.parallel)
 
     def test_errors_on_invalid_parallel_name(self):
         form = ScriptForm(
@@ -598,7 +598,7 @@ class TestScriptForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
-        self.assertEquals(script_type, script.script_type)
+        self.assertEqual(script_type, script.script_type)
 
     def test_loads_yaml_embedded_attributes(self):
         embedded_yaml = {
@@ -634,33 +634,33 @@ class TestScriptForm(MAASServerTestCase):
         form = ScriptForm(data={"script": script_content})
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
-        self.assertEquals(embedded_yaml["name"], script.name)
-        self.assertEquals(embedded_yaml["title"], script.title)
-        self.assertEquals(embedded_yaml["description"], script.description)
+        self.assertEqual(embedded_yaml["name"], script.name)
+        self.assertEqual(embedded_yaml["title"], script.title)
+        self.assertEqual(embedded_yaml["description"], script.description)
         self.assertThat(script.tags, ContainsAll(embedded_yaml["tags"]))
-        self.assertEquals(embedded_yaml["script_type"], script.script_type)
-        self.assertEquals(embedded_yaml["hardware_type"], script.hardware_type)
-        self.assertEquals(embedded_yaml["parallel"], script.parallel)
+        self.assertEqual(embedded_yaml["script_type"], script.script_type)
+        self.assertEqual(embedded_yaml["hardware_type"], script.hardware_type)
+        self.assertEqual(embedded_yaml["parallel"], script.parallel)
         self.assertItemsEqual(embedded_yaml["results"], script.results)
         self.assertItemsEqual(embedded_yaml["parameters"], script.parameters)
         self.assertDictEqual(embedded_yaml["packages"], script.packages)
-        self.assertEquals(
+        self.assertEqual(
             timedelta(0, embedded_yaml["timeout"]), script.timeout
         )
-        self.assertEquals(embedded_yaml["destructive"], script.destructive)
-        self.assertEquals(embedded_yaml["may_reboot"], script.may_reboot)
+        self.assertEqual(embedded_yaml["destructive"], script.destructive)
+        self.assertEqual(embedded_yaml["may_reboot"], script.may_reboot)
         if embedded_yaml["script_type"] == SCRIPT_TYPE.COMMISSIONING:
             self.assertItemsEqual(
                 embedded_yaml["for_hardware"], script.for_hardware
             )
-            self.assertEquals(
+            self.assertEqual(
                 embedded_yaml["recommission"], script.recommission
             )
         else:
             self.assertItemsEqual([], script.for_hardware)
             self.assertFalse(script.recommission)
         self.assertFalse(script.default)
-        self.assertEquals(script_content, script.script.data)
+        self.assertEqual(script_content, script.script.data)
 
     def test_only_loads_when_script_updated(self):
         script = factory.make_Script(
@@ -672,7 +672,7 @@ class TestScriptForm(MAASServerTestCase):
         form = ScriptForm(instance=script, data={"name": name})
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
-        self.assertEquals(name, script.name)
+        self.assertEqual(name, script.name)
 
     def test_user_option_unable_to_over_yaml_value(self):
         name = factory.make_name("name")
@@ -733,7 +733,7 @@ class TestScriptForm(MAASServerTestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
         script = form.save()
-        self.assertEquals(name, script.name)
+        self.assertEqual(name, script.name)
 
     def tests_yaml_tags_can_be_string(self):
         tags = [factory.make_name("tag") for _ in range(3)]
@@ -1149,8 +1149,8 @@ class TestCommissioningScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form._errors)
         form.save(request)
         new_script = Script.objects.get(name=name)
-        self.assertEquals(SCRIPT_TYPE.COMMISSIONING, new_script.script_type)
-        self.assertEquals(content, new_script.script.data)
+        self.assertEqual(SCRIPT_TYPE.COMMISSIONING, new_script.script_type)
+        self.assertEqual(content, new_script.script.data)
 
     def test_creates_commissioning_script_from_filename(self):
         request = HttpRequest()
@@ -1164,8 +1164,8 @@ class TestCommissioningScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form._errors)
         form.save(request)
         new_script = Script.objects.get(name=name)
-        self.assertEquals(SCRIPT_TYPE.COMMISSIONING, new_script.script_type)
-        self.assertEquals(content, new_script.script.data)
+        self.assertEqual(SCRIPT_TYPE.COMMISSIONING, new_script.script_type)
+        self.assertEqual(content, new_script.script.data)
 
     def test_updates_commissioning_script(self):
         request = HttpRequest()
@@ -1179,8 +1179,8 @@ class TestCommissioningScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form._errors)
         form.save(request)
         new_script = Script.objects.get(name=script.name)
-        self.assertEquals(SCRIPT_TYPE.COMMISSIONING, new_script.script_type)
-        self.assertEquals(content, new_script.script.data)
+        self.assertEqual(SCRIPT_TYPE.COMMISSIONING, new_script.script_type)
+        self.assertEqual(content, new_script.script.data)
 
     def test_creates_audit_event(self):
         request = HttpRequest()
@@ -1227,8 +1227,8 @@ class TestTestingScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form._errors)
         form.save(request)
         new_script = Script.objects.get(name=name)
-        self.assertEquals(SCRIPT_TYPE.TESTING, new_script.script_type)
-        self.assertEquals(content, new_script.script.data)
+        self.assertEqual(SCRIPT_TYPE.TESTING, new_script.script_type)
+        self.assertEqual(content, new_script.script.data)
 
     def test_creates_test_script_from_filename(self):
         request = HttpRequest()
@@ -1242,8 +1242,8 @@ class TestTestingScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form._errors)
         form.save(request)
         new_script = Script.objects.get(name=name)
-        self.assertEquals(SCRIPT_TYPE.TESTING, new_script.script_type)
-        self.assertEquals(content, new_script.script.data)
+        self.assertEqual(SCRIPT_TYPE.TESTING, new_script.script_type)
+        self.assertEqual(content, new_script.script.data)
 
     def test_updates_test_script(self):
         request = HttpRequest()
@@ -1257,8 +1257,8 @@ class TestTestingScriptForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form._errors)
         form.save(request)
         new_script = Script.objects.get(name=script.name)
-        self.assertEquals(SCRIPT_TYPE.TESTING, new_script.script_type)
-        self.assertEquals(content, new_script.script.data)
+        self.assertEqual(SCRIPT_TYPE.TESTING, new_script.script_type)
+        self.assertEqual(content, new_script.script.data)
 
     def test_creates_audit_event(self):
         request = HttpRequest()
diff --git a/src/maasserver/forms/tests/test_sslkey.py b/src/maasserver/forms/tests/test_sslkey.py
index 63113a2..f13a8ed 100644
--- a/src/maasserver/forms/tests/test_sslkey.py
+++ b/src/maasserver/forms/tests/test_sslkey.py
@@ -27,4 +27,4 @@ class TestSSLKeyForm(MAASServerTestCase):
         form.save(factory.pick_choice(ENDPOINT_CHOICES), request)
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Created SSL key.")
+        self.assertEqual(event.description, "Created SSL key.")
diff --git a/src/maasserver/forms/tests/test_subnet.py b/src/maasserver/forms/tests/test_subnet.py
index e1845a4..0d5228e 100644
--- a/src/maasserver/forms/tests/test_subnet.py
+++ b/src/maasserver/forms/tests/test_subnet.py
@@ -311,7 +311,7 @@ class TestSubnetForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), dict(form.errors))
         form.save()
         subnet = reload_object(subnet)
-        self.assertEquals(dns_servers, subnet.dns_servers)
+        self.assertEqual(dns_servers, subnet.dns_servers)
 
     def test_doesnt_overwrite_other_fields(self):
         new_name = factory.make_name("subnet")
@@ -355,7 +355,7 @@ class TestSubnetForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), dict(form.errors))
         form.save()
         subnet = reload_object(subnet)
-        self.assertEquals(dns_servers, subnet.dns_servers)
+        self.assertEqual(dns_servers, subnet.dns_servers)
 
     def test_clean_dns_servers_accepts_space_separated_list(self):
         subnet = factory.make_Subnet()
@@ -368,4 +368,4 @@ class TestSubnetForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), dict(form.errors))
         form.save()
         subnet = reload_object(subnet)
-        self.assertEquals(dns_servers, subnet.dns_servers)
+        self.assertEqual(dns_servers, subnet.dns_servers)
diff --git a/src/maasserver/forms/tests/test_vlan.py b/src/maasserver/forms/tests/test_vlan.py
index 1f25e3a..a2b19d9 100644
--- a/src/maasserver/forms/tests/test_vlan.py
+++ b/src/maasserver/forms/tests/test_vlan.py
@@ -272,7 +272,7 @@ class TestVLANForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         form.save()
         vlan = reload_object(vlan)
-        self.assertEquals(relay_vlan.id, vlan.relay_vlan.id)
+        self.assertEqual(relay_vlan.id, vlan.relay_vlan.id)
 
     def test_update_clears_relay_vlan_when_None(self):
         relay_vlan = factory.make_VLAN()
@@ -299,7 +299,7 @@ class TestVLANForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         form.save()
         vlan = reload_object(vlan)
-        self.assertEquals(space.id, vlan.space.id)
+        self.assertEqual(space.id, vlan.space.id)
 
     def test_update_sets_space_by_specifier(self):
         vlan = factory.make_VLAN()
@@ -308,7 +308,7 @@ class TestVLANForm(MAASServerTestCase):
         self.assertTrue(form.is_valid(), form.errors)
         form.save()
         vlan = reload_object(vlan)
-        self.assertEquals(space.id, vlan.space.id)
+        self.assertEqual(space.id, vlan.space.id)
 
     def test_update_clears_space_when_None(self):
         space = factory.make_Space()
diff --git a/src/maasserver/models/signals/tests/test_interfaces.py b/src/maasserver/models/signals/tests/test_interfaces.py
index 5bd8659..b09b10e 100644
--- a/src/maasserver/models/signals/tests/test_interfaces.py
+++ b/src/maasserver/models/signals/tests/test_interfaces.py
@@ -261,7 +261,7 @@ class TestInterfaceVLANUpdateController(MAASServerTestCase):
         new_vlan = new_fabric.get_default_vlan()
         interface.vlan = new_vlan
         interface.save()
-        self.assertEquals(new_vlan, reload_object(subnet).vlan)
+        self.assertEqual(new_vlan, reload_object(subnet).vlan)
 
     def test_doesnt_move_link_subnets_when_target_vlan_is_None(self):
         node = self.maker()
@@ -271,7 +271,7 @@ class TestInterfaceVLANUpdateController(MAASServerTestCase):
         factory.make_StaticIPAddress(subnet=subnet, interface=interface)
         interface.vlan = None
         interface.save()
-        self.assertEquals(old_vlan, reload_object(subnet).vlan)
+        self.assertEqual(old_vlan, reload_object(subnet).vlan)
 
     def test_doesnt_move_link_subnets_when_source_vlan_is_None(self):
         node = self.maker()
@@ -283,7 +283,7 @@ class TestInterfaceVLANUpdateController(MAASServerTestCase):
         factory.make_StaticIPAddress(subnet=subnet, interface=interface)
         interface.vlan = factory.make_VLAN()
         interface.save()
-        self.assertEquals(interface.vlan, reload_object(subnet).vlan)
+        self.assertEqual(interface.vlan, reload_object(subnet).vlan)
 
     def test_moves_children_vlans_to_same_fabric(self):
         node = self.maker()
@@ -302,14 +302,14 @@ class TestInterfaceVLANUpdateController(MAASServerTestCase):
         new_vlan = new_fabric.get_default_vlan()
         parent.vlan = new_vlan
         parent.save()
-        self.assertEquals(new_vlan, reload_object(subnet).vlan)
+        self.assertEqual(new_vlan, reload_object(subnet).vlan)
         vlan_interface = reload_object(vlan_interface)
-        self.assertEquals(
+        self.assertEqual(
             (new_fabric.id, old_vlan.vid),
             (vlan_interface.vlan.fabric.id, vlan_interface.vlan.vid),
         )
         vlan_subnet = reload_object(vlan_subnet)
-        self.assertEquals(
+        self.assertEqual(
             (new_fabric.id, old_vlan.vid),
             (vlan_subnet.vlan.fabric.id, vlan_subnet.vlan.vid),
         )
diff --git a/src/maasserver/models/signals/tests/test_nodes.py b/src/maasserver/models/signals/tests/test_nodes.py
index 27888d6..38c4bdc 100644
--- a/src/maasserver/models/signals/tests/test_nodes.py
+++ b/src/maasserver/models/signals/tests/test_nodes.py
@@ -36,7 +36,7 @@ class TestNodeDeletion(MAASServerTestCase):
         events = [factory.make_Event(node=node) for _ in range(3)]
         node.delete()
         for event in events:
-            self.assertEquals(event.node_hostname, node_hostname)
+            self.assertEqual(event.node_hostname, node_hostname)
 
     def test_deleting_node_sets_node_to_null(self):
         node = factory.make_Node()
@@ -87,7 +87,7 @@ class TestNodePreviousStatus(MAASServerTestCase):
         )
         node.status = random.choice(NODE_TRANSITIONS[node.status])
         node.save()
-        self.assertEquals(previous_status, node.previous_status)
+        self.assertEqual(previous_status, node.previous_status)
 
 
 class TestNodeClearsOwnerNEWOrREADYStatus(MAASServerTestCase):
diff --git a/src/maasserver/models/signals/tests/test_podhints.py b/src/maasserver/models/signals/tests/test_podhints.py
index f11a3cb..696e574 100644
--- a/src/maasserver/models/signals/tests/test_podhints.py
+++ b/src/maasserver/models/signals/tests/test_podhints.py
@@ -17,6 +17,6 @@ class TestCreatePodChanged(MAASServerTestCase):
         node = factory.make_Node(memory=2048)
         pod.hints.nodes.add(node)
         pod.sync_hints_from_nodes()
-        self.assertEquals(2048, pod.memory)
+        self.assertEqual(2048, pod.memory)
         pod.hints.nodes.remove(node)
-        self.assertEquals(0, reload_object(pod).memory)
+        self.assertEqual(0, reload_object(pod).memory)
diff --git a/src/maasserver/models/signals/tests/test_services.py b/src/maasserver/models/signals/tests/test_services.py
index 0c237ef..ce50387 100644
--- a/src/maasserver/models/signals/tests/test_services.py
+++ b/src/maasserver/models/signals/tests/test_services.py
@@ -88,9 +88,7 @@ class TestRegionControllerProcess(MAASServerTestCase):
         rack_controllers = [factory.make_RackController() for _ in range(3)]
         mock_create_for = self.patch(Service.objects, "create_services_for")
         factory.make_RegionControllerProcess()
-        self.assertEquals(
-            len(rack_controllers) + 1, mock_create_for.call_count
-        )
+        self.assertEqual(len(rack_controllers) + 1, mock_create_for.call_count)
 
     def test_calls_update_rackd_status_on_all_racks_on_create(self):
         rack_controllers = [factory.make_RackController() for _ in range(3)]
@@ -98,7 +96,7 @@ class TestRegionControllerProcess(MAASServerTestCase):
             RackController, "update_rackd_status"
         )
         factory.make_RegionControllerProcess()
-        self.assertEquals(
+        self.assertEqual(
             len(rack_controllers), mock_update_rackd_status.call_count
         )
 
@@ -107,7 +105,7 @@ class TestRegionControllerProcess(MAASServerTestCase):
         process = factory.make_RegionControllerProcess()
         mock_create_for = self.patch(Service.objects, "create_services_for")
         process.delete()
-        self.assertEquals(len(rack_controllers), mock_create_for.call_count)
+        self.assertEqual(len(rack_controllers), mock_create_for.call_count)
 
     def test_calls_update_rackd_status_on_all_racks_on_delete(self):
         rack_controllers = [factory.make_RackController() for _ in range(3)]
@@ -116,6 +114,6 @@ class TestRegionControllerProcess(MAASServerTestCase):
             RackController, "update_rackd_status"
         )
         process.delete()
-        self.assertEquals(
+        self.assertEqual(
             len(rack_controllers), mock_update_rackd_status.call_count
         )
diff --git a/src/maasserver/models/signals/tests/test_users.py b/src/maasserver/models/signals/tests/test_users.py
index d581351..0198f65 100644
--- a/src/maasserver/models/signals/tests/test_users.py
+++ b/src/maasserver/models/signals/tests/test_users.py
@@ -18,4 +18,4 @@ class TestUserUsername(MAASServerTestCase):
         events = [factory.make_Event(user=user) for _ in range(3)]
         user.delete()
         for event in events:
-            self.assertEquals(event.username, username)
+            self.assertEqual(event.username, username)
diff --git a/src/maasserver/models/tests/test_bmc.py b/src/maasserver/models/tests/test_bmc.py
index 76216e9..280f6e2 100644
--- a/src/maasserver/models/tests/test_bmc.py
+++ b/src/maasserver/models/tests/test_bmc.py
@@ -2414,7 +2414,7 @@ class TestPod(MAASServerTestCase):
         )
         node = reload_object(node)
         self.assertItemsEqual([node], pod.hints.nodes.all())
-        self.assertEquals(NODE_STATUS.DEPLOYED, node.status)
+        self.assertEqual(NODE_STATUS.DEPLOYED, node.status)
         self.assertIsNotNone(node.current_commissioning_script_set)
 
     def test_sync_converts_existing_device(self):
@@ -2435,8 +2435,8 @@ class TestPod(MAASServerTestCase):
         )
         device = reload_object(device)
         self.assertItemsEqual([device], pod.hints.nodes.all())
-        self.assertEquals(NODE_STATUS.DEPLOYED, device.status)
-        self.assertEquals(NODE_TYPE.MACHINE, device.node_type)
+        self.assertEqual(NODE_STATUS.DEPLOYED, device.status)
+        self.assertEqual(NODE_TYPE.MACHINE, device.node_type)
         self.assertIsNotNone(device.current_commissioning_script_set)
 
     def test_sync_creates_machine(self):
@@ -2449,11 +2449,11 @@ class TestPod(MAASServerTestCase):
             ),
             factory.make_User(),
         )
-        self.assertEquals(1, pod.hints.nodes.count())
+        self.assertEqual(1, pod.hints.nodes.count())
         node = pod.hints.nodes.first()
-        self.assertEquals(pod.name, node.hostname)
-        self.assertEquals(NODE_STATUS.DEPLOYED, node.status)
-        self.assertEquals(NODE_TYPE.MACHINE, node.node_type)
+        self.assertEqual(pod.name, node.hostname)
+        self.assertEqual(NODE_STATUS.DEPLOYED, node.status)
+        self.assertEqual(NODE_TYPE.MACHINE, node.node_type)
         self.assertItemsEqual(
             mac_addresses,
             [str(iface.mac_address) for iface in node.interface_set.all()],
@@ -2491,15 +2491,15 @@ class TestPod(MAASServerTestCase):
                 elif bd.type == "iscsi":
                     iscsi_storage += bd.size
 
-        self.assertEquals(pod.hints.cores, cores)
-        self.assertEquals(
+        self.assertEqual(pod.hints.cores, cores)
+        self.assertEqual(
             pod.hints.cpu_speed,
             int(mean(cpu_speeds)),
             f"Wrong hint ({pod.hints.cpu_speed}) for CPU speed. CPU speeds of nodes: {cpu_speeds}",
         )
-        self.assertEquals(pod.hints.memory, memory)
-        self.assertEquals(pod.hints.local_disks, len(nodes))
-        self.assertEquals(pod.hints.iscsi_storage, iscsi_storage)
+        self.assertEqual(pod.hints.memory, memory)
+        self.assertEqual(pod.hints.local_disks, len(nodes))
+        self.assertEqual(pod.hints.iscsi_storage, iscsi_storage)
 
     def test_get_used_cores(self):
         pod = factory.make_Pod()
@@ -2508,7 +2508,7 @@ class TestPod(MAASServerTestCase):
             cores = random.randint(1, 4)
             total_cores += cores
             factory.make_Node(bmc=pod, cpu_count=cores)
-        self.assertEquals(total_cores, pod.get_used_cores())
+        self.assertEqual(total_cores, pod.get_used_cores())
 
     def test_get_used_memory(self):
         pod = factory.make_Pod()
@@ -2517,7 +2517,7 @@ class TestPod(MAASServerTestCase):
             memory = random.randint(1, 4)
             total_memory += memory
             factory.make_Node(bmc=pod, memory=memory)
-        self.assertEquals(total_memory, pod.get_used_memory())
+        self.assertEqual(total_memory, pod.get_used_memory())
 
     def test_get_used_local_storage(self):
         pod = factory.make_Pod()
@@ -2527,7 +2527,7 @@ class TestPod(MAASServerTestCase):
             total_storage += storage
             node = factory.make_Node(bmc=pod, with_boot_disk=False)
             factory.make_PhysicalBlockDevice(node=node, size=storage)
-        self.assertEquals(total_storage, pod.get_used_local_storage())
+        self.assertEqual(total_storage, pod.get_used_local_storage())
 
     def test_get_used_local_disks(self):
         pod = factory.make_Pod()
@@ -2535,7 +2535,7 @@ class TestPod(MAASServerTestCase):
             node = factory.make_Node(bmc=pod, with_boot_disk=False)
             for _ in range(3):
                 factory.make_PhysicalBlockDevice(node=node)
-        self.assertEquals(9, pod.get_used_local_disks())
+        self.assertEqual(9, pod.get_used_local_disks())
 
     def test_get_used_iscsi_storage(self):
         pod = factory.make_Pod()
@@ -2545,7 +2545,7 @@ class TestPod(MAASServerTestCase):
             total_storage += storage
             node = factory.make_Node(bmc=pod, with_boot_disk=False)
             factory.make_ISCSIBlockDevice(node=node, size=storage)
-        self.assertEquals(total_storage, pod.get_used_iscsi_storage())
+        self.assertEqual(total_storage, pod.get_used_iscsi_storage())
 
     def test_sync_machine_memory(self):
         pod = factory.make_Pod(pod_type="lxd")
diff --git a/src/maasserver/models/tests/test_bootresource.py b/src/maasserver/models/tests/test_bootresource.py
index f0e1c9d..0c32b14 100644
--- a/src/maasserver/models/tests/test_bootresource.py
+++ b/src/maasserver/models/tests/test_bootresource.py
@@ -189,7 +189,7 @@ class TestBootResourceManager(MAASServerTestCase):
             architecture="amd64/hwe-16.04",
             extra={"subarches": "hwe-p,hwe-t,hwe-16.04,hwe-16.10"},
         )
-        self.assertEquals(
+        self.assertEqual(
             ["hwe-16.04"], BootResource.objects.get_usable_hwe_kernels()
         )
 
@@ -198,7 +198,7 @@ class TestBootResourceManager(MAASServerTestCase):
             architecture="amd64/hwe-16.04",
             extra={"subarches": "hwe-p,hwe-t,hwe-16.04,hwe-16.10"},
         )
-        self.assertEquals(
+        self.assertEqual(
             ["hwe-p", "hwe-t", "hwe-16.04", "hwe-16.10"],
             BootResource.objects.get_supported_hwe_kernels(),
         )
diff --git a/src/maasserver/models/tests/test_bootsourcecache.py b/src/maasserver/models/tests/test_bootsourcecache.py
index 18ac56f..8a75908 100644
--- a/src/maasserver/models/tests/test_bootsourcecache.py
+++ b/src/maasserver/models/tests/test_bootsourcecache.py
@@ -33,7 +33,7 @@ class TestBootSourceCache(MAASServerTestCase):
     def test_get_release_title_returns_release_title(self):
         release_title = factory.make_name("release_title")
         cache = factory.make_BootSourceCache(release_title=release_title)
-        self.assertEquals(
+        self.assertEqual(
             release_title,
             BootSourceCache.objects.get_release_title(cache.os, cache.release),
         )
@@ -54,7 +54,7 @@ class TestBootSourceCache(MAASServerTestCase):
     def test_get_release_codename_returns_release_codename(self):
         release_codename = factory.make_name("release_codename")
         cache = factory.make_BootSourceCache(release_codename=release_codename)
-        self.assertEquals(
+        self.assertEqual(
             release_codename,
             BootSourceCache.objects.get_release_codename(
                 cache.os, cache.release
diff --git a/src/maasserver/models/tests/test_cleansave.py b/src/maasserver/models/tests/test_cleansave.py
index fa4437a..bfeaf25 100644
--- a/src/maasserver/models/tests/test_cleansave.py
+++ b/src/maasserver/models/tests/test_cleansave.py
@@ -21,12 +21,12 @@ class TestCleanSave(MAASLegacyServerTestCase):
     def test_state_is_clean_save_based(self):
         obj = CleanSaveTestModel.objects.create()
         self.assertIsInstance(obj._state, CleanSaveModelState)
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_setting_property(self):
         obj = CleanSaveModelState()
         obj.test_prop = sentinel.value
-        self.assertEquals(sentinel.value, obj.test_prop)
+        self.assertEqual(sentinel.value, obj.test_prop)
 
     def test_handling_deferred_field_getting(self):
         obj = CleanSaveTestModel.objects.create()
@@ -43,24 +43,24 @@ class TestCleanSave(MAASLegacyServerTestCase):
     def test_field_marked_changed_for_new_obj(self):
         obj = CleanSaveTestModel()
         obj.field = "test"
-        self.assertEquals({"field": None}, obj._state._changed_fields)
+        self.assertEqual({"field": None}, obj._state._changed_fields)
 
     def test_field_marked_changed_for_new_obj_when_reset(self):
         obj = CleanSaveTestModel()
         obj.field = "test"
         obj.field = None
-        self.assertEquals({"field": None}, obj._state._changed_fields)
+        self.assertEqual({"field": None}, obj._state._changed_fields)
 
     def test_field_marked_changed_for_existing_obj(self):
         obj = CleanSaveTestModel.objects.create()
         obj.field = "test"
-        self.assertEquals({"field": None}, obj._state._changed_fields)
+        self.assertEqual({"field": None}, obj._state._changed_fields)
 
     def test_field_not_marked_changed_for_existing_obj_when_reset(self):
         obj = CleanSaveTestModel.objects.create()
         obj.field = "test"
         obj.field = None
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_field_not_marked_changed_when_refresh_from_db(self):
         obj = CleanSaveTestModel.objects.create()
@@ -69,8 +69,8 @@ class TestCleanSave(MAASLegacyServerTestCase):
         duplicate.save()
 
         obj.refresh_from_db()
-        self.assertEquals("test", obj.field)
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual("test", obj.field)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_field_not_marked_changed_when_refresh_from_db_no_fields(self):
         obj = CleanSaveTestModel.objects.create()
@@ -79,8 +79,8 @@ class TestCleanSave(MAASLegacyServerTestCase):
         duplicate.save()
 
         obj.refresh_from_db(fields=[])
-        self.assertEquals(None, obj.field)
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual(None, obj.field)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_field_not_marked_changed_when_refresh_with_changed_fields(self):
         obj = CleanSaveTestModel.objects.create()
@@ -89,15 +89,15 @@ class TestCleanSave(MAASLegacyServerTestCase):
         duplicate.save()
 
         obj.refresh_from_db(fields=["field"])
-        self.assertEquals("test", obj.field)
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual("test", obj.field)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_field_not_marked_changed_when_refresh_with_same_fields(self):
         obj = CleanSaveTestModel.objects.create()
 
         obj.refresh_from_db(fields=["field"])
-        self.assertEquals(None, obj.field)
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual(None, obj.field)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_field_marked_changed_when_refresh_from_db_with_no_fields(self):
         obj = CleanSaveTestModel.objects.create()
@@ -107,27 +107,27 @@ class TestCleanSave(MAASLegacyServerTestCase):
 
         obj.field = "test"
         obj.refresh_from_db(fields=[])
-        self.assertEquals("test", obj.field)
-        self.assertEquals({"field": None}, obj._state._changed_fields)
+        self.assertEqual("test", obj.field)
+        self.assertEqual({"field": None}, obj._state._changed_fields)
 
     def test_field_marked_changed_rel_id_for_new_obj(self):
         related = GenericTestModel.objects.create(field="")
         obj = CleanSaveTestModel()
         obj.related_id = related.id
-        self.assertEquals({"related_id": None}, obj._state._changed_fields)
+        self.assertEqual({"related_id": None}, obj._state._changed_fields)
 
     def test_field_marked_changed_rel_attname_for_new_obj(self):
         related = GenericTestModel.objects.create(field="")
         obj = CleanSaveTestModel()
         obj.related = related
-        self.assertEquals({"related_id": None}, obj._state._changed_fields)
+        self.assertEqual({"related_id": None}, obj._state._changed_fields)
 
     def test_field_marked_changed_rel_id_for_existing_obj(self):
         related = GenericTestModel.objects.create(field="")
         new_related = GenericTestModel.objects.create(field="")
         obj = CleanSaveTestModel.objects.create(related=related)
         obj.related_id = new_related.id
-        self.assertEquals(
+        self.assertEqual(
             {"related_id": related.id}, obj._state._changed_fields
         )
 
@@ -136,7 +136,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
         new_related = GenericTestModel.objects.create(field="")
         obj = CleanSaveTestModel.objects.create(related=related)
         obj.related = new_related
-        self.assertEquals(
+        self.assertEqual(
             {"related_id": related.id}, obj._state._changed_fields
         )
 
@@ -146,7 +146,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
         obj = CleanSaveTestModel.objects.create(related=related)
         obj.related_id = new_related.id
         obj.related_id = related.id
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_field_not_marked_changed_rel_attname_for_existing_obj(self):
         related = GenericTestModel.objects.create(field="")
@@ -154,7 +154,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
         obj = CleanSaveTestModel.objects.create(related=related)
         obj.related = new_related
         obj.related = related
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_save_always_calls_save_when_new(self):
         mock_save = self.patch(Model, "save")
@@ -185,7 +185,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
         obj = CleanSaveTestModel()
         obj.field = "test"
         obj.save()
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_save_performed_with_force_update(self):
         obj = CleanSaveTestModel.objects.create()
@@ -237,7 +237,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
                 using="default",
             ),
         )
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_save_table_updates_update_fields_with_changed_fields(self):
         related = GenericTestModel.objects.create(field="")
@@ -257,7 +257,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
                 using="default",
             ),
         )
-        self.assertEquals({}, obj._state._changed_fields)
+        self.assertEqual({}, obj._state._changed_fields)
 
     def test_save_ignores_clean_on_deferred(self):
         obj = CleanSaveTestModel.objects.create(field="test")
@@ -306,7 +306,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
     def test_utils_get_changed(self):
         obj = CleanSaveTestModel.objects.create()
         obj.field = "test"
-        self.assertEquals({"field"}, obj._state.get_changed())
+        self.assertEqual({"field"}, obj._state.get_changed())
 
     def test_utils_has_changed_True(self):
         obj = CleanSaveTestModel.objects.create()
@@ -331,7 +331,7 @@ class TestCleanSave(MAASLegacyServerTestCase):
         new_related = GenericTestModel.objects.create(field="")
         obj = CleanSaveTestModel.objects.create(related=related)
         obj.related = new_related
-        self.assertEquals(related.id, obj._state.get_old_value("related_id"))
+        self.assertEqual(related.id, obj._state.get_old_value("related_id"))
 
     def test_utils_get_old_value_returns_None_when_not_changed(self):
         obj = CleanSaveTestModel.objects.create()
diff --git a/src/maasserver/models/tests/test_config.py b/src/maasserver/models/tests/test_config.py
index 08e2e55..1948ed2 100644
--- a/src/maasserver/models/tests/test_config.py
+++ b/src/maasserver/models/tests/test_config.py
@@ -127,7 +127,7 @@ class ConfigTest(MAASServerTestCase):
                 if name != expected_names[0]
             }
         )
-        self.assertEquals(expected_dict, observed)
+        self.assertEqual(expected_dict, observed)
 
     def test_manager_get_configs_returns_passed_defaults(self):
         expected = get_default_config()
@@ -139,7 +139,7 @@ class ConfigTest(MAASServerTestCase):
         defaults = [expected_dict[name] for name in expected_names]
         for name, value in expected_dict.items():
             Config.objects.set_config(name, value)
-        self.assertEquals(
+        self.assertEqual(
             expected_dict, Config.objects.get_configs(expected_names, defaults)
         )
 
diff --git a/src/maasserver/models/tests/test_filesystemgroup.py b/src/maasserver/models/tests/test_filesystemgroup.py
index 488c747..88b099b 100644
--- a/src/maasserver/models/tests/test_filesystemgroup.py
+++ b/src/maasserver/models/tests/test_filesystemgroup.py
@@ -1025,14 +1025,14 @@ class TestFilesystemGroup(MAASServerTestCase):
 
     def test_get_size_returns_total_size_with_vmfs(self):
         vmfs = factory.make_VMFS()
-        self.assertEquals(vmfs.get_total_size(), vmfs.get_size())
+        self.assertEqual(vmfs.get_total_size(), vmfs.get_size())
 
     def test_get_total_size(self):
         vmfs = factory.make_VMFS()
         size = 0
         for fs in vmfs.filesystems.all():
             size += fs.get_size()
-        self.assertEquals(size, vmfs.get_total_size())
+        self.assertEqual(size, vmfs.get_total_size())
 
     def test_is_lvm_returns_true_when_LVM_VG(self):
         fsgroup = FilesystemGroup(group_type=FILESYSTEM_GROUP_TYPE.LVM_VG)
@@ -1083,7 +1083,7 @@ class TestFilesystemGroup(MAASServerTestCase):
         part = factory.make_Partition()
         name = factory.make_name("datastore")
         vmfs = VMFS.objects.create_vmfs(name, [part])
-        self.assertEquals(
+        self.assertEqual(
             "/vmfs/volumes/%s" % name,
             vmfs.virtual_device.get_effective_filesystem().mount_point,
         )
diff --git a/src/maasserver/models/tests/test_interface.py b/src/maasserver/models/tests/test_interface.py
index 918252e..9652490 100644
--- a/src/maasserver/models/tests/test_interface.py
+++ b/src/maasserver/models/tests/test_interface.py
@@ -163,7 +163,7 @@ class TestInterfaceManager(MAASServerTestCase):
             node=node, mac_address=mac_address
         )
         self.assertFalse(created)
-        self.assertEquals(interface, retrieved_interface)
+        self.assertEqual(interface, retrieved_interface)
 
     def test_get_or_create_with_parents(self):
         parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
@@ -182,7 +182,7 @@ class TestInterfaceManager(MAASServerTestCase):
             node=parent1.node, parents=[parent1, parent2]
         )
         self.assertFalse(created)
-        self.assertEquals(interface, retrieved_interface)
+        self.assertEqual(interface, retrieved_interface)
 
     def test_get_interface_dict_for_node(self):
         node1 = factory.make_Node()
@@ -1341,8 +1341,8 @@ class InterfaceTest(MAASServerTestCase):
         interface.interface_speed = 100
         interface.link_speed = 1000
         interface.save()
-        self.assertEquals(100, interface.interface_speed)
-        self.assertEquals(1000, interface.link_speed)
+        self.assertEqual(100, interface.interface_speed)
+        self.assertEqual(1000, interface.link_speed)
 
     def test_save_link_speed_may_exceed_unknown_interface_speed(self):
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
@@ -1350,14 +1350,14 @@ class InterfaceTest(MAASServerTestCase):
         interface.link_speed = 1000
         interface.save()
         interface = reload_object(interface)
-        self.assertEquals(0, interface.interface_speed)
-        self.assertEquals(1000, interface.link_speed)
+        self.assertEqual(0, interface.interface_speed)
+        self.assertEqual(1000, interface.link_speed)
 
     def test_save_if_link_disconnected_set_link_speed_to_zero(self):
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
         interface.link_connected = False
         interface.save()
-        self.assertEquals(0, interface.link_speed)
+        self.assertEqual(0, interface.link_speed)
 
 
 class InterfaceUpdateNeighbourTest(MAASServerTestCase):
@@ -1771,7 +1771,7 @@ class InterfaceMTUTest(MAASServerTestCase):
                 ),
             ),
         )
-        self.assertEquals([parent.id], [p.id for p in bridge.parents.all()])
+        self.assertEqual([parent.id], [p.id for p in bridge.parents.all()])
 
 
 class VLANInterfaceTest(MAASServerTestCase):
@@ -3649,13 +3649,13 @@ class TestClaimAutoIPs(MAASTransactionServerTestCase):
             )
         with transaction.atomic():
             observed = interface.claim_auto_ips()
-        self.assertEquals(
+        self.assertEqual(
             1,
             len(observed),
             "Should have 1 AUTO IP addresses with an IP address assigned.",
         )
-        self.assertEquals(subnet, observed[0].subnet)
-        self.assertEquals(
+        self.assertEqual(subnet, observed[0].subnet)
+        self.assertEqual(
             IPAddress(network.first + 2), IPAddress(observed[0].ip)
         )
 
@@ -3790,7 +3790,7 @@ class TestCreateAcquiredBridge(MAASServerTestCase):
                 ),
             ),
         )
-        self.assertEquals([parent.id], [p.id for p in bridge.parents.all()])
+        self.assertEqual([parent.id], [p.id for p in bridge.parents.all()])
 
     def test_creates_acquired_bridge_with_passed_options(self):
         parent = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
@@ -3818,7 +3818,7 @@ class TestCreateAcquiredBridge(MAASServerTestCase):
                 ),
             ),
         )
-        self.assertEquals([parent.id], [p.id for p in bridge.parents.all()])
+        self.assertEqual([parent.id], [p.id for p in bridge.parents.all()])
 
     def test_creates_acquired_bridge_moves_links_from_parent_to_bridge(self):
         parent = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
@@ -3847,11 +3847,11 @@ class TestCreateAcquiredBridge(MAASServerTestCase):
                 ),
             ),
         )
-        self.assertEquals([parent.id], [p.id for p in bridge.parents.all()])
-        self.assertEquals(
+        self.assertEqual([parent.id], [p.id for p in bridge.parents.all()])
+        self.assertEqual(
             [bridge.id], [nic.id for nic in auto_ip.interface_set.all()]
         )
-        self.assertEquals(
+        self.assertEqual(
             [bridge.id], [nic.id for nic in static_ip.interface_set.all()]
         )
 
diff --git a/src/maasserver/models/tests/test_iscsiblockdevice.py b/src/maasserver/models/tests/test_iscsiblockdevice.py
index 8f6335d..442dace 100644
--- a/src/maasserver/models/tests/test_iscsiblockdevice.py
+++ b/src/maasserver/models/tests/test_iscsiblockdevice.py
@@ -85,4 +85,4 @@ class TestISCSIBlockDevice(MAASServerTestCase):
             block_size=512,
             target=target,
         )
-        self.assertEquals("iscsi:%s" % target, block_device.target)
+        self.assertEqual("iscsi:%s" % target, block_device.target)
diff --git a/src/maasserver/models/tests/test_node.py b/src/maasserver/models/tests/test_node.py
index 3c21d98..20b5dee 100644
--- a/src/maasserver/models/tests/test_node.py
+++ b/src/maasserver/models/tests/test_node.py
@@ -676,7 +676,7 @@ class TestRackControllerManager(MAASServerTestCase):
         ip = random.choice(["127.0.0.1", "::1"])
         mock_getaddr_info.return_value = (("", "", "", "", (ip,)),)
         self.useFixture(MAASIDFixture(rack.system_id))
-        self.assertEquals(
+        self.assertEqual(
             [rack], RackController.objects.filter_by_url_accessible(ip, False)
         )
 
@@ -724,7 +724,7 @@ class TestRackControllerManager(MAASServerTestCase):
         url = factory.pick_ip_in_Subnet(accessible_subnet)
         mock_getaddr_info = self.patch(node_module.socket, "getaddrinfo")
         mock_getaddr_info.return_value = (("", "", "", "", (url,)),)
-        self.assertEquals(
+        self.assertEqual(
             None, RackController.objects.get_accessible_by_url(url, False)
         )
 
@@ -769,7 +769,7 @@ class TestRegionControllerManager(MAASServerTestCase):
         config_uuid = Config.objects.get_config("uuid")
         self.assertThat(region_running, IsInstance(RegionController))
         self.assertThat(region_running, Equals(region))
-        self.assertEquals(created_uuid, config_uuid)
+        self.assertEqual(created_uuid, config_uuid)
 
     def test_get_or_create_uuid_returns_stored_uuid(self):
         region = factory.make_RegionController()
@@ -783,8 +783,8 @@ class TestRegionControllerManager(MAASServerTestCase):
         stored_uuid = RegionController.objects.get_or_create_uuid()
         self.assertThat(region_running, IsInstance(RegionController))
         self.assertThat(region_running, Equals(region))
-        self.assertEquals(stored_uuid, config_uuid)
-        self.assertEquals(created_uuid, stored_uuid)
+        self.assertEqual(stored_uuid, config_uuid)
+        self.assertEqual(created_uuid, stored_uuid)
 
 
 class TestRegionControllerManagerGetOrCreateRunningController(
@@ -930,7 +930,7 @@ class TestRegionControllerManagerGetOrCreateRunningController(
 
     def assertControllerCreated(self, region):
         # A controller is created and it is always a region controller.
-        self.assertEquals(NODE_TYPE.REGION_CONTROLLER, region.node_type)
+        self.assertEqual(NODE_TYPE.REGION_CONTROLLER, region.node_type)
         # It's a fresh controller so the worker user is always owner.
         self.assertThat(region.owner, Equals(get_worker_user()))
 
@@ -955,7 +955,7 @@ class TestRegionControllerManagerGetOrCreateRunningController(
 
     def assertControllerNotDiscovered(self, region, host):
         # A controller is created and it is always a region controller.
-        self.assertEquals(NODE_TYPE.REGION_CONTROLLER, region.node_type)
+        self.assertEqual(NODE_TYPE.REGION_CONTROLLER, region.node_type)
         # It's new; the primary key differs from the host we planted.
         self.assertThat(region.id, Not(Equals(host.id)))
         # It's a fresh controller so the worker user is always owner.
@@ -3570,8 +3570,8 @@ class TestNode(MAASServerTestCase):
             user=admin,
             commissioning_scripts=[script.name],
         )
-        self.assertEquals(0, ScriptSet.objects.count())
-        self.assertEquals(0, ScriptResult.objects.count())
+        self.assertEqual(0, ScriptSet.objects.count())
+        self.assertEqual(0, ScriptResult.objects.count())
 
     def test_start_commissioning_fails_on_xenial_with_network_testing_t(self):
         Config.objects.set_config("commissioning_distro_series", "xenial")
@@ -3586,8 +3586,8 @@ class TestNode(MAASServerTestCase):
             user=admin,
             testing_scripts=[script.name],
         )
-        self.assertEquals(0, ScriptSet.objects.count())
-        self.assertEquals(0, ScriptResult.objects.count())
+        self.assertEqual(0, ScriptSet.objects.count())
+        self.assertEqual(0, ScriptResult.objects.count())
 
     def test_abort_commissioning_reverts_to_sane_state_on_error(self):
         # If abort commissioning hits an error when trying to stop the
@@ -3830,7 +3830,7 @@ class TestNode(MAASServerTestCase):
         node.start_testing(admin, testing_scripts=[script.name])
         post_commit_hooks.reset()  # Ignore these for now.
         node = reload_object(node)
-        self.assertEquals(NODE_STATUS.TESTING, node.status)
+        self.assertEqual(NODE_STATUS.TESTING, node.status)
         self.assertThat(mock_node_start, MockCalledOnce())
 
     def test_start_testing_changes_status_and_starts_new_node(self):
@@ -3850,7 +3850,7 @@ class TestNode(MAASServerTestCase):
         node.start_testing(admin, testing_scripts=[script.name])
         post_commit_hooks.reset()  # Ignore these for now.
         node = reload_object(node)
-        self.assertEquals(NODE_STATUS.TESTING, node.status)
+        self.assertEqual(NODE_STATUS.TESTING, node.status)
         self.assertThat(mock_node_start, MockCalledOnce())
 
     def test_start_testing_sets_options(self):
@@ -3870,7 +3870,7 @@ class TestNode(MAASServerTestCase):
         )
         post_commit_hooks.reset()  # Ignore these for now.
         node = reload_object(node)
-        self.assertEquals(enable_ssh, node.enable_ssh)
+        self.assertEqual(enable_ssh, node.enable_ssh)
 
     def test_start_testing_sets_user_data(self):
         script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING)
@@ -4065,8 +4065,8 @@ class TestNode(MAASServerTestCase):
             admin,
             testing_scripts=[script.name],
         )
-        self.assertEquals(0, ScriptSet.objects.count())
-        self.assertEquals(0, ScriptResult.objects.count())
+        self.assertEqual(0, ScriptSet.objects.count())
+        self.assertEqual(0, ScriptResult.objects.count())
 
     def test_save_logs_node_status_transition(self):
         self.disable_node_query()
@@ -4257,11 +4257,11 @@ class TestNode(MAASServerTestCase):
         node.mark_failed(script_result_status=script_result_status)
 
         for script_result in updated_script_results:
-            self.assertEquals(
+            self.assertEqual(
                 script_result_status, reload_object(script_result).status
             )
         for script_result in untouched_script_results:
-            self.assertEquals(
+            self.assertEqual(
                 script_result.status, reload_object(script_result).status
             )
 
@@ -8523,7 +8523,7 @@ class TestNode_Start(MAASTransactionServerTestCase):
             user, power_type="manual"
         )
         node.start(user)
-        self.assertEquals(NODE_STATUS.DEPLOYING, node.status)
+        self.assertEqual(NODE_STATUS.DEPLOYING, node.status)
 
     def test_creates_acquired_bridges_for_install_kvm(self):
         user = factory.make_User()
@@ -8543,11 +8543,11 @@ class TestNode_Start(MAASTransactionServerTestCase):
         node = reload_object(node)
         bridge = BridgeInterface.objects.get(node=node)
         interface = node.interface_set.first()
-        self.assertEquals(NODE_STATUS.DEPLOYING, node.status)
-        self.assertEquals(bridge.mac_address, interface.mac_address)
-        self.assertEquals(bridge.params["bridge_type"], bridge_type)
-        self.assertEquals(bridge.params["bridge_stp"], bridge_stp)
-        self.assertEquals(bridge.params["bridge_fd"], bridge_fd)
+        self.assertEqual(NODE_STATUS.DEPLOYING, node.status)
+        self.assertEqual(bridge.mac_address, interface.mac_address)
+        self.assertEqual(bridge.params["bridge_type"], bridge_type)
+        self.assertEqual(bridge.params["bridge_stp"], bridge_stp)
+        self.assertEqual(bridge.params["bridge_fd"], bridge_fd)
         self.assertTrue(node.install_kvm)
 
     def test_doesnt_change_broken(self):
@@ -8558,7 +8558,7 @@ class TestNode_Start(MAASTransactionServerTestCase):
         node.status = NODE_STATUS.BROKEN
         node.save()
         node.start(user)
-        self.assertEquals(NODE_STATUS.BROKEN, node.status)
+        self.assertEqual(NODE_STATUS.BROKEN, node.status)
 
     def test_claims_auto_ip_addresses(self):
         user = factory.make_User()
@@ -9136,14 +9136,14 @@ class TestNode_Start(MAASTransactionServerTestCase):
             name=EVENT_TYPES.NODE_POWER_QUERY_FAILED
         )
         event = node.event_set.get(type=event_type)
-        self.assertEquals(
+        self.assertEqual(
             "(%s) - Aborting NEW and reverting to NEW. Unable to power "
             "control the node. Please check power credentials." % user,
             event.description,
         )
 
         for script_result in script_results:
-            self.assertEquals(
+            self.assertEqual(
                 SCRIPT_STATUS.ABORTED, reload_object(script_result).status
             )
 
@@ -9220,7 +9220,7 @@ class TestGetBMCClientConnectionInfo(MAASServerTestCase):
         fallback.system_id = fake_fallback_id
         mock_fallbacks.return_value = [fallback]
 
-        self.assertEquals(
+        self.assertEqual(
             ([fake_bmc_id], [fake_fallback_id]),
             node._get_bmc_client_connection_info(),
         )
@@ -9233,7 +9233,7 @@ class TestGetBMCClientConnectionInfo(MAASServerTestCase):
             name=EVENT_TYPES.NODE_POWER_QUERY_FAILED
         )
         event = node.event_set.get(type=event_type)
-        self.assertEquals(
+        self.assertEqual(
             (
                 "No rack controllers can access the BMC of node %s"
                 % node.hostname
@@ -13807,7 +13807,7 @@ class TestRackController(MAASTransactionServerTestCase):
         )
         system_id = region_and_rack.system_id
         region_and_rack.as_rack_controller().delete()
-        self.assertEquals(
+        self.assertEqual(
             NODE_TYPE.REGION_CONTROLLER,
             Node.objects.get(system_id=system_id).node_type,
         )
@@ -13817,7 +13817,7 @@ class TestRackController(MAASTransactionServerTestCase):
         rack.bmc = factory.make_BMC()
         rack.save()
         rack.delete()
-        self.assertEquals(
+        self.assertEqual(
             NODE_TYPE.MACHINE,
             Node.objects.get(system_id=rack.system_id).node_type,
         )
@@ -13927,16 +13927,16 @@ class TestRackController(MAASTransactionServerTestCase):
         images = rack_controller.list_boot_images()
         self.assertTrue(images["connected"])
         self.assertItemsEqual(self.expected_images, images["images"])
-        self.assertEquals("synced", images["status"])
-        self.assertEquals("synced", rack_controller.get_image_sync_status())
+        self.assertEqual("synced", images["status"])
+        self.assertEqual("synced", rack_controller.get_image_sync_status())
 
     def test_list_boot_images_when_disconnected(self):
         rack_controller = factory.make_RackController()
         images = rack_controller.list_boot_images()
-        self.assertEquals(False, images["connected"])
+        self.assertEqual(False, images["connected"])
         self.assertItemsEqual([], images["images"])
-        self.assertEquals("unknown", images["status"])
-        self.assertEquals("unknown", rack_controller.get_image_sync_status())
+        self.assertEqual("unknown", images["status"])
+        self.assertEqual("unknown", rack_controller.get_image_sync_status())
 
     def test_list_boot_images_when_connection_closed(self):
         rack_controller = factory.make_RackController()
@@ -13944,10 +13944,10 @@ class TestRackController(MAASTransactionServerTestCase):
             boot_images, "get_boot_images"
         ).side_effect = ConnectionClosed()
         images = rack_controller.list_boot_images()
-        self.assertEquals(False, images["connected"])
+        self.assertEqual(False, images["connected"])
         self.assertItemsEqual([], images["images"])
-        self.assertEquals("unknown", images["status"])
-        self.assertEquals("unknown", rack_controller.get_image_sync_status())
+        self.assertEqual("unknown", images["status"])
+        self.assertEqual("unknown", rack_controller.get_image_sync_status())
 
     def test_list_boot_images_region_importing(self):
         rack_controller = factory.make_RackController()
@@ -13962,8 +13962,8 @@ class TestRackController(MAASTransactionServerTestCase):
         self.assertThat(fake_is_import_resources_running, MockCalledOnce())
         self.assertTrue(images["connected"])
         self.assertItemsEqual(self.expected_images, images["images"])
-        self.assertEquals("region-importing", images["status"])
-        self.assertEquals(
+        self.assertEqual("region-importing", images["status"])
+        self.assertEqual(
             "region-importing", rack_controller.get_image_sync_status()
         )
 
@@ -13981,8 +13981,8 @@ class TestRackController(MAASTransactionServerTestCase):
         images = rack_controller.list_boot_images()
         self.assertTrue(images["connected"])
         self.assertItemsEqual(self.expected_images, images["images"])
-        self.assertEquals("syncing", images["status"])
-        self.assertEquals("syncing", rack_controller.get_image_sync_status())
+        self.assertEqual("syncing", images["status"])
+        self.assertEqual("syncing", rack_controller.get_image_sync_status())
 
     def test_list_boot_images_out_of_sync(self):
         rack_controller = factory.make_RackController()
@@ -13998,8 +13998,8 @@ class TestRackController(MAASTransactionServerTestCase):
         images = rack_controller.list_boot_images()
         self.assertTrue(images["connected"])
         self.assertItemsEqual(self.expected_images, images["images"])
-        self.assertEquals("out-of-sync", images["status"])
-        self.assertEquals(
+        self.assertEqual("out-of-sync", images["status"])
+        self.assertEqual(
             "out-of-sync", rack_controller.get_image_sync_status()
         )
 
@@ -14015,7 +14015,7 @@ class TestRackController(MAASTransactionServerTestCase):
         images = rack_controller.list_boot_images()
         self.assertTrue(images["connected"])
         self.assertItemsEqual([], images["images"])
-        self.assertEquals("syncing", images["status"])
+        self.assertEqual("syncing", images["status"])
 
     def test_is_import_images_running(self):
         running = factory.pick_bool()
@@ -14029,7 +14029,7 @@ class TestRackController(MAASTransactionServerTestCase):
         protocol.IsImportBootImagesRunning.return_value = defer.succeed(
             {"running": running}
         )
-        self.assertEquals(
+        self.assertEqual(
             running, rackcontroller.is_import_boot_images_running()
         )
 
@@ -14045,7 +14045,7 @@ class TestRegionController(MAASServerTestCase):
             node_type=NODE_TYPE.REGION_AND_RACK_CONTROLLER
         )
         region_and_rack.as_region_controller().delete()
-        self.assertEquals(
+        self.assertEqual(
             NODE_TYPE.RACK_CONTROLLER,
             Node.objects.get(system_id=region_and_rack.system_id).node_type,
         )
@@ -14055,7 +14055,7 @@ class TestRegionController(MAASServerTestCase):
         region.bmc = factory.make_BMC()
         region.save()
         region.delete()
-        self.assertEquals(
+        self.assertEqual(
             NODE_TYPE.MACHINE,
             Node.objects.get(system_id=region.system_id).node_type,
         )
@@ -15021,7 +15021,7 @@ class TestNodeInterfaceClone__MappingBetweenNodes(MAASServerTestCase):
         error = self.assertRaises(
             ValidationError, node2._get_interface_mapping_between_nodes, node1
         )
-        self.assertEquals(
+        self.assertEqual(
             "destination node physical interfaces do not match the "
             "source nodes physical interfaces: other, match",
             error.message,
diff --git a/src/maasserver/models/tests/test_ownerdata.py b/src/maasserver/models/tests/test_ownerdata.py
index af3087e..0877e8a 100644
--- a/src/maasserver/models/tests/test_ownerdata.py
+++ b/src/maasserver/models/tests/test_ownerdata.py
@@ -23,7 +23,7 @@ class TestOwnerData(MAASServerTestCase):
             for _ in range(3)
         }
         OwnerData.objects.set_owner_data(node, owner_data)
-        self.assertEquals(owner_data, self.get_owner_data(node))
+        self.assertEqual(owner_data, self.get_owner_data(node))
 
     def test_set_owner_data_updates_data(self):
         node = factory.make_Node()
@@ -35,7 +35,7 @@ class TestOwnerData(MAASServerTestCase):
         for key in owner_data.keys():
             owner_data[key] = factory.make_name("value")
         OwnerData.objects.set_owner_data(node, owner_data)
-        self.assertEquals(owner_data, self.get_owner_data(node))
+        self.assertEqual(owner_data, self.get_owner_data(node))
 
     def test_set_owner_data_removes_data(self):
         node = factory.make_Node()
@@ -47,4 +47,4 @@ class TestOwnerData(MAASServerTestCase):
         for key in owner_data.keys():
             owner_data[key] = None
         OwnerData.objects.set_owner_data(node, owner_data)
-        self.assertEquals({}, self.get_owner_data(node))
+        self.assertEqual({}, self.get_owner_data(node))
diff --git a/src/maasserver/models/tests/test_packagerepository.py b/src/maasserver/models/tests/test_packagerepository.py
index 3758897..ffed1d1 100644
--- a/src/maasserver/models/tests/test_packagerepository.py
+++ b/src/maasserver/models/tests/test_packagerepository.py
@@ -20,7 +20,7 @@ class TestPackageRepositoryManager(MAASServerTestCase):
         archive = factory.make_PackageRepository(
             url=main_url, default=True, arches=["i386", "amd64"]
         )
-        self.assertEquals(
+        self.assertEqual(
             archive, PackageRepository.objects.get_default_archive(arch)
         )
 
@@ -30,7 +30,7 @@ class TestPackageRepositoryManager(MAASServerTestCase):
         archive = factory.make_PackageRepository(
             url=main_url, default=False, arches=["i386", "amd64"]
         )
-        self.assertEquals(
+        self.assertEqual(
             archive,
             PackageRepository.objects.get_additional_repositories(
                 arch
@@ -68,13 +68,13 @@ class TestPackageRepositoryManager(MAASServerTestCase):
         archive = factory.make_PackageRepository(
             url=url, default=False, arches=[arch, factory.make_name()]
         )
-        self.assertEquals(
+        self.assertEqual(
             ppa_archive,
             PackageRepository.objects.get_additional_repositories(
                 ppa_arch
             ).first(),
         )
-        self.assertEquals(
+        self.assertEqual(
             archive,
             PackageRepository.objects.get_additional_repositories(
                 arch
diff --git a/src/maasserver/models/tests/test_partitiontable.py b/src/maasserver/models/tests/test_partitiontable.py
index 9544ed1..ae1b9c7 100644
--- a/src/maasserver/models/tests/test_partitiontable.py
+++ b/src/maasserver/models/tests/test_partitiontable.py
@@ -163,7 +163,7 @@ class TestPartitionTable(MAASServerTestCase):
         partition_table = factory.make_PartitionTable(
             block_device=block_device
         )
-        self.assertEquals(
+        self.assertEqual(
             PARTITION_TABLE_EXTRA_SPACE, partition_table.get_overhead_size()
         )
 
@@ -173,7 +173,7 @@ class TestPartitionTable(MAASServerTestCase):
         partition_table = factory.make_PartitionTable(
             block_device=block_device
         )
-        self.assertEquals(
+        self.assertEqual(
             PARTITION_TABLE_EXTRA_SPACE + PREP_PARTITION_SIZE,
             partition_table.get_overhead_size(),
         )
@@ -186,7 +186,7 @@ class TestPartitionTable(MAASServerTestCase):
         partition_table = factory.make_PartitionTable(
             block_device=block_device
         )
-        self.assertEquals(
+        self.assertEqual(
             PARTITION_TABLE_EXTRA_SPACE + BIOS_GRUB_PARTITION_SIZE,
             partition_table.get_overhead_size(),
         )
diff --git a/src/maasserver/models/tests/test_podstoragepool.py b/src/maasserver/models/tests/test_podstoragepool.py
index 2af4f68..bfc406b 100644
--- a/src/maasserver/models/tests/test_podstoragepool.py
+++ b/src/maasserver/models/tests/test_podstoragepool.py
@@ -15,8 +15,8 @@ class TestPodStoragePool(MAASServerTestCase):
         for _ in range(3):
             bd = factory.make_PhysicalBlockDevice(storage_pool=pool)
             size += bd.size
-        self.assertEquals(size, pool.get_used_storage())
+        self.assertEqual(size, pool.get_used_storage())
 
     def test_get_used_storage_returns_zero(self):
         pool = factory.make_PodStoragePool()
-        self.assertEquals(0, pool.get_used_storage())
+        self.assertEqual(0, pool.get_used_storage())
diff --git a/src/maasserver/models/tests/test_versionedtextfile.py b/src/maasserver/models/tests/test_versionedtextfile.py
index e74e7ce..2e208ba 100644
--- a/src/maasserver/models/tests/test_versionedtextfile.py
+++ b/src/maasserver/models/tests/test_versionedtextfile.py
@@ -95,7 +95,7 @@ class VersionedTextFileTest(MAASServerTestCase):
         for _ in range(10):
             textfile = textfile.update(factory.make_string())
             textfile_ids.append(textfile.id)
-        self.assertEquals(textfile, textfile.revert(0))
+        self.assertEqual(textfile, textfile.revert(0))
         self.assertItemsEqual(
             textfile_ids, [f.id for f in textfile.previous_versions()]
         )
@@ -110,7 +110,7 @@ class VersionedTextFileTest(MAASServerTestCase):
         revert_to = random.randint(-10, -1)
         reverted_ids = textfile_ids[revert_to:]
         remaining_ids = textfile_ids[:revert_to]
-        self.assertEquals(
+        self.assertEqual(
             textfile_ids[revert_to - 1], textfile.revert(revert_to).id
         )
         for i in reverted_ids:
@@ -130,7 +130,7 @@ class VersionedTextFileTest(MAASServerTestCase):
             textfile = textfile.update(factory.make_string())
             textfile_ids.append(textfile.id)
         revert_to = random.randint(-10, -1)
-        self.assertEquals(
+        self.assertEqual(
             textfile_ids[revert_to - 1], textfile.revert(revert_to, False).id
         )
         for i in textfile_ids:
@@ -160,7 +160,7 @@ class VersionedTextFileTest(MAASServerTestCase):
             reverted_or_remaining.append(i)
             if i == revert_to:
                 reverted_or_remaining = reverted_ids
-        self.assertEquals(
+        self.assertEqual(
             VersionedTextFile.objects.get(id=revert_to),
             textfile.revert(revert_to),
         )
@@ -181,7 +181,7 @@ class VersionedTextFileTest(MAASServerTestCase):
             textfile = textfile.update(factory.make_string())
             textfile_ids.append(textfile.id)
         revert_to = random.choice(textfile_ids)
-        self.assertEquals(
+        self.assertEqual(
             VersionedTextFile.objects.get(id=revert_to),
             textfile.revert(revert_to, False),
         )
@@ -232,13 +232,13 @@ class VersionedTextFileTest(MAASServerTestCase):
         textfile = VersionedTextFile.objects.create(
             data='#!/bin/sh\r\necho "Created on Windows!"\r\n'
         )
-        self.assertEquals(
+        self.assertEqual(
             '#!/bin/sh\necho "Created on Windows!"\n', textfile.data
         )
         updated_textfile = textfile.update(
             '#!/bin/sh\r\necho "Updated on Windows!"\r\n'
         )
         self.assertNotEquals(textfile, updated_textfile)
-        self.assertEquals(
+        self.assertEqual(
             '#!/bin/sh\necho "Updated on Windows!"\n', updated_textfile.data
         )
diff --git a/src/maasserver/prometheus/tests/test_stats.py b/src/maasserver/prometheus/tests/test_stats.py
index 235fd86..b37a1a5 100644
--- a/src/maasserver/prometheus/tests/test_stats.py
+++ b/src/maasserver/prometheus/tests/test_stats.py
@@ -44,14 +44,14 @@ class TestPrometheusHandler(MAASServerTestCase):
         self.patch(stats, "PROMETHEUS_SUPPORTED", True)
         response = self.client.get(reverse("metrics"))
         self.assertEqual("text/html; charset=utf-8", response["Content-Type"])
-        self.assertEquals(response.status_code, http.client.NOT_FOUND)
+        self.assertEqual(response.status_code, http.client.NOT_FOUND)
 
     def test_prometheus_stats_handler_not_found_not_supported(self):
         Config.objects.set_config("prometheus_enabled", True)
         self.patch(stats, "PROMETHEUS_SUPPORTED", False)
         response = self.client.get(reverse("metrics"))
         self.assertEqual("text/html; charset=utf-8", response["Content-Type"])
-        self.assertEquals(response.status_code, http.client.NOT_FOUND)
+        self.assertEqual(response.status_code, http.client.NOT_FOUND)
 
     def test_prometheus_stats_handler_returns_success(self):
         Config.objects.set_config("prometheus_enabled", True)
@@ -59,7 +59,7 @@ class TestPrometheusHandler(MAASServerTestCase):
         mock_prom_cli.generate_latest.return_value = {}
         response = self.client.get(reverse("metrics"))
         self.assertEqual("text/plain", response["Content-Type"])
-        self.assertEquals(response.status_code, http.client.OK)
+        self.assertEqual(response.status_code, http.client.OK)
 
     def test_prometheus_stats_handler_returns_metrics(self):
         Config.objects.set_config("prometheus_enabled", True)
diff --git a/src/maasserver/rpc/tests/test_boot.py b/src/maasserver/rpc/tests/test_boot.py
index 1e19ada..1dbb43b 100644
--- a/src/maasserver/rpc/tests/test_boot.py
+++ b/src/maasserver/rpc/tests/test_boot.py
@@ -223,7 +223,7 @@ class TestGetConfig(MAASServerTestCase):
             mac=mac,
             query_count=9,
         )
-        self.assertEquals(
+        self.assertEqual(
             {
                 "system_id": node.system_id,
                 "arch": node.split_arch()[0],
@@ -268,7 +268,7 @@ class TestGetConfig(MAASServerTestCase):
             mac=mac,
             query_count=9,
         )
-        self.assertEquals(
+        self.assertEqual(
             {
                 "system_id": node.system_id,
                 "arch": node.split_arch()[0],
@@ -312,7 +312,7 @@ class TestGetConfig(MAASServerTestCase):
             mac=mac,
             query_count=8,
         )
-        self.assertEquals(
+        self.assertEqual(
             {
                 "system_id": device.system_id,
                 "arch": device.split_arch()[0],
@@ -360,7 +360,7 @@ class TestGetConfig(MAASServerTestCase):
         config = get_config(
             rack_controller.system_id, local_ip, remote_ip, mac=mac
         )
-        self.assertEquals(config["purpose"], "xinstall")
+        self.assertEqual(config["purpose"], "xinstall")
 
     def test_returns_kparams_for_known_node(self):
         rack_controller = factory.make_RackController()
@@ -1403,19 +1403,19 @@ class TestGetBootFilenames(MAASServerTestCase):
             arch, subarch, osystem, series
         )
 
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL
             ).filename,
             kernel,
         )
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD
             ).filename,
             initrd,
         )
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_DTB
             ).filename,
@@ -1435,19 +1435,19 @@ class TestGetBootFilenames(MAASServerTestCase):
             arch, "generic", osystem, series
         )
 
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL
             ).filename,
             kernel,
         )
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD
             ).filename,
             initrd,
         )
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_DTB
             ).filename,
@@ -1486,13 +1486,13 @@ class TestGetBootFilenames(MAASServerTestCase):
             arch, subarch, osystem, series
         )
 
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL
             ).filename,
             kernel,
         )
-        self.assertEquals(
+        self.assertEqual(
             boot_resource_set.files.get(
                 filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD
             ).filename,
diff --git a/src/maasserver/rpc/tests/test_leases.py b/src/maasserver/rpc/tests/test_leases.py
index cb81a6e..134ecef 100644
--- a/src/maasserver/rpc/tests/test_leases.py
+++ b/src/maasserver/rpc/tests/test_leases.py
@@ -71,14 +71,12 @@ class TestUpdateLease(MAASServerTestCase):
         action = factory.make_name("action")
         kwargs = self.make_kwargs(action=action)
         error = self.assertRaises(LeaseUpdateError, update_lease, **kwargs)
-        self.assertEquals("Unknown lease action: %s" % action, str(error))
+        self.assertEqual("Unknown lease action: %s" % action, str(error))
 
     def test_raises_LeaseUpdateError_for_no_subnet(self):
         kwargs = self.make_kwargs()
         error = self.assertRaises(LeaseUpdateError, update_lease, **kwargs)
-        self.assertEquals(
-            "No subnet exists for: %s" % kwargs["ip"], str(error)
-        )
+        self.assertEqual("No subnet exists for: %s" % kwargs["ip"], str(error))
 
     def test_raises_LeaseUpdateError_for_ipv4_mismatch(self):
         ipv6_network = factory.make_ipv6_network()
@@ -86,7 +84,7 @@ class TestUpdateLease(MAASServerTestCase):
         kwargs = self.make_kwargs(subnet=subnet)
         kwargs["ip_family"] = "ipv4"
         error = self.assertRaises(LeaseUpdateError, update_lease, **kwargs)
-        self.assertEquals(
+        self.assertEqual(
             "Family for the subnet does not match. Expected: ipv4", str(error)
         )
 
@@ -96,7 +94,7 @@ class TestUpdateLease(MAASServerTestCase):
         kwargs = self.make_kwargs(subnet=subnet)
         kwargs["ip_family"] = "ipv6"
         error = self.assertRaises(LeaseUpdateError, update_lease, **kwargs)
-        self.assertEquals(
+        self.assertEqual(
             "Family for the subnet does not match. Expected: ipv6", str(error)
         )
 
@@ -140,7 +138,7 @@ class TestUpdateLease(MAASServerTestCase):
             mac_address=kwargs["mac"]
         ).first()
         self.assertIsNotNone(unknown_interface)
-        self.assertEquals(subnet.vlan, unknown_interface.vlan)
+        self.assertEqual(subnet.vlan, unknown_interface.vlan)
         sip = unknown_interface.ip_addresses.first()
         self.assertIsNotNone(sip)
         self.assertThat(
@@ -168,7 +166,7 @@ class TestUpdateLease(MAASServerTestCase):
             mac_address=kwargs["mac"]
         ).first()
         self.assertIsNotNone(unknown_interface)
-        self.assertEquals(subnet.vlan, unknown_interface.vlan)
+        self.assertEqual(subnet.vlan, unknown_interface.vlan)
         sip = unknown_interface.ip_addresses.first()
         self.assertIsNotNone(sip)
         self.assertThat(
@@ -198,7 +196,7 @@ class TestUpdateLease(MAASServerTestCase):
             mac_address=kwargs["mac"]
         ).first()
         self.assertIsNotNone(unknown_interface)
-        self.assertEquals(subnet.vlan, unknown_interface.vlan)
+        self.assertEqual(subnet.vlan, unknown_interface.vlan)
         sip = unknown_interface.ip_addresses.first()
         self.assertIsNotNone(sip)
         dnsrr = get_one(DNSResource.objects.filter(name=hostname))
@@ -232,7 +230,7 @@ class TestUpdateLease(MAASServerTestCase):
             mac_address=kwargs["mac"]
         ).first()
         self.assertIsNotNone(unknown_interface)
-        self.assertEquals(subnet.vlan, unknown_interface.vlan)
+        self.assertEqual(subnet.vlan, unknown_interface.vlan)
         sip = unknown_interface.ip_addresses.first()
         self.assertIsNotNone(sip)
         self.assertThat(sip.dnsresource_set.all(), Not(Contains(sip)))
@@ -251,7 +249,7 @@ class TestUpdateLease(MAASServerTestCase):
             mac_address=kwargs["mac"]
         ).first()
         self.assertIsNotNone(unknown_interface)
-        self.assertEquals(subnet.vlan, unknown_interface.vlan)
+        self.assertEqual(subnet.vlan, unknown_interface.vlan)
         sip = unknown_interface.ip_addresses.first()
         self.assertIsNotNone(sip)
         self.assertThat(sip.dnsresource_set.all(), Not(Contains(sip)))
diff --git a/src/maasserver/rpc/tests/test_nodes.py b/src/maasserver/rpc/tests/test_nodes.py
index 3c5acd8..89cea28 100644
--- a/src/maasserver/rpc/tests/test_nodes.py
+++ b/src/maasserver/rpc/tests/test_nodes.py
@@ -383,7 +383,7 @@ class TestListClusterNodesPowerParameters(MAASServerTestCase):
 
         power_parameters = list_cluster_nodes_power_parameters(rack.system_id)
         system_ids = [params["system_id"] for params in power_parameters]
-        self.assertEquals(sorted(node_ids), sorted(system_ids))
+        self.assertEqual(sorted(node_ids), sorted(system_ids))
 
     def test_returns_unchecked_nodes_first(self):
         rack = factory.make_RackController(power_type="")
diff --git a/src/maasserver/rpc/tests/test_rackcontrollers.py b/src/maasserver/rpc/tests/test_rackcontrollers.py
index ab90b8d..181ee77 100644
--- a/src/maasserver/rpc/tests/test_rackcontrollers.py
+++ b/src/maasserver/rpc/tests/test_rackcontrollers.py
@@ -313,7 +313,7 @@ class TestRegisterRackController(MAASServerTestCase):
         version = "1.10.2"
         node = factory.make_Node(node_type=NODE_TYPE.MACHINE)
         register(system_id=node.system_id, version=version)
-        self.assertEquals(version, node.as_rack_controller().version)
+        self.assertEqual(version, node.as_rack_controller().version)
 
     def test_updates_interfaces(self):
         # Interfaces are set on existing rack controllers.
@@ -467,7 +467,7 @@ class TestUpdateForeignDHCP(MAASServerTestCase):
         )
         dhcp_ip = factory.make_ip_address()
         update_foreign_dhcp(rack_controller.system_id, interface.name, dhcp_ip)
-        self.assertEquals(dhcp_ip, reload_object(interface.vlan).external_dhcp)
+        self.assertEqual(dhcp_ip, reload_object(interface.vlan).external_dhcp)
 
     def test_logs_warning_for_external_dhcp_on_interface_no_vlan(self):
         rack_controller = factory.make_RackController(interface=False)
diff --git a/src/maasserver/rpc/tests/test_regionservice.py b/src/maasserver/rpc/tests/test_regionservice.py
index 05fffaf..832e8da 100644
--- a/src/maasserver/rpc/tests/test_regionservice.py
+++ b/src/maasserver/rpc/tests/test_regionservice.py
@@ -431,7 +431,7 @@ class TestRegionServer(MAASTransactionServerTestCase):
                 "interfaces": {},
             },
         )
-        self.assertEquals(rack_controller.system_id, protocol.ident)
+        self.assertEqual(rack_controller.system_id, protocol.ident)
 
     @wait_for_reactor
     @inlineCallbacks
@@ -474,7 +474,7 @@ class TestRegionServer(MAASTransactionServerTestCase):
                 "interfaces": {},
             },
         )
-        self.assertEquals(sentinel.host, protocol.host)
+        self.assertEqual(sentinel.host, protocol.host)
 
     @wait_for_reactor
     @inlineCallbacks
@@ -538,7 +538,7 @@ class TestRegionServer(MAASTransactionServerTestCase):
             ),
             CannotRegisterRackController,
         )
-        self.assertEquals(
+        self.assertEqual(
             (
                 "Failed to register rack controller 'None' with the master. "
                 "Connection will be dropped.",
@@ -549,7 +549,7 @@ class TestRegionServer(MAASTransactionServerTestCase):
 
 class TestRackClient(MAASTestCase):
     def test_defined_cache_calls(self):
-        self.assertEquals(
+        self.assertEqual(
             [cluster.DescribePowerTypes, cluster.DescribeNOSTypes],
             RackClient.cache_calls,
         )
@@ -583,7 +583,7 @@ class TestRackClient(MAASTestCase):
         result = yield client(cluster.DescribePowerTypes)
         # The result is a copy. It should equal the result but not be
         # the same object.
-        self.assertEquals(power_types, result)
+        self.assertEqual(power_types, result)
         self.assertIsNot(power_types, result)
 
     @wait_for_reactor
@@ -1093,7 +1093,7 @@ class TestRegionService(MAASTestCase):
         self.assertEqual({uuid: set()}, service.waiters)
 
         def check(conn_returned):
-            self.assertEquals(conn, conn_returned)
+            self.assertEqual(conn, conn_returned)
 
         return d.addCallback(check)
 
diff --git a/src/maasserver/rpc/tests/test_regionservice_calls.py b/src/maasserver/rpc/tests/test_regionservice_calls.py
index a1dfe15..32d3a2f 100644
--- a/src/maasserver/rpc/tests/test_regionservice_calls.py
+++ b/src/maasserver/rpc/tests/test_regionservice_calls.py
@@ -1303,7 +1303,7 @@ class TestRegionProtocol_RequestNodeInforByMACAddress(
         copy_response = dict(response)
         del copy_response["boot_type"]
         self.assertAttributes(node, copy_response)
-        self.assertEquals("fastpath", response["boot_type"])
+        self.assertEqual("fastpath", response["boot_type"])
 
     @wait_for_reactor
     def test_request_node_info_by_mac_address_raises_if_unknown_mac(self):
diff --git a/src/maasserver/tests/test_audit.py b/src/maasserver/tests/test_audit.py
index 42ed53e..2dc79e2 100644
--- a/src/maasserver/tests/test_audit.py
+++ b/src/maasserver/tests/test_audit.py
@@ -25,8 +25,8 @@ class CreateAuditEventTest(MAASServerTestCase):
         create_audit_event(EVENT_TYPES.NODE_PXE_REQUEST, endpoint, request)
         event = Event.objects.get(node=None, type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(endpoint, event.endpoint)
-        self.assertEquals("", event.user_agent)
+        self.assertEqual(endpoint, event.endpoint)
+        self.assertEqual("", event.user_agent)
 
     def test_create_audit_event_creates_audit_event_with_user_agent(self):
         node = factory.make_Node()
@@ -45,7 +45,7 @@ class CreateAuditEventTest(MAASServerTestCase):
         )
         event = Event.objects.get(node=node, type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(request.META["HTTP_USER_AGENT"], event.user_agent)
+        self.assertEqual(request.META["HTTP_USER_AGENT"], event.user_agent)
 
     def test_create_audit_event_creates_audit_event_with_description(self):
         node = factory.make_Node()
@@ -66,8 +66,8 @@ class CreateAuditEventTest(MAASServerTestCase):
         )
         event = Event.objects.get(node=node, type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(request.META["HTTP_USER_AGENT"], event.user_agent)
-        self.assertEquals(description, event.description)
+        self.assertEqual(request.META["HTTP_USER_AGENT"], event.user_agent)
+        self.assertEqual(description, event.description)
 
     def test_create_audit_event_creates_audit_event_with_AnonymousUser(self):
         request = HttpRequest()
diff --git a/src/maasserver/tests/test_bootresources.py b/src/maasserver/tests/test_bootresources.py
index e89be3c..609d784 100644
--- a/src/maasserver/tests/test_bootresources.py
+++ b/src/maasserver/tests/test_bootresources.py
@@ -335,8 +335,8 @@ class TestSimpleStreamsHandler(MAASServerTestCase):
         )
         response = self.get_stream_client("maas:v2:download.json")
         output = json.loads(response.content.decode(settings.DEFAULT_CHARSET))
-        self.assertEquals(kflavor, output["products"][product]["kflavor"])
-        self.assertEquals(
+        self.assertEqual(kflavor, output["products"][product]["kflavor"])
+        self.assertEqual(
             bootloader_type, output["products"][product]["bootloader-type"]
         )
         self.assertTrue(output["products"][product]["rolling"])
@@ -849,11 +849,11 @@ class TestBootResourceStore(MAASServerTestCase):
         }
         store = BootResourceStore()
         resource = store.get_or_create_boot_resource(product)
-        self.assertEquals(BOOT_RESOURCE_TYPE.SYNCED, resource.rtype)
-        self.assertEquals("ubuntu-core/16-pc", resource.name)
-        self.assertEquals("amd64/generic", resource.architecture)
+        self.assertEqual(BOOT_RESOURCE_TYPE.SYNCED, resource.rtype)
+        self.assertEqual("ubuntu-core/16-pc", resource.name)
+        self.assertEqual("amd64/generic", resource.architecture)
         self.assertIsNone(resource.bootloader_type)
-        self.assertEquals("pc-kernel", resource.kflavor)
+        self.assertEqual("pc-kernel", resource.kflavor)
         self.assertDictEqual({"title": "Ubuntu Core 16 PC"}, resource.extra)
 
     def test_get_or_create_boot_resource_set_creates_resource_set(self):
@@ -935,7 +935,7 @@ class TestBootResourceStore(MAASServerTestCase):
                 rfile.save()
             for rfile in resource_set.files.all():
                 self.assertIn(rfile.filename, files)
-                self.assertEquals(rfile.filetype, product["ftype"])
+                self.assertEqual(rfile.filetype, product["ftype"])
 
     def test_get_resource_file_log_identifier_returns_valid_ident(self):
         os = factory.make_name("os")
@@ -1022,7 +1022,7 @@ class TestBootResourceStore(MAASServerTestCase):
         store.delete_content_to_finalize()
         self.assertIsNone(reload_object(rfile_one))
         self.assertIsNone(reload_object(rfile_two))
-        self.assertEquals({}, store._content_to_finalize)
+        self.assertEqual({}, store._content_to_finalize)
 
     def test_finalize_does_nothing_if_resources_to_delete_hasnt_changed(self):
         self.patch(bootresources.Event.objects, "create_region_event")
diff --git a/src/maasserver/tests/test_bootsources.py b/src/maasserver/tests/test_bootsources.py
index 6bcb549..1be1755 100644
--- a/src/maasserver/tests/test_bootsources.py
+++ b/src/maasserver/tests/test_bootsources.py
@@ -220,7 +220,7 @@ class TestHelpers(MAASServerTestCase):
         os_title = factory.make_name("os_title")
         release_title = factory.make_name("release_title")
         gadget_title = factory.make_name("gadget_title")
-        self.assertEquals(
+        self.assertEqual(
             "%s %s %s" % (os_title, release_title, gadget_title),
             get_product_title(
                 {
@@ -234,7 +234,7 @@ class TestHelpers(MAASServerTestCase):
     def test_get_product_title_with_os_and_release_titles(self):
         os_title = factory.make_name("os_title")
         release_title = factory.make_name("release_title")
-        self.assertEquals(
+        self.assertEqual(
             "%s %s" % (os_title, release_title),
             get_product_title(
                 {"os_title": os_title, "release_title": release_title}
@@ -346,7 +346,7 @@ class TestPrivateUpdateCache(MAASServerTestCase):
             source.to_dict_without_selections(),
             image_mapping,
         )
-        self.assertEquals(5, queries)
+        self.assertEqual(5, queries)
 
         # Now that they all already exist, it should only be 4 queries.
         queries, _ = count_queries(
@@ -354,7 +354,7 @@ class TestPrivateUpdateCache(MAASServerTestCase):
             source.to_dict_without_selections(),
             image_mapping,
         )
-        self.assertEquals(4, queries)
+        self.assertEqual(4, queries)
 
         # Do it again just to be sure.
         queries, _ = count_queries(
@@ -362,7 +362,7 @@ class TestPrivateUpdateCache(MAASServerTestCase):
             source.to_dict_without_selections(),
             image_mapping,
         )
-        self.assertEquals(4, queries)
+        self.assertEqual(4, queries)
 
 
 class TestPrivateCacheBootSources(MAASTransactionServerTestCase):
diff --git a/src/maasserver/tests/test_config_forms.py b/src/maasserver/tests/test_config_forms.py
index 53f2508..4e36435 100644
--- a/src/maasserver/tests/test_config_forms.py
+++ b/src/maasserver/tests/test_config_forms.py
@@ -207,7 +207,7 @@ class TestFormWithDictCharField(MAASServerTestCase):
             ],
             required=False,
         )
-        self.assertEquals(
+        self.assertEqual(
             default_value, multi_field.clean_sub_fields("")["field_a"]
         )
 
diff --git a/src/maasserver/tests/test_dhcp.py b/src/maasserver/tests/test_dhcp.py
index 1ed1e19..ee0aba5 100644
--- a/src/maasserver/tests/test_dhcp.py
+++ b/src/maasserver/tests/test_dhcp.py
@@ -162,7 +162,7 @@ class TestIPIsStickyOrAuto(MAASServerTestCase):
 
     def test_returns_correct_result(self):
         ip_address = factory.make_StaticIPAddress(alloc_type=self.alloc_type)
-        self.assertEquals(self.result, dhcp.ip_is_sticky_or_auto(ip_address))
+        self.assertEqual(self.result, dhcp.ip_is_sticky_or_auto(ip_address))
 
 
 class TestGetBestInterface(MAASServerTestCase):
@@ -182,7 +182,7 @@ class TestGetBestInterface(MAASServerTestCase):
         bond = factory.make_Interface(
             INTERFACE_TYPE.BOND, node=rack_controller, parents=[nic0, nic1]
         )
-        self.assertEquals(bond, dhcp.get_best_interface([physical, bond]))
+        self.assertEqual(bond, dhcp.get_best_interface([physical, bond]))
 
     def test_returns_physical_over_vlan(self):
         rack_controller = factory.make_RackController()
@@ -192,7 +192,7 @@ class TestGetBestInterface(MAASServerTestCase):
         vlan = factory.make_Interface(
             INTERFACE_TYPE.VLAN, node=rack_controller, parents=[physical]
         )
-        self.assertEquals(physical, dhcp.get_best_interface([physical, vlan]))
+        self.assertEqual(physical, dhcp.get_best_interface([physical, vlan]))
 
     def test_returns_first_interface_when_all_physical(self):
         rack_controller = factory.make_RackController()
@@ -202,7 +202,7 @@ class TestGetBestInterface(MAASServerTestCase):
             )
             for _ in range(3)
         ]
-        self.assertEquals(interfaces[0], dhcp.get_best_interface(interfaces))
+        self.assertEqual(interfaces[0], dhcp.get_best_interface(interfaces))
 
     def test_returns_first_interface_when_all_vlan(self):
         rack_controller = factory.make_RackController()
@@ -215,7 +215,7 @@ class TestGetBestInterface(MAASServerTestCase):
             )
             for _ in range(3)
         ]
-        self.assertEquals(interfaces[0], dhcp.get_best_interface(interfaces))
+        self.assertEqual(interfaces[0], dhcp.get_best_interface(interfaces))
 
 
 class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
@@ -295,7 +295,7 @@ class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
         factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet, interface=interface
         )
-        self.assertEquals(
+        self.assertEqual(
             [interface],
             dhcp.get_interfaces_with_ip_on_vlan(
                 rack_controller, vlan, subnet.get_ipnetwork().version
@@ -353,7 +353,7 @@ class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
             subnet=subnet_with_dynamic_range,
             interface=interface_two,
         )
-        self.assertEquals(
+        self.assertEqual(
             [interface_two, interface_one],
             dhcp.get_interfaces_with_ip_on_vlan(
                 rack_controller, vlan, subnet.get_ipnetwork().version
@@ -427,7 +427,7 @@ class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
             subnet=subnet,
             interface=interface,
         )
-        self.assertEquals(
+        self.assertEqual(
             [],
             dhcp.get_interfaces_with_ip_on_vlan(
                 rack_controller, vlan, subnet.get_ipnetwork().version
@@ -460,7 +460,7 @@ class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
             subnet=other_subnet,
             interface=other_interface,
         )
-        self.assertEquals(
+        self.assertEqual(
             [interface],
             dhcp.get_interfaces_with_ip_on_vlan(
                 rack_controller, vlan, subnet.get_ipnetwork().version
@@ -493,7 +493,7 @@ class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
             subnet=other_subnet,
             interface=other_interface,
         )
-        self.assertEquals(
+        self.assertEqual(
             [interface],
             dhcp.get_interfaces_with_ip_on_vlan(
                 rack_controller, vlan, subnet.get_ipnetwork().version
@@ -511,7 +511,7 @@ class TestGetInterfacesWithIPOnVLAN(MAASServerTestCase):
         factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet, interface=interface
         )
-        self.assertEquals(
+        self.assertEqual(
             [interface],
             dhcp.get_interfaces_with_ip_on_vlan(
                 rack_controller,
@@ -673,7 +673,7 @@ class TestGenManagedVLANsFor(MAASServerTestCase):
 
         # Should only contain the subnets that are managed by the rack
         # controller and the best interface should have been selected.
-        self.assertEquals(
+        self.assertEqual(
             {vlan_one, vlan_two},
             set(dhcp.gen_managed_vlans_for(rack_controller)),
         )
@@ -702,7 +702,7 @@ class TestGenManagedVLANsFor(MAASServerTestCase):
 
         # Should only contain the subnets that are managed by the rack
         # controller and the best interface should have been selected.
-        self.assertEquals(
+        self.assertEqual(
             relay_vlans.union(set([vlan_one])),
             set(dhcp.gen_managed_vlans_for(rack_controller)),
         )
@@ -810,7 +810,7 @@ class TestIPIsOnVLAN(MAASServerTestCase):
             # make_StaticIPAddress always creates a subnet so set it to None.
             ip_address.subnet = None
             ip_address.save()
-        self.assertEquals(
+        self.assertEqual(
             self.result, dhcp.ip_is_on_vlan(ip_address, expected_vlan)
         )
 
@@ -825,7 +825,7 @@ class TestGetIPAddressForInterface(MAASServerTestCase):
         ip_address = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet, interface=interface
         )
-        self.assertEquals(
+        self.assertEqual(
             ip_address, dhcp.get_ip_address_for_interface(interface, vlan)
         )
 
@@ -854,7 +854,7 @@ class TestGetIPAddressForRackController(MAASServerTestCase):
         ip_address = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet, interface=interface
         )
-        self.assertEquals(
+        self.assertEqual(
             ip_address,
             dhcp.get_ip_address_for_rack_controller(rack_controller, vlan),
         )
@@ -883,7 +883,7 @@ class TestGetIPAddressForRackController(MAASServerTestCase):
             subnet=subnet,
             interface=bond_interface,
         )
-        self.assertEquals(
+        self.assertEqual(
             bond_ip_address,
             dhcp.get_ip_address_for_rack_controller(rack_controller, vlan),
         )
@@ -1120,7 +1120,7 @@ class TestGetDefaultDNSServers(MAASServerTestCase):
         self.assertItemsEqual(
             servers[0:-1], [IPAddress(r1_address.ip), IPAddress(r2_address.ip)]
         )
-        self.assertEquals(IPAddress("10.0.0.1"), servers[-1])
+        self.assertEqual(IPAddress("10.0.0.1"), servers[-1])
 
     def test_doesnt_include_remote_region_ip(self):
         # Regression test for LP:1881133
@@ -1584,7 +1584,7 @@ class TestMakeSubnetConfig(MAASServerTestCase):
             [factory.make_name("ntp")],
             default_domain,
         )
-        self.assertEquals(
+        self.assertEqual(
             [
                 {"ip_range_low": "10.9.8.11", "ip_range_high": "10.9.8.20"},
                 {"ip_range_low": "10.9.8.21", "ip_range_high": "10.9.8.30"},
@@ -1613,7 +1613,7 @@ class TestMakeSubnetConfig(MAASServerTestCase):
             default_domain,
             failover_peer=failover_peer,
         )
-        self.assertEquals(
+        self.assertEqual(
             [
                 {
                     "ip_range_low": "10.9.8.11",
@@ -2016,7 +2016,7 @@ class TestMakeFailoverPeerConfig(MAASServerTestCase):
             interface=secondary_interface,
         )
         failover_peer_name = "failover-vlan-%d" % vlan.id
-        self.assertEquals(
+        self.assertEqual(
             (
                 failover_peer_name,
                 {
@@ -2056,7 +2056,7 @@ class TestMakeFailoverPeerConfig(MAASServerTestCase):
             interface=secondary_interface,
         )
         failover_peer_name = "failover-vlan-%d" % vlan.id
-        self.assertEquals(
+        self.assertEqual(
             (
                 failover_peer_name,
                 {
@@ -2136,7 +2136,7 @@ class TestGetDHCPConfigureFor(MAASServerTestCase):
             dhcp_snippets=DHCPSnippet.objects.all(),
         )
 
-        self.assertEquals(
+        self.assertEqual(
             {
                 "name": "failover-vlan-%d" % ha_vlan.id,
                 "mode": "primary",
@@ -2145,7 +2145,7 @@ class TestGetDHCPConfigureFor(MAASServerTestCase):
             },
             observed_failover,
         )
-        self.assertEquals(
+        self.assertEqual(
             sorted(
                 [
                     {
@@ -2297,7 +2297,7 @@ class TestGetDHCPConfigureFor(MAASServerTestCase):
         for observed_subnet in observed_subnets:
             del observed_subnet["dns_servers"]
 
-        self.assertEquals(
+        self.assertEqual(
             {
                 "name": "failover-vlan-%d" % ha_vlan.id,
                 "mode": "primary",
@@ -2306,7 +2306,7 @@ class TestGetDHCPConfigureFor(MAASServerTestCase):
             },
             observed_failover,
         )
-        self.assertEquals(
+        self.assertEqual(
             sorted(
                 [
                     {
@@ -3195,7 +3195,7 @@ class TestValidateDHCPConfig(MAASTransactionServerTestCase):
         rack_controller, config = self.create_rack_controller()
         self.prepare_rpc(rack_controller)
 
-        self.assertEquals([], dhcp.validate_dhcp_config())
+        self.assertEqual([], dhcp.validate_dhcp_config())
 
     def test_returns_errors_when_invalid(self):
         rack_controller, config = self.create_rack_controller()
diff --git a/src/maasserver/tests/test_eventloop.py b/src/maasserver/tests/test_eventloop.py
index 1483066..83433eb 100644
--- a/src/maasserver/tests/test_eventloop.py
+++ b/src/maasserver/tests/test_eventloop.py
@@ -356,7 +356,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["rpc"]["factory"],
         )
         self.assertFalse(eventloop.loop.factories["rpc"]["only_on_master"])
-        self.assertEquals(
+        self.assertEqual(
             ["ipc-worker"], eventloop.loop.factories["rpc"]["requires"]
         )
 
@@ -458,7 +458,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["web"]["factory"],
         )
         # Has a dependency of postgres-listener.
-        self.assertEquals(
+        self.assertEqual(
             ["postgres-listener-worker", "status-worker"],
             eventloop.loop.factories["web"]["requires"],
         )
@@ -477,7 +477,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["rack-controller"]["factory"],
         )
         # Has a dependency of ipc-worker and postgres-listener.
-        self.assertEquals(
+        self.assertEqual(
             ["ipc-worker", "postgres-listener-worker"],
             eventloop.loop.factories["rack-controller"]["requires"],
         )
@@ -495,7 +495,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.make_ServiceMonitorService,
             eventloop.loop.factories["service-monitor"]["factory"],
         )
-        self.assertEquals(
+        self.assertEqual(
             [], eventloop.loop.factories["service-monitor"]["requires"]
         )
         self.assertTrue(
@@ -511,7 +511,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["status-worker"]["factory"],
         )
         # Has a dependency of database-tasks.
-        self.assertEquals(
+        self.assertEqual(
             ["database-tasks"],
             eventloop.loop.factories["status-worker"]["requires"],
         )
@@ -530,7 +530,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["ntp"]["factory"],
         )
         # Has a no dependencies.
-        self.assertEquals([], eventloop.loop.factories["ntp"]["requires"])
+        self.assertEqual([], eventloop.loop.factories["ntp"]["requires"])
         self.assertTrue(eventloop.loop.factories["ntp"]["only_on_master"])
 
     def test_make_SyslogService(self):
@@ -542,7 +542,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["syslog"]["factory"],
         )
         # Has a no dependencies.
-        self.assertEquals([], eventloop.loop.factories["syslog"]["requires"])
+        self.assertEqual([], eventloop.loop.factories["syslog"]["requires"])
         self.assertTrue(eventloop.loop.factories["syslog"]["only_on_master"])
 
     def test_make_WorkersService(self):
@@ -554,7 +554,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["workers"]["factory"],
         )
         # Has a no dependencies.
-        self.assertEquals([], eventloop.loop.factories["workers"]["requires"])
+        self.assertEqual([], eventloop.loop.factories["workers"]["requires"])
         self.assertTrue(eventloop.loop.factories["workers"]["only_on_master"])
         self.assertTrue(eventloop.loop.factories["workers"]["not_all_in_one"])
 
@@ -567,11 +567,11 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["ipc-master"]["factory"],
         )
         # Has a no dependencies.
-        self.assertEquals(
+        self.assertEqual(
             [], eventloop.loop.factories["ipc-master"]["requires"]
         )
         # Has an optional dependency on workers.
-        self.assertEquals(
+        self.assertEqual(
             ["workers"], eventloop.loop.factories["ipc-master"]["optional"]
         )
         self.assertTrue(
@@ -587,7 +587,7 @@ class TestFactories(MAASServerTestCase):
             eventloop.loop.factories["ipc-worker"]["factory"],
         )
         # Has a no dependencies.
-        self.assertEquals(
+        self.assertEqual(
             [], eventloop.loop.factories["ipc-worker"]["requires"]
         )
         self.assertFalse(
diff --git a/src/maasserver/tests/test_fields.py b/src/maasserver/tests/test_fields.py
index 7f8e440..926364a 100644
--- a/src/maasserver/tests/test_fields.py
+++ b/src/maasserver/tests/test_fields.py
@@ -835,7 +835,7 @@ class TestVersionedTextFileField(MAASServerTestCase):
         data = factory.make_string()
         versioned_text_file_field = VersionedTextFileField()
         versioned_text_file = versioned_text_file_field.clean(data)
-        self.assertEquals(data, versioned_text_file.data)
+        self.assertEqual(data, versioned_text_file.data)
         self.assertIsNone(versioned_text_file.previous_version)
 
     def test_create_requires_value(self):
@@ -851,22 +851,22 @@ class TestVersionedTextFileField(MAASServerTestCase):
         versioned_text_file = versioned_text_file_field.clean(
             {"data": data, "comment": comment}
         )
-        self.assertEquals(data, versioned_text_file.data)
-        self.assertEquals(comment, versioned_text_file.comment)
+        self.assertEqual(data, versioned_text_file.data)
+        self.assertEqual(comment, versioned_text_file.comment)
         self.assertIsNone(versioned_text_file.previous_version)
 
     def test_update_does_nothing_on_none(self):
         data = VersionedTextFile.objects.create(data=factory.make_string())
         versioned_text_file_field = VersionedTextFileField(initial=data)
-        self.assertEquals(data, versioned_text_file_field.clean(None))
+        self.assertEqual(data, versioned_text_file_field.clean(None))
 
     def test_creates_new_link(self):
         old_ver = VersionedTextFile.objects.create(data=factory.make_string())
         versioned_text_file_field = VersionedTextFileField(initial=old_ver)
         data = factory.make_string()
         new_ver = versioned_text_file_field.clean(data)
-        self.assertEquals(data, new_ver.data)
-        self.assertEquals(old_ver, new_ver.previous_version)
+        self.assertEqual(data, new_ver.data)
+        self.assertEqual(old_ver, new_ver.previous_version)
 
     def test_creates_new_link_accepts_dict(self):
         old_ver = VersionedTextFile.objects.create(data=factory.make_string())
@@ -876,9 +876,9 @@ class TestVersionedTextFileField(MAASServerTestCase):
         new_ver = versioned_text_file_field.clean(
             {"new_data": data, "comment": comment}
         )
-        self.assertEquals(data, new_ver.data)
-        self.assertEquals(comment, new_ver.comment)
-        self.assertEquals(old_ver, new_ver.previous_version)
+        self.assertEqual(data, new_ver.data)
+        self.assertEqual(comment, new_ver.comment)
+        self.assertEqual(old_ver, new_ver.previous_version)
 
 
 class TestURLOrPPAValidator(MAASServerTestCase):
diff --git a/src/maasserver/tests/test_ipc.py b/src/maasserver/tests/test_ipc.py
index a67d826..ee0214a 100644
--- a/src/maasserver/tests/test_ipc.py
+++ b/src/maasserver/tests/test_ipc.py
@@ -54,18 +54,18 @@ class TestGetIPCSocketPath(MAASTestCase):
         self.useFixture(
             EnvironmentVariableFixture("MAAS_IPC_SOCKET_PATH", path)
         )
-        self.assertEquals(path, get_ipc_socket_path())
+        self.assertEqual(path, get_ipc_socket_path())
 
     def test_returns_ipc_from_maas_data(self):
         path = factory.make_name("path")
         self.useFixture(EnvironmentVariableFixture("MAAS_DATA", path))
-        self.assertEquals(
+        self.assertEqual(
             os.path.join(path, "maas-regiond.sock"), get_ipc_socket_path()
         )
 
     def test_returns_ipc_at_default_location(self):
         self.useFixture(EnvironmentVariableFixture("MAAS_DATA", None))
-        self.assertEquals(
+        self.assertEqual(
             "/var/lib/maas/maas-regiond.sock", get_ipc_socket_path()
         )
 
@@ -142,15 +142,15 @@ class TestIPCCommunication(MAASTransactionServerTestCase):
             return RegionControllerProcess.objects.get(region=region, pid=pid)
 
         process = yield deferToDatabase(getProcessFromDB)
-        self.assertEquals(process.id, master.connections[pid]["process_id"])
+        self.assertEqual(process.id, master.connections[pid]["process_id"])
 
         worker_procId = yield worker.processId.get(timeout=2)
-        self.assertEquals(process.id, worker_procId)
+        self.assertEqual(process.id, worker_procId)
 
         yield worker.stopService()
 
         yield disconnected.get(timeout=2)
-        self.assertEquals({}, master.connections)
+        self.assertEqual({}, master.connections)
 
         process = yield deferToDatabase(reload_object, process)
         self.assertIsNone(process)
@@ -217,7 +217,7 @@ class TestIPCCommunication(MAASTransactionServerTestCase):
             )
 
         endpoints = yield deferToDatabase(getEndpoints)
-        self.assertEquals(
+        self.assertEqual(
             master._getListenAddresses(master.connections[pid]["rpc"]["port"]),
             endpoints,
         )
@@ -294,7 +294,7 @@ class TestIPCCommunication(MAASTransactionServerTestCase):
 
         connection = yield deferToDatabase(getConnection)
         self.assertIsNotNone(connection)
-        self.assertEquals(
+        self.assertEqual(
             {connid: (rackd.system_id, address, port)},
             master.connections[pid]["rpc"]["connections"],
         )
@@ -331,7 +331,7 @@ class TestIPCCommunication(MAASTransactionServerTestCase):
             process = yield deferToDatabase(
                 RegionControllerProcess.objects.get, id=data["process_id"]
             )
-            self.assertEquals(pid, process.pid)
+            self.assertEqual(pid, process.pid)
 
         yield master.stopService()
 
@@ -404,7 +404,7 @@ class TestIPCCommunication(MAASTransactionServerTestCase):
         yield master.update()
 
         region_process = yield deferToDatabase(reload_object, region_process)
-        self.assertEquals(current_time, region_process.updated)
+        self.assertEqual(current_time, region_process.updated)
 
         yield master.stopService()
 
diff --git a/src/maasserver/tests/test_listener.py b/src/maasserver/tests/test_listener.py
index 0e12135..8699b02 100644
--- a/src/maasserver/tests/test_listener.py
+++ b/src/maasserver/tests/test_listener.py
@@ -573,9 +573,9 @@ class TestPostgresListenerService(MAASServerTestCase):
         listener = PostgresListenerService()
         channel = factory.make_name("channel", sep="_").lower()
         listener.register(channel, sentinel.handler)
-        self.assertEquals({channel: [sentinel.handler]}, listener.listeners)
+        self.assertEqual({channel: [sentinel.handler]}, listener.listeners)
         listener.unregister(channel, sentinel.handler)
-        self.assertEquals({}, listener.listeners)
+        self.assertEqual({}, listener.listeners)
 
     def test_unregister_removes_handler_others(self):
         listener = PostgresListenerService()
@@ -583,7 +583,7 @@ class TestPostgresListenerService(MAASServerTestCase):
         listener.register(channel, sentinel.handler1)
         listener.register(channel, sentinel.handler2)
         listener.unregister(channel, sentinel.handler2)
-        self.assertEquals({channel: [sentinel.handler1]}, listener.listeners)
+        self.assertEqual({channel: [sentinel.handler1]}, listener.listeners)
 
     @wait_for_reactor
     @inlineCallbacks
diff --git a/src/maasserver/tests/test_node_action.py b/src/maasserver/tests/test_node_action.py
index add7166..6ec7c70 100644
--- a/src/maasserver/tests/test_node_action.py
+++ b/src/maasserver/tests/test_node_action.py
@@ -370,13 +370,11 @@ class TestCommissionAction(MAASServerTestCase):
             )
         script_sets = ScriptSet.objects.all()
         node = reload_object(node)
-        self.assertEquals(2, len(script_sets))
-        self.assertEquals(
+        self.assertEqual(2, len(script_sets))
+        self.assertEqual(
             node.current_commissioning_script_set_id, script_sets[0].id
         )
-        self.assertEquals(
-            node.current_testing_script_set_id, script_sets[1].id
-        )
+        self.assertEqual(node.current_testing_script_set_id, script_sets[1].id)
         self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
         self.assertThat(
             node_start,
diff --git a/src/maasserver/tests/test_node_constraint_filter_forms.py b/src/maasserver/tests/test_node_constraint_filter_forms.py
index 96dd0a6..9c0a514 100644
--- a/src/maasserver/tests/test_node_constraint_filter_forms.py
+++ b/src/maasserver/tests/test_node_constraint_filter_forms.py
@@ -872,7 +872,7 @@ class TestFilterNodeForm(MAASServerTestCase, FilterConstraintsMixin):
         _, storage, _ = self.assertConstrainedNodes(
             [node1], {"storage": "part:0(partition)"}
         )
-        self.assertEquals(
+        self.assertEqual(
             {node1.id: {"partition:%d" % partition.id: "part"}}, storage
         )
 
@@ -928,7 +928,7 @@ class TestFilterNodeForm(MAASServerTestCase, FilterConstraintsMixin):
         _, storage, _ = self.assertConstrainedNodes(
             [node1], {"storage": "part:0(partition,ssd-part)"}
         )
-        self.assertEquals(
+        self.assertEqual(
             {node1.id: {"partition:%d" % partition.id: "part"}}, storage
         )
 
@@ -1090,7 +1090,7 @@ class TestFilterNodeForm(MAASServerTestCase, FilterConstraintsMixin):
         _, storage, _ = self.assertConstrainedNodes(
             [node3], {"storage": "0,4,4,4,part:0(partition)"}
         )
-        self.assertEquals(
+        self.assertEqual(
             {node3.id: {"partition:%d" % partition.id: "part"}}, storage
         )
 
@@ -1203,11 +1203,11 @@ class TestFilterNodeForm(MAASServerTestCase, FilterConstraintsMixin):
             value: key for key, value in constraint_map[node.id].items()
         }
         disk0 = node.blockdevice_set.get(id=constraints["root"])
-        self.assertEquals(virtual.id, disk0.id)
+        self.assertEqual(virtual.id, disk0.id)
         disk1 = node.blockdevice_set.get(id=constraints["physical"])
-        self.assertEquals(physical.id, disk1.id)
+        self.assertEqual(physical.id, disk1.id)
         disk2 = node.blockdevice_set.get(id=constraints["iscsi"])
-        self.assertEquals(iscsi.id, disk2.id)
+        self.assertEqual(iscsi.id, disk2.id)
 
     def test_fabrics_constraint(self):
         fabric1 = factory.make_Fabric(name="fabric1")
diff --git a/src/maasserver/tests/test_preseed.py b/src/maasserver/tests/test_preseed.py
index dce8a02..8aacc00 100644
--- a/src/maasserver/tests/test_preseed.py
+++ b/src/maasserver/tests/test_preseed.py
@@ -472,7 +472,7 @@ class TestPreseedContext(MAASServerTestCase):
         remote_syslog = "192.168.1.1:514"
         Config.objects.set_config("remote_syslog", remote_syslog)
         context = get_preseed_context(make_HttpRequest())
-        self.assertEquals(remote_syslog, context["syslog_host_port"])
+        self.assertEqual(remote_syslog, context["syslog_host_port"])
 
     def test_get_preseed_context_uses_maas_syslog_port(self):
         syslog_port = factory.pick_port()
diff --git a/src/maasserver/tests/test_rack_controller.py b/src/maasserver/tests/test_rack_controller.py
index ef255f9..01dda0c 100644
--- a/src/maasserver/tests/test_rack_controller.py
+++ b/src/maasserver/tests/test_rack_controller.py
@@ -212,8 +212,8 @@ class TestRackControllerService(
         listener.register(f"sys_dhcp_{rack_id}", service.dhcpHandler)
         service.coreHandler("sys_core_%d" % processId, "unwatch_%d" % rack_id)
         self.assertNotIn(f"sys_dhcp_{rack_id}", listener.listeners)
-        self.assertEquals(set(), service.watching)
-        self.assertEquals(set(), service.needsDHCPUpdate)
+        self.assertEqual(set(), service.watching)
+        self.assertEqual(set(), service.needsDHCPUpdate)
 
     def test_coreHandler_unwatch_doesnt_call_unregister(self):
         processId = random.randint(0, 100)
@@ -240,8 +240,8 @@ class TestRackControllerService(
         dhcp_channel = f"sys_dhcp_{rack_id}"
         self.assertIn(dhcp_channel, listener.listeners)
         self.assertIn(service.dhcpHandler, listener.listeners[dhcp_channel])
-        self.assertEquals(set([rack_id]), service.watching)
-        self.assertEquals(set([rack_id]), service.needsDHCPUpdate)
+        self.assertEqual(set([rack_id]), service.watching)
+        self.assertEqual(set([rack_id]), service.needsDHCPUpdate)
         self.assertThat(mock_startProcessing, MockCalledOnceWith())
 
     def test_coreHandler_watch_doesnt_call_register(self):
@@ -256,8 +256,8 @@ class TestRackControllerService(
         service.coreHandler(sys_channel, "watch_%d" % rack_id)
         self.assertNotIn(sys_channel, listener.listeners)
         self.assertNotIn(sys_channel, listener.registeredChannels)
-        self.assertEquals(set([rack_id]), service.watching)
-        self.assertEquals(set([rack_id]), service.needsDHCPUpdate)
+        self.assertEqual(set([rack_id]), service.watching)
+        self.assertEqual(set([rack_id]), service.needsDHCPUpdate)
         self.assertThat(mock_startProcessing, MockCalledOnceWith())
 
     def test_coreHandler_raises_ValueError_for_unknown_action(self):
@@ -278,7 +278,7 @@ class TestRackControllerService(
         service.watching = set([rack_id])
         mock_startProcessing = self.patch(service, "startProcessing")
         service.dhcpHandler("sys_dhcp_%d" % rack_id, "")
-        self.assertEquals(set([rack_id]), service.needsDHCPUpdate)
+        self.assertEqual(set([rack_id]), service.needsDHCPUpdate)
         self.assertThat(mock_startProcessing, MockCalledOnceWith())
 
     def test_dhcpHandler_doesnt_add_to_needsDHCPUpdate(self):
@@ -287,7 +287,7 @@ class TestRackControllerService(
         service = RackControllerService(sentinel.ipcWorker, listener)
         mock_startProcessing = self.patch(service, "startProcessing")
         service.dhcpHandler("sys_dhcp_%d" % rack_id, "")
-        self.assertEquals(set(), service.needsDHCPUpdate)
+        self.assertEqual(set(), service.needsDHCPUpdate)
         self.assertThat(mock_startProcessing, MockNotCalled())
 
     def test_startProcessing_doesnt_call_start_when_looping_call_running(self):
diff --git a/src/maasserver/tests/test_region_controller.py b/src/maasserver/tests/test_region_controller.py
index 625314f..aad8dc5 100644
--- a/src/maasserver/tests/test_region_controller.py
+++ b/src/maasserver/tests/test_region_controller.py
@@ -554,7 +554,7 @@ class TestRegionControllerService(MAASServerTestCase):
                 action=RBAC_ACTION.REMOVE, resource_id=4, resource_name="r-4"
             ),
         ]
-        self.assertEquals(
+        self.assertEqual(
             (
                 [
                     Resource(identifier=2, name="r-2"),
@@ -704,7 +704,7 @@ class TestRegionControllerServiceTransactional(MAASTransactionServerTestCase):
         service = RegionControllerService(sentinel.listener)
         self.patch(service, "_getRBACClient").return_value = rbac_client
 
-        self.assertEquals([], service._rbacSync())
+        self.assertEqual([], service._rbacSync())
         self.assertThat(
             rbac_client.update_resources,
             MockCalledOnceWith("resource-pool", updates=resources),
@@ -730,7 +730,7 @@ class TestRegionControllerServiceTransactional(MAASTransactionServerTestCase):
         self.patch(service, "_getRBACClient").return_value = rbac_client
         service.rbacInit = True
 
-        self.assertEquals(reasons, service._rbacSync())
+        self.assertEqual(reasons, service._rbacSync())
         self.assertThat(
             rbac_client.update_resources,
             MockCalledOnceWith(
@@ -764,7 +764,7 @@ class TestRegionControllerServiceTransactional(MAASTransactionServerTestCase):
         self.patch(service, "_getRBACClient").return_value = rbac_client
         service.rbacInit = True
 
-        self.assertEquals(reasons, service._rbacSync())
+        self.assertEqual(reasons, service._rbacSync())
         self.assertThat(
             rbac_client.update_resources,
             MockCallsMatch(
diff --git a/src/maasserver/tests/test_start_up.py b/src/maasserver/tests/test_start_up.py
index 0ef1397..30b267c 100644
--- a/src/maasserver/tests/test_start_up.py
+++ b/src/maasserver/tests/test_start_up.py
@@ -127,7 +127,7 @@ class TestInnerStartUp(MAASServerTestCase):
         with post_commit_hooks:
             start_up.inner_start_up(master=True)
         ubuntu = UbuntuOS()
-        self.assertEquals(
+        self.assertEqual(
             Config.objects.get_config("commissioning_distro_series"),
             ubuntu.get_default_commissioning_release(),
         )
@@ -142,7 +142,7 @@ class TestInnerStartUp(MAASServerTestCase):
         Config.objects.set_config("commissioning_distro_series", release)
         with post_commit_hooks:
             start_up.inner_start_up(master=False)
-        self.assertEquals(
+        self.assertEqual(
             Config.objects.get_config("commissioning_distro_series"), release
         )
         self.assertFalse(
diff --git a/src/maasserver/tests/test_stats.py b/src/maasserver/tests/test_stats.py
index 3a74a20..7c5f886 100644
--- a/src/maasserver/tests/test_stats.py
+++ b/src/maasserver/tests/test_stats.py
@@ -67,7 +67,7 @@ class TestMAASStats(MAASServerTestCase):
             factory.make_Machine(architecture=arch)
         stats = get_machines_by_architecture()
         compare = {"amd64": 1, "i386": 1, "arm64": 1, "ppc64el": 1, "s390x": 1}
-        self.assertEquals(stats, compare)
+        self.assertEqual(stats, compare)
 
     def test_get_kvm_pods_stats(self):
         pod1 = self.make_pod(
@@ -101,7 +101,7 @@ class TestMAASStats(MAASServerTestCase):
             },
             "kvm_utilized_resources": {"cores": 0, "memory": 0, "storage": 0},
         }
-        self.assertEquals(compare, stats)
+        self.assertEqual(compare, stats)
 
     def test_get_kvm_pods_stats_no_pod(self):
         self.assertEqual(
@@ -183,7 +183,7 @@ class TestMAASStats(MAASServerTestCase):
                 "subnets_v6": len(v6),
             },
         }
-        self.assertEquals(json.loads(stats), expected)
+        self.assertEqual(json.loads(stats), expected)
 
     def test_get_maas_stats_no_machines(self):
         expected = {
@@ -224,7 +224,7 @@ class TestMAASStats(MAASServerTestCase):
                 json.dumps(get_maas_stats()).encode()
             ).decode()
         }
-        self.assertEquals(params, get_request_params())
+        self.assertEqual(params, get_request_params())
 
     def test_make_user_agent_request(self):
         factory.make_RegionRackController()
diff --git a/src/maasserver/tests/test_status_monitor.py b/src/maasserver/tests/test_status_monitor.py
index c89342c..09b3ad5 100644
--- a/src/maasserver/tests/test_status_monitor.py
+++ b/src/maasserver/tests/test_status_monitor.py
@@ -55,7 +55,7 @@ class TestMarkNodesFailedAfterExpiring(MAASServerTestCase):
         )
         # MAAS logs in the status_monitor that the timeout was detected. It
         # then logs the transisition in the node signal handler.
-        self.assertEquals(
+        self.assertEqual(
             len(NODE_FAILURE_MONITORED_STATUS_TRANSITIONS),
             len(maaslog.call_args_list) / 2,
         )
@@ -128,7 +128,7 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
         # No exception should be raised.
         mark_nodes_failed_after_missing_script_timeout(now(), 20)
         node = reload_object(node)
-        self.assertEquals(self.status, node.status)
+        self.assertEqual(self.status, node.status)
         self.assertThat(self.maaslog, MockNotCalled())
 
     def test_mark_nodes_failed_after_missing_timeout_heartbeat(self):
@@ -151,8 +151,8 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
         )
         node = reload_object(node)
 
-        self.assertEquals(self.failed_status, node.status)
-        self.assertEquals(
+        self.assertEqual(self.failed_status, node.status)
+        self.assertEqual(
             "Node has not been heard from for the last %s minutes"
             % node_timeout,
             node.error_description,
@@ -173,7 +173,7 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
                 self.maaslog.call_args_list,
             )
         for script_result in script_results:
-            self.assertEquals(
+            self.assertEqual(
                 SCRIPT_STATUS.TIMEDOUT, reload_object(script_result).status
             )
 
@@ -194,7 +194,7 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
         mark_nodes_failed_after_missing_script_timeout(current_time, 20)
         node = reload_object(node)
 
-        self.assertEquals(
+        self.assertEqual(
             current_time
             - (current_time - script_set.last_ping)
             + timedelta(minutes=get_node_timeout(self.status, 20)),
@@ -226,8 +226,8 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
         mark_nodes_failed_after_missing_script_timeout(current_time, 20)
         node = reload_object(node)
 
-        self.assertEquals(self.failed_status, node.status)
-        self.assertEquals(
+        self.assertEqual(self.failed_status, node.status)
+        self.assertEqual(
             "%s has run past it's timeout(%s)"
             % (
                 running_script_result.name,
@@ -254,16 +254,16 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
                 call("%s: Stopped because SSH is disabled" % node.hostname),
                 self.maaslog.call_args_list,
             )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.PASSED, reload_object(passed_script_result).status
         )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.FAILED, reload_object(failed_script_result).status
         )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.ABORTED, reload_object(pending_script_result).status
         )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.TIMEDOUT, reload_object(running_script_result).status
         )
 
@@ -293,18 +293,18 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
         mark_nodes_failed_after_missing_script_timeout(current_time, 20)
         node = reload_object(node)
 
-        self.assertEquals(self.status, node.status)
+        self.assertEqual(self.status, node.status)
         self.assertThat(self.mock_stop, MockNotCalled())
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.PASSED, reload_object(passed_script_result).status
         )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.FAILED, reload_object(failed_script_result).status
         )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.PENDING, reload_object(pending_script_result).status
         )
-        self.assertEquals(
+        self.assertEqual(
             SCRIPT_STATUS.RUNNING, reload_object(running_script_result).status
         )
 
@@ -352,8 +352,8 @@ class TestMarkNodesFailedAfterMissingScriptTimeout(MAASServerTestCase):
         # 5. Get all testing ScriptResults
         # 6. Get all commissioning Scripts
         # 7. Get all testing Scripts
-        self.assertEquals(7, counter_one.num_queries)
-        self.assertEquals(7, counter_many.num_queries)
+        self.assertEqual(7, counter_one.num_queries)
+        self.assertEqual(7, counter_many.num_queries)
 
 
 class TestStatusMonitorService(MAASServerTestCase):
diff --git a/src/maasserver/tests/test_storage_layouts.py b/src/maasserver/tests/test_storage_layouts.py
index a15d202..29dcffa 100644
--- a/src/maasserver/tests/test_storage_layouts.py
+++ b/src/maasserver/tests/test_storage_layouts.py
@@ -120,13 +120,13 @@ class TestGetAppliedStorageLayoutForNode(MAASServerTestCase):
         )
         layout = self.layout_class(node)
         layout.configure()
-        self.assertEquals(
+        self.assertEqual(
             (bd, self.layout_name), get_applied_storage_layout_for_node(node)
         )
 
     def test_returns_unknown(self):
         node = factory.make_Node()
-        self.assertEquals(
+        self.assertEqual(
             (None, "unknown"), get_applied_storage_layout_for_node(node)
         )
 
@@ -418,7 +418,7 @@ class TestStorageLayoutBase(MAASServerTestCase):
         factory.make_PhysicalBlockDevice(node=node, size=LARGE_BLOCK_DEVICE)
         layout = StorageLayoutBase(node, {})
         self.assertTrue(layout.is_valid(), layout.errors)
-        self.assertEquals(node.get_boot_disk(), layout.get_root_device())
+        self.assertEqual(node.get_boot_disk(), layout.get_root_device())
 
     def test_get_root_device_returns_root_device_if_set(self):
         node = make_Node_with_uefi_boot_method()
@@ -959,7 +959,7 @@ class TestFlatStorageLayout(MAASServerTestCase, LayoutHelpersMixin):
         )
         layout = FlatStorageLayout(node)
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_without_uefi(self):
         node = make_arm64_Node_without_uefi_boot_method()
@@ -968,7 +968,7 @@ class TestFlatStorageLayout(MAASServerTestCase, LayoutHelpersMixin):
         )
         layout = FlatStorageLayout(node)
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_returns_none_when_not_found(self):
         node = make_Node_with_uefi_boot_method()
@@ -1275,7 +1275,7 @@ class TestLVMStorageLayout(MAASServerTestCase, LayoutHelpersMixin):
         )
         layout = LVMStorageLayout(node)
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_without_uefi(self):
         node = make_arm64_Node_without_uefi_boot_method()
@@ -1284,7 +1284,7 @@ class TestLVMStorageLayout(MAASServerTestCase, LayoutHelpersMixin):
         )
         layout = LVMStorageLayout(node)
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_returns_none_when_not_found(self):
         node = make_Node_with_uefi_boot_method()
@@ -1805,7 +1805,7 @@ class TestBcacheStorageLayout(MAASServerTestCase):
         )
         layout = BcacheStorageLayout(node)
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_without_uefi(self):
         node = make_arm64_Node_without_uefi_boot_method()
@@ -1817,7 +1817,7 @@ class TestBcacheStorageLayout(MAASServerTestCase):
         )
         layout = BcacheStorageLayout(node, {"cache_no_part": True})
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_returns_none_when_not_found(self):
         node = make_Node_with_uefi_boot_method()
@@ -1953,7 +1953,7 @@ class TestVMFS6StorageLayout(MAASServerTestCase):
         )
         layout = VMFS6StorageLayout(node)
         layout.configure()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_without_datastore(self):
         node = make_Node_with_uefi_boot_method()
@@ -1965,7 +1965,7 @@ class TestVMFS6StorageLayout(MAASServerTestCase):
         # A user can delete the VMFS Datastore but the layout should still
         # be detected for the UI.
         node.virtualblockdevice_set.delete()
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual(bd, layout.is_layout())
 
     def test_is_layout_returns_none_when_not_found(self):
         node = make_Node_with_uefi_boot_method()
@@ -2007,8 +2007,8 @@ class TestBlankStorageLayout(MAASServerTestCase):
         layout = BlankStorageLayout(node)
         if self.layout_class != BlankStorageLayout:
             self.assertIsNone(layout.is_layout())
-        self.assertEquals("blank", layout.configure())
-        self.assertEquals(bd, layout.is_layout())
+        self.assertEqual("blank", layout.configure())
+        self.assertEqual(bd, layout.is_layout())
         self.assertFalse(node.virtualblockdevice_set.exists())
         for bd in node.blockdevice_set.all():
             self.assertFalse(bd.filesystem_set.exists())
diff --git a/src/maasserver/tests/test_workers.py b/src/maasserver/tests/test_workers.py
index d9cfe0c..e0575ff 100644
--- a/src/maasserver/tests/test_workers.py
+++ b/src/maasserver/tests/test_workers.py
@@ -29,14 +29,14 @@ class TestWorkersCount(MAASTestCase):
     def test_MAX_WORKERS_COUNT_default_cpucount(self):
         from maasserver.workers import MAX_WORKERS_COUNT
 
-        self.assertEquals(os.cpu_count(), MAX_WORKERS_COUNT)
+        self.assertEqual(os.cpu_count(), MAX_WORKERS_COUNT)
 
     def test_set_max_workers_count(self):
         worker_count = random.randint(1, 8)
         set_max_workers_count(worker_count)
         from maasserver.workers import MAX_WORKERS_COUNT
 
-        self.assertEquals(worker_count, MAX_WORKERS_COUNT)
+        self.assertEqual(worker_count, MAX_WORKERS_COUNT)
 
 
 class TestWorkersService(MAASTestCase):
@@ -47,8 +47,8 @@ class TestWorkersService(MAASTestCase):
 
         from maasserver.workers import MAX_WORKERS_COUNT
 
-        self.assertEquals(MAX_WORKERS_COUNT, service.worker_count)
-        self.assertEquals(sys.argv[0], service.worker_cmd)
+        self.assertEqual(MAX_WORKERS_COUNT, service.worker_count)
+        self.assertEqual(sys.argv[0], service.worker_cmd)
 
     def test_calls_spawnWorkers_on_start(self):
         service = WorkersService(reactor)
@@ -87,12 +87,12 @@ class TestWorkersService(MAASTestCase):
         try:
             service.startService()
 
-            self.assertEquals(1, len(service.workers))
+            self.assertEqual(1, len(service.workers))
             pid = list(service.workers.keys())[0]
             service.killWorker(pid)
             yield dv.get(timeout=2)
             self.assertNotIn(pid, service.workers)
-            self.assertEquals(1, len(service.workers))
+            self.assertEqual(1, len(service.workers))
         finally:
             service.stopService()
 
@@ -115,12 +115,12 @@ class TestWorkersService(MAASTestCase):
         try:
             service.startService()
 
-            self.assertEquals(1, len(service.workers))
+            self.assertEqual(1, len(service.workers))
             pid = list(service.workers.keys())[0]
             service.termWorker(pid)
             yield dv.get(timeout=2)
             self.assertNotIn(pid, service.workers)
-            self.assertEquals(1, len(service.workers))
+            self.assertEqual(1, len(service.workers))
         finally:
             service.stopService()
 
@@ -142,7 +142,7 @@ class TestWorkersService(MAASTestCase):
 
         try:
             service.startService()
-            self.assertEquals(1, len(service.workers))
+            self.assertEqual(1, len(service.workers))
         finally:
             service.stopService()
 
diff --git a/src/maasserver/triggers/tests/test_system_listener.py b/src/maasserver/triggers/tests/test_system_listener.py
index 1573f02..6189c4c 100644
--- a/src/maasserver/triggers/tests/test_system_listener.py
+++ b/src/maasserver/triggers/tests/test_system_listener.py
@@ -4104,7 +4104,7 @@ class TestDNSDNSResourceListener(
                     for pub in DNSPublication.objects.order_by("-id")[:2]
                 ]
             )
-            self.assertEquals(
+            self.assertEqual(
                 list(sources),
                 [
                     "zone %s removed resource %s"
@@ -4683,7 +4683,7 @@ class TestDNSInterfaceListener(
                     for pub in DNSPublication.objects.order_by("-id")[:2]
                 ]
             )
-            self.assertEquals(
+            self.assertEqual(
                 list(sources),
                 [
                     "node %s removed interface %s" % (old_hostname, nic_name),
diff --git a/src/maasserver/utils/tests/test_osystems.py b/src/maasserver/utils/tests/test_osystems.py
index ef11c9f..541ee16 100644
--- a/src/maasserver/utils/tests/test_osystems.py
+++ b/src/maasserver/utils/tests/test_osystems.py
@@ -590,7 +590,7 @@ class TestGetReleaseVersionFromString(MAASServerTestCase):
         )
 
     def test_get_release_version_from_string(self):
-        self.assertEquals(
+        self.assertEqual(
             self.expected, get_release_version_from_string(self.string)
         )
 
@@ -786,7 +786,7 @@ class TestValidateHweKernel(MAASServerTestCase):
             None, "hwe-16.04-edge", "%s/generic" % arch, "ubuntu", "xenial"
         )
 
-        self.assertEquals("hwe-16.04-edge", kernel)
+        self.assertEqual("hwe-16.04-edge", kernel)
         self.assertThat(
             mock_get_usable_hwe_kernels,
             MockCalledOnceWith("ubuntu/xenial", arch, "generic"),
@@ -799,10 +799,10 @@ class TestValidateMinHweKernel(MAASServerTestCase):
         self.patch(
             BootResource.objects, "get_supported_hwe_kernels"
         ).return_value = (kernel,)
-        self.assertEquals(kernel, validate_min_hwe_kernel(kernel))
+        self.assertEqual(kernel, validate_min_hwe_kernel(kernel))
 
     def test_returns_empty_string_when_none(self):
-        self.assertEquals("", validate_min_hwe_kernel(None))
+        self.assertEqual("", validate_min_hwe_kernel(None))
 
     def test_raises_exception_when_not_found(self):
         self.assertRaises(
@@ -886,21 +886,21 @@ class TestGetReleaseFromDB(MAASServerTestCase):
 
     def test_finds_by_subarch(self):
         release = self.make_boot_source_cache()
-        self.assertEquals(
+        self.assertEqual(
             release["series"],
             get_release_from_db(release["version"].split(" ")[0])["series"],
         )
 
     def test_finds_by_release(self):
         release = self.make_boot_source_cache()
-        self.assertEquals(
+        self.assertEqual(
             release["version"],
             get_release_from_db(release["series"])["version"],
         )
 
     def test_finds_by_release_first_letter(self):
         release = self.make_boot_source_cache()
-        self.assertEquals(
+        self.assertEqual(
             release["version"],
             get_release_from_db(release["series"][0])["version"],
         )
diff --git a/src/maasserver/utils/tests/test_storage.py b/src/maasserver/utils/tests/test_storage.py
index 695aed0..88761c9 100644
--- a/src/maasserver/utils/tests/test_storage.py
+++ b/src/maasserver/utils/tests/test_storage.py
@@ -174,4 +174,4 @@ class TestUsedFor(MAASServerTestCase):
     def test_vmfs(self):
         vmfs = factory.make_VMFS()
         part = vmfs.filesystems.first().partition
-        self.assertEquals("VMFS extent for %s" % vmfs.name, used_for(part))
+        self.assertEqual("VMFS extent for %s" % vmfs.name, used_for(part))
diff --git a/src/maasserver/utils/tests/test_utils.py b/src/maasserver/utils/tests/test_utils.py
index 34c6311..5fd47f4 100644
--- a/src/maasserver/utils/tests/test_utils.py
+++ b/src/maasserver/utils/tests/test_utils.py
@@ -223,7 +223,7 @@ class TestFindRackController(MAASServerTestCase):
         subnet.vlan.dhcp_on = True
         subnet.vlan.primary_rack = rack_controller
         subnet.vlan.save()
-        self.assertEquals(
+        self.assertEqual(
             rack_controller.system_id,
             find_rack_controller(
                 make_request(factory.pick_ip_in_Subnet(subnet))
@@ -305,13 +305,13 @@ class GetRemoteIPTest(MAASTestCase):
         ip_address = factory.make_ipv4_address()
         request = HttpRequest()
         request.META = {"HTTP_X_FORWARDED_FOR": ip_address}
-        self.assertEquals(ip_address, get_remote_ip(request))
+        self.assertEqual(ip_address, get_remote_ip(request))
 
     def test_gets_client_ipv6_for_HTTP_X_FORWARDED_FOR(self):
         ip_address = factory.make_ipv6_address()
         request = HttpRequest()
         request.META = {"HTTP_X_FORWARDED_FOR": ip_address}
-        self.assertEquals(ip_address, get_remote_ip(request))
+        self.assertEqual(ip_address, get_remote_ip(request))
 
     def test_gets_client_ip_for_X_FORWARDED_FOR_with_proxies(self):
         ip_address = factory.make_ipv4_address()
@@ -321,19 +321,19 @@ class GetRemoteIPTest(MAASTestCase):
         request.META = {
             "HTTP_X_FORWARDED_FOR": "%s, %s, %s" % (ip_address, proxy1, proxy2)
         }
-        self.assertEquals(ip_address, get_remote_ip(request))
+        self.assertEqual(ip_address, get_remote_ip(request))
 
     def test_gets_client_ipv4_for_REMOTE_ADDR(self):
         ip_address = factory.make_ipv4_address()
         request = HttpRequest()
         request.META = {"REMOTE_ADDR": ip_address}
-        self.assertEquals(ip_address, get_remote_ip(request))
+        self.assertEqual(ip_address, get_remote_ip(request))
 
     def test_gets_client_ipv6_for_REMOTE_ADDR(self):
         ip_address = factory.make_ipv6_address()
         request = HttpRequest()
         request.META = {"REMOTE_ADDR": ip_address}
-        self.assertEquals(ip_address, get_remote_ip(request))
+        self.assertEqual(ip_address, get_remote_ip(request))
 
     def test_fallsback_to_REMOTE_ADDR_for_invalid_X_FORWARDED_FOR(self):
         ip_address = factory.make_ipv4_address()
@@ -342,7 +342,7 @@ class GetRemoteIPTest(MAASTestCase):
             "HTTP_X_FORWARDED_FOR": factory.make_name("garbage ip"),
             "REMOTE_ADDR": ip_address,
         }
-        self.assertEquals(ip_address, get_remote_ip(request))
+        self.assertEqual(ip_address, get_remote_ip(request))
 
     def test_returns_None_for_invalid_ip(self):
         ip_address = factory.make_name("garbage ip")
diff --git a/src/maasserver/views/tests/test_account.py b/src/maasserver/views/tests/test_account.py
index ce954da..092c23f 100644
--- a/src/maasserver/views/tests/test_account.py
+++ b/src/maasserver/views/tests/test_account.py
@@ -130,7 +130,7 @@ class TestLogin(MAASServerTestCase):
         )
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Logged in user.")
+        self.assertEqual(event.description, "Logged in user.")
 
 
 class TestLogout(MAASServerTestCase):
@@ -164,7 +164,7 @@ class TestLogout(MAASServerTestCase):
         self.client.post(reverse("logout"))
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Logged out user.")
+        self.assertEqual(event.description, "Logged out user.")
 
 
 def token_to_dict(token):
@@ -329,7 +329,7 @@ class TestAuthenticate(MAASServerTestCase):
         )
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Retrieved API (OAuth) token.")
+        self.assertEqual(event.description, "Retrieved API (OAuth) token.")
 
     def test_authenticate_creates_audit_event_without_tokens(self):
         username = factory.make_name("username")
@@ -347,7 +347,7 @@ class TestAuthenticate(MAASServerTestCase):
         )
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
-        self.assertEquals(event.description, "Created API (OAuth) token.")
+        self.assertEqual(event.description, "Created API (OAuth) token.")
 
 
 class TestCSRF(MAASServerTestCase):
diff --git a/src/maasserver/websockets/handlers/tests/test_bootresource.py b/src/maasserver/websockets/handlers/tests/test_bootresource.py
index e8c889f..7b55a11 100644
--- a/src/maasserver/websockets/handlers/tests/test_bootresource.py
+++ b/src/maasserver/websockets/handlers/tests/test_bootresource.py
@@ -284,7 +284,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         handler = BootResourceHandler(owner, {}, None)
         response = handler.poll({})
         json_obj = json.loads(response)
-        self.assertEquals(
+        self.assertEqual(
             commissioning_series.value,
             json_obj["ubuntu"]["commissioning_series"],
         )
@@ -704,7 +704,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         response = handler.poll({})
         json_obj = json.loads(response)
         ubuntu_core_images = json_obj["ubuntu_core_images"]
-        self.assertEquals(
+        self.assertEqual(
             [
                 {
                     "name": "%s/%s/%s/%s"
@@ -730,7 +730,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         response = handler.poll({})
         json_obj = json.loads(response)
         ubuntu_core_images = json_obj["ubuntu_core_images"]
-        self.assertEquals(
+        self.assertEqual(
             [
                 {
                     "name": "%s/%s/%s/%s"
@@ -750,7 +750,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         response = handler.poll({})
         json_obj = json.loads(response)
         other_images = json_obj["other_images"]
-        self.assertEquals(
+        self.assertEqual(
             [
                 {
                     "name": "%s/%s/%s/%s"
@@ -776,7 +776,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         response = handler.poll({})
         json_obj = json.loads(response)
         other_images = json_obj["other_images"]
-        self.assertEquals(
+        self.assertEqual(
             [
                 {
                     "name": "%s/%s/%s/%s"
@@ -796,7 +796,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         factory.make_BootSourceCache(os="ubuntu-core")
         response = handler.poll({})
         json_obj = json.loads(response)
-        self.assertEquals([], json_obj["other_images"])
+        self.assertEqual([], json_obj["other_images"])
 
     def test_other_images_filters_out_bootloaders(self):
         owner = factory.make_admin()
@@ -806,7 +806,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         )
         response = handler.poll({})
         json_obj = json.loads(response)
-        self.assertEquals([], json_obj["other_images"])
+        self.assertEqual([], json_obj["other_images"])
 
     def test_prefers_title_from_boot_resource_extra(self):
         owner = factory.make_admin()
@@ -815,7 +815,7 @@ class TestBootResourcePoll(MAASServerTestCase, PatchOSInfoMixin):
         self.make_other_resource(extra={"title": title})
         response = handler.poll({})
         json_obj = json.loads(response)
-        self.assertEquals(title, json_obj["resources"][0]["title"])
+        self.assertEqual(title, json_obj["resources"][0]["title"])
 
 
 class TestBootResourceStopImport(MAASTransactionServerTestCase):
@@ -830,7 +830,7 @@ class TestBootResourceStopImport(MAASTransactionServerTestCase):
         mock_stop_import = self.patch_stop_import_resources()
         result = handler.stop_import({})
         self.assertThat(mock_stop_import, MockCalledOnceWith())
-        self.assertEquals(handler.poll({}), result)
+        self.assertEqual(handler.poll({}), result)
 
 
 class TestBootResourceSaveUbuntu(
diff --git a/src/maasserver/websockets/handlers/tests/test_config.py b/src/maasserver/websockets/handlers/tests/test_config.py
index eccae08..2774982 100644
--- a/src/maasserver/websockets/handlers/tests/test_config.py
+++ b/src/maasserver/websockets/handlers/tests/test_config.py
@@ -52,7 +52,7 @@ class TestConfigHandler(MAASServerTestCase):
         user = factory.make_User()
         handler = ConfigHandler(user, {}, None)
         Config.objects.set_config("curtin_verbose", True)
-        self.assertEquals(
+        self.assertEqual(
             {"name": "curtin_verbose", "value": True},
             handler.get({"name": "curtin_verbose"}),
         )
@@ -62,7 +62,7 @@ class TestConfigHandler(MAASServerTestCase):
         handler = ConfigHandler(user, {}, None)
         Config.objects.set_config("curtin_verbose", True)
         handler.get({"name": "curtin_verbose"})
-        self.assertEquals({"curtin_verbose"}, handler.cache["loaded_pks"])
+        self.assertEqual({"curtin_verbose"}, handler.cache["loaded_pks"])
 
     def test_get_requires_name(self):
         user = factory.make_User()
@@ -121,7 +121,7 @@ class TestConfigHandler(MAASServerTestCase):
         user = factory.make_admin()
         handler = ConfigHandler(user, {}, None)
         updated = handler.update({"name": "curtin_verbose", "value": True})
-        self.assertEquals({"name": "curtin_verbose", "value": True}, updated)
+        self.assertEqual({"name": "curtin_verbose", "value": True}, updated)
         self.assertTrue(Config.objects.get_config("curtin_verbose"))
 
     def test_update_cannot_update_uuid(self):
@@ -159,9 +159,7 @@ class TestConfigHandler(MAASServerTestCase):
             handler.update,
             {"name": "http_proxy", "value": factory.make_name("invalid")},
         )
-        self.assertEquals(
-            {"value": ["Enter a valid URL."]}, error.message_dict
-        )
+        self.assertEqual({"value": ["Enter a valid URL."]}, error.message_dict)
 
     def test_on_listen_returns_None_if_excluded(self):
         user = factory.make_User()
diff --git a/src/maasserver/websockets/handlers/tests/test_dhcpsnippet.py b/src/maasserver/websockets/handlers/tests/test_dhcpsnippet.py
index 92a3989..c1f7b34 100644
--- a/src/maasserver/websockets/handlers/tests/test_dhcpsnippet.py
+++ b/src/maasserver/websockets/handlers/tests/test_dhcpsnippet.py
@@ -124,7 +124,7 @@ class TestDHCPSnippetHandler(MAASServerTestCase):
         node = factory.make_Node()
         handler.update({"id": dhcp_snippet.id, "node": node.system_id})
         dhcp_snippet = reload_object(dhcp_snippet)
-        self.assertEquals(node, dhcp_snippet.node)
+        self.assertEqual(node, dhcp_snippet.node)
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
         self.assertEqual(
@@ -168,7 +168,7 @@ class TestDHCPSnippetHandler(MAASServerTestCase):
         remaining_ids = textfile_ids[:revert_to]
         handler.revert({"id": dhcp_snippet.id, "to": revert_to})
         dhcp_snippet = reload_object(dhcp_snippet)
-        self.assertEquals(
+        self.assertEqual(
             VersionedTextFile.objects.get(id=textfile_ids[revert_to - 1]).data,
             dhcp_snippet.value.data,
         )
diff --git a/src/maasserver/websockets/handlers/tests/test_discovery.py b/src/maasserver/websockets/handlers/tests/test_discovery.py
index 1597dea..de6e98f 100644
--- a/src/maasserver/websockets/handlers/tests/test_discovery.py
+++ b/src/maasserver/websockets/handlers/tests/test_discovery.py
@@ -87,7 +87,7 @@ class TestDiscoveryHandler(MAASServerTestCase):
             self.dehydrate_discovery(discovery, for_list=True)
             for discovery in [d0, d1, d2, d3, d4]
         ]
-        self.assertEquals(expected_discoveries, handler.list({}))
+        self.assertEqual(expected_discoveries, handler.list({}))
 
     def test_list_starts_after_first_seen(self):
         user = factory.make_User()
@@ -108,7 +108,7 @@ class TestDiscoveryHandler(MAASServerTestCase):
             self.dehydrate_discovery(discovery, for_list=True)
             for discovery in [d3, d4]
         ]
-        self.assertEquals(
+        self.assertEqual(
             expected_discoveries, handler.list({"start": first_seen})
         )
 
diff --git a/src/maasserver/websockets/handlers/tests/test_machine.py b/src/maasserver/websockets/handlers/tests/test_machine.py
index 3f700b0..8f46f16 100644
--- a/src/maasserver/websockets/handlers/tests/test_machine.py
+++ b/src/maasserver/websockets/handlers/tests/test_machine.py
@@ -501,7 +501,7 @@ class TestMachineHandler(MAASServerTestCase):
         handler._script_results[cached_node.id] = cached_content
         handler._cache_pks([node])
 
-        self.assertEquals(
+        self.assertEqual(
             script_result.id,
             handler._script_results[node.id][
                 script_result.script.hardware_type
@@ -515,7 +515,7 @@ class TestMachineHandler(MAASServerTestCase):
                 for result in results
             ],
         )
-        self.assertEquals(
+        self.assertEqual(
             cached_content, handler._script_results[cached_node.id]
         )
 
@@ -704,8 +704,8 @@ class TestMachineHandler(MAASServerTestCase):
         _, _, ret = handler.on_listen_for_active_pk(
             "update", node.system_id, node
         )
-        self.assertEquals(ret["commissioning_status"]["passed"], 10)
-        self.assertEquals(ret["testing_status"]["passed"], 10)
+        self.assertEqual(ret["commissioning_status"]["passed"], 10)
+        self.assertEqual(ret["testing_status"]["passed"], 10)
 
     def test_cache_clears_on_reload(self):
         owner = factory.make_User()
@@ -799,11 +799,11 @@ class TestMachineHandler(MAASServerTestCase):
             if disk["id"] == node.boot_disk.id:
                 for partition in disk["partitions"]:
                     if partition["name"].endswith("-part3"):
-                        self.assertEquals(
+                        self.assertEqual(
                             "VMFS extent for datastore1", partition["used_for"]
                         )
                     else:
-                        self.assertEquals(
+                        self.assertEqual(
                             "VMware ESXi OS partition", partition["used_for"]
                         )
                         self.assertDictEqual(
@@ -1694,7 +1694,7 @@ class TestMachineHandler(MAASServerTestCase):
         node = factory.make_Node(owner=owner)
         handler = MachineHandler(owner, {}, None)
         observed = handler.get_summary_xml({"system_id": node.system_id})
-        self.assertEquals("", observed)
+        self.assertEqual("", observed)
 
     def test_dehydrate_summary_xml_returns_data(self):
         owner = factory.make_User()
@@ -1708,7 +1708,7 @@ class TestMachineHandler(MAASServerTestCase):
         script_result.store_result(exit_status=0, stdout=lldp_data)
         observed = handler.get_summary_xml({"system_id": node.system_id})
         probed_details = merge_details_cleanly(get_single_probed_details(node))
-        self.assertEquals(
+        self.assertEqual(
             etree.tostring(probed_details, encoding=str, pretty_print=True),
             observed,
         )
@@ -1718,7 +1718,7 @@ class TestMachineHandler(MAASServerTestCase):
         node = factory.make_Node(owner=owner)
         handler = MachineHandler(owner, {}, None)
         observed = handler.get_summary_yaml({"system_id": node.system_id})
-        self.assertEquals("", observed)
+        self.assertEqual("", observed)
 
     def test_dehydrate_summary_yaml_returns_data(self):
         owner = factory.make_User()
@@ -4326,7 +4326,7 @@ class TestMachineHandlerCheckPower(MAASTransactionServerTestCase):
         power_state = yield machine_handler.check_power(
             {"system_id": node.system_id}
         )
-        self.assertEquals(power_state, POWER_STATE.UNKNOWN)
+        self.assertEqual(power_state, POWER_STATE.UNKNOWN)
 
     @wait_for_reactor
     @inlineCallbacks
@@ -4339,7 +4339,7 @@ class TestMachineHandlerCheckPower(MAASTransactionServerTestCase):
         power_state = yield machine_handler.check_power(
             {"system_id": node.system_id}
         )
-        self.assertEquals(power_state, POWER_STATE.UNKNOWN)
+        self.assertEqual(power_state, POWER_STATE.UNKNOWN)
 
     @wait_for_reactor
     @inlineCallbacks
@@ -4353,7 +4353,7 @@ class TestMachineHandlerCheckPower(MAASTransactionServerTestCase):
         power_state = yield machine_handler.check_power(
             {"system_id": node.system_id}
         )
-        self.assertEquals(power_state, POWER_STATE.ERROR)
+        self.assertEqual(power_state, POWER_STATE.ERROR)
         self.assertThat(
             mock_log_err,
             MockCalledOnceWith(
diff --git a/src/maasserver/websockets/handlers/tests/test_node_result.py b/src/maasserver/websockets/handlers/tests/test_node_result.py
index 5f6b35c..3899f83 100644
--- a/src/maasserver/websockets/handlers/tests/test_node_result.py
+++ b/src/maasserver/websockets/handlers/tests/test_node_result.py
@@ -75,9 +75,7 @@ class TestNodeResultHandler(MAASServerTestCase):
         user = factory.make_User()
         handler = NodeResultHandler(user, {}, None)
         node = factory.make_Node()
-        self.assertEquals(
-            node, handler.get_node({"system_id": node.system_id})
-        )
+        self.assertEqual(node, handler.get_node({"system_id": node.system_id}))
         self.assertDictEqual(
             {node.system_id: node}, handler.cache["system_ids"]
         )
@@ -88,7 +86,7 @@ class TestNodeResultHandler(MAASServerTestCase):
         fake_system_id = factory.make_name("system_id")
         fake_node = factory.make_name("node")
         handler.cache["system_ids"][fake_system_id] = fake_node
-        self.assertEquals(
+        self.assertEqual(
             fake_node, handler.get_node({"system_id": fake_system_id})
         )
 
@@ -294,7 +292,7 @@ class TestNodeResultHandler(MAASServerTestCase):
         for _ in range(6):
             factory.make_ScriptResult(script_set=script_set)
         start = random.randint(0, 5)
-        self.assertEquals(
+        self.assertEqual(
             6 - start,
             len(handler.list({"system_id": node.system_id, "start": start})),
         )
@@ -307,7 +305,7 @@ class TestNodeResultHandler(MAASServerTestCase):
         for _ in range(6):
             factory.make_ScriptResult(script_set=script_set)
         limit = random.randint(0, 6)
-        self.assertEquals(
+        self.assertEqual(
             limit,
             len(handler.list({"system_id": node.system_id, "limit": limit})),
         )
@@ -382,7 +380,7 @@ class TestNodeResultHandler(MAASServerTestCase):
             output=combined,
             script_set=factory.make_ScriptSet(node=node),
         )
-        self.assertEquals(
+        self.assertEqual(
             combined.decode(),
             handler.get_result_data(
                 {"id": script_result.id, "data_type": "combined"}
@@ -399,7 +397,7 @@ class TestNodeResultHandler(MAASServerTestCase):
             stdout=stdout,
             script_set=factory.make_ScriptSet(node=node),
         )
-        self.assertEquals(
+        self.assertEqual(
             stdout.decode(),
             handler.get_result_data(
                 {"id": script_result.id, "data_type": "stdout"}
@@ -416,7 +414,7 @@ class TestNodeResultHandler(MAASServerTestCase):
             stderr=stderr,
             script_set=factory.make_ScriptSet(node=node),
         )
-        self.assertEquals(
+        self.assertEqual(
             stderr.decode(),
             handler.get_result_data(
                 {"id": script_result.id, "data_type": "stderr"}
@@ -433,7 +431,7 @@ class TestNodeResultHandler(MAASServerTestCase):
             result=result,
             script_set=factory.make_ScriptSet(node=node),
         )
-        self.assertEquals(
+        self.assertEqual(
             result.decode(),
             handler.get_result_data(
                 {"id": script_result.id, "data_type": "result"}
@@ -444,7 +442,7 @@ class TestNodeResultHandler(MAASServerTestCase):
         user = factory.make_User()
         handler = NodeResultHandler(user, {}, None)
         id = random.randint(0, 100)
-        self.assertEquals(
+        self.assertEqual(
             "Unknown ScriptResult id %s" % id,
             handler.get_result_data({"id": id}),
         )
@@ -460,7 +458,7 @@ class TestNodeResultHandler(MAASServerTestCase):
             script_set=factory.make_ScriptSet(node=node),
         )
         unknown_data_type = factory.make_name("data_type")
-        self.assertEquals(
+        self.assertEqual(
             "Unknown data_type %s" % unknown_data_type,
             handler.get_result_data(
                 {"id": script_result.id, "data_type": unknown_data_type}
diff --git a/src/maasserver/websockets/handlers/tests/test_packagerepository.py b/src/maasserver/websockets/handlers/tests/test_packagerepository.py
index 35fb13c..e297d88 100644
--- a/src/maasserver/websockets/handlers/tests/test_packagerepository.py
+++ b/src/maasserver/websockets/handlers/tests/test_packagerepository.py
@@ -90,7 +90,7 @@ class TestPackageRepositoryHandler(MAASServerTestCase):
         url = factory.make_url(scheme="http")
         handler.update({"id": package_repository.id, "url": url})
         package_repository = reload_object(package_repository)
-        self.assertEquals(url, package_repository.url)
+        self.assertEqual(url, package_repository.url)
         event = Event.objects.get(type__level=AUDIT)
         self.assertIsNotNone(event)
         self.assertEqual(
diff --git a/src/maasserver/websockets/handlers/tests/test_subnet.py b/src/maasserver/websockets/handlers/tests/test_subnet.py
index b77fd2a..6ea887b 100644
--- a/src/maasserver/websockets/handlers/tests/test_subnet.py
+++ b/src/maasserver/websockets/handlers/tests/test_subnet.py
@@ -84,7 +84,7 @@ class TestSubnetHandler(MAASServerTestCase):
         subnet = factory.make_Subnet()
         self.assertIsNone(handler.cache.get("staticroutes"))
         queries, _ = count_queries(handler.get, {"id": subnet.id})
-        self.assertEquals(5, queries)
+        self.assertEqual(5, queries)
         self.assertIsNotNone(handler.cache["staticroutes"])
 
     def test_list(self):
@@ -121,9 +121,9 @@ class TestSubnetHandler(MAASServerTestCase):