Merge ~peppepetra/charm-sudo-pair:blacken-20.08 into charm-sudo-pair:master

[Giuseppe Petralia]

[Paul Goins (vultaire)]

LGTM.

review: Approve

[Xav Paice (xavpaice)]

LGTM

review: Approve

diff --git a/src/actions/actions.py b/src/actions/actions.py
index 1cb455c..2416eb3 100755
--- a/src/actions/actions.py
+++ b/src/actions/actions.py
@@ -30,7 +30,7 @@ def remove():
     sph.deconfigure()
     msg = "Successfully removed sudo-pair config and binaries"
     action_set({"message": msg})
-    status_set('active', msg)
+    status_set("active", msg)
 
 
 # A dictionary of all the defined actions to callables (which take
diff --git a/src/lib/libsudopair.py b/src/lib/libsudopair.py
index 05d1f9d..cbaf467 100644
--- a/src/lib/libsudopair.py
+++ b/src/lib/libsudopair.py
@@ -25,8 +25,8 @@ def group_names_to_group_ids(group_names):
     :param group_names: i.e. "root,user1,user2"
     :return gids: i.e. "0,1001,1002"
     """
-    group_names = list(filter(check_valid_group, group_names.split(',')))
-    return ','.join(map(str, (map(group_id, group_names))))
+    group_names = list(filter(check_valid_group, group_names.split(",")))
+    return ",".join(map(str, (map(group_id, group_names))))
 
 
 def copy_file(source, destination, owner, group, perms):
@@ -37,8 +37,10 @@ def copy_file(source, destination, owner, group, perms):
             # This is a terrible default directory permission, as the file
             # or its siblings will often contain secrets.
             host.mkdir(os.path.dirname(destination), owner, group, perms=0o755)
-        with open(source, 'rb') as source_f:
-            host.write_file(destination, source_f.read(), perms=perms, owner=owner, group=group)
+        with open(source, "rb") as source_f:
+            host.write_file(
+                destination, source_f.read(), perms=perms, owner=owner, group=group
+            )
 
 
 class SudoPairHelper(object):
@@ -47,17 +49,17 @@ class SudoPairHelper(object):
     def __init__(self):
         """Retrieve charm config and set defaults."""
         self.charm_config = hookenv.config()
-        self.binary_path = '/usr/bin/sudo_approve'
-        self.sudo_conf_path = '/etc/sudo.conf'
-        self.sudoers_path = '/etc/sudoers'
-        self.sudo_lib_path = '/usr/lib/sudo/sudo_pair.so'
+        self.binary_path = "/usr/bin/sudo_approve"
+        self.sudo_conf_path = "/etc/sudo.conf"
+        self.sudoers_path = "/etc/sudoers"
+        self.sudo_lib_path = "/usr/lib/sudo/sudo_pair.so"
         self.sudoers_bypass_path = "/etc/sudoers.d/91-bypass-sudopair-cmds"
-        self.user_prompt_path = '/etc/sudo_pair.prompt.user'
-        self.pair_prompt_path = '/etc/sudo_pair.prompt.pair'
-        self.socket_dir = '/var/run/sudo_pair'
-        self.tmpfiles_conf = '/usr/lib/tmpfiles.d/sudo_pair.conf'
-        self.owner = 'root'
-        self.group = 'root'
+        self.user_prompt_path = "/etc/sudo_pair.prompt.user"
+        self.pair_prompt_path = "/etc/sudo_pair.prompt.pair"
+        self.socket_dir = "/var/run/sudo_pair"
+        self.tmpfiles_conf = "/usr/lib/tmpfiles.d/sudo_pair.conf"
+        self.owner = "root"
+        self.group = "root"
         self.socket_dir_perms = 0o644
         self.sudo_pair_so_perms = 0o644
         self.prompt_perms = 0o644
@@ -68,12 +70,16 @@ class SudoPairHelper(object):
     def get_config(self):
         """Return config as a dict."""
         config = {
-            'binary_path': self.binary_path,
-            'user_prompt_path': self.user_prompt_path,
-            'pair_prompt_path': self.pair_prompt_path,
-            'socket_dir': self.socket_dir,
-            'gids_enforced': group_names_to_group_ids(self.charm_config['groups_enforced']),
-            'gids_exempted': group_names_to_group_ids(self.charm_config['groups_exempted']),
+            "binary_path": self.binary_path,
+            "user_prompt_path": self.user_prompt_path,
+            "pair_prompt_path": self.pair_prompt_path,
+            "socket_dir": self.socket_dir,
+            "gids_enforced": group_names_to_group_ids(
+                self.charm_config["groups_enforced"]
+            ),
+            "gids_exempted": group_names_to_group_ids(
+                self.charm_config["groups_exempted"]
+            ),
         }
 
         config.update(self.charm_config)
@@ -85,12 +91,23 @@ class SudoPairHelper(object):
 
     def render_sudo_conf(self):
         """Render sudo.conf file."""
-        return templating.render('sudo.conf.tmpl', self.sudo_conf_path, self.get_config(),
-                                 perms=self.sudo_conf_perms, owner=self.owner, group=self.group)
+        return templating.render(
+            "sudo.conf.tmpl",
+            self.sudo_conf_path,
+            self.get_config(),
+            perms=self.sudo_conf_perms,
+            owner=self.owner,
+            group=self.group,
+        )
 
     def create_socket_dir(self):
         """Create socket dir."""
-        host.mkdir(self.socket_dir, perms=self.socket_dir_perms, owner=self.owner, group=self.group)
+        host.mkdir(
+            self.socket_dir,
+            perms=self.socket_dir_perms,
+            owner=self.owner,
+            group=self.group,
+        )
 
     def create_tmpfiles_conf(self):
         """Create temporary conf file."""
@@ -99,36 +116,71 @@ class SudoPairHelper(object):
 
     def install_sudo_pair_so(self):
         """Install sudo-pair lib."""
-        sudo_pair_lib = os.path.join(hookenv.charm_dir(), 'files', 'sudo_pair.so')
-        copy_file(sudo_pair_lib, self.sudo_lib_path, self.owner, self.group, self.sudo_pair_so_perms)
+        sudo_pair_lib = os.path.join(hookenv.charm_dir(), "files", "sudo_pair.so")
+        copy_file(
+            sudo_pair_lib,
+            self.sudo_lib_path,
+            self.owner,
+            self.group,
+            self.sudo_pair_so_perms,
+        )
 
     def copy_user_prompt(self):
         """Copy user prompt on the unit."""
-        prompt_file = os.path.join(hookenv.charm_dir(), 'files', 'sudo.prompt.user')
-        copy_file(prompt_file, self.user_prompt_path, self.owner, self.group, self.prompt_perms)
+        prompt_file = os.path.join(hookenv.charm_dir(), "files", "sudo.prompt.user")
+        copy_file(
+            prompt_file,
+            self.user_prompt_path,
+            self.owner,
+            self.group,
+            self.prompt_perms,
+        )
 
     def copy_pair_prompt(self):
         """Copy pair prompt on the unit."""
-        prompt_file = os.path.join(hookenv.charm_dir(), 'files', 'sudo.prompt.pair')
-        copy_file(prompt_file, self.pair_prompt_path, self.owner, self.group, self.prompt_perms)
+        prompt_file = os.path.join(hookenv.charm_dir(), "files", "sudo.prompt.pair")
+        copy_file(
+            prompt_file,
+            self.pair_prompt_path,
+            self.owner,
+            self.group,
+            self.prompt_perms,
+        )
 
     def copy_sudoers(self):
         """Copy sudoers file on the unit."""
-        sudoers_file = os.path.join(hookenv.charm_dir(), 'files', 'sudoers')
-        copy_file(sudoers_file, self.sudoers_path, self.owner, self.group, self.sudoers_perms)
+        sudoers_file = os.path.join(hookenv.charm_dir(), "files", "sudoers")
+        copy_file(
+            sudoers_file, self.sudoers_path, self.owner, self.group, self.sudoers_perms
+        )
 
     def render_sudo_approve(self):
         """Render sudo-approve file."""
         hookenv.log("Rendering sudo_approve.tmpl to {}".format(self.binary_path))
-        return templating.render('sudo_approve.tmpl', self.binary_path, self.get_config(),
-                                 perms=self.sudo_approve_perms, owner=self.owner, group=self.group)
+        return templating.render(
+            "sudo_approve.tmpl",
+            self.binary_path,
+            self.get_config(),
+            perms=self.sudo_approve_perms,
+            owner=self.owner,
+            group=self.group,
+        )
 
     def render_bypass_cmds(self):
         """Render bypass command file."""
-        if self.get_config()['bypass_cmds'] != "" and self.get_config()['bypass_group'] != "":
+        if (
+            self.get_config()["bypass_cmds"] != ""
+            and self.get_config()["bypass_group"] != ""
+        ):
             hookenv.log("Render bypass cmds to {}".format(self.sudoers_bypass_path))
-            return templating.render('91-bypass-sudopair-cmds.tmpl', self.sudoers_bypass_path,
-                                     self.get_config(), perms=0o440, owner=self.owner, group=self.group)
+            return templating.render(
+                "91-bypass-sudopair-cmds.tmpl",
+                self.sudoers_bypass_path,
+                self.get_config(),
+                perms=0o440,
+                owner=self.owner,
+                group=self.group,
+            )
         return None
 
     def deconfigure(self):
@@ -140,7 +192,7 @@ class SudoPairHelper(object):
             self.user_prompt_path,
             self.pair_prompt_path,
             self.sudoers_bypass_path,
-            self.tmpfiles_conf
+            self.tmpfiles_conf,
         ]
         hookenv.log("Deleting: {}".format(paths))
         for path in paths:
@@ -148,4 +200,6 @@ class SudoPairHelper(object):
                 os.unlink(path)
             except Exception as e:
                 # We're trying hard to delete all files, even if some might fail
-                hookenv.log("Got exception unlinking {}: {}, continuing".format(path, e))
+                hookenv.log(
+                    "Got exception unlinking {}: {}, continuing".format(path, e)
+                )
diff --git a/src/reactive/sudo_pair.py b/src/reactive/sudo_pair.py
index 974dd66..ed1d7ba 100644
--- a/src/reactive/sudo_pair.py
+++ b/src/reactive/sudo_pair.py
@@ -7,10 +7,14 @@ from libsudopair import SudoPairHelper
 sph = SudoPairHelper()
 
 
-@when('apt.installed.socat')
-@when_not('sudo-pair.configured')
+@when("apt.installed.socat")
+@when_not("sudo-pair.configured")
 def install_sudo_pair():
-    # Install sudo_pair.so, create socket dir, copy sudo_approve to /usr/bin, copy prompts to /etc
+    """Install sudo pair.
+
+    Install sudo_pair.so, create socket dir, copy sudo_approve to /usr/bin
+    and copy prompts to /etc.
+    """
     sph.install_sudo_pair_so()
 
     sph.create_socket_dir()
@@ -32,18 +36,21 @@ def install_sudo_pair():
     # Add Plugin sudo_pair sudo_pair.so to sudo.conf
     sph.render_sudo_conf()
 
-    set_state('sudo-pair.installed')
-    set_state('sudo-pair.configured')
-    hookenv.status_set('active', 'sudo pairing for users groups: [{}]'.format(sph.get_config()['gids_enforced']))
+    set_state("sudo-pair.installed")
+    set_state("sudo-pair.configured")
+    hookenv.status_set(
+        "active",
+        "sudo pairing for users groups: [{}]".format(sph.get_config()["gids_enforced"]),
+    )
 
 
-@hook('config-changed')
+@hook("config-changed")
 def reconfigure_sudo_pair_charm():
     sph.set_charm_config(hookenv.config())
-    remove_state('sudo-pair.configured')
+    remove_state("sudo-pair.configured")
 
 
-@hook('stop')
+@hook("stop")
 def stop():
     sph.deconfigure()
-    remove_state('sudo-pair.installed')
+    remove_state("sudo-pair.installed")
diff --git a/src/tests/functional/conftest.py b/src/tests/functional/conftest.py
index 68f3ffe..7a8523e 100644
--- a/src/tests/functional/conftest.py
+++ b/src/tests/functional/conftest.py
@@ -16,7 +16,7 @@ import pytest
 STAT_FILE = "python3 -c \"import json; import os; s=os.stat('%s'); print(json.dumps({'uid': s.st_uid, 'gid': s.st_gid, 'mode': oct(s.st_mode), 'size': s.st_size}))\""  # noqa: E501
 
 
[e-mail]_fixture(scope='module')
[e-mail]_fixture(scope="module")
 def event_loop(request):
     """Override the default pytest event loop to allow for broaded scopedv fixtures."""
     loop = asyncio.get_event_loop_policy().new_event_loop()
@@ -27,7 +27,7 @@ def event_loop(request):
     asyncio.set_event_loop(None)
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def controller():
     """Connect to the current controller."""
     controller = Controller()
@@ -36,21 +36,21 @@ async def controller():
     await controller.disconnect()
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def model(controller):
     """Create a model that lives only for the duration of the test."""
     model_name = "functest-{}".format(uuid.uuid4())
     model = await controller.add_model(model_name)
     yield model
     await model.disconnect()
-    if os.getenv('PYTEST_KEEP_MODEL'):
+    if os.getenv("PYTEST_KEEP_MODEL"):
         return
     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 current_model():
     """Return the current model, does not create or destroy it."""
     model = Model()
@@ -62,29 +62,34 @@ async def current_model():
 @pytest.fixture
 async def get_app(model):
     """Return the application requested."""
+
     async def _get_app(name):
         try:
             return model.applications[name]
         except KeyError:
             raise JujuError("Cannot find application {}".format(name))
+
     return _get_app
 
 
 @pytest.fixture
 async def get_unit(model):
     """Return the requested <app_name>/<unit_number> unit."""
+
     async def _get_unit(name):
         try:
-            (app_name, unit_number) = name.split('/')
+            (app_name, unit_number) = name.split("/")
             return model.applications[app_name].units[unit_number]
         except (KeyError, ValueError):
             raise JujuError("Cannot find unit {}".format(name))
+
     return _get_unit
 
 
 @pytest.fixture
 async def get_entity(model, get_unit, get_app):
     """Return a unit or an application."""
+
     async def _get_entity(name):
         try:
             return await get_unit(name)
@@ -93,6 +98,7 @@ async def get_entity(model, get_unit, get_app):
                 return await get_app(name)
             except JujuError:
                 raise JujuError("Cannot find entity {}".format(name))
+
     return _get_entity
 
 
@@ -104,14 +110,12 @@ async def run_command(get_unit):
     :param cmd: Command to be run
     :param target: Unit object or unit name string
     """
