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

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

1 files changed, 359 insertions, 202 deletions

diff --git a/tests/unittests/cmd/test_status.py b/tests/unittests/cmd/test_status.py
index 49eae043..acd1fea5 100644
--- a/tests/unittests/cmd/test_status.py
+++ b/tests/unittests/cmd/test_status.py
@@ -1,26 +1,25 @@
 # This file is part of cloud-init. See LICENSE file for license information.
 
-from collections import namedtuple
 import os
+from collections import namedtuple
 from io import StringIO
 from textwrap import dedent
 
 from cloudinit.atomic_helper import write_json
 from cloudinit.cmd import status
 from cloudinit.util import ensure_file
-from tests.unittests.helpers import CiTestCase, wrap_and_call, mock
+from tests.unittests.helpers import CiTestCase, mock, wrap_and_call
 
-mypaths = namedtuple('MyPaths', 'run_dir')
-myargs = namedtuple('MyArgs', 'long wait')
+mypaths = namedtuple("MyPaths", "run_dir")
+myargs = namedtuple("MyArgs", "long wait")
 
 
 class TestStatus(CiTestCase):
-
     def setUp(self):
         super(TestStatus, self).setUp()
         self.new_root = self.tmp_dir()
-        self.status_file = self.tmp_path('status.json', self.new_root)
-        self.disable_file = self.tmp_path('cloudinit-disable', self.new_root)
+        self.status_file = self.tmp_path("status.json", self.new_root)
+        self.disable_file = self.tmp_path("cloudinit-disable", self.new_root)
         self.paths = mypaths(run_dir=self.new_root)
 
         class FakeInit(object):
@@ -35,285 +34,419 @@ class TestStatus(CiTestCase):
         self.init_class = FakeInit
 
     def test__is_cloudinit_disabled_false_on_sysvinit(self):
-        '''When not in an environment using systemd, return False.'''
+        """When not in an environment using systemd, return False."""
         ensure_file(self.disable_file)  # Create the ignored disable file
         (is_disabled, reason) = wrap_and_call(
-            'cloudinit.cmd.status',
-            {'uses_systemd': False,
-             'get_cmdline': "root=/dev/my-root not-important"},
-            status._is_cloudinit_disabled, self.disable_file, self.paths)
+            "cloudinit.cmd.status",
+            {
+                "uses_systemd": False,
+                "get_cmdline": "root=/dev/my-root not-important",
+            },
+            status._is_cloudinit_disabled,
+            self.disable_file,
+            self.paths,
+        )
         self.assertFalse(
-            is_disabled, 'expected enabled cloud-init on sysvinit')
-        self.assertEqual('Cloud-init enabled on sysvinit', reason)
+            is_disabled, "expected enabled cloud-init on sysvinit"
+        )
+        self.assertEqual("Cloud-init enabled on sysvinit", reason)
 
     def test__is_cloudinit_disabled_true_on_disable_file(self):
-        '''When using systemd and disable_file is present return disabled.'''
+        """When using systemd and disable_file is present return disabled."""
         ensure_file(self.disable_file)  # Create observed disable file
         (is_disabled, reason) = wrap_and_call(
-            'cloudinit.cmd.status',
-            {'uses_systemd': True,
-             'get_cmdline': "root=/dev/my-root not-important"},
-            status._is_cloudinit_disabled, self.disable_file, self.paths)
-        self.assertTrue(is_disabled, 'expected disabled cloud-init')
+            "cloudinit.cmd.status",
+            {
+                "uses_systemd": True,
+                "get_cmdline": "root=/dev/my-root not-important",
+            },
+            status._is_cloudinit_disabled,
+            self.disable_file,
+            self.paths,
+        )
+        self.assertTrue(is_disabled, "expected disabled cloud-init")
         self.assertEqual(
-            'Cloud-init disabled by {0}'.format(self.disable_file), reason)
+            "Cloud-init disabled by {0}".format(self.disable_file), reason
+        )
 
     def test__is_cloudinit_disabled_false_on_kernel_cmdline_enable(self):
-        '''Not disabled when using systemd and enabled via commandline.'''
+        """Not disabled when using systemd and enabled via commandline."""
         ensure_file(self.disable_file)  # Create ignored disable file
         (is_disabled, reason) = wrap_and_call(
-            'cloudinit.cmd.status',
-            {'uses_systemd': True,
-             'get_cmdline': 'something cloud-init=enabled else'},
-            status._is_cloudinit_disabled, self.disable_file, self.paths)
-        self.assertFalse(is_disabled, 'expected enabled cloud-init')
+            "cloudinit.cmd.status",
+            {
+                "uses_systemd": True,
+                "get_cmdline": "something cloud-init=enabled else",
+            },
+            status._is_cloudinit_disabled,
+            self.disable_file,
+            self.paths,
+        )
+        self.assertFalse(is_disabled, "expected enabled cloud-init")
         self.assertEqual(
-            'Cloud-init enabled by kernel command line cloud-init=enabled',
-            reason)
+            "Cloud-init enabled by kernel command line cloud-init=enabled",
+            reason,
+        )
 
     def test__is_cloudinit_disabled_true_on_kernel_cmdline(self):
