Merge ~xavpaice/charm-sysconfig:linting into charm-sysconfig:master

[Xav Paice]

Re-lint using Black standard

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[Alvaro Uria (aluria)]

+1

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision 1b3e8bb26e059993187aaf1485a761ecbbd95bba

diff --git a/src/lib/lib_sysconfig.py b/src/lib/lib_sysconfig.py
index 803ae20..475812c 100644
--- a/src/lib/lib_sysconfig.py
+++ b/src/lib/lib_sysconfig.py
@@ -18,18 +18,18 @@ from charms.reactive.helpers import any_file_changed
 import yaml
 
 
-GRUB_DEFAULT = 'Advanced options for Ubuntu>Ubuntu, with Linux {}'
-CPUFREQUTILS_TMPL = 'cpufrequtils.j2'
-GRUB_CONF_TMPL = 'grub.j2'
-SYSTEMD_SYSTEM_TMPL = 'etc.systemd.system.conf.j2'
-SYSTEMD_RESOLVED_TMPL = 'etc.systemd.resolved.conf.j2'
+GRUB_DEFAULT = "Advanced options for Ubuntu>Ubuntu, with Linux {}"
+CPUFREQUTILS_TMPL = "cpufrequtils.j2"
+GRUB_CONF_TMPL = "grub.j2"
+SYSTEMD_SYSTEM_TMPL = "etc.systemd.system.conf.j2"
+SYSTEMD_RESOLVED_TMPL = "etc.systemd.resolved.conf.j2"
 
-CPUFREQUTILS = '/etc/default/cpufrequtils'
-GRUB_CONF = '/etc/default/grub.d/90-sysconfig.cfg'
-SYSTEMD_SYSTEM = '/etc/systemd/system.conf'
-SYSTEMD_RESOLVED = '/etc/systemd/resolved.conf'
-SYSCTL_CONF = '/etc/sysctl.d/90-charm-sysconfig.conf'
-KERNEL = 'kernel'
+CPUFREQUTILS = "/etc/default/cpufrequtils"
+GRUB_CONF = "/etc/default/grub.d/90-sysconfig.cfg"
+SYSTEMD_SYSTEM = "/etc/systemd/system.conf"
+SYSTEMD_RESOLVED = "/etc/systemd/resolved.conf"
+SYSCTL_CONF = "/etc/sysctl.d/90-charm-sysconfig.conf"
+KERNEL = "kernel"
 
 
 def parse_config_flags(config_flags):
@@ -41,15 +41,15 @@ def parse_config_flags(config_flags):
     key_value_pairs = config_flags.split(",")
     parsed_config_flags = {}
     for index, pair in enumerate(key_value_pairs):
-        if '=' in pair:
-            key, value = map(str.strip, pair.split('=', 1))
+        if "=" in pair:
+            key, value = map(str.strip, pair.split("=", 1))
             # Note(peppepetra): if value contains a comma that is also used as
             # delimiter, we need to reconstruct the value
             i = index + 1
             while i < len(key_value_pairs):
-                if '=' in key_value_pairs[i]:
+                if "=" in key_value_pairs[i]:
                     break
-                value += ',' + key_value_pairs[i]
+                value += "," + key_value_pairs[i]
                 i += 1
             parsed_config_flags[key] = value
     return parsed_config_flags
@@ -62,7 +62,7 @@ def running_kernel():
 
 def boot_time():
     """Return timestamp of last boot."""
-    with open('/proc/uptime', 'r') as f:
+    with open("/proc/uptime", "r") as f:
         uptime_seconds = float(f.readline().split()[0])
         boot_time = datetime.now(timezone.utc) - timedelta(seconds=uptime_seconds)
         return boot_time
@@ -84,7 +84,7 @@ class BootResourceState:
     def calculate_resource_sha256sum(self, resource_name):
         """Calcucate sha256sum of contents of provided resource."""
         sha = hashlib.sha256()
-        sha.update(open(resource_name, 'rb').read())
+        sha.update(open(resource_name, "rb").read())
         return sha.hexdigest()
 
     def update_resource_checksums(self, resources):
@@ -93,8 +93,10 @@ class BootResourceState:
             if not os.path.exists(resource):
                 continue
 
-            self.db.set("{}.sha256sum".format(self.key_for(resource)),
-                        self.calculate_resource_sha256sum(resource))
+            self.db.set(
+                "{}.sha256sum".format(self.key_for(resource)),
+                self.calculate_resource_sha256sum(resource),
+            )
 
     def set_resource(self, resource_name):
         """Update db entry for the resource_name with time.now."""
@@ -116,7 +118,9 @@ class BootResourceState:
         tfloat = self.db.get(self.key_for(resource_name))
         if tfloat is not None:
             return datetime.fromtimestamp(tfloat, timezone.utc)
-        return datetime.min.replace(tzinfo=timezone.utc)  # We don't have a ts -> changed at dawn of time
+        return datetime.min.replace(
+            tzinfo=timezone.utc
+        )  # We don't have a ts -> changed at dawn of time
 
     def checksum_changed(self, resource_name):
         """Return True if checksum has changed since last recorded."""
@@ -139,11 +143,13 @@ class BootResourceState:
         :return: list of names
         """
         boot_ts = boot_time()
-        time_changed = [name for name in resource_names
-                        if boot_ts < self.get_resource_changed_timestamp(name)]
+        time_changed = [
+            name
+            for name in resource_names
+            if boot_ts < self.get_resource_changed_timestamp(name)
+        ]
 
-        csum_changed = [name for name in resource_names
-                        if self.checksum_changed(name)]
+        csum_changed = [name for name in resource_names if self.checksum_changed(name)]
 
         a = set(time_changed)
         b = set(csum_changed)
@@ -172,7 +178,7 @@ class SysConfigHelper:
     @property
     def enable_container(self):
         """Return enable-container config."""
-        return self.charm_config['enable-container']
+        return self.charm_config["enable-container"]
 
     @property
     def reservation(self):
@@ -181,14 +187,14 @@ class SysConfigHelper:
         [DEPRECATED]: this option should no longer be used.
         Instead cpu-affinity-range and isolcpus should be used.
         """
-        return self.charm_config['reservation']
+        return self.charm_config["reservation"]
 
     @property
     def cpu_affinity_range(self):
         """Return cpu-affinity-range config."""
         if self.reservation == "affinity" and self.cpu_range:
             return self.cpu_range
-        return self.charm_config['cpu-affinity-range']
+        return self.charm_config["cpu-affinity-range"]
 
     @property
     def cpu_range(self):
@@ -197,84 +203,81 @@ class SysConfigHelper:
         [DEPRECATED]: this option should no longer be used.
         Instead cpu-affinity-range and isolcpus should be used.
         """
-        return self.charm_config['cpu-range']
+        return self.charm_config["cpu-range"]
 
     @property
     def hugepages(self):
         """Return hugepages config."""
-        return self.charm_config['hugepages']
+        return self.charm_config["hugepages"]
 
     @property
     def hugepagesz(self):
         """Return hugepagesz config."""
-        return self.charm_config['hugepagesz']
+        return self.charm_config["hugepagesz"]
 
     @property
     def isolcpus(self):
         """Return isolcpus config."""
         if self.reservation == "isolcpus" and self.cpu_range:
             return self.cpu_range
-        return self.charm_config['isolcpus']
+        return self.charm_config["isolcpus"]
 
     @property
     def raid_autodetection(self):
         """Return raid-autodetection config option."""
-        return self.charm_config['raid-autodetection']
+        return self.charm_config["raid-autodetection"]
 
     @property
     def enable_pti(self):
         """Return raid-autodetection config option."""
-        return self.charm_config['enable-pti']
+        return self.charm_config["enable-pti"]
 
     @property
     def enable_iommu(self):
         """Return enable-iommu config option."""
-        return self.charm_config['enable-iommu']
+        return self.charm_config["enable-iommu"]
 
     @property
     def grub_config_flags(self):
         """Return grub-config-flags config option."""
-        return parse_config_flags(self.charm_config['grub-config-flags'])
+        return parse_config_flags(self.charm_config["grub-config-flags"])
 
     @property
     def systemd_config_flags(self):
         """Return systemd-config-flags config option."""
-        return parse_config_flags(self.charm_config['systemd-config-flags'])
+        return parse_config_flags(self.charm_config["systemd-config-flags"])
 
     @property
     def kernel_version(self):
         """Return kernel-version config option."""
-        return self.charm_config['kernel-version']
+        return self.charm_config["kernel-version"]
 
     @property
     def update_grub(self):
         """Return update-grub config option."""
-        return self.charm_config['update-grub']
+        return self.charm_config["update-grub"]
 
     @property
     def governor(self):
         """Return governor config option."""
-        return self.charm_config['governor']
+        return self.charm_config["governor"]
 
     @property
     def resolved_cache_mode(self):
         """Return resolved-cache-mode config option."""
-        return self.charm_config['resolved-cache-mode']
+        return self.charm_config["resolved-cache-mode"]
 
     @property
     def sysctl_config(self):
         """Return sysctl config option."""
-        raw_str = self.charm_config['sysctl']
+        raw_str = self.charm_config["sysctl"]
 
         try:
             parsed = yaml.safe_load(raw_str)
         except yaml.YAMLError:
             err_msg = "Error parsing sysctl YAML"
-            hookenv.status_set('blocked', err_msg)
-            hookenv.log(
-                "%s: %s" % (err_msg, raw_str),
-                level=hookenv.ERROR
-            )
+            hookenv.status_set("blocked", err_msg)
+            hookenv.log("%s: %s" % (err_msg, raw_str), level=hookenv.ERROR)
             raise
 
         return parsed
@@ -286,9 +289,9 @@ class SysConfigHelper:
         [DEPRECATED]: this option should no longer be used.
         Instead grub-config-flags and systemd-config-flags should be used.
         """