+
     async def _run_command(cmd, target):
-        unit = (
-            target
-            if type(target) is juju.unit.Unit
-            else await get_unit(target)
-        )
+        unit = target if type(target) is juju.unit.Unit else await get_unit(target)
         action = await unit.run(cmd)
         return action.results
+
     return _run_command
 
 
@@ -123,10 +127,12 @@ async def file_stat(run_command):
     :param path: File path
     :param target: Unit object or unit name string
     """
+
     async def _file_stat(path, target):
         cmd = STAT_FILE % path
         results = await run_command(cmd, target)
-        return json.loads(results['Stdout'])
+        return json.loads(results["Stdout"])
+
     return _file_stat
 
 
@@ -138,16 +144,19 @@ async def file_contents(run_command):
     :param path: File path
     :param target: Unit object or unit name string
     """
+
     async def _file_contents(path, target):
-        cmd = 'cat {}'.format(path)
+        cmd = "cat {}".format(path)
         results = await run_command(cmd, target)
-        return results['Stdout']
+        return results["Stdout"]
+
     return _file_contents
 
 
 @pytest.fixture
 async def reconfigure_app(get_app, model):
     """Apply a different config to the requested app."""
+
     async def _reconfigure_app(cfg, target):
         application = (
             target
@@ -156,14 +165,17 @@ async def reconfigure_app(get_app, model):
         )
         await application.set_config(cfg)
         await application.get_config()