-        '''When using systemd and disable_file is present return disabled.'''
+        """When using systemd and disable_file is present return disabled."""
         (is_disabled, reason) = wrap_and_call(
-            'cloudinit.cmd.status',
-            {'uses_systemd': True,
-             'get_cmdline': 'something cloud-init=disabled else'},
-            status._is_cloudinit_disabled, self.disable_file, self.paths)
-        self.assertTrue(is_disabled, 'expected disabled cloud-init')
+            "cloudinit.cmd.status",
+            {
+                "uses_systemd": True,
+                "get_cmdline": "something cloud-init=disabled else",
+            },
+            status._is_cloudinit_disabled,
+            self.disable_file,
+            self.paths,
+        )
+        self.assertTrue(is_disabled, "expected disabled cloud-init")
         self.assertEqual(
-            'Cloud-init disabled by kernel parameter cloud-init=disabled',
-            reason)
+            "Cloud-init disabled by kernel parameter cloud-init=disabled",
+            reason,
+        )
 
     def test__is_cloudinit_disabled_true_when_generator_disables(self):
-        '''When cloud-init-generator doesn't write enabled file return True.'''
-        enabled_file = os.path.join(self.paths.run_dir, 'enabled')
+        """When cloud-init-generator doesn't write enabled file return True."""
+        enabled_file = os.path.join(self.paths.run_dir, "enabled")
         self.assertFalse(os.path.exists(enabled_file))
         (is_disabled, reason) = wrap_and_call(
-            'cloudinit.cmd.status',
-            {'uses_systemd': True,
-             'get_cmdline': 'something'},
-            status._is_cloudinit_disabled, self.disable_file, self.paths)
-        self.assertTrue(is_disabled, 'expected disabled cloud-init')
-        self.assertEqual('Cloud-init disabled by cloud-init-generator', reason)
+            "cloudinit.cmd.status",
+            {"uses_systemd": True, "get_cmdline": "something"},
+            status._is_cloudinit_disabled,
+            self.disable_file,
+            self.paths,
+        )
+        self.assertTrue(is_disabled, "expected disabled cloud-init")
+        self.assertEqual("Cloud-init disabled by cloud-init-generator", reason)
 
     def test__is_cloudinit_disabled_false_when_enabled_in_systemd(self):
-        '''Report enabled when systemd generator creates the enabled file.'''
-        enabled_file = os.path.join(self.paths.run_dir, 'enabled')
+        """Report enabled when systemd generator creates the enabled file."""
+        enabled_file = os.path.join(self.paths.run_dir, "enabled")
         ensure_file(enabled_file)
         (is_disabled, reason) = wrap_and_call(
-            'cloudinit.cmd.status',
-            {'uses_systemd': True,
-             'get_cmdline': 'something ignored'},
-            status._is_cloudinit_disabled, self.disable_file, self.paths)
-        self.assertFalse(is_disabled, 'expected enabled cloud-init')
+            "cloudinit.cmd.status",
+            {"uses_systemd": True, "get_cmdline": "something ignored"},
+            status._is_cloudinit_disabled,
+            self.disable_file,
+            self.paths,
+        )
+        self.assertFalse(is_disabled, "expected enabled cloud-init")
         self.assertEqual(
-            'Cloud-init enabled by systemd cloud-init-generator', reason)
+            "Cloud-init enabled by systemd cloud-init-generator", reason
+        )
 
     def test_status_returns_not_run(self):
