Adopt Black and isort (SC-700) (#1157)

Applied Black and isort, fixed any linting issues, updated tox.ini
and CI.

1 files changed, 150 insertions, 100 deletions

diff --git a/tests/unittests/config/test_cc_lxd.py b/tests/unittests/config/test_cc_lxd.py
index 887987c0..720274d6 100644
--- a/tests/unittests/config/test_cc_lxd.py
+++ b/tests/unittests/config/test_cc_lxd.py
@@ -3,7 +3,6 @@ from unittest import mock
 
 from cloudinit.config import cc_lxd
 from tests.unittests import helpers as t_help
-
 from tests.unittests.util import get_cloud
 
 
@@ -12,11 +11,11 @@ class TestLxd(t_help.CiTestCase):
     with_logs = True
 
     lxd_cfg = {
-        'lxd': {
-            'init': {
-                'network_address': '0.0.0.0',
-                'storage_backend': 'zfs',
-                'storage_pool': 'poolname',
+        "lxd": {
+            "init": {
+                "network_address": "0.0.0.0",
+                "storage_backend": "zfs",
+                "storage_pool": "poolname",
             }
         }
     }
@@ -27,16 +26,26 @@ class TestLxd(t_help.CiTestCase):
         cc = get_cloud()
         mock_subp.which.return_value = True
         m_maybe_clean.return_value = None
-        cc_lxd.handle('cc_lxd', self.lxd_cfg, cc, self.logger, [])
+        cc_lxd.handle("cc_lxd", self.lxd_cfg, cc, self.logger, [])
         self.assertTrue(mock_subp.which.called)
         # no bridge config, so maybe_cleanup should not be called.
         self.assertFalse(m_maybe_clean.called)
         self.assertEqual(
-            [mock.call(['lxd', 'waitready', '--timeout=300']),
-             mock.call(
-                 ['lxd', 'init', '--auto', '--network-address=0.0.0.0',
-                  '--storage-backend=zfs', '--storage-pool=poolname'])],
-            mock_subp.subp.call_args_list)
+            [
+                mock.call(["lxd", "waitready", "--timeout=300"]),
+                mock.call(
+                    [
+                        "lxd",
+                        "init",
+                        "--auto",
+                        "--network-address=0.0.0.0",
+                        "--storage-backend=zfs",
+                        "--storage-pool=poolname",
+                    ]
+                ),
+            ],
+            mock_subp.subp.call_args_list,
+        )
 
     @mock.patch("cloudinit.config.cc_lxd.maybe_cleanup_default")
     @mock.patch("cloudinit.config.cc_lxd.subp")
@@ -44,20 +53,20 @@ class TestLxd(t_help.CiTestCase):
         cc = get_cloud()
         cc.distro = mock.MagicMock()
         mock_subp.which.return_value = None
-        cc_lxd.handle('cc_lxd', self.lxd_cfg, cc, self.logger, [])
-        self.assertNotIn('WARN', self.logs.getvalue())
+        cc_lxd.handle("cc_lxd", self.lxd_cfg, cc, self.logger, [])
+        self.assertNotIn("WARN", self.logs.getvalue())
         self.assertTrue(cc.distro.install_packages.called)
-        cc_lxd.handle('cc_lxd', self.lxd_cfg, cc, self.logger, [])
+        cc_lxd.handle("cc_lxd", self.lxd_cfg, cc, self.logger, [])
         self.assertFalse(m_maybe_clean.called)
         install_pkg = cc.distro.install_packages.call_args_list[0][0][0]
-        self.assertEqual(sorted(install_pkg), ['lxd', 'zfsutils-linux'])
+        self.assertEqual(sorted(install_pkg), ["lxd", "zfsutils-linux"])
 
     @mock.patch("cloudinit.config.cc_lxd.maybe_cleanup_default")
     @mock.patch("cloudinit.config.cc_lxd.subp")
     def test_no_init_does_nothing(self, mock_subp, m_maybe_clean):
         cc = get_cloud()
         cc.distro = mock.MagicMock()
-        cc_lxd.handle('cc_lxd', {'lxd': {}}, cc, self.logger, [])
+        cc_lxd.handle("cc_lxd", {"lxd": {}}, cc, self.logger, [])
         self.assertFalse(cc.distro.install_packages.called)
         self.assertFalse(mock_subp.subp.called)
         self.assertFalse(m_maybe_clean.called)
@@ -67,118 +76,150 @@ class TestLxd(t_help.CiTestCase):
     def test_no_lxd_does_nothing(self, mock_subp, m_maybe_clean):
         cc = get_cloud()
         cc.distro = mock.MagicMock()
-        cc_lxd.handle('cc_lxd', {'package_update': True}, cc, self.logger, [])
+        cc_lxd.handle("cc_lxd", {"package_update": True}, cc, self.logger, [])
         self.assertFalse(cc.distro.install_packages.called)
         self.assertFalse(mock_subp.subp.called)
         self.assertFalse(m_maybe_clean.called)
 
     def test_lxd_debconf_new_full(self):
-        data = {"mode": "new",
-                "name": "testbr0",
-                "ipv4_address": "10.0.8.1",
-                "ipv4_netmask": "24",
-                "ipv4_dhcp_first": "10.0.8.2",
-                "ipv4_dhcp_last": "10.0.8.254",
-                "ipv4_dhcp_leases": "250",
-                "ipv4_nat": "true",
-                "ipv6_address": "fd98:9e0:3744::1",
-                "ipv6_netmask": "64",
-                "ipv6_nat": "true",
-                "domain": "lxd"}
+        data = {
+            "mode": "new",
+            "name": "testbr0",
+            "ipv4_address": "10.0.8.1",
+            "ipv4_netmask": "24",
+            "ipv4_dhcp_first": "10.0.8.2",
+            "ipv4_dhcp_last": "10.0.8.254",
+            "ipv4_dhcp_leases": "250",
+            "ipv4_nat": "true",
+            "ipv6_address": "fd98:9e0:3744::1",
+            "ipv6_netmask": "64",
+            "ipv6_nat": "true",
+            "domain": "lxd",
+        }
         self.assertEqual(
             cc_lxd.bridge_to_debconf(data),
-            {"lxd/setup-bridge": "true",
-             "lxd/bridge-name": "testbr0",
-             "lxd/bridge-ipv4": "true",
-             "lxd/bridge-ipv4-address": "10.0.8.1",
-             "lxd/bridge-ipv4-netmask": "24",
-             "lxd/bridge-ipv4-dhcp-first": "10.0.8.2",
-             "lxd/bridge-ipv4-dhcp-last": "10.0.8.254",
-             "lxd/bridge-ipv4-dhcp-leases": "250",
-             "lxd/bridge-ipv4-nat": "true",
-             "lxd/bridge-ipv6": "true",
-             "lxd/bridge-ipv6-address": "fd98:9e0:3744::1",
-             "lxd/bridge-ipv6-netmask": "64",
-             "lxd/bridge-ipv6-nat": "true",
-             "lxd/bridge-domain": "lxd"})
+            {
+                "lxd/setup-bridge": "true",
+                "lxd/bridge-name": "testbr0",
+                "lxd/bridge-ipv4": "true",
+                "lxd/bridge-ipv4-address": "10.0.8.1",
+                "lxd/bridge-ipv4-netmask": "24",
+                "lxd/bridge-ipv4-dhcp-first": "10.0.8.2",
+                "lxd/bridge-ipv4-dhcp-last": "10.0.8.254",
+                "lxd/bridge-ipv4-dhcp-leases": "250",
+                "lxd/bridge-ipv4-nat": "true",
+                "lxd/bridge-ipv6": "true",
+                "lxd/bridge-ipv6-address": "fd98:9e0:3744::1",
+                "lxd/bridge-ipv6-netmask": "64",
+                "lxd/bridge-ipv6-nat": "true",
+                "lxd/bridge-domain": "lxd",
+            },
+        )
 
     def test_lxd_debconf_new_partial(self):
-        data = {"mode": "new",
-                "ipv6_address": "fd98:9e0:3744::1",
-                "ipv6_netmask": "64",
-                "ipv6_nat": "true"}
+        data = {
+            "mode": "new",
+            "ipv6_address": "fd98:9e0:3744::1",
+            "ipv6_netmask": "64",
+            "ipv6_nat": "true",
+        }
         self.assertEqual(
             cc_lxd.bridge_to_debconf(data),
-            {"lxd/setup-bridge": "true",
-             "lxd/bridge-ipv6": "true",
-             "lxd/bridge-ipv6-address": "fd98:9e0:3744::1",
-             "lxd/bridge-ipv6-netmask": "64",
-             "lxd/bridge-ipv6-nat": "true"})
+            {
+                "lxd/setup-bridge": "true",
+                "lxd/bridge-ipv6": "true",
+                "lxd/bridge-ipv6-address": "fd98:9e0:3744::1",
+                "lxd/bridge-ipv6-netmask": "64",
+                "lxd/bridge-ipv6-nat": "true",
+            },
+        )
 
     def test_lxd_debconf_existing(self):