-        await model.block_until(lambda: application.status == 'active')
+        await model.block_until(lambda: application.status == "active")
+
     return _reconfigure_app
 
 
 @pytest.fixture
 async def create_group(run_command):
     """Create the UNIX group specified."""
+
     async def _create_group(group_name, target):
         cmd = "sudo groupadd %s" % group_name
         await run_command(cmd, target)
+
     return _create_group
diff --git a/src/tests/functional/test_deploy.py b/src/tests/functional/test_deploy.py
index 1d531d1..7f24224 100644
--- a/src/tests/functional/test_deploy.py
+++ b/src/tests/functional/test_deploy.py
@@ -117,7 +117,7 @@ async def test_sudoers_bypass_conf(file_contents, unit):
 
 
 async def test_reconfigure(reconfigure_app, file_contents, unit, app):
-    """Change a charm config parameter and verify that it has been propagated to the unit."""
+    """Change a charm config parameter and verify it is applied."""
     sudo_approve_path = "/usr/bin/sudo_approve"
     await reconfigure_app(cfg={"auto_approve": "false"}, target=app)
     sudo_approve_content = await file_contents(path=sudo_approve_path, target=unit)
diff --git a/src/tests/unit/conftest.py b/src/tests/unit/conftest.py
index c0800ea..9ca50ec 100644
--- a/src/tests/unit/conftest.py
+++ b/src/tests/unit/conftest.py
@@ -14,25 +14,26 @@ 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"]
 
         return cfg
 