-        '''When status.json does not exist yet, return 'not run'.'''
+        """When status.json does not exist yet, return 'not run'."""
         self.assertFalse(
-            os.path.exists(self.status_file), 'Unexpected status.json found')
+            os.path.exists(self.status_file), "Unexpected status.json found"
+        )
         cmdargs = myargs(long=False, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
-        self.assertEqual('status: not run\n', m_stdout.getvalue())
+        self.assertEqual("status: not run\n", m_stdout.getvalue())
 
     def test_status_returns_disabled_long_on_presence_of_disable_file(self):
-        '''When cloudinit is disabled, return disabled reason.'''
+        """When cloudinit is disabled, return disabled reason."""
 
         checked_files = []
 
         def fakeexists(filepath):
             checked_files.append(filepath)
-            status_file = os.path.join(self.paths.run_dir, 'status.json')
+            status_file = os.path.join(self.paths.run_dir, "status.json")
             return bool(not filepath == status_file)
 
         cmdargs = myargs(long=True, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'os.path.exists': {'side_effect': fakeexists},
-                 '_is_cloudinit_disabled': (True, 'disabled for some reason'),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "os.path.exists": {"side_effect": fakeexists},
+                    "_is_cloudinit_disabled": (
+                        True,
+                        "disabled for some reason",
+                    ),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
         self.assertEqual(
-            [os.path.join(self.paths.run_dir, 'status.json')],
-            checked_files)
-        expected = dedent('''\
+            [os.path.join(self.paths.run_dir, "status.json")], checked_files
+        )
+        expected = dedent(
+            """\
             status: disabled
             detail:
             disabled for some reason
-        ''')
+        """
+        )
         self.assertEqual(expected, m_stdout.getvalue())
 
     def test_status_returns_running_on_no_results_json(self):
-        '''Report running when status.json exists but result.json does not.'''
-        result_file = self.tmp_path('result.json', self.new_root)
+        """Report running when status.json exists but result.json does not."""
+        result_file = self.tmp_path("result.json", self.new_root)
         write_json(self.status_file, {})
         self.assertFalse(
-            os.path.exists(result_file), 'Unexpected result.json found')
+            os.path.exists(result_file), "Unexpected result.json found"
+        )
         cmdargs = myargs(long=False, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
-        self.assertEqual('status: running\n', m_stdout.getvalue())
+        self.assertEqual("status: running\n", m_stdout.getvalue())
 
     def test_status_returns_running(self):
-        '''Report running when status exists with an unfinished stage.'''
-        ensure_file(self.tmp_path('result.json', self.new_root))
-        write_json(self.status_file,
-                   {'v1': {'init': {'start': 1, 'finished': None}}})
+        """Report running when status exists with an unfinished stage."""
+        ensure_file(self.tmp_path("result.json", self.new_root))
+        write_json(
+            self.status_file, {"v1": {"init": {"start": 1, "finished": None}}}
+        )
         cmdargs = myargs(long=False, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
-        self.assertEqual('status: running\n', m_stdout.getvalue())
+        self.assertEqual("status: running\n", m_stdout.getvalue())
 
     def test_status_returns_done(self):
-        '''Report done results.json exists no stages are unfinished.'''
-        ensure_file(self.tmp_path('result.json', self.new_root))
+        """Report done results.json exists no stages are unfinished."""
+        ensure_file(self.tmp_path("result.json", self.new_root))
         write_json(
             self.status_file,
-            {'v1': {'stage': None,  # No current stage running
-                    'datasource': (
-                        'DataSourceNoCloud [seed=/var/.../seed/nocloud-net]'
-                        '[dsmode=net]'),
-                    'blah': {'finished': 123.456},
-                    'init': {'errors': [], 'start': 124.567,
-                             'finished': 125.678},
-                    'init-local': {'start': 123.45, 'finished': 123.46}}})
+            {
+                "v1": {
+                    "stage": None,  # No current stage running
+                    "datasource": (
+                        "DataSourceNoCloud [seed=/var/.../seed/nocloud-net]"
+                        "[dsmode=net]"
+                    ),
+                    "blah": {"finished": 123.456},
+                    "init": {
+                        "errors": [],
+                        "start": 124.567,
+                        "finished": 125.678,
+                    },
+                    "init-local": {"start": 123.45, "finished": 123.46},
+                }
+            },
+        )
         cmdargs = myargs(long=False, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
-        self.assertEqual('status: done\n', m_stdout.getvalue())
+        self.assertEqual("status: done\n", m_stdout.getvalue())
 
     def test_status_returns_done_long(self):
-        '''Long format of done status includes datasource info.'''
-        ensure_file(self.tmp_path('result.json', self.new_root))
+        """Long format of done status includes datasource info."""
+        ensure_file(self.tmp_path("result.json", self.new_root))
         write_json(
             self.status_file,
-            {'v1': {'stage': None,
-                    'datasource': (
-                        'DataSourceNoCloud [seed=/var/.../seed/nocloud-net]'
-                        '[dsmode=net]'),
-                    'init': {'start': 124.567, 'finished': 125.678},
-                    'init-local': {'start': 123.45, 'finished': 123.46}}})
+            {
+                "v1": {
+                    "stage": None,
+                    "datasource": (
+                        "DataSourceNoCloud [seed=/var/.../seed/nocloud-net]"
+                        "[dsmode=net]"
+                    ),
+                    "init": {"start": 124.567, "finished": 125.678},
+                    "init-local": {"start": 123.45, "finished": 123.46},
+                }
+            },
+        )
         cmdargs = myargs(long=True, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
-        expected = dedent('''\
+        expected = dedent(
+            """\
             status: done
             time: Thu, 01 Jan 1970 00:02:05 +0000
             detail:
             DataSourceNoCloud [seed=/var/.../seed/nocloud-net][dsmode=net]
-        ''')
+        """
+        )
         self.assertEqual(expected, m_stdout.getvalue())
 
     def test_status_on_errors(self):
-        '''Reports error when any stage has errors.'''
+        """Reports error when any stage has errors."""
         write_json(
             self.status_file,
-            {'v1': {'stage': None,
-                    'blah': {'errors': [], 'finished': 123.456},
-                    'init': {'errors': ['error1'], 'start': 124.567,
-                             'finished': 125.678},
-                    'init-local': {'start': 123.45, 'finished': 123.46}}})
+            {
+                "v1": {
+                    "stage": None,
+                    "blah": {"errors": [], "finished": 123.456},
+                    "init": {
+                        "errors": ["error1"],
+                        "start": 124.567,
+                        "finished": 125.678,
+                    },
+                    "init-local": {"start": 123.45, "finished": 123.46},
+                }
+            },
+        )
         cmdargs = myargs(long=False, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(1, retcode)
-        self.assertEqual('status: error\n', m_stdout.getvalue())
+        self.assertEqual("status: error\n", m_stdout.getvalue())
 
     def test_status_on_errors_long(self):
-        '''Long format of error status includes all error messages.'''
+        """Long format of error status includes all error messages."""
         write_json(
             self.status_file,
-            {'v1': {'stage': None,
-                    'datasource': (
-                        'DataSourceNoCloud [seed=/var/.../seed/nocloud-net]'
-                        '[dsmode=net]'),
-                    'init': {'errors': ['error1'], 'start': 124.567,
-                             'finished': 125.678},
-                    'init-local': {'errors': ['error2', 'error3'],
-                                   'start': 123.45, 'finished': 123.46}}})
+            {
+                "v1": {
+                    "stage": None,
+                    "datasource": (
+                        "DataSourceNoCloud [seed=/var/.../seed/nocloud-net]"
+                        "[dsmode=net]"
+                    ),
+                    "init": {
+                        "errors": ["error1"],
+                        "start": 124.567,
+                        "finished": 125.678,
+                    },
+                    "init-local": {
+                        "errors": ["error2", "error3"],
+                        "start": 123.45,
+                        "finished": 123.46,
+                    },
+                }
+            },
+        )
         cmdargs = myargs(long=True, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(1, retcode)
-        expected = dedent('''\
+        expected = dedent(
+            """\
             status: error
             time: Thu, 01 Jan 1970 00:02:05 +0000
             detail:
             error1
             error2
             error3
-        ''')
+        """
+        )
         self.assertEqual(expected, m_stdout.getvalue())
 
     def test_status_returns_running_long_format(self):
-        '''Long format reports the stage in which we are running.'''
+        """Long format reports the stage in which we are running."""
         write_json(
             self.status_file,
-            {'v1': {'stage': 'init',
-                    'init': {'start': 124.456, 'finished': None},
-                    'init-local': {'start': 123.45, 'finished': 123.46}}})
+            {
+                "v1": {
+                    "stage": "init",
+                    "init": {"start": 124.456, "finished": None},
+                    "init-local": {"start": 123.45, "finished": 123.46},
+                }
+            },
+        )
         cmdargs = myargs(long=True, wait=False)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
-        expected = dedent('''\
+        expected = dedent(
+            """\
             status: running
             time: Thu, 01 Jan 1970 00:02:04 +0000
             detail:
             Running in stage: init
-        ''')
+        """
+        )
         self.assertEqual(expected, m_stdout.getvalue())
 
     def test_status_wait_blocks_until_done(self):
-        '''Specifying wait will poll every 1/4 second until done state.'''
+        """Specifying wait will poll every 1/4 second until done state."""
         running_json = {
-            'v1': {'stage': 'init',
-                   'init': {'start': 124.456, 'finished': None},
-                   'init-local': {'start': 123.45, 'finished': 123.46}}}
+            "v1": {
+                "stage": "init",
+                "init": {"start": 124.456, "finished": None},
+                "init-local": {"start": 123.45, "finished": 123.46},
+            }
+        }
         done_json = {
-            'v1': {'stage': None,
-                   'init': {'start': 124.456, 'finished': 125.678},
-                   'init-local': {'start': 123.45, 'finished': 123.46}}}
+            "v1": {
+                "stage": None,
+                "init": {"start": 124.456, "finished": 125.678},
+                "init-local": {"start": 123.45, "finished": 123.46},
+            }
+        }
 
         self.sleep_calls = 0
 
@@ -324,32 +457,46 @@ class TestStatus(CiTestCase):
                 write_json(self.status_file, running_json)
             elif self.sleep_calls == 3:
                 write_json(self.status_file, done_json)
-                result_file = self.tmp_path('result.json', self.new_root)
+                result_file = self.tmp_path("result.json", self.new_root)
                 ensure_file(result_file)
 
         cmdargs = myargs(long=False, wait=True)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'sleep': {'side_effect': fake_sleep},
-                 '_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "sleep": {"side_effect": fake_sleep},
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(0, retcode)
         self.assertEqual(4, self.sleep_calls)
-        self.assertEqual('....\nstatus: done\n', m_stdout.getvalue())
+        self.assertEqual("....\nstatus: done\n", m_stdout.getvalue())
 
     def test_status_wait_blocks_until_error(self):
-        '''Specifying wait will poll every 1/4 second until error state.'''
+        """Specifying wait will poll every 1/4 second until error state."""
         running_json = {
-            'v1': {'stage': 'init',
-                   'init': {'start': 124.456, 'finished': None},
-                   'init-local': {'start': 123.45, 'finished': 123.46}}}
+            "v1": {
+                "stage": "init",
+                "init": {"start": 124.456, "finished": None},
+                "init-local": {"start": 123.45, "finished": 123.46},
+            }
+        }
         error_json = {
-            'v1': {'stage': None,
-                   'init': {'errors': ['error1'], 'start': 124.456,
-                            'finished': 125.678},
-                   'init-local': {'start': 123.45, 'finished': 123.46}}}
+            "v1": {
+                "stage": None,
+                "init": {
+                    "errors": ["error1"],
+                    "start": 124.456,
+                    "finished": 125.678,
+                },
+                "init-local": {"start": 123.45, "finished": 123.46},
+            }
+        }
 
         self.sleep_calls = 0
 
@@ -362,30 +509,40 @@ class TestStatus(CiTestCase):
                 write_json(self.status_file, error_json)
 
         cmdargs = myargs(long=False, wait=True)
-        with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+        with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
             retcode = wrap_and_call(
-                'cloudinit.cmd.status',
-                {'sleep': {'side_effect': fake_sleep},
-                 '_is_cloudinit_disabled': (False, ''),
-                 'Init': {'side_effect': self.init_class}},
-                status.handle_status_args, 'ignored', cmdargs)
+                "cloudinit.cmd.status",
+                {
+                    "sleep": {"side_effect": fake_sleep},
+                    "_is_cloudinit_disabled": (False, ""),
+                    "Init": {"side_effect": self.init_class},
+                },
+                status.handle_status_args,
+                "ignored",
+                cmdargs,
+            )
         self.assertEqual(1, retcode)
         self.assertEqual(4, self.sleep_calls)
-        self.assertEqual('....\nstatus: error\n', m_stdout.getvalue())
+        self.assertEqual("....\nstatus: error\n", m_stdout.getvalue())
 
     def test_status_main(self):
-        '''status.main can be run as a standalone script.'''
-        write_json(self.status_file,
-                   {'v1': {'init': {'start': 1, 'finished': None}}})
+        """status.main can be run as a standalone script."""
+        write_json(
+            self.status_file, {"v1": {"init": {"start": 1, "finished": None}}}
+        )
         with self.assertRaises(SystemExit) as context_manager:
-            with mock.patch('sys.stdout', new_callable=StringIO) as m_stdout:
+            with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
                 wrap_and_call(
-                    'cloudinit.cmd.status',
-                    {'sys.argv': {'new': ['status']},
-                     '_is_cloudinit_disabled': (False, ''),
-                     'Init': {'side_effect': self.init_class}},
-                    status.main)
+                    "cloudinit.cmd.status",
+                    {
+                        "sys.argv": {"new": ["status"]},
+                        "_is_cloudinit_disabled": (False, ""),
+                        "Init": {"side_effect": self.init_class},
+                    },
+                    status.main,
+                )
         self.assertEqual(0, context_manager.exception.code)
-        self.assertEqual('status: running\n', m_stdout.getvalue())
+        self.assertEqual("status: running\n", m_stdout.getvalue())
+
 
 # vi: ts=4 expandtab syntax=python