-        data = {"mode": "existing",
-                "name": "testbr0"}
+        data = {"mode": "existing", "name": "testbr0"}
         self.assertEqual(
             cc_lxd.bridge_to_debconf(data),
-            {"lxd/setup-bridge": "false",
-             "lxd/use-existing-bridge": "true",
-             "lxd/bridge-name": "testbr0"})
+            {
+                "lxd/setup-bridge": "false",
+                "lxd/use-existing-bridge": "true",
+                "lxd/bridge-name": "testbr0",
+            },
+        )
 
     def test_lxd_debconf_none(self):
         data = {"mode": "none"}
         self.assertEqual(
             cc_lxd.bridge_to_debconf(data),
-            {"lxd/setup-bridge": "false",
-             "lxd/bridge-name": ""})
+            {"lxd/setup-bridge": "false", "lxd/bridge-name": ""},
+        )
 
     def test_lxd_cmd_new_full(self):
-        data = {"mode": "new",
-                "name": "testbr0",
-                "ipv4_address": "10.0.8.1",
-                "ipv4_netmask": "24",
-                "ipv4_dhcp_first": "10.0.8.2",
-                "ipv4_dhcp_last": "10.0.8.254",
-                "ipv4_dhcp_leases": "250",
-                "ipv4_nat": "true",
-                "ipv6_address": "fd98:9e0:3744::1",
-                "ipv6_netmask": "64",
-                "ipv6_nat": "true",
-                "domain": "lxd"}
+        data = {
+            "mode": "new",
+            "name": "testbr0",
+            "ipv4_address": "10.0.8.1",
+            "ipv4_netmask": "24",
+            "ipv4_dhcp_first": "10.0.8.2",
+            "ipv4_dhcp_last": "10.0.8.254",
+            "ipv4_dhcp_leases": "250",
+            "ipv4_nat": "true",
+            "ipv6_address": "fd98:9e0:3744::1",
+            "ipv6_netmask": "64",
+            "ipv6_nat": "true",
+            "domain": "lxd",
+        }
         self.assertEqual(
             cc_lxd.bridge_to_cmd(data),
-            (["network", "create", "testbr0",
-              "ipv4.address=10.0.8.1/24", "ipv4.nat=true",
-              "ipv4.dhcp.ranges=10.0.8.2-10.0.8.254",
-              "ipv6.address=fd98:9e0:3744::1/64",
-              "ipv6.nat=true", "dns.domain=lxd"],
-             ["network", "attach-profile",
-              "testbr0", "default", "eth0"]))
+            (
+                [
+                    "network",
+                    "create",
+                    "testbr0",
+                    "ipv4.address=10.0.8.1/24",
+                    "ipv4.nat=true",
+                    "ipv4.dhcp.ranges=10.0.8.2-10.0.8.254",
+                    "ipv6.address=fd98:9e0:3744::1/64",
+                    "ipv6.nat=true",
+                    "dns.domain=lxd",
+                ],
+                ["network", "attach-profile", "testbr0", "default", "eth0"],
+            ),
+        )
 
     def test_lxd_cmd_new_partial(self):