-    monkeypatch.setattr('charmhelpers.core.hookenv.config', mock_config)
+    monkeypatch.setattr("charmhelpers.core.hookenv.config", mock_config)
 
 
 @pytest.fixture
 def mock_charm_dir(monkeypatch):
-    monkeypatch.setattr('charmhelpers.core.hookenv.charm_dir', lambda: '.')
+    monkeypatch.setattr("charmhelpers.core.hookenv.charm_dir", lambda: ".")
 
 
 @pytest.fixture
 def sph(mock_hookenv_config, mock_charm_dir, tmpdir):
     from libsudopair import SudoPairHelper
+
     sph = SudoPairHelper()
     sph.owner = pwd.getpwuid(os.getuid()).pw_name
     sph.group = grp.getgrgid(os.getgid()).gr_name
diff --git a/src/tests/unit/test_actions.py b/src/tests/unit/test_actions.py
index c2da297..d6d86d7 100644
--- a/src/tests/unit/test_actions.py
+++ b/src/tests/unit/test_actions.py
@@ -1,17 +1,18 @@
 import os
 import sys
 import unittest.mock as mock
-action_path = os.path.join(os.path.dirname(__file__), '..', '..', 'actions')
+
+action_path = os.path.join(os.path.dirname(__file__), "..", "..", "actions")
 sys.path.append(action_path)