-        if not self.charm_config.get('config-flags'):
+        if not self.charm_config.get("config-flags"):
             return {}
-        flags = config_flags_parser(self.charm_config['config-flags'])
+        flags = config_flags_parser(self.charm_config["config-flags"])
         return flags
 
     def _render_boot_resource(self, source, target, context):
@@ -299,10 +302,10 @@ class SysConfigHelper:
     @staticmethod
     def _render_resource(source, target, context):
         """Render the template."""
-        render(source=source, templates_dir='templates', target=target, context=context)
+        render(source=source, templates_dir="templates", target=target, context=context)
 
     def _is_kernel_already_running(self):
-        """Check if the kernel version required by charm config is equal to kernel running."""
+        """Check if the kernel version required by charm config = kernel running."""
         configured = self.kernel_version
         if configured == running_kernel():
             hookenv.log("Already running kernel: {}".format(configured), hookenv.DEBUG)
@@ -312,21 +315,34 @@ class SysConfigHelper:
     def _update_grub(self):
         """Call update-grub when update-grub config param is set to True."""
         if self.update_grub and not host.is_container():
-            subprocess.check_call(['/usr/sbin/update-grub'])
-            hookenv.log('Running update-grub to apply grub conf updates', hookenv.DEBUG)
+            subprocess.check_call(["/usr/sbin/update-grub"])
+            hookenv.log("Running update-grub to apply grub conf updates", hookenv.DEBUG)
 
     def is_config_valid(self):
         """Validate config parameters."""
         valid = True
 
         for config_key, value, valid_values in (
-                ('reservation', self.reservation, ['off', 'isolcpus', 'affinity']),
-                ('raid-autodetection', self.raid_autodetection, ['', 'noautodetect', 'partitionable']),
-                ('governor', self.governor, ['', 'powersave', 'performance']),
-                ('resolved-cache-mode', self.resolved_cache_mode, ['', 'yes', 'no', 'no-negative']),
+            ("reservation", self.reservation, ["off", "isolcpus", "affinity"]),
+            (
+                "raid-autodetection",
+                self.raid_autodetection,
+                ["", "noautodetect", "partitionable"],
+            ),
+            ("governor", self.governor, ["", "powersave", "performance"]),
+            (
+                "resolved-cache-mode",
+                self.resolved_cache_mode,
+                ["", "yes", "no", "no-negative"],
+            ),
         ):
             if value not in valid_values:
-                hookenv.log('{} not valid. Possible values: {}'.format(config_key, repr(valid_values)), hookenv.DEBUG)
+                hookenv.log(
+                    "{} not valid. Possible values: {}".format(
+                        config_key, repr(valid_values)
+                    ),
+                    hookenv.DEBUG,
+                )
                 valid = False
 
         return valid
@@ -347,60 +363,64 @@ class SysConfigHelper:
         # This is to keep the old method of specifying the isolcpus
         # by specifying the reservation and the cpu_range
         if self.isolcpus:
-            context['isolcpus'] = self.isolcpus
+            context["isolcpus"] = self.isolcpus
         if self.hugepages:
-            context['hugepages'] = self.hugepages
+            context["hugepages"] = self.hugepages
         if self.hugepagesz:
-            context['hugepagesz'] = self.hugepagesz
+            context["hugepagesz"] = self.hugepagesz
         if self.raid_autodetection:
-            context['raid'] = self.raid_autodetection
+            context["raid"] = self.raid_autodetection
         if not self.enable_pti:
-            context['pti_off'] = True
+            context["pti_off"] = True
         if self.enable_iommu:
-            context['iommu'] = True
+            context["iommu"] = True
 
         # Note(peppepetra): First check if new grub-config-flags is used
         # if not try to fallback into legacy config-flags
         if self.grub_config_flags:
-            context['grub_config_flags'] = self.grub_config_flags
+            context["grub_config_flags"] = self.grub_config_flags
         else:
-            context['grub_config_flags'] = parse_config_flags(self.config_flags.get('grub', ''))
+            context["grub_config_flags"] = parse_config_flags(
+                self.config_flags.get("grub", "")
+            )
 
         if self.kernel_version and not self._is_kernel_already_running():
-            context['grub_default'] = GRUB_DEFAULT.format(self.kernel_version)
+            context["grub_default"] = GRUB_DEFAULT.format(self.kernel_version)
 
         self._render_boot_resource(GRUB_CONF_TMPL, GRUB_CONF, context)
-        hookenv.log('grub configuration updated')
+        hookenv.log("grub configuration updated")
         self._update_grub()
 
     def update_systemd_system_file(self):
         """Update /etc/systemd/system.conf according to charm configuration."""
         context = {}
         if self.cpu_affinity_range:
-            context['cpu_affinity_range'] = self.cpu_affinity_range
+            context["cpu_affinity_range"] = self.cpu_affinity_range
 
         # Note(peppepetra): First check if new systemd-config-flags is used
         # if not try to fallback into legacy config-flags
         if self.systemd_config_flags:
-            context['systemd_config_flags'] = self.systemd_config_flags
+            context["systemd_config_flags"] = self.systemd_config_flags
         else:
-            context['systemd_config_flags'] = parse_config_flags(self.config_flags.get('systemd', ''))
+            context["systemd_config_flags"] = parse_config_flags(
+                self.config_flags.get("systemd", "")
+            )
 
         self._render_boot_resource(SYSTEMD_SYSTEM_TMPL, SYSTEMD_SYSTEM, context)
-        hookenv.log('systemd configuration updated')
+        hookenv.log("systemd configuration updated")
 
     def update_systemd_resolved(self):
         """Update /etc/systemd/resolved.conf according to charm configuration."""
         context = {}
         if self.resolved_cache_mode:
-            context['cache'] = self.resolved_cache_mode
+            context["cache"] = self.resolved_cache_mode
         self._update_systemd_resolved(context)
-        hookenv.log('systemd-resolved configuration updated')
+        hookenv.log("systemd-resolved configuration updated")
 
     def update_sysctl(self):
         """Update sysctl according to charm configuration."""
         sysctl.create(self.sysctl_config or {}, SYSCTL_CONF)
-        hookenv.log('sysctl updated')
+        hookenv.log("sysctl updated")
 
     def install_configured_kernel(self):
         """Install kernel as given by the kernel-version config option.
@@ -408,14 +428,14 @@ class SysConfigHelper:
         Will install kernel and matching modules-extra package
         """
         if not self.kernel_version or self._is_kernel_already_running():
-            hookenv.log(
-                'Kernel is already running the required version',
-                hookenv.DEBUG
-            )
+            hookenv.log("Kernel is already running the required version", hookenv.DEBUG)
             return
 
         configured = self.kernel_version
-        pkgs = [tmpl.format(configured) for tmpl in ["linux-image-{}", "linux-modules-extra-{}"]]
+        pkgs = [
+            tmpl.format(configured)
+            for tmpl in ["linux-image-{}", "linux-modules-extra-{}"]
+        ]
         apt_update()
         apt_install(pkgs)
         hookenv.log("installing: {}".format(pkgs))
@@ -423,28 +443,34 @@ class SysConfigHelper:
 
     def update_cpufreq(self):
         """Update /etc/default/cpufrequtils and restart cpufrequtils service."""
-        if self.governor not in ('', 'performance', 'powersave'):
+        if self.governor not in ("", "performance", "powersave"):
             return
-        context = {'governor': self.governor}
+        context = {"governor": self.governor}
         self._render_boot_resource(CPUFREQUTILS_TMPL, CPUFREQUTILS, context)
-        # Ensure the ondemand service is disabled if governor is set, lp#1822774, lp#1863659, lp#740127
+        # Ensure the ondemand service is disabled if governor is set,
+        # lp#1822774, lp#1863659, lp#740127
         # Ondemand service is not updated during test if host is container.
         if not host.is_container():
-            hookenv.log('disabling the ondemand services for lp#1822774, lp#1863659,'
-                        ' and lp#740127 if a governor is specified', hookenv.DEBUG)
+            hookenv.log(
+                "disabling the ondemand services for lp#1822774, lp#1863659,"
+                " and lp#740127 if a governor is specified",
+                hookenv.DEBUG,
+            )
             if self.governor:
                 subprocess.call(
-                    ['/bin/systemctl', 'mask', 'ondemand'],
-                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+                    ["/bin/systemctl", "mask", "ondemand"],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
                 )
             else:
                 # Renable ondemand when governor is unset.
                 subprocess.call(
-                    ['/bin/systemctl', 'unmask', 'ondemand'],
-                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+                    ["/bin/systemctl", "unmask", "ondemand"],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
                 )
 