-        data = {"mode": "new",
-                "ipv6_address": "fd98:9e0:3744::1",
-                "ipv6_netmask": "64",
-                "ipv6_nat": "true"}
+        data = {
+            "mode": "new",
+            "ipv6_address": "fd98:9e0:3744::1",
+            "ipv6_netmask": "64",
+            "ipv6_nat": "true",
+        }
         self.assertEqual(
             cc_lxd.bridge_to_cmd(data),
-            (["network", "create", "lxdbr0", "ipv4.address=none",
-              "ipv6.address=fd98:9e0:3744::1/64", "ipv6.nat=true"],
-             ["network", "attach-profile",
-              "lxdbr0", "default", "eth0"]))
+            (
+                [
+                    "network",
+                    "create",
+                    "lxdbr0",
+                    "ipv4.address=none",
+                    "ipv6.address=fd98:9e0:3744::1/64",
+                    "ipv6.nat=true",
+                ],
+                ["network", "attach-profile", "lxdbr0", "default", "eth0"],
+            ),
+        )
 
     def test_lxd_cmd_existing(self):
-        data = {"mode": "existing",
-                "name": "testbr0"}
+        data = {"mode": "existing", "name": "testbr0"}
         self.assertEqual(
             cc_lxd.bridge_to_cmd(data),
-            (None, ["network", "attach-profile",
-                    "testbr0", "default", "eth0"]))
+            (
+                None,
+                ["network", "attach-profile", "testbr0", "default", "eth0"],
+            ),
+        )
 
     def test_lxd_cmd_none(self):
         data = {"mode": "none"}