-import actions # NOQA
+import actions  # NOQA
 
 
[e-mail]('libsudopair.SudoPairHelper')
[e-mail]('actions.action_set')
[e-mail]('actions.status_set')
[e-mail]("libsudopair.SudoPairHelper")
[e-mail]("actions.action_set")
[e-mail]("actions.status_set")
 def test_remove_action(status_set, action_set, sudo_pair_helper):
     actions.remove()
-    msg = 'Successfully removed sudo-pair config and binaries'
-    action_set.assert_called_with({'message': msg})
-    status_set.assert_called_with('active', msg)
+    msg = "Successfully removed sudo-pair config and binaries"
+    action_set.assert_called_with({"message": msg})
+    status_set.assert_called_with("active", msg)
     sudo_pair_helper().deconfigure.assert_called()
diff --git a/src/tests/unit/test_libsudopair.py b/src/tests/unit/test_libsudopair.py
index 3a598af..874f0a3 100644
--- a/src/tests/unit/test_libsudopair.py
+++ b/src/tests/unit/test_libsudopair.py
@@ -2,14 +2,11 @@ import filecmp
 import grp
 import os
 
-from libsudopair import (
-    check_valid_group,
-    group_id
-)
+from libsudopair import check_valid_group, group_id
 
 
 def test_check_valid_group():