-        host.service_restart('cpufrequtils')
+        host.service_restart("cpufrequtils")
 
     def remove_grub_configuration(self):
         """Remove /etc/default/grub.d/90-sysconfig.cfg if exists.
@@ -456,8 +482,8 @@ class SysConfigHelper:
             return
         os.remove(grub_configuration_path)
         hookenv.log(
-            'deleted grub configuration at {}'.format(grub_configuration_path),
-            hookenv.DEBUG
+            "deleted grub configuration at {}".format(grub_configuration_path),
+            hookenv.DEBUG,
         )
         self._update_grub()
         self.boot_resources.set_resource(GRUB_CONF)
@@ -470,8 +496,7 @@ class SysConfigHelper:
         context = {}
         self._render_boot_resource(SYSTEMD_SYSTEM_TMPL, SYSTEMD_SYSTEM, context)
         hookenv.log(
-            'deleted systemd configuration at {}'.format(SYSTEMD_SYSTEM),
-            hookenv.DEBUG
+            "deleted systemd configuration at {}".format(SYSTEMD_SYSTEM), hookenv.DEBUG
         )
 
     def remove_resolved_configuration(self):
@@ -481,14 +506,14 @@ class SysConfigHelper:
         """
         self._update_systemd_resolved({})
         hookenv.log(
-            'deleted resolved configuration at {}'.format(SYSTEMD_RESOLVED),
-            hookenv.DEBUG
+            "deleted resolved configuration at {}".format(SYSTEMD_RESOLVED),
+            hookenv.DEBUG,
         )
 
     def _update_systemd_resolved(self, context):
         self._render_resource(SYSTEMD_RESOLVED_TMPL, SYSTEMD_RESOLVED, context)
         if any_file_changed([SYSTEMD_RESOLVED]):
-            host.service_restart('systemd-resolved')
+            host.service_restart("systemd-resolved")
 
     def remove_cpufreq_configuration(self):
         """Remove cpufrequtils configuration.
@@ -497,16 +522,18 @@ class SysConfigHelper:
         """
         context = {}
         if not host.is_container():