-        self.assertEqual(
-            cc_lxd.bridge_to_cmd(data),
-            (None, None))
+        self.assertEqual(cc_lxd.bridge_to_cmd(data), (None, None))
 
 
 class TestLxdMaybeCleanupDefault(t_help.CiTestCase):
@@ -190,21 +231,24 @@ class TestLxdMaybeCleanupDefault(t_help.CiTestCase):
     def test_network_other_than_default_not_deleted(self, m_lxc):
         """deletion or removal should only occur if bridge is default."""
         cc_lxd.maybe_cleanup_default(
-            net_name="lxdbr1", did_init=True, create=True, attach=True)
+            net_name="lxdbr1", did_init=True, create=True, attach=True
+        )
         m_lxc.assert_not_called()
 
     @mock.patch("cloudinit.config.cc_lxd._lxc")
     def test_did_init_false_does_not_delete(self, m_lxc):
         """deletion or removal should only occur if did_init is True."""
         cc_lxd.maybe_cleanup_default(
-            net_name=self.defnet, did_init=False, create=True, attach=True)
+            net_name=self.defnet, did_init=False, create=True, attach=True
+        )
         m_lxc.assert_not_called()
 
     @mock.patch("cloudinit.config.cc_lxd._lxc")
     def test_network_deleted_if_create_true(self, m_lxc):
         """deletion of network should occur if create is True."""
         cc_lxd.maybe_cleanup_default(
-            net_name=self.defnet, did_init=True, create=True, attach=False)
+            net_name=self.defnet, did_init=True, create=True, attach=False
+        )
         m_lxc.assert_called_with(["network", "delete", self.defnet])
 
     @mock.patch("cloudinit.config.cc_lxd._lxc")
@@ -213,10 +257,16 @@ class TestLxdMaybeCleanupDefault(t_help.CiTestCase):
         nic_name = "my_nic"
         profile = "my_profile"
         cc_lxd.maybe_cleanup_default(
-            net_name=self.defnet, did_init=True, create=False, attach=True,
-            profile=profile, nic_name=nic_name)
+            net_name=self.defnet,
+            did_init=True,
+            create=False,
+            attach=True,
+            profile=profile,
+            nic_name=nic_name,
+        )
         m_lxc.assert_called_once_with(
-            ["profile", "device", "remove", profile, nic_name])
+            ["profile", "device", "remove", profile, nic_name]
+        )
 
 
 # vi: ts=4 expandtab