-    assert not check_valid_group('fake_group')
+    assert not check_valid_group("fake_group")
     assert check_valid_group(grp.getgrgid(os.getgid()).gr_name)
 
 
@@ -17,7 +14,7 @@ def test_group_id():
     assert group_id(grp.getgrgid(os.getgid()).gr_name) == os.getgid()
 
 
-class TestSudoPairHelper():
+class TestSudoPairHelper:
     """Module to test SudoPairHelper lib."""
 
     def test_pytest(self):
@@ -31,12 +28,12 @@ class TestSudoPairHelper():
     def test_get_config(self, sph):
         """Check if config contains all the required entries."""
         default_keywords = [
-            'binary_path',
-            'user_prompt_path',
-            'pair_prompt_path',
-            'socket_dir',
-            'gids_enforced',
-            'gids_exempted',
+            "binary_path",
+            "user_prompt_path",
+            "pair_prompt_path",
+            "socket_dir",
+            "gids_enforced",
+            "gids_exempted",
         ]
         config = sph.get_config()
         for option in default_keywords:
@@ -45,11 +42,11 @@ class TestSudoPairHelper():
     def test_set_charm_config(self, sph):
         """Set new config."""
         charm_config = {
-            'groups_enforced': 'root',
-            'groups_exempted': '',
-            'bypass_cmds': '',
-            'bypass_group': '',
-            'auto_approve': True
+            "groups_enforced": "root",
+            "groups_exempted": "",
+            "bypass_cmds": "",
+            "bypass_group": "",
+            "auto_approve": True,
         }
 
         sph.set_charm_config(charm_config)
@@ -62,67 +59,79 @@ class TestSudoPairHelper():
         """Check that sudo.conf is rendered correctly."""
         # Default config
         content = sph.render_sudo_conf()
-        expected_content = 'Plugin sudo_pair sudo_pair.so binary_path={} ' \
-                           'user_prompt_path={} ' \
-                           'pair_prompt_path={} socket_dir={} gids_enforced={}'.format(
-                               tmpdir.join('/usr/bin/sudo_approve'),
-                               tmpdir.join('/etc/sudo_pair.prompt.user'),
-                               tmpdir.join('/etc/sudo_pair.prompt.pair'),
-                               tmpdir.join('/var/run/sudo_pair'),
-                               '0')
+        expected_content = (
+            "Plugin sudo_pair sudo_pair.so binary_path={} "
+            "user_prompt_path={} "
+            "pair_prompt_path={} socket_dir={} gids_enforced={}".format(
+                tmpdir.join("/usr/bin/sudo_approve"),
+                tmpdir.join("/etc/sudo_pair.prompt.user"),
+                tmpdir.join("/etc/sudo_pair.prompt.pair"),
+                tmpdir.join("/var/run/sudo_pair"),
+                "0",
+            )
+        )
         assert expected_content in content
 
         # Gid exempted
         groups_exempted = grp.getgrgid(os.getgid()).gr_name
         charm_config = {
-            'groups_enforced': 'root',
-            'groups_exempted': groups_exempted,
-            'bypass_cmds': '',
-            'bypass_group': '',
-            'auto_approve': True
+            "groups_enforced": "root",
+            "groups_exempted": groups_exempted,
+            "bypass_cmds": "",
+            "bypass_group": "",
+            "auto_approve": True,
         }
 
         sph.set_charm_config(charm_config)