-            hookenv.log('Enabling the ondemand initscript for lp#1822774'
-                        ' and lp#740127', 'DEBUG')
+            hookenv.log(
+                "Enabling the ondemand initscript for lp#1822774" " and lp#740127",
+                "DEBUG",
+            )
             subprocess.call(
-                ['/bin/systemctl', 'unmask', 'ondemand'],
-                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+                ["/bin/systemctl", "unmask", "ondemand"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
             )
 
         self._render_boot_resource(CPUFREQUTILS_TMPL, CPUFREQUTILS, context)
         hookenv.log(
-            'deleted cpufreq configuration at {}'.format(CPUFREQUTILS),
-            hookenv.DEBUG
+            "deleted cpufreq configuration at {}".format(CPUFREQUTILS), hookenv.DEBUG
         )
-        host.service_restart('cpufrequtils')
+        host.service_restart("cpufrequtils")
diff --git a/src/reactive/sysconfig.py b/src/reactive/sysconfig.py
index ecbe0eb..b829d83 100644
--- a/src/reactive/sysconfig.py
+++ b/src/reactive/sysconfig.py
@@ -29,26 +29,34 @@ from charms.reactive import (
     when_not,
 )
 
-from lib_sysconfig import CPUFREQUTILS, GRUB_CONF, KERNEL, SYSTEMD_RESOLVED, SYSTEMD_SYSTEM, SysConfigHelper
+from lib_sysconfig import (
+    CPUFREQUTILS,
+    GRUB_CONF,
+    KERNEL,
+    SYSTEMD_RESOLVED,
+    SYSTEMD_SYSTEM,
+    SysConfigHelper,
+)
 
 
-@when_none('sysconfig.installed', 'sysconfig.unsupported')
-@when('juju-info.connected')
+@when_none("sysconfig.installed", "sysconfig.unsupported")
+@when("juju-info.connected")
 def install_sysconfig():
     """Install the charm if it is not running on a container.
 
-    Deploy can be forced using enable-container option only for testing. (Default: false).
+    Deploy can be forced using enable-container option only for testing.
+    (Default: false).
     """
     syshelper = SysConfigHelper()
 
     # container not supported unless enable-container=true for testing purpose
     if host.is_container() and not syshelper.enable_container:
-        hookenv.status_set('blocked', 'containers are not supported')
-        set_flag('sysconfig.unsupported')
+        hookenv.status_set("blocked", "containers are not supported")
+        set_flag("sysconfig.unsupported")
         return
 
     if not syshelper.is_config_valid():
-        hookenv.status_set('blocked', 'configuration parameters not valid.')
+        hookenv.status_set("blocked", "configuration parameters not valid.")
         return
 
     syshelper.install_configured_kernel()
@@ -56,68 +64,71 @@ def install_sysconfig():
     syshelper.update_grub_file()
     syshelper.update_systemd_system_file()
     syshelper.update_systemd_resolved()
-    set_flag('sysconfig.installed')
+    set_flag("sysconfig.installed")
     update_status()
 
 
-@when('sysconfig.installed')
-@when_not('sysconfig.unsupported')
-@when('config.changed')
+@when("sysconfig.installed")
+@when_not("sysconfig.unsupported")
+@when("config.changed")
 def config_changed():
     """Apply configuration updates if the charm is installed."""
     syshelper = SysConfigHelper()
-    hookenv.status_set('maintenance', 'applying changes')
+    hookenv.status_set("maintenance", "applying changes")
 
     if not syshelper.is_config_valid():
-        hookenv.status_set('blocked', 'configuration parameters not valid.')
+        hookenv.status_set("blocked", "configuration parameters not valid.")
         return
 
     # Kernel
-    if syshelper.charm_config.changed('kernel-version'):
+    if syshelper.charm_config.changed("kernel-version"):
         syshelper.install_configured_kernel()
 
     # cpufreq
-    if syshelper.charm_config.changed('governor') or helpers.any_file_changed([CPUFREQUTILS]):
+    if syshelper.charm_config.changed("governor") or helpers.any_file_changed(
+        [CPUFREQUTILS]
+    ):
         syshelper.update_cpufreq()
 
     # GRUB
-    if any(syshelper.charm_config.changed(flag) for flag in (
-            'reservation',
-            'hugepages',
-            'hugepagesz',
-            'raid-autodetection',
-            'enable-pti',
-            'enable-iommu',
-            'grub-config-flags',
-            'kernel-version',
-            'update-grub',
-            'config-flags',
-            'cpu-range',
-    )) or helpers.any_file_changed([GRUB_CONF]):
+    if any(
+        syshelper.charm_config.changed(flag)
+        for flag in (
+            "reservation",
+            "hugepages",
+            "hugepagesz",
+            "raid-autodetection",
+            "enable-pti",
+            "enable-iommu",
+            "grub-config-flags",
+            "kernel-version",
+            "update-grub",
+            "config-flags",
+            "cpu-range",
+        )
+    ) or helpers.any_file_changed([GRUB_CONF]):
         syshelper.update_grub_file()
 
     # systemd
-    if any(syshelper.charm_config.changed(flag) for flag in (
-            'reservation',
-            'systemd-config-flags',
-            'cpu-range',
-            'config-flags',
-    )) or helpers.any_file_changed([SYSTEMD_SYSTEM]):
+    if any(
+        syshelper.charm_config.changed(flag)
+        for flag in ("reservation", "systemd-config-flags", "cpu-range", "config-flags")
+    ) or helpers.any_file_changed([SYSTEMD_SYSTEM]):
         syshelper.update_systemd_system_file()
 
     # systemd resolved
-    if any(syshelper.charm_config.changed(flag) for flag in (
-            'resolved-cache-mode',
-    )) or helpers.any_file_changed([SYSTEMD_RESOLVED]):
+    if any(
+        syshelper.charm_config.changed(flag) for flag in ("resolved-cache-mode",)
+    ) or helpers.any_file_changed([SYSTEMD_RESOLVED]):
         syshelper.update_systemd_resolved()
 
-    if syshelper.charm_config.changed('sysctl'):
+    if syshelper.charm_config.changed("sysctl"):
         syshelper.update_sysctl()
 
     update_status()
 
 
-@hook('upgrade-charm')
+@hook("upgrade-charm")
 def upgrade_charm():
     """Extras to run when charm is upgraded."""
     # NOTE(hopem): do this for backwards compatibility to ensure that db
@@ -127,44 +138,48 @@ def upgrade_charm():
     update_status()
 
 
-@hook('update-status')
+@hook("update-status")
 def update_status():
     """Update the workload message checking if reboot is needed.
 
     Note: After the reboot use clear-notification action to clear the
     'reboot required' message.
     """
-    if is_flag_set('sysconfig.unsupported'):
+    if is_flag_set("sysconfig.unsupported"):
         return
 
     resources = [KERNEL, SYSTEMD_SYSTEM, GRUB_CONF]
-    boot_changes = SysConfigHelper.boot_resources.resources_changed_since_boot(resources)
+    boot_changes = SysConfigHelper.boot_resources.resources_changed_since_boot(
+        resources
+    )
 
     if boot_changes:
-        hookenv.status_set('active', 'reboot required. Changes in: {}'.format(', '.join(boot_changes)))
+        hookenv.status_set(
+            "active", "reboot required. Changes in: {}".format(", ".join(boot_changes))
+        )
     else:
-        hookenv.status_set('active', 'ready')
+        hookenv.status_set("active", "ready")
 
 
-@when('config.changed.enable-container')
-@when_not('sysconfig.installed')
+@when("config.changed.enable-container")
+@when_not("sysconfig.installed")
 def enable_container_changed():
     """Trigger installation if enable-container option changed."""
-    clear_flag('sysconfig.unsupported')
+    clear_flag("sysconfig.unsupported")
 
 
-@when('sysconfig.installed')
-@when_not('juju-info.available')
+@when("sysconfig.installed")
+@when_not("juju-info.available")
 def remove_configuration():
     """Remove configuration applied by the charm if the juju-info relation is departed.
 
     For safety, kernels installed by the charm won't be removed.
     """
-    hookenv.status_set('maintenance', 'removing sysconfig configurations')
+    hookenv.status_set("maintenance", "removing sysconfig configurations")
     syshelper = SysConfigHelper()
     syshelper.remove_cpufreq_configuration()
     syshelper.remove_grub_configuration()
     syshelper.remove_systemd_configuration()
     syshelper.remove_resolved_configuration()
-    clear_flag('sysconfig.installed')
-    clear_flag('sysconfig.unsupported')
+    clear_flag("sysconfig.installed")
+    clear_flag("sysconfig.unsupported")
diff --git a/src/tests/functional/conftest.py b/src/tests/functional/conftest.py
index 29c78fd..f7f32e9 100644
--- a/src/tests/functional/conftest.py
+++ b/src/tests/functional/conftest.py
@@ -20,7 +20,7 @@ from juju_tools import JujuTools
 import pytest
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 def event_loop():
     """Override the default pytest event loop.
 
@@ -34,7 +34,7 @@ def event_loop():
     asyncio.set_event_loop(None)
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def controller():
     """Connect to the current controller."""
     _controller = Controller()
@@ -43,27 +43,28 @@ async def controller():
     await _controller.disconnect()
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def model(controller):
     """Destroy the model at the end of the test."""
     model_name = "functest-{}".format(str(uuid.uuid4())[-12:])
-    _model = await controller.add_model(model_name,
-                                        cloud_name=os.getenv('PYTEST_CLOUD_NAME'),
-                                        region=os.getenv('PYTEST_CLOUD_REGION'),
-                                        )
+    _model = await controller.add_model(
+        model_name,
+        cloud_name=os.getenv("PYTEST_CLOUD_NAME"),
+        region=os.getenv("PYTEST_CLOUD_REGION"),
+    )
     # https://github.com/juju/python-libjuju/issues/267
-    subprocess.check_call(['juju', 'models'])
+    subprocess.check_call(["juju", "models"])
     while model_name not in await controller.list_models():
         await asyncio.sleep(1)
     yield _model
     await _model.disconnect()
-    if not os.getenv('PYTEST_KEEP_MODEL'):
+    if not os.getenv("PYTEST_KEEP_MODEL"):
         await controller.destroy_model(model_name)
         while model_name in await controller.list_models():
             await asyncio.sleep(1)
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def jujutools(controller, model):
     """Return JujuTools instance."""
     tools = JujuTools(controller, model)
diff --git a/src/tests/functional/juju_tools.py b/src/tests/functional/juju_tools.py
index c7c791e..71b4aac 100644
--- a/src/tests/functional/juju_tools.py
+++ b/src/tests/functional/juju_tools.py
@@ -8,7 +8,11 @@ import juju
 
 
 class JujuTools:
-    """Permit to run command in a unit under tests (generic command, os.stat and cat <file>)."""
+    """Helper class to run command in a unit under test.
+
+    Permit to run command in a unit under tests (generic command, os.stat and
+    cat <file>).
+    """
 
     def __init__(self, controller, model):
         """Initialize controller and model under test."""
@@ -37,14 +41,17 @@ class JujuTools:
         :param target: Unit object or unit name string
         """
         python3 = "python3 -c '{}'"
-        python_cmd = ('import pickle;'
-                      'import base64;'
-                      '{}'
-                      'print(base64.b64encode(pickle.dumps({})), end="")'
-                      .format(imports, remote_cmd))
+        python_cmd = (
+            "import pickle;"
+            "import base64;"
+            "{}"
+            'print(base64.b64encode(pickle.dumps({})), end="")'.format(
+                imports, remote_cmd
+            )
+        )
         cmd = python3.format(python_cmd)
         results = await self.run_command(cmd, target)
-        return pickle.loads(base64.b64decode(bytes(results['Stdout'][2:-1], 'utf8')))
+        return pickle.loads(base64.b64decode(bytes(results["Stdout"][2:-1], "utf8")))
 
     async def file_stat(self, path, target):
         """Run stat on a file.
@@ -52,9 +59,8 @@ class JujuTools:
         :param path: File path
         :param target: Unit object or unit name string
         """
-        imports = 'import os;'
-        python_cmd = ('os.stat("{}")'
-                      .format(path))
+        imports = "import os;"
+        python_cmd = 'os.stat("{}")'.format(path)
         print("Calling remote cmd: " + python_cmd)
         return await self.remote_object(imports, python_cmd, target)
 
@@ -64,6 +70,6 @@ class JujuTools:
         :param path: File path
         :param target: Unit object or unit name string
         """
-        cmd = 'cat {}'.format(path)
+        cmd = "cat {}".format(path)
         result = await self.run_command(cmd, target)
-        return result['Stdout']
+        return result["Stdout"]
diff --git a/src/tests/functional/test_deploy.py b/src/tests/functional/test_deploy.py
index ea85064..84b2cd3 100644
--- a/src/tests/functional/test_deploy.py
+++ b/src/tests/functional/test_deploy.py
@@ -13,20 +13,16 @@ import websockets
 # Treat all tests as coroutines
 pytestmark = pytest.mark.asyncio
 
-charm_build_dir = os.getenv('CHARM_BUILD_DIR', '..').rstrip('/')
+charm_build_dir = os.getenv("CHARM_BUILD_DIR", "..").rstrip("/")
 
-series = [
-    'focal',
-    'bionic',
-    'xenial',
-]
+series = ["focal", "bionic", "xenial"]
 
-sources = [('local', '{}/builds/sysconfig'.format(charm_build_dir))]
+sources = [("local", "{}/builds/sysconfig".format(charm_build_dir))]
 
 TIMEOUT = 600
 MODEL_ACTIVE_TIMEOUT = 10
-GRUB_DEFAULT = 'Advanced options for Ubuntu>Ubuntu, with Linux {}'
-PRINCIPAL_APP_NAME = 'ubuntu-{}'
+GRUB_DEFAULT = "Advanced options for Ubuntu>Ubuntu, with Linux {}"
+PRINCIPAL_APP_NAME = "ubuntu-{}"
 
 # Uncomment for re-using the current model, useful for debugging functional tests
 # @pytest.fixture(scope='module')
@@ -54,39 +50,42 @@ def source(request):
 @pytest.fixture
 async def app(model, series, source):
     """Return application of the charm under test."""
-    app_name = 'sysconfig-{}-{}'.format(series, source[0])
-    return await model._wait_for_new('application', app_name)
+    app_name = "sysconfig-{}-{}".format(series, source[0])
+    return await model._wait_for_new("application", app_name)
 
 
 # Tests
 
+
 async def test_sysconfig_deploy(model, series, source, request):
     """Deploys the sysconfig charm as a subordinate of ubuntu."""
-    channel = 'stable'
-    sysconfig_app_name = 'sysconfig-{}-{}'.format(series, source[0])
+    channel = "stable"
+    sysconfig_app_name = "sysconfig-{}-{}".format(series, source[0])
     principal_app_name = PRINCIPAL_APP_NAME.format(series)
 
     ubuntu_app = await model.deploy(
-        'cs:ubuntu',
-        application_name=principal_app_name,
-        series=series,
-        channel=channel,
+        "cs:ubuntu", application_name=principal_app_name, series=series, channel=channel
     )
 
-    await model.block_until(
-        lambda: ubuntu_app.status == 'active',
-        timeout=TIMEOUT
-    )
+    await model.block_until(lambda: ubuntu_app.status == "active", timeout=TIMEOUT)
 
     # Using subprocess b/c libjuju fails with JAAS
     # https://github.com/juju/python-libjuju/issues/221
-    cmd = ['juju', 'deploy', source[1], '-m', model.info.name,
-           '--series', series, sysconfig_app_name]
-
-    if request.node.get_closest_marker('xfail'):
+    cmd = [
+        "juju",
+        "deploy",
+        source[1],
+        "-m",
+        model.info.name,
+        "--series",
+        series,
+        sysconfig_app_name,
+    ]
+
+    if request.node.get_closest_marker("xfail"):
         # If series is 'xfail' force install to allow testing against versions not in
         # metadata.yaml
-        cmd.append('--force')
+        cmd.append("--force")
     subprocess.check_call(cmd)
 
     # This is pretty horrible, but we can't deploy via libjuju
@@ -97,145 +96,134 @@ async def test_sysconfig_deploy(model, series, source, request):
         except KeyError:
             await asyncio.sleep(5)
 
-    await sysconfig_app.add_relation('juju-info', '{}:juju-info'.format(principal_app_name))
-
-    await model.block_until(
-        lambda: sysconfig_app.status == 'blocked',
-        timeout=TIMEOUT
+    await sysconfig_app.add_relation(
+        "juju-info", "{}:juju-info".format(principal_app_name)
     )
 
+    await model.block_until(lambda: sysconfig_app.status == "blocked", timeout=TIMEOUT)
+
 
 async def test_cannot_run_in_container(app):
     """Test that default config doesn't allow to install in container."""
-    assert app.status == 'blocked'
+    assert app.status == "blocked"
 
 
 async def test_forced_deploy(app, model):
     """Force to install in container for testing purpose."""
-    await app.set_config({'enable-container': 'true'})
-    await model.block_until(
-        lambda: app.status == 'active',
-        timeout=TIMEOUT
-    )
-    assert app.status == 'active'
+    await app.set_config({"enable-container": "true"})
+    await model.block_until(lambda: app.status == "active", timeout=TIMEOUT)
+    assert app.status == "active"
 
 
 async def test_cpufrequtils_intalled(app, jujutools):
     """Verify cpufrequtils pkg is installed."""
     unit = app.units[0]
-    cmd = 'dpkg -l | grep cpufrequtils'
+    cmd = "dpkg -l | grep cpufrequtils"
     results = await jujutools.run_command(cmd, unit)
-    assert results['Code'] == '0'
+    assert results["Code"] == "0"
 
 
 async def test_default_config(app, jujutools):
     """Test default configuration for grub, systemd and cpufrequtils."""
     unit = app.units[0]
 
-    grup_path = '/etc/default/grub.d/90-sysconfig.cfg'
+    grup_path = "/etc/default/grub.d/90-sysconfig.cfg"
     grub_content = await jujutools.file_contents(grup_path, unit)
-    assert 'isolcpus' not in grub_content
-    assert 'hugepages' not in grub_content
-    assert 'hugepagesz' not in grub_content
-    assert 'raid' not in grub_content
-    assert 'pti=off' in grub_content
-    assert 'intel_iommu' not in grub_content
-    assert 'GRUB_DEFAULT' not in grub_content
-
-    systemd_path = '/etc/systemd/system.conf'
+    assert "isolcpus" not in grub_content
+    assert "hugepages" not in grub_content
+    assert "hugepagesz" not in grub_content
+    assert "raid" not in grub_content
+    assert "pti=off" in grub_content
+    assert "intel_iommu" not in grub_content
+    assert "GRUB_DEFAULT" not in grub_content
+
+    systemd_path = "/etc/systemd/system.conf"
     systemd_content = await jujutools.file_contents(systemd_path, unit)
     systemd_valid = True
     for line in systemd_content:
-        if line.startswith('CPUAffinity='):
+        if line.startswith("CPUAffinity="):
             systemd_valid = False
     assert systemd_valid
 
-    cpufreq_path = '/etc/default/cpufrequtils'
+    cpufreq_path = "/etc/default/cpufrequtils"
     cpufreq_content = await jujutools.file_contents(cpufreq_path, unit)
-    assert 'GOVERNOR' not in cpufreq_content
+    assert "GOVERNOR" not in cpufreq_content
 
 
 async def test_config_changed(app, model, jujutools):
     """Test configuration changed for grub, systemd, cpufrqutils and kernel."""
-    kernel_version = '4.15.0-38-generic'
-    if 'focal' in app.entity_id:
-        # override the kernel_version for focal, we specify the oldest one ever released, as normal installations
+    kernel_version = "4.15.0-38-generic"
+    if "focal" in app.entity_id:
+        # override the kernel_version for focal, we specify the oldest one ever
+        # released, as normal installations
         # will updated to newest available
-        kernel_version = '5.4.0-29-generic'
-    linux_pkg = 'linux-image-{}'.format(kernel_version)
-    linux_modules_extra_pkg = 'linux-modules-extra-{}'.format(kernel_version)
+        kernel_version = "5.4.0-29-generic"
+    linux_pkg = "linux-image-{}".format(kernel_version)
+    linux_modules_extra_pkg = "linux-modules-extra-{}".format(kernel_version)
 
     await app.set_config(
         {
-            'isolcpus': '1,2,3,4',
-            'hugepages': '100',
-            'hugepagesz': '1G',
-            'raid-autodetection': 'noautodetect',
-            'enable-pti': 'true',
-            'enable-iommu': 'false',
-            'kernel-version': kernel_version,
-            'grub-config-flags': 'GRUB_TIMEOUT=10',
-            'config-flags': '{"grub": "TEST=test"}',  # config-flags are ignored when grub-config-flags are used
-            'systemd-config-flags': 'LogLevel=warning,DumpCore=no',
-            'governor': 'powersave'
+            "isolcpus": "1,2,3,4",
+            "hugepages": "100",
+            "hugepagesz": "1G",
+            "raid-autodetection": "noautodetect",
+            "enable-pti": "true",
+            "enable-iommu": "false",
+            "kernel-version": kernel_version,
+            "grub-config-flags": "GRUB_TIMEOUT=10",
+            # config-flags are ignored when grub-config-flags are used
+            "config-flags": '{"grub": "TEST=test"}',
+            "systemd-config-flags": "LogLevel=warning,DumpCore=no",
+            "governor": "powersave",
         }
     )
-    await model.block_until(
-        lambda: app.status == 'active',
-        timeout=TIMEOUT
-    )
-    assert app.status == 'active'
+    await model.block_until(lambda: app.status == "active", timeout=TIMEOUT)
+    assert app.status == "active"
 
     unit = app.units[0]
 
-    grup_path = '/etc/default/grub.d/90-sysconfig.cfg'
+    grup_path = "/etc/default/grub.d/90-sysconfig.cfg"
     grub_content = await jujutools.file_contents(grup_path, unit)
-    assert 'isolcpus=1,2,3,4' in grub_content
-    assert 'hugepages=100' in grub_content
-    assert 'hugepagesz=1G' in grub_content
-    assert 'raid=noautodetect' in grub_content
-    assert 'pti=off' not in grub_content
-    assert 'intel_iommu=on iommu=pt' not in grub_content
-    assert 'GRUB_DEFAULT="{}"'.format(GRUB_DEFAULT.format(kernel_version)) in grub_content
-    assert 'GRUB_TIMEOUT=10' in grub_content
-    assert 'TEST=test' not in grub_content
+    assert "isolcpus=1,2,3,4" in grub_content
+    assert "hugepages=100" in grub_content
+    assert "hugepagesz=1G" in grub_content
+    assert "raid=noautodetect" in grub_content
+    assert "pti=off" not in grub_content
+    assert "intel_iommu=on iommu=pt" not in grub_content
+    assert (
+        'GRUB_DEFAULT="{}"'.format(GRUB_DEFAULT.format(kernel_version)) in grub_content
+    )
+    assert "GRUB_TIMEOUT=10" in grub_content
+    assert "TEST=test" not in grub_content
 
     # Reconfiguring reservation from isolcpus to affinity
     # isolcpus will be removed from grub and affinity added to systemd
 
-    await app.set_config(
-        {
-            'isolcpus': '',
-            'cpu-affinity-range': '1,2,3,4'
-        }
-    )
+    await app.set_config({"isolcpus": "", "cpu-affinity-range": "1,2,3,4"})
 
-    await model.block_until(
-        lambda: app.status == 'active',
-        timeout=TIMEOUT
-    )
-    assert app.status == 'active'
+    await model.block_until(lambda: app.status == "active", timeout=TIMEOUT)
+    assert app.status == "active"
 
-    systemd_path = '/etc/systemd/system.conf'
+    systemd_path = "/etc/systemd/system.conf"
     systemd_content = await jujutools.file_contents(systemd_path, unit)
 
-    assert 'CPUAffinity=1,2,3,4' in systemd_content
+    assert "CPUAffinity=1,2,3,4" in systemd_content
 
-    assert 'LogLevel=warning' in systemd_content
-    assert 'DumpCore=no' in systemd_content
+    assert "LogLevel=warning" in systemd_content
+    assert "DumpCore=no" in systemd_content
 
     grub_content = await jujutools.file_contents(grup_path, unit)
-    assert 'isolcpus' not in grub_content
+    assert "isolcpus" not in grub_content
 
-    cpufreq_path = '/etc/default/cpufrequtils'
+    cpufreq_path = "/etc/default/cpufrequtils"
     cpufreq_content = await jujutools.file_contents(cpufreq_path, unit)
-    assert 'GOVERNOR=powersave' in cpufreq_content
+    assert "GOVERNOR=powersave" in cpufreq_content
 
     # test new kernel installed
     for pkg in (linux_pkg, linux_modules_extra_pkg):
-        cmd = 'dpkg -l | grep {}'.format(pkg)
+        cmd = "dpkg -l | grep {}".format(pkg)
         results = await jujutools.run_command(cmd, unit)
-        assert results['Code'] == '0'
+        assert results["Code"] == "0"
 
     # test update-status show that reboot is required
     assert "reboot required." in unit.workload_status_message
@@ -244,9 +232,9 @@ async def test_config_changed(app, model, jujutools):
 async def test_clear_notification(app):
     """Tests that clear-notification action complete."""
     unit = app.units[0]
-    action = await unit.run_action('clear-notification')
+    action = await unit.run_action("clear-notification")
     action = await action.wait()
-    assert action.status == 'completed'
+    assert action.status == "completed"
 
 
 # This may need to be removed at some point once the reservation
@@ -256,81 +244,58 @@ async def test_wrong_reservation(app, model):
 
     Expect application is blocked until correct value is set.
     """
-    await app.set_config(
-        {
-            'reservation': 'changeme'
-        }
-    )
-    await model.block_until(
-        lambda: app.status == 'blocked',
-        timeout=TIMEOUT
-    )
-    assert app.status == 'blocked'
+    await app.set_config({"reservation": "changeme"})
+    await model.block_until(lambda: app.status == "blocked", timeout=TIMEOUT)
+    assert app.status == "blocked"
     unit = app.units[0]
-    assert 'configuration parameters not valid.' in unit.workload_status_message
+    assert "configuration parameters not valid." in unit.workload_status_message
 
-    await app.set_config(
-        {
-            'reservation': 'off'
-        }
-    )
-    await model.block_until(
-        lambda: app.status == 'active',
-        timeout=TIMEOUT
-    )
+    await app.set_config({"reservation": "off"})
+    await model.block_until(lambda: app.status == "active", timeout=TIMEOUT)
 
 
[e-mail]('key,bad_value,good_value', [
-    ('raid-autodetection', 'changeme', ''),
-    ('governor', 'changeme', ''),
-    ('resolved-cache-mode', 'changeme', ''),
-])
[e-mail](
+    "key,bad_value,good_value",
+    [
+        ("raid-autodetection", "changeme", ""),
+        ("governor", "changeme", ""),
+        ("resolved-cache-mode", "changeme", ""),
+    ],
+)
 async def test_invalid_configuration_parameters(app, model, key, bad_value, good_value):
     """Tests wrong config value is used.
 
     Expect application is blocked until correct value is set.
     """
-    await app.set_config(
-        {
-            key: bad_value
-        }
-    )
-    await model.block_until(
-        lambda: app.status == 'blocked',
-        timeout=TIMEOUT
-    )
-    assert app.status == 'blocked'
+    await app.set_config({key: bad_value})
+    await model.block_until(lambda: app.status == "blocked", timeout=TIMEOUT)
+    assert app.status == "blocked"
     unit = app.units[0]
-    assert 'configuration parameters not valid.' in unit.workload_status_message
+    assert "configuration parameters not valid." in unit.workload_status_message
 
-    await app.set_config(
-        {
-            key: good_value
-        }
-    )
-    await model.block_until(
-        lambda: app.status == 'active',
-        timeout=TIMEOUT
-    )
+    await app.set_config({key: good_value})
+    await model.block_until(lambda: app.status == "active", timeout=TIMEOUT)
 
 
[e-mail]('cache_setting', [
-    'yes',
-    'no',
-    'no-negative',
-])
[e-mail]("cache_setting", ["yes", "no", "no-negative"])
 async def test_set_resolved_cache(app, model, jujutools, cache_setting):
     """Tests resolved cache settings."""
+
     def is_model_settled():
-        return app.units[0].workload_status == 'active' and app.units[0].agent_status == 'idle'
+        return (
+            app.units[0].workload_status == "active"
+            and app.units[0].agent_status == "idle"  # noqa: W503
+        )
 
     await model.block_until(is_model_settled, timeout=TIMEOUT)
 
-    await app.set_config({'resolved-cache-mode': cache_setting})
+    await app.set_config({"resolved-cache-mode": cache_setting})
     # NOTE: app.set_config() doesn't seem to wait for the model to go to a
     # non-active/idle state.
     try:
-        await model.block_until(lambda: not is_model_settled(), timeout=MODEL_ACTIVE_TIMEOUT)
+        await model.block_until(
+            lambda: not is_model_settled(), timeout=MODEL_ACTIVE_TIMEOUT
+        )
     except websockets.ConnectionClosed:
         # It's possible (although unlikely) that we missed the charm transitioning from
         # idle to active and back.
@@ -338,36 +303,42 @@ async def test_set_resolved_cache(app, model, jujutools, cache_setting):
 
     await model.block_until(is_model_settled, timeout=TIMEOUT)
 
-    resolved_conf_content = await jujutools.file_contents('/etc/systemd/resolved.conf', app.units[0])
-    assert re.search('^Cache={}$'.format(cache_setting), resolved_conf_content, re.MULTILINE)
+    resolved_conf_content = await jujutools.file_contents(
+        "/etc/systemd/resolved.conf", app.units[0]
+    )
+    assert re.search(
+        "^Cache={}$".format(cache_setting), resolved_conf_content, re.MULTILINE
+    )
 
 
[e-mail]('sysctl', ['1', '0'])
[e-mail]("sysctl", ["1", "0"])
 async def test_set_sysctl(app, model, jujutools, sysctl):
     """Tests sysctl settings."""
+
     def is_model_settled():
-        return app.units[0].workload_status == 'active' and app.units[0].agent_status == 'idle'
+        return (
+            app.units[0].workload_status == "active"
+            and app.units[0].agent_status == "idle"  # noqa: W503
+        )
 
     await model.block_until(is_model_settled, timeout=TIMEOUT)
 
-    await app.set_config({
-        'sysctl': "net.ipv4.ip_forward: %s" % sysctl
-    })
+    await app.set_config({"sysctl": "net.ipv4.ip_forward: %s" % sysctl})
     # NOTE: app.set_config() doesn't seem to wait for the model to go to a
     # non-active/idle state.
     try:
-        await model.block_until(lambda: not is_model_settled(), timeout=MODEL_ACTIVE_TIMEOUT)
+        await model.block_until(
+            lambda: not is_model_settled(), timeout=MODEL_ACTIVE_TIMEOUT
+        )
     except websockets.ConnectionClosed:
         # It's possible (although unlikely) that we missed the charm transitioning from
         # idle to active and back.
         pass
 
     await model.block_until(is_model_settled, timeout=TIMEOUT)
-    result = await jujutools.run_command('sysctl -a', app.units[0])
-    content = result['Stdout']
-    assert re.search(
-        '^net.ipv4.ip_forward = {}$'.format(sysctl), content, re.MULTILINE
-    )
+    result = await jujutools.run_command("sysctl -a", app.units[0])
+    content = result["Stdout"]
+    assert re.search("^net.ipv4.ip_forward = {}$".format(sysctl), content, re.MULTILINE)
 
 
 async def test_uninstall(app, model, jujutools, series):
@@ -376,42 +347,36 @@ async def test_uninstall(app, model, jujutools, series):
     # after removing the relation with ubuntu
     await app.set_config(
         {
-            'reservation': 'affinity',
-            'cpu-range': '1,2,3,4',
-            'governor': 'performance',
-            'raid-autodetection': ''
+            "reservation": "affinity",
+            "cpu-range": "1,2,3,4",
+            "governor": "performance",
+            "raid-autodetection": "",
         }
     )
 
-    await model.block_until(
-        lambda: app.status == 'active',
-        timeout=TIMEOUT
-    )
+    await model.block_until(lambda: app.status == "active", timeout=TIMEOUT)
 
     principal_app_name = PRINCIPAL_APP_NAME.format(series)
     principal_app = model.applications[principal_app_name]
 
-    await app.destroy_relation('juju-info', '{}:juju-info'.format(principal_app_name))
+    await app.destroy_relation("juju-info", "{}:juju-info".format(principal_app_name))
 
-    await model.block_until(
-        lambda: len(app.units) == 0,
-        timeout=TIMEOUT
-    )
+    await model.block_until(lambda: len(app.units) == 0, timeout=TIMEOUT)
 
     unit = principal_app.units[0]
-    grup_path = '/etc/default/grub.d/90-sysconfig.cfg'
-    cmd = 'cat {}'.format(grup_path)
+    grup_path = "/etc/default/grub.d/90-sysconfig.cfg"
+    cmd = "cat {}".format(grup_path)
     results = await jujutools.run_command(cmd, unit)
-    assert results['Code'] != '0'
+    assert results["Code"] != "0"
 
-    systemd_path = '/etc/systemd/system.conf'
+    systemd_path = "/etc/systemd/system.conf"
     systemd_content = await jujutools.file_contents(systemd_path, unit)
-    assert 'CPUAffinity=1,2,3,4' not in systemd_content
+    assert "CPUAffinity=1,2,3,4" not in systemd_content
 
-    resolved_path = '/etc/systemd/resolved.conf'
+    resolved_path = "/etc/systemd/resolved.conf"
     resolved_content = await jujutools.file_contents(resolved_path, unit)
-    assert not re.search('^Cache=', resolved_content, re.MULTILINE)
+    assert not re.search("^Cache=", resolved_content, re.MULTILINE)
 
-    cpufreq_path = '/etc/default/cpufrequtils'
+    cpufreq_path = "/etc/default/cpufrequtils"
     cpufreq_content = await jujutools.file_contents(cpufreq_path, unit)
-    assert 'GOVERNOR' not in cpufreq_content
+    assert "GOVERNOR" not in cpufreq_content
diff --git a/src/tests/unit/conftest.py b/src/tests/unit/conftest.py
index 50dd26e..7a94633 100644
--- a/src/tests/unit/conftest.py
+++ b/src/tests/unit/conftest.py
@@ -9,19 +9,20 @@ import pytest
 @pytest.fixture
 def mock_layers(monkeypatch):
     import sys
-    sys.modules['charms.layer'] = mock.Mock()
-    sys.modules['reactive'] = mock.Mock()
+
+    sys.modules["charms.layer"] = mock.Mock()
+    sys.modules["reactive"] = mock.Mock()
     # Mock any functions in layers that need to be mocked here
 
     def options(layer):
         # mock options for layers here
-        if layer == 'example-layer':
-            options = {'port': 9999}
+        if layer == "example-layer":
+            options = {"port": 9999}
             return options
         else:
             return None
 
-    monkeypatch.setattr('lib_sysconfig.layer.options', options)
+    monkeypatch.setattr("lib_sysconfig.layer.options", options)
 
 
 @pytest.fixture
@@ -30,35 +31,36 @@ def mock_hookenv_config(monkeypatch):
 
     def mock_config():
         cfg = {}
-        yml = yaml.load(open('./config.yaml'))
+        yml = yaml.load(open("./config.yaml"))
 
         # Load all defaults
-        for key, value in yml['options'].items():
-            cfg[key] = value['default']
+        for key, value in yml["options"].items():
+            cfg[key] = value["default"]
 
         # Manually add cfg from other layers
         # cfg['my-other-layer'] = 'mock'
         return cfg
 
-    monkeypatch.setattr('lib_sysconfig.hookenv.config', mock_config)
+    monkeypatch.setattr("lib_sysconfig.hookenv.config", mock_config)
 
 
 @pytest.fixture
 def mock_remote_unit(monkeypatch):
-    monkeypatch.setattr('lib_sysconfig.hookenv.remote_unit', lambda: 'unit-mock/0')
+    monkeypatch.setattr("lib_sysconfig.hookenv.remote_unit", lambda: "unit-mock/0")
 
 
 @pytest.fixture
 def mock_charm_dir(monkeypatch):
-    monkeypatch.setattr('lib_sysconfig.hookenv.charm_dir', lambda: '/mock/charm/dir')
+    monkeypatch.setattr("lib_sysconfig.hookenv.charm_dir", lambda: "/mock/charm/dir")
 
 
 @pytest.fixture
 def sysconfig(tmpdir, mock_hookenv_config, mock_charm_dir, monkeypatch):
     from lib_sysconfig import SysConfigHelper
+
     helper = SysConfigHelper()
 
     # Any other functions that load helper will get this version
-    monkeypatch.setattr('lib_sysconfig.SysConfigHelper', lambda: helper)
+    monkeypatch.setattr("lib_sysconfig.SysConfigHelper", lambda: helper)
 
     return helper
diff --git a/src/tests/unit/test_lib.py b/src/tests/unit/test_lib.py
index 72d8b70..df93a76 100644
--- a/src/tests/unit/test_lib.py
+++ b/src/tests/unit/test_lib.py
@@ -86,8 +86,9 @@ class TestBootResourceState:
         mock_boot_time.return_value = self.datetime - timedelta(1)
         boot_resource = self.boot_resource()
         with NamedTemporaryFile() as ftmp:
-            with mock.patch.object(boot_resource,
-                                   'calculate_resource_sha256sum') as mock_calc:
+            with mock.patch.object(
+                boot_resource, "calculate_resource_sha256sum"
+            ) as mock_calc:
                 mock_calc.return_value = "1234"
                 changed = boot_resource.resources_changed_since_boot([ftmp.name])
                 assert not changed
@@ -98,8 +99,9 @@ class TestBootResourceState:
         mock_boot_time.return_value = self.datetime - timedelta(1)
         boot_resource = self.boot_resource()
         with NamedTemporaryFile() as ftmp:
-            with mock.patch.object(boot_resource,
-                                   'calculate_resource_sha256sum') as mock_calc:
+            with mock.patch.object(
+                boot_resource, "calculate_resource_sha256sum"
+            ) as mock_calc:
                 mock_calc.return_value = "2345"
                 changed = boot_resource.resources_changed_since_boot([ftmp.name])
                 assert changed
@@ -137,8 +139,10 @@ class TestLib:
             context=expected,
         )
         check_call.assert_called_with(
-            ['/bin/systemctl', 'mask', 'ondemand'],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            ["/bin/systemctl", "mask", "ondemand"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
 
     @mock.patch("lib_sysconfig.subprocess.call")
     @mock.patch("lib_sysconfig.hookenv.config")
@@ -162,14 +166,18 @@ class TestLib:
         )
         restart.assert_called()
         check_call.assert_called_with(
-            ['/bin/systemctl', 'unmask', 'ondemand'],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            ["/bin/systemctl", "unmask", "ondemand"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
 
     @mock.patch("lib_sysconfig.subprocess.call")
     @mock.patch("lib_sysconfig.hookenv.config")
     @mock.patch("lib_sysconfig.host.service_restart")
     @mock.patch("lib_sysconfig.render")
-    def test_update_cpufreq_governor_not_available(self, render, restart, config, check_call):
+    def test_update_cpufreq_governor_not_available(
+        self, render, restart, config, check_call
+    ):
         """Set wrong governor.
 
         Expect /etc/default/cpufrequtils is not rendered
@@ -199,9 +207,9 @@ class TestLib:
             "raid-autodetection": "noautodetect",
             "enable-pti": True,
             "enable-iommu": True,
-            "grub-config-flags": "TEST_KEY=\"TEST VALUE, WITH COMMA\", GRUB_TIMEOUT=0",
+            "grub-config-flags": 'TEST_KEY="TEST VALUE, WITH COMMA", GRUB_TIMEOUT=0',
             "kernel-version": "4.15.0-38-generic",
-            "update-grub": True
+            "update-grub": True,
         }
 
         expected = {
@@ -210,8 +218,12 @@ class TestLib:
             "hugepagesz": "1G",
             "raid": "noautodetect",
             "iommu": True,
-            "grub_config_flags": {"GRUB_TIMEOUT": "0", "TEST_KEY": "\"TEST VALUE, WITH COMMA\""},
-            "grub_default": "Advanced options for Ubuntu>Ubuntu, with Linux 4.15.0-38-generic"
+            "grub_config_flags": {
+                "GRUB_TIMEOUT": "0",
+                "TEST_KEY": '"TEST VALUE, WITH COMMA"',
+            },
+            "grub_default": "Advanced options for Ubuntu>Ubuntu, "
+            "with Linux 4.15.0-38-generic",
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -241,9 +253,9 @@ class TestLib:
             "raid-autodetection": "noautodetect",
             "enable-pti": True,
             "enable-iommu": True,
-            "grub-config-flags": "TEST_KEY=\"TEST VALUE, WITH COMMA\", GRUB_TIMEOUT=0",
+            "grub-config-flags": 'TEST_KEY="TEST VALUE, WITH COMMA", GRUB_TIMEOUT=0',
             "kernel-version": "4.15.0-38-generic",
-            "update-grub": True
+            "update-grub": True,
         }
 
         expected = {
@@ -252,8 +264,12 @@ class TestLib:
             "hugepagesz": "1G",
             "raid": "noautodetect",
             "iommu": True,
-            "grub_config_flags": {"GRUB_TIMEOUT": "0", "TEST_KEY": "\"TEST VALUE, WITH COMMA\""},
-            "grub_default": "Advanced options for Ubuntu>Ubuntu, with Linux 4.15.0-38-generic"
+            "grub_config_flags": {
+                "GRUB_TIMEOUT": "0",
+                "TEST_KEY": '"TEST VALUE, WITH COMMA"',
+            },
+            "grub_default": "Advanced options for Ubuntu>Ubuntu, "
+            "with Linux 4.15.0-38-generic",
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -283,14 +299,18 @@ class TestLib:
             "raid-autodetection": "",
             "enable-pti": True,
             "enable-iommu": False,
-            "config-flags": "{ 'grub': 'GRUB_TIMEOUT=0, TEST=line with space, and comma'}",
+            "config-flags": "{ 'grub': 'GRUB_TIMEOUT=0, "
+            "TEST=line with space, and comma'}",
             "grub-config-flags": "",
             "kernel-version": "",
             "update-grub": True,
         }
 
         expected = {
-            "grub_config_flags": {"GRUB_TIMEOUT": "0", "TEST": "line with space, and comma"},
+            "grub_config_flags": {
+                "GRUB_TIMEOUT": "0",
+                "TEST": "line with space, and comma",
+            }
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -320,9 +340,9 @@ class TestLib:
             "raid-autodetection": "noautodetect",
             "enable-pti": False,
             "enable-iommu": True,
-            "grub-config-flags": "GRUB_TIMEOUT=0, TEST=\"one,two,three, four\"",
+            "grub-config-flags": 'GRUB_TIMEOUT=0, TEST="one,two,three, four"',
             "kernel-version": "4.15.0-38-generic",
-            "update-grub": False
+            "update-grub": False,
         }
 
         expected = {
@@ -331,9 +351,10 @@ class TestLib:
             "hugepagesz": "1G",
             "raid": "noautodetect",
             "iommu": True,
-            "grub_config_flags": {"GRUB_TIMEOUT": "0", "TEST": "\"one,two,three, four\""},
-            "grub_default": "Advanced options for Ubuntu>Ubuntu, with Linux 4.15.0-38-generic",
-            'pti_off': True
+            "grub_config_flags": {"GRUB_TIMEOUT": "0", "TEST": '"one,two,three, four"'},
+            "grub_default": "Advanced options for Ubuntu>Ubuntu, "
+            "with Linux 4.15.0-38-generic",
+            "pti_off": True,
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -357,15 +378,15 @@ class TestLib:
         config.return_value = {
             "reservation": "off",
             "cpu-affinity-range": "0-10",
-            "systemd-config-flags": "DefaultLimitRTTIME=1,DefaultTasksMax=10"
+            "systemd-config-flags": "DefaultLimitRTTIME=1,DefaultTasksMax=10",
         }
 
         expected = {
             "cpu_affinity_range": "0-10",
             "systemd_config_flags": {
                 "DefaultLimitRTTIME": "1",
-                "DefaultTasksMax": "10"
-            }
+                "DefaultTasksMax": "10",
+            },
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -388,15 +409,15 @@ class TestLib:
         config.return_value = {
             "reservation": "affinity",
             "cpu-range": "0-10",
-            "systemd-config-flags": "DefaultLimitRTTIME=1,DefaultTasksMax=10"
+            "systemd-config-flags": "DefaultLimitRTTIME=1,DefaultTasksMax=10",
         }
 
         expected = {
             "cpu_affinity_range": "0-10",
             "systemd_config_flags": {
                 "DefaultLimitRTTIME": "1",
-                "DefaultTasksMax": "10"
-            }
+                "DefaultTasksMax": "10",
+            },
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -420,15 +441,15 @@ class TestLib:
             "reservation": "off",
             "cpu-affinity-range": "0-10",
             "config-flags": "{'systemd': 'DefaultLimitRTTIME=1, DefaultTasksMax=10'}",
-            "systemd-config-flags": ""
+            "systemd-config-flags": "",
         }
 
         expected = {
             "cpu_affinity_range": "0-10",
             "systemd_config_flags": {
                 "DefaultLimitRTTIME": "1",
-                "DefaultTasksMax": "10"
-            }
+                "DefaultTasksMax": "10",
+            },
         }
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -445,21 +466,24 @@ class TestLib:
     @mock.patch("lib_sysconfig.hookenv.config")
     @mock.patch("lib_sysconfig.running_kernel")
     @mock.patch("lib_sysconfig.hookenv.log")
-    def test_install_configured_kernel_true(self, log, running_kernel, config, apt_update, apt_install):
+    def test_install_configured_kernel_true(
+        self, log, running_kernel, config, apt_update, apt_install
+    ):
         """Set config kernel=4.15.0-38-generic and running kernel is different.
 
         Expect apt install is called.
         """
-        config.return_value = {
-            "kernel-version": "4.15.0-38-generic"
-        }
+        config.return_value = {"kernel-version": "4.15.0-38-generic"}
 
         running_kernel.return_value = "4.4.0-38-generic"
         sysh = lib_sysconfig.SysConfigHelper()
         sysh.install_configured_kernel()
 
         apt_install.assert_called_with(
-            ["linux-image-{}".format("4.15.0-38-generic"), "linux-modules-extra-{}".format("4.15.0-38-generic")]
+            [
+                "linux-image-{}".format("4.15.0-38-generic"),
+                "linux-modules-extra-{}".format("4.15.0-38-generic"),
+            ]
         )
 
     @mock.patch("lib_sysconfig.apt_install")
@@ -467,15 +491,15 @@ class TestLib:
     @mock.patch("lib_sysconfig.hookenv.config")
     @mock.patch("lib_sysconfig.running_kernel")
     @mock.patch("lib_sysconfig.hookenv.log")