-        expected_content = \
-            'Plugin sudo_pair sudo_pair.so binary_path={} user_prompt_path={} ' \
-            'pair_prompt_path={} socket_dir={} gids_enforced={} gids_exempted={}'.format(
-                tmpdir.join('/usr/bin/sudo_approve'),
-                tmpdir.join('/etc/sudo_pair.prompt.user'),
-                tmpdir.join('/etc/sudo_pair.prompt.pair'),
-                tmpdir.join('/var/run/sudo_pair'), '0', os.getgid())
+        expected_content = (
+            "Plugin sudo_pair sudo_pair.so binary_path={} user_prompt_path={} "
+            "pair_prompt_path={} socket_dir={} gids_enforced={} "
+            "gids_exempted={}".format(
+                tmpdir.join("/usr/bin/sudo_approve"),
+                tmpdir.join("/etc/sudo_pair.prompt.user"),
+                tmpdir.join("/etc/sudo_pair.prompt.pair"),
+                tmpdir.join("/var/run/sudo_pair"),
+                "0",
+                os.getgid(),
+            )
+        )
 
         content = sph.render_sudo_conf()
         assert expected_content in content
 
         # Groups enforced
-        groups_enforced = 'root,' + grp.getgrgid(os.getgid()).gr_name
+        groups_enforced = "root," + grp.getgrgid(os.getgid()).gr_name
         charm_config = {
-            'groups_enforced': groups_enforced,
-            'groups_exempted': '',
-            'bypass_cmds': '',
-            'bypass_group': '',
-            'auto_approve': True
+            "groups_enforced": groups_enforced,
+            "groups_exempted": "",
+            "bypass_cmds": "",
+            "bypass_group": "",
+            "auto_approve": True,
         }
         sph.set_charm_config(charm_config)
-        expected_content = 'Plugin sudo_pair sudo_pair.so binary_path={} user_prompt_path={} ' \
-                           'pair_prompt_path={} socket_dir={} gids_enforced={}'.format(
-                               tmpdir.join('/usr/bin/sudo_approve'),
-                               tmpdir.join('/etc/sudo_pair.prompt.user'),
-                               tmpdir.join('/etc/sudo_pair.prompt.pair'),
-                               tmpdir.join('/var/run/sudo_pair'), '0,{}'.format(os.getgid()))
+        expected_content = (
+            "Plugin sudo_pair sudo_pair.so binary_path={} user_prompt_path={} "
+            "pair_prompt_path={} socket_dir={} gids_enforced={}".format(
+                tmpdir.join("/usr/bin/sudo_approve"),
+                tmpdir.join("/etc/sudo_pair.prompt.user"),
+                tmpdir.join("/etc/sudo_pair.prompt.pair"),
+                tmpdir.join("/var/run/sudo_pair"),
+                "0,{}".format(os.getgid()),
+            )
+        )
         content = sph.render_sudo_conf()
         assert expected_content in content
 
     def test_render_bypass_cmds(self, sph):
         """Check that sudoers file is rendered correctly."""
         # Root bypass /bin/ls
-        expected_content = '%root ALL = (ALL) NOLOG_OUTPUT: /bin/ls'
+        expected_content = "%root ALL = (ALL) NOLOG_OUTPUT: /bin/ls"
         charm_config = {
-            'groups_enforced': 'root',
-            'groups_exempted': '',
-            'bypass_cmds': '/bin/ls',
-            'bypass_group': 'root',
-            'auto_approve': True
+            "groups_enforced": "root",
+            "groups_exempted": "",
+            "bypass_cmds": "/bin/ls",
+            "bypass_group": "root",
+            "auto_approve": True,
         }
         sph.set_charm_config(charm_config)
         content = sph.render_bypass_cmds()
@@ -131,9 +140,11 @@ class TestSudoPairHelper():
     def test_render_sudo_approve(self, sph, tmpdir):
         """Check that sudo_approve file is rendered correctly."""
         # Auto Approve true
-        expected_content = 'echo ${log_line} >> /var/log/sudo_pair.log'
-        socket_dir = tmpdir.join('/var/run/sudo_pair')
-        expected_content_socket_dir = 'declare -r SUDO_SOCKET_PATH="{}"'.format(socket_dir)
+        expected_content = "echo ${log_line} >> /var/log/sudo_pair.log"
+        socket_dir = tmpdir.join("/var/run/sudo_pair")
+        expected_content_socket_dir = 'declare -r SUDO_SOCKET_PATH="{}"'.format(
+            socket_dir
+        )
         content = sph.render_sudo_approve()
         assert expected_content in content
         assert expected_content_socket_dir in content