-    def test_install_configured_kernel_false(self, log, running_kernel, config, apt_update, apt_install):
+    def test_install_configured_kernel_false(
+        self, log, running_kernel, config, apt_update, apt_install
+    ):
         """Set config kernel=4.15.0-38-generic and running kernel is the same.
 
         Expect apt install is not called.
         """
         kernel_version = "4.15.0-38-generic"
-        config.return_value = {
-            "kernel-version": kernel_version
-        }
+        config.return_value = {"kernel-version": kernel_version}
 
         running_kernel.return_value = "4.15.0-38-generic"
         sysh = lib_sysconfig.SysConfigHelper()
@@ -488,14 +512,14 @@ class TestLib:
     @mock.patch("lib_sysconfig.hookenv.config")
     @mock.patch("lib_sysconfig.running_kernel")
     @mock.patch("lib_sysconfig.hookenv.log")
-    def test_install_configured_kernel_no_specified(self, log, running_kernel, config, apt_update, apt_install):
+    def test_install_configured_kernel_no_specified(
+        self, log, running_kernel, config, apt_update, apt_install
+    ):
         """Set config kernel=''.
 
         Expect apt install is not called.
         """
-        config.return_value = {
-            "kernel-version": ""
-        }
+        config.return_value = {"kernel-version": ""}
 
         running_kernel.return_value = "4.15.0-38-generic"
         sysh = lib_sysconfig.SysConfigHelper()
@@ -512,9 +536,7 @@ class TestLib:
 
         Expect os.remove is called
         """
-        config.return_value = {
-            "update-grub": False
-        }
+        config.return_value = {"update-grub": False}
         exists.return_value = True
 
         with NamedTemporaryFile() as ftmp:
@@ -532,9 +554,7 @@ class TestLib:
 
         Expect os.remove is not called
         """
-        config.return_value = {
-            "update-grub": False
-        }
+        config.return_value = {"update-grub": False}
         exists.return_value = False
 
         sysh = lib_sysconfig.SysConfigHelper()
@@ -557,7 +577,7 @@ class TestLib:
             source=lib_sysconfig.SYSTEMD_SYSTEM_TMPL,
             target=lib_sysconfig.SYSTEMD_SYSTEM,
             templates_dir="templates",
-            context={}
+            context={},
         )
 
     @mock.patch("lib_sysconfig.hookenv.config")
@@ -565,7 +585,9 @@ class TestLib:
     @mock.patch("lib_sysconfig.host.service_restart")
     @mock.patch("lib_sysconfig.subprocess.call")
     @mock.patch("lib_sysconfig.hookenv.log")
-    def test_remove_cpufreq_configuration_xenial(self, log, check_call, restart, render, config):
+    def test_remove_cpufreq_configuration_xenial(
+        self, log, check_call, restart, render, config
+    ):
         """Test remove cpufrequtlis configuration.
 
         Expect config is rendered with empty context.
@@ -574,18 +596,22 @@ class TestLib:
         sysh.remove_cpufreq_configuration()
 
         check_call.assert_called_with(
-            ['/bin/systemctl', 'unmask', 'ondemand'],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            ["/bin/systemctl", "unmask", "ondemand"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
         render.assert_called_with(
             source=lib_sysconfig.CPUFREQUTILS_TMPL,
             target=lib_sysconfig.CPUFREQUTILS,
             templates_dir="templates",
-            context={}
+            context={},
         )
         restart.assert_called()
 
-    @pytest.mark.parametrize("invalid_config_key", [
-        "reservation", "raid-autodetection", "governor", "resolved-cache-mode"])
+    @pytest.mark.parametrize(
+        "invalid_config_key",
+        ["reservation", "raid-autodetection", "governor", "resolved-cache-mode"],
+    )
     @mock.patch("lib_sysconfig.hookenv.config")
     def test_wrong_config(self, config, invalid_config_key):
         """Test wrong configuration value.