@@ -141,11 +152,11 @@ class TestSudoPairHelper():
         # Auto Approve false
         expected_content = 'echo "You can\'t approve your own session."'
         charm_config = {
-            'groups_enforced': 'root',
-            'groups_exempted': '',
-            'bypass_cmds': '/bin/ls',
-            'bypass_group': 'root',
-            'auto_approve': False
+            "groups_enforced": "root",
+            "groups_exempted": "",
+            "bypass_cmds": "/bin/ls",
+            "bypass_group": "root",
+            "auto_approve": False,
         }
         sph.set_charm_config(charm_config)
         content = sph.render_sudo_approve()
@@ -154,32 +165,38 @@ class TestSudoPairHelper():
     def test_create_socket_dir(self, sph, tmpdir):
         """Check that sudo_pair socket dir exists."""
         sph.create_socket_dir()
-        assert os.path.exists(tmpdir.join('/var/run/sudo_pair'))
+        assert os.path.exists(tmpdir.join("/var/run/sudo_pair"))
 
     def test_create_tmpfiles_conf(self, sph, tmpdir):
         """Check that sudo pair temporary conf is rendered correctly."""
         sph.create_tmpfiles_conf()
-        expected_content = 'd {} 0755 - - -\n'.format(sph.socket_dir)
-        with open(tmpdir.join('/usr/lib/tmpfiles.d/sudo_pair.conf')) as f:
+        expected_content = "d {} 0755 - - -\n".format(sph.socket_dir)
+        with open(tmpdir.join("/usr/lib/tmpfiles.d/sudo_pair.conf")) as f:
             content = f.read()
         assert expected_content in content
 
     def test_install_sudo_pair_so(self, sph, tmpdir):
         """Check that sudo system lib exists."""
         sph.install_sudo_pair_so()
-        assert filecmp.cmp('./files/sudo_pair.so', tmpdir.join('/usr/lib/sudo/sudo_pair.so'))
+        assert filecmp.cmp(
+            "./files/sudo_pair.so", tmpdir.join("/usr/lib/sudo/sudo_pair.so")
+        )
 
     def test_copy_user_prompt(self, sph, tmpdir):
         """Check that user prompt exists."""
         sph.copy_user_prompt()
-        assert filecmp.cmp('./files/sudo.prompt.user', tmpdir.join('/etc/sudo_pair.prompt.user'))
+        assert filecmp.cmp(
+            "./files/sudo.prompt.user", tmpdir.join("/etc/sudo_pair.prompt.user")
+        )
 
     def test_copy_pair_prompt(self, sph, tmpdir):
         """Check that pair prompt exists."""
         sph.copy_pair_prompt()
-        assert filecmp.cmp('./files/sudo.prompt.pair', tmpdir.join('/etc/sudo_pair.prompt.pair'))
+        assert filecmp.cmp(
+            "./files/sudo.prompt.pair", tmpdir.join("/etc/sudo_pair.prompt.pair")
+        )
 
     def test_copy_sudoers(self, sph, tmpdir):
         """Check that sudoers file exists."""
         sph.copy_sudoers()
-        assert filecmp.cmp('./files/sudoers', tmpdir.join('/etc/sudoers'))
+        assert filecmp.cmp("./files/sudoers", tmpdir.join("/etc/sudoers"))
diff --git a/src/tox.ini b/src/tox.ini
index d07b692..2085ea9 100644
--- a/src/tox.ini
+++ b/src/tox.ini
@@ -25,7 +25,7 @@ passenv =
 [testenv:lint]
 commands =
     flake8
-#TODO    black --check --exclude "/(\.eggs|\.git|\.tox|\.venv|\.build|dist|charmhelpers|mod)/" .
+    black --check --exclude "/(\.eggs|\.git|\.tox|\.venv|\.build|dist|charmhelpers|mod)/" .
 deps =
     black
     flake8
@@ -43,8 +43,7 @@ exclude =
     mod,
     .build
 
-max-line-length = 120
-#TODO max-line-length = 88
+max-line-length = 88
 max-complexity = 10
 
 [testenv:black]