@@ -597,7 +623,7 @@ class TestLib:
             "raid-autodetection": "",
             "governor": "",
             "resolved-cache-mode": "",
-            invalid_config_key: 'wrong',  # Will override the selected key with an invalid value
+            invalid_config_key: "wrong",  # Will override key with an invalid value
         }
         config.return_value = return_value
         sysh = lib_sysconfig.SysConfigHelper()
@@ -606,9 +632,7 @@ class TestLib:
     @mock.patch("lib_sysconfig.hookenv.config")
     def test_enable_container(self, config):
         """Test enable container."""
-        config.return_value = {
-            "enable-container": True
-        }
+        config.return_value = {"enable-container": True}
         sysh = lib_sysconfig.SysConfigHelper()
 
         assert sysh.enable_container
@@ -617,7 +641,9 @@ class TestLib:
     @mock.patch("lib_sysconfig.hookenv.config")
     @mock.patch("lib_sysconfig.host.service_restart")
     @mock.patch("lib_sysconfig.render")
-    def test_update_resolved_file_unchanged(self, render, restart, config, file_changed):
+    def test_update_resolved_file_unchanged(
+        self, render, restart, config, file_changed
+    ):
         """systemd-resolved is not restarted when the config file is unchanged."""
         file_changed.return_value = False
         self._test_update_resolved_common(render, config)
@@ -658,15 +684,12 @@ class TestLib:
         with mock.patch("builtins.open", mock.mock_open()) as mock_file:
             sysh.update_sysctl()
 
-        mock_file.assert_called_with(lib_sysconfig.SYSCTL_CONF, 'w')
+        mock_file.assert_called_with(lib_sysconfig.SYSCTL_CONF, "w")
         handle = mock_file()
-        handle.write.has_calls([
-            mock.call('net.ipv4.ip_forward=1\n'),
-            mock.call('vm.swappiness=60\n'),
-        ])
-        check_call.assert_called_with([
-            'sysctl', '-p', lib_sysconfig.SYSCTL_CONF
-        ])
+        handle.write.has_calls(
+            [mock.call("net.ipv4.ip_forward=1\n"), mock.call("vm.swappiness=60\n")]
+        )
+        check_call.assert_called_with(["sysctl", "-p", lib_sysconfig.SYSCTL_CONF])
 
     @mock.patch("lib_sysconfig.hookenv")
     def test_update_sysctl_invalid_yaml(self, hookenv):
@@ -676,8 +699,7 @@ class TestLib:
         with pytest.raises(Exception):
             sysh.update_sysctl()
         hookenv.log.assert_called_once_with(
-            "Error parsing sysctl YAML: {invalid",
-            level=hookenv.ERROR
+            "Error parsing sysctl YAML: {invalid", level=hookenv.ERROR
         )
         hookenv.status_set.assert_called_once_with(
             "blocked", "Error parsing sysctl YAML"
diff --git a/src/tox.ini b/src/tox.ini
index 1b641ce..f932ee3 100644
--- a/src/tox.ini
+++ b/src/tox.ini
@@ -33,8 +33,11 @@ deps = -r{toxinidir}/tests/functional/requirements.txt
        -r{toxinidir}/requirements.txt
 
 [testenv:lint]
-commands = flake8
+commands =
+    black --check reactive lib tests
+    flake8
 deps =
+    black
     flake8
     flake8-docstrings
     flake8-import-order
@@ -47,5 +50,5 @@ exclude =
     .git,
     __pycache__,
     .tox,
-max-line-length = 120
+max-line-length = 88
 max-complexity = 10