diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 14024de73..766d801bb 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -29,6 +29,12 @@ repos:
     hooks:
       - id: remove-tabs
         exclude: '.*\.(svg)$'
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.1
+    hooks:
+      - id: ruff-check
+        args: ['--fix', '--unsafe-fixes']
+      - id: ruff-format
   - repo: https://opendev.org/openstack/hacking
     rev: 7.0.0
     hooks:
@@ -40,16 +46,6 @@ repos:
     hooks:
       - id: bandit
         args: ['-c', 'pyproject.toml']
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.1
-    hooks:
-      - id: ruff-check
-        args: ['--fix', '--unsafe-fixes']
-  - repo: https://github.com/hhatto/autopep8
-    rev: v2.3.2
-    hooks:
-      - id: autopep8
-        files: '^.*\.py$'
   - repo: https://github.com/codespell-project/codespell
     rev: v2.4.1
     hooks:
diff --git a/api-ref/source/conf.py b/api-ref/source/conf.py
index 177107174..e98853c99 100644
--- a/api-ref/source/conf.py
+++ b/api-ref/source/conf.py
@@ -22,10 +22,7 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-extensions = [
-    'openstackdocstheme',
-    'os_api_ref',
-]
+extensions = ['openstackdocstheme', 'os_api_ref']
 
 # -- General configuration ----------------------------------------------------
 
@@ -60,9 +57,7 @@ html_theme = 'openstackdocs'
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-html_theme_options = {
-    "sidebar_mode": "toc",
-}
+html_theme_options = {"sidebar_mode": "toc"}
 
 # -- Options for LaTeX output -------------------------------------------------
 
@@ -70,6 +65,11 @@ html_theme_options = {
 # (source start file, target name, title, author, documentclass
 # [howto/manual]).
 latex_documents = [
-    ('index', 'Watcher.tex', 'Infrastructure Optimization API Reference',
-     'OpenStack Foundation', 'manual'),
+    (
+        'index',
+        'Watcher.tex',
+        'Infrastructure Optimization API Reference',
+        'OpenStack Foundation',
+        'manual',
+    )
 ]
diff --git a/doc/ext/term.py b/doc/ext/term.py
index a882d59d5..f157774bf 100644
--- a/doc/ext/term.py
+++ b/doc/ext/term.py
@@ -24,12 +24,29 @@ from watcher.version import version_string
 
 
 class BaseWatcherDirective(rst.Directive):
-
-    def __init__(self, name, arguments, options, content, lineno,
-                 content_offset, block_text, state, state_machine):
+    def __init__(
+        self,
+        name,
+        arguments,
+        options,
+        content,
+        lineno,
+        content_offset,
+        block_text,
+        state,
+        state_machine,
+    ):
         super().__init__(
-            name, arguments, options, content, lineno,
-            content_offset, block_text, state, state_machine)
+            name,
+            arguments,
+            options,
+            content,
+            lineno,
+            content_offset,
+            block_text,
+            state,
+            state_machine,
+        )
         self.result = statemachine.ViewList()
 
     def run(self):
@@ -143,7 +160,8 @@ class WatcherFunc(BaseWatcherDirective):
             error = self.state_machine.reporter.error(
                 f'The "{self.name}" directive is empty; content required.',
                 nodes.literal_block(self.block_text, self.block_text),
-                line=self.lineno)
+                line=self.lineno,
+            )
             return [error]
 
         func_path = self.content[0]
@@ -164,8 +182,9 @@ class WatcherFunc(BaseWatcherDirective):
         self.add_textblock(textblock)
 
         try:
-            node_class = getattr(nodes,
-                                 self.options.get('format', 'paragraph'))
+            node_class = getattr(
+                nodes, self.options.get('format', 'paragraph')
+            )
         except Exception as exc:
             raise self.error(exc)
 
diff --git a/doc/ext/versioned_notifications.py b/doc/ext/versioned_notifications.py
index 96633efcf..73d456ebd 100644
--- a/doc/ext/versioned_notifications.py
+++ b/doc/ext/versioned_notifications.py
@@ -28,7 +28,6 @@ from watcher.objects import base
 
 
 class VersionedNotificationDirective(Directive):
-
     SAMPLE_ROOT = 'doc/notification_samples/'
     TOGGLE_SCRIPT = """
 <script>
@@ -51,15 +50,16 @@ jQuery(document).ready(function(){
         ovos = base.WatcherObjectRegistry.obj_classes()
         for name, cls in ovos.items():
             cls = cls[0]
-            if (issubclass(cls, notification.NotificationBase) and
-                    cls != notification.NotificationBase):
-
+            if (
+                issubclass(cls, notification.NotificationBase)
+                and cls != notification.NotificationBase
+            ):
                 payload_name = cls.fields['payload'].objname
                 payload_cls = ovos[payload_name][0]
                 for sample in cls.samples:
-                    notifications.append((cls.__name__,
-                                          payload_cls.__name__,
-                                          sample))
+                    notifications.append(
+                        (cls.__name__, payload_cls.__name__, sample)
+                    )
         return sorted(notifications)
 
     def _build_markup(self, notifications):
@@ -90,7 +90,7 @@ jQuery(document).ready(function(){
 
         # fill the table content, one notification per row
         for name, payload, sample_file in notifications:
-            event_type = sample_file[0: -5].replace('-', '.')
+            event_type = sample_file[0:-5].replace('-', '.')
 
             row = nodes.row()
             body.append(row)
@@ -115,11 +115,15 @@ jQuery(document).ready(function(){
             with open(self.SAMPLE_ROOT + sample_file) as f:
                 sample_content = f.read()
 
-            event_type = sample_file[0: -5]
-            html_str = self.TOGGLE_SCRIPT % ((event_type, ) * 3)
-            html_str += (f"<input type='button' id='{event_type}-hideshow' "
-                         "value='hide/show sample'>")
-            html_str += (f"<div id='{event_type}-div'><pre>{sample_content}</pre></div>")
+            event_type = sample_file[0:-5]
+            html_str = self.TOGGLE_SCRIPT % ((event_type,) * 3)
+            html_str += (
+                f"<input type='button' id='{event_type}-hideshow' "
+                "value='hide/show sample'>"
+            )
+            html_str += (
+                f"<div id='{event_type}-div'><pre>{sample_content}</pre></div>"
+            )
 
             raw = nodes.raw('', html_str, format="html")
             col.append(raw)
@@ -128,5 +132,6 @@ jQuery(document).ready(function(){
 
 
 def setup(app):
-    app.add_directive('versioned_notifications',
-                      VersionedNotificationDirective)
+    app.add_directive(
+        'versioned_notifications', VersionedNotificationDirective
+    )
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 0efceacb1..3015217b5 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -45,9 +45,9 @@ extensions = [
 ]
 
 wsme_protocols = ['restjson']
-config_generator_config_file = [(
-    '../../etc/watcher/oslo-config-generator/watcher.conf',
-    '_static/watcher')]
+config_generator_config_file = [
+    ('../../etc/watcher/oslo-config-generator/watcher.conf', '_static/watcher')
+]
 sample_config_basename = 'watcher'
 
 # The suffix of source filenames.
@@ -92,14 +92,28 @@ pygments_style = 'native'
 # List of tuples 'sourcefile', 'target', u'title', u'Authors name', 'manual'
 
 man_pages = [
-    ('man/watcher-api', 'watcher-api', 'Watcher API Server',
-     ['OpenStack'], 1),
-    ('man/watcher-applier', 'watcher-applier', 'Watcher Applier',
-     ['OpenStack'], 1),
-    ('man/watcher-db-manage', 'watcher-db-manage',
-     'Watcher Db Management Utility', ['OpenStack'], 1),
-    ('man/watcher-decision-engine', 'watcher-decision-engine',
-     'Watcher Decision Engine', ['OpenStack'], 1),
+    ('man/watcher-api', 'watcher-api', 'Watcher API Server', ['OpenStack'], 1),
+    (
+        'man/watcher-applier',
+        'watcher-applier',
+        'Watcher Applier',
+        ['OpenStack'],
+        1,
+    ),
+    (
+        'man/watcher-db-manage',
+        'watcher-db-manage',
+        'Watcher Db Management Utility',
+        ['OpenStack'],
+        1,
+    ),
+    (
+        'man/watcher-decision-engine',
+        'watcher-decision-engine',
+        'Watcher Decision Engine',
+        ['OpenStack'],
+        1,
+    ),
 ]
 
 # -- Options for HTML output --------------------------------------------------
@@ -127,10 +141,13 @@ openstackdocs_bug_tag = ''
 # (source start file, target name, title, author, documentclass
 # [howto/manual]).
 latex_documents = [
-    ('index',
-     'doc-watcher.tex',
-     'Watcher Documentation',
-     'OpenStack Foundation', 'manual'),
+    (
+        'index',
+        'doc-watcher.tex',
+        'Watcher Documentation',
+        'OpenStack Foundation',
+        'manual',
+    )
 ]
 
 # If false, no module index is generated.
diff --git a/releasenotes/source/conf.py b/releasenotes/source/conf.py
index a8c15c7c3..d708d4a15 100644
--- a/releasenotes/source/conf.py
+++ b/releasenotes/source/conf.py
@@ -35,8 +35,7 @@
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['reno.sphinxext',
-              'openstackdocstheme']
+extensions = ['reno.sphinxext', 'openstackdocstheme']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -183,10 +182,8 @@ htmlhelp_basename = 'watcherdoc'
 latex_elements = {
     # The paper size ('letterpaper' or 'a4paper').
     # 'papersize': 'letterpaper',
-
     # The font size ('10pt', '11pt' or '12pt').
     # 'pointsize': '10pt',
-
     # Additional stuff for the LaTeX preamble.
     # 'preamble': '',
 }
@@ -194,8 +191,13 @@ latex_elements = {
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual])
 latex_documents = [
-    ('index', 'watcher.tex', 'Watcher Documentation',
-     'Watcher developers', 'manual'),
+    (
+        'index',
+        'watcher.tex',
+        'Watcher Documentation',
+        'Watcher developers',
+        'manual',
+    )
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -224,8 +226,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'watcher', 'Watcher Documentation',
-     ['Watcher developers'], 1)
+    ('index', 'watcher', 'Watcher Documentation', ['Watcher developers'], 1)
 ]
 
 # If true, show URL addresses after external links.
@@ -238,9 +239,15 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    ('index', 'watcher', 'Watcher Documentation',
-     'Watcher developers', 'watcher', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        'index',
+        'watcher',
+        'Watcher Documentation',
+        'Watcher developers',
+        'watcher',
+        'One line description of project.',
+        'Miscellaneous',
+    )
 ]
 
 # Documents to append as an appendix to all manuals.
diff --git a/setup.py b/setup.py
index 0fa6510d8..4cb14e180 100644
--- a/setup.py
+++ b/setup.py
@@ -16,6 +16,4 @@
 import setuptools
 
 
-setuptools.setup(
-    setup_requires=['pbr>=2.0.0'],
-    pbr=True)
+setuptools.setup(setup_requires=['pbr>=2.0.0'], pbr=True)
diff --git a/tox.ini b/tox.ini
index 0f332f006..30fa9dbaa 100644
--- a/tox.ini
+++ b/tox.ini
@@ -134,11 +134,12 @@ commands =
 [flake8]
 filename = *.py,app.wsgi
 show-source=True
+select = H,N
 # W504 line break after binary operator
 # H301 one import per line incorrectly triggers when
 # imports need to be wrapped in () due to line length
 # H306 ruff handles imports
-ignore= H105,E123,E226,N320,H202,W504,W503,H306,H301
+ignore= H105,H202,H306,H301,N320
 builtins= _
 enable-extensions = H106,H203,H904
 exclude=.venv,.git,.tox,dist,doc,*lib/python*,*egg,build,*sqlalchemy/alembic/versions/*,demo/,releasenotes
diff --git a/watcher/api/acl.py b/watcher/api/acl.py
index 621e254a2..06b1a83aa 100644
--- a/watcher/api/acl.py
+++ b/watcher/api/acl.py
@@ -36,6 +36,8 @@ def install(app, conf, public_routes):
     """
     if not CONF.get('enable_authentication'):
         return app
-    return auth_token.AuthTokenMiddleware(app,
-                                          conf=dict(conf.keystone_authtoken),
-                                          public_api_routes=public_routes)
+    return auth_token.AuthTokenMiddleware(
+        app,
+        conf=dict(conf.keystone_authtoken),
+        public_api_routes=public_routes,
+    )
diff --git a/watcher/api/app.py b/watcher/api/app.py
index 90abca09b..972355052 100644
--- a/watcher/api/app.py
+++ b/watcher/api/app.py
@@ -46,7 +46,7 @@ def setup_app(config=None):
         logging=getattr(config, 'logging', {}),
         debug=CONF.debug,
         wrap_app=_wrap_app,
-        **app_conf
+        **app_conf,
     )
 
     return acl.install(app, CONF, config.app.acl_public_routes)
diff --git a/watcher/api/app.wsgi b/watcher/api/app.wsgi
index 9ca4db4d9..33e194efe 100644
--- a/watcher/api/app.wsgi
+++ b/watcher/api/app.wsgi
@@ -15,7 +15,6 @@
 Use this file for deploying the API service under Apache2 mod_wsgi.
 """
 
-
 # This script is deprecated and it will be removed in U release.
 # Please switch to automatically generated watcher-api-wsgi script instead.
 from watcher.api import wsgi
diff --git a/watcher/api/config.py b/watcher/api/config.py
index d0a071538..876aebce3 100644
--- a/watcher/api/config.py
+++ b/watcher/api/config.py
@@ -19,10 +19,7 @@ from watcher.api import hooks
 
 # Server Specific Configurations
 # See https://pecan.readthedocs.org/en/latest/configuration.html#server-configuration # noqa
-server = {
-    'port': '9322',
-    'host': '127.0.0.1'
-}
+server = {'port': '9322', 'host': '127.0.0.1'}
 
 # Pecan Application Configurations
 # See https://pecan.readthedocs.org/en/latest/configuration.html#application-configuration # noqa
@@ -33,10 +30,7 @@ if not cfg.CONF.api.get("enable_webhooks_auth"):
 app = {
     'root': 'watcher.api.controllers.root.RootController',
     'modules': ['watcher.api'],
-    'hooks': [
-        hooks.ContextHook(),
-        hooks.NoExceptionTracebackHook(),
-    ],
+    'hooks': [hooks.ContextHook(), hooks.NoExceptionTracebackHook()],
     'static_root': '%(confdir)s/public',
     'enable_acl': True,
     'acl_public_routes': acl_public_routes,
@@ -44,12 +38,6 @@ app = {
 
 # WSME Configurations
 # See https://wsme.readthedocs.org/en/latest/integrate.html#configuration
-wsme = {
-    'debug': cfg.CONF.get("debug") if "debug" in cfg.CONF else False,
-}
+wsme = {'debug': cfg.CONF.get("debug") if "debug" in cfg.CONF else False}
 
-PECAN_CONFIG = {
-    "server": server,
-    "app": app,
-    "wsme": wsme,
-}
+PECAN_CONFIG = {"server": server, "app": app, "wsme": wsme}
diff --git a/watcher/api/controllers/base.py b/watcher/api/controllers/base.py
index 91e4e0906..49a6b11ca 100644
--- a/watcher/api/controllers/base.py
+++ b/watcher/api/controllers/base.py
@@ -23,7 +23,6 @@ from wsme import types as wtypes
 
 
 class APIBase(wtypes.Base):
-
     created_at = wsme.wsattr(datetime.datetime, readonly=True)
     """The time in UTC at which the object is created"""
 
@@ -35,10 +34,11 @@ class APIBase(wtypes.Base):
 
     def as_dict(self):
         """Render this object as a dict of its fields."""
-        return {k: getattr(self, k)
-                for k in self.fields
-                if hasattr(self, k) and
-                getattr(self, k) != wsme.Unset}
+        return {
+            k: getattr(self, k)
+            for k in self.fields
+            if hasattr(self, k) and getattr(self, k) != wsme.Unset
+        }
 
     def unset_fields_except(self, except_list=None):
         """Unset fields so they don't appear in the message body.
@@ -77,7 +77,8 @@ class Version:
 
         """
         (self.major, self.minor) = Version.parse_headers(
-            headers, default_version, latest_version)
+            headers, default_version, latest_version
+        )
 
     def __repr__(self):
         return f'{self.major}.{self.minor}'
@@ -94,8 +95,8 @@ class Version:
 
         """
         version_str = microversion_parse.get_version(
-            headers,
-            service_type='infra-optim')
+            headers, service_type='infra-optim'
+        )
 
         minimal_version = (1, 0)
 
@@ -122,7 +123,8 @@ class Version:
 
         if len(version) != 2:
             raise exc.HTTPNotAcceptable(
-                f"Invalid value for {Version.string} header")
+                f"Invalid value for {Version.string} header"
+            )
         return version
 
     def __gt__(self, other):
diff --git a/watcher/api/controllers/link.py b/watcher/api/controllers/link.py
index d024cb45d..a7dad4edc 100644
--- a/watcher/api/controllers/link.py
+++ b/watcher/api/controllers/link.py
@@ -46,15 +46,24 @@ class Link(base.APIBase):
     """Indicates the type of document/link."""
 
     @staticmethod
-    def make_link(rel_name, url, resource, resource_args,
-                  bookmark=False, type=wtypes.Unset):
-        href = build_url(resource, resource_args,
-                         bookmark=bookmark, base_url=url)
+    def make_link(
+        rel_name,
+        url,
+        resource,
+        resource_args,
+        bookmark=False,
+        type=wtypes.Unset,
+    ):
+        href = build_url(
+            resource, resource_args, bookmark=bookmark, base_url=url
+        )
         return Link(href=href, rel=rel_name, type=type)
 
     @classmethod
     def sample(cls):
-        sample = cls(href="http://localhost:6385/chassis/"
-                          "eaaca217-e7d8-47b4-bb41-3f99f20eed89",
-                     rel="bookmark")
+        sample = cls(
+            href="http://localhost:6385/chassis/"
+            "eaaca217-e7d8-47b4-bb41-3f99f20eed89",
+            rel="bookmark",
+        )
         return sample
diff --git a/watcher/api/controllers/root.py b/watcher/api/controllers/root.py
index aaa22bff6..fa4439f1d 100644
--- a/watcher/api/controllers/root.py
+++ b/watcher/api/controllers/root.py
@@ -59,14 +59,15 @@ class Version(base.APIBase):
         version.status = status
         version.max_version = v.max_version_string()
         version.min_version = v.min_version_string()
-        version.links = [link.Link.make_link('self',
-                                             pecan.request.application_url,
-                                             id, '', bookmark=True)]
+        version.links = [
+            link.Link.make_link(
+                'self', pecan.request.application_url, id, '', bookmark=True
+            )
+        ]
         return version
 
 
 class Root(base.APIBase):
-
     name = wtypes.text
     """The name of the API"""
 
@@ -83,16 +84,17 @@ class Root(base.APIBase):
     def convert():
         root = Root()
         root.name = "OpenStack Watcher API"
-        root.description = ("Watcher is an OpenStack project which aims to "
-                            "improve physical resources usage through "
-                            "better VM placement.")
+        root.description = (
+            "Watcher is an OpenStack project which aims to "
+            "improve physical resources usage through "
+            "better VM placement."
+        )
         root.versions = [Version.convert('v1')]
         root.default_version = Version.convert('v1')
         return root
 
 
 class RootController(rest.RestController):
-
     _versions = ['v1']
     """All supported API versions"""
 
diff --git a/watcher/api/controllers/v1/__init__.py b/watcher/api/controllers/v1/__init__.py
index cc8a76914..6f425f372 100644
--- a/watcher/api/controllers/v1/__init__.py
+++ b/watcher/api/controllers/v1/__init__.py
@@ -47,20 +47,29 @@ from watcher.api.controllers.v1 import webhooks
 
 def min_version():
     return base.Version(
-        {base.Version.string: ' '.join([versions.service_type_string(),
-                                        versions.min_version_string()])},
-        versions.min_version_string(), versions.max_version_string())
+        {
+            base.Version.string: ' '.join(
+                [versions.service_type_string(), versions.min_version_string()]
+            )
+        },
+        versions.min_version_string(),
+        versions.max_version_string(),
+    )
 
 
 def max_version():
     return base.Version(
-        {base.Version.string: ' '.join([versions.service_type_string(),
-                                        versions.max_version_string()])},
-        versions.min_version_string(), versions.max_version_string())
+        {
+            base.Version.string: ' '.join(
+                [versions.service_type_string(), versions.max_version_string()]
+            )
+        },
+        versions.min_version_string(),
+        versions.max_version_string(),
+    )
 
 
 class APIBase(wtypes.Base):
-
     created_at = wsme.wsattr(datetime.datetime, readonly=True)
     """The time in UTC at which the object is created"""
 
@@ -72,10 +81,11 @@ class APIBase(wtypes.Base):
 
     def as_dict(self):
         """Render this object as a dict of its fields."""
-        return {k: getattr(self, k)
-                for k in self.fields
-                if hasattr(self, k) and
-                getattr(self, k) != wsme.Unset}
+        return {
+            k: getattr(self, k)
+            for k in self.fields
+            if hasattr(self, k) and getattr(self, k) != wsme.Unset
+        }
 
     def unset_fields_except(self, except_list=None):
         """Unset fields so they don't appear in the message body.
@@ -143,77 +153,74 @@ class V1(APIBase):
         v1 = V1()
         v1.id = "v1"
         base_url = pecan.request.application_url
-        v1.links = [link.Link.make_link('self', base_url,
-                                        'v1', '', bookmark=True),
-                    link.Link.make_link('describedby',
-                                        'http://docs.openstack.org',
-                                        'developer/watcher/dev',
-                                        'api-spec-v1.html',
-                                        bookmark=True, type='text/html')
-                    ]
-        v1.media_types = [MediaType('application/json',
-                          'application/vnd.openstack.watcher.v1+json')]
-        v1.audit_templates = [link.Link.make_link('self',
-                                                  base_url,
-                                                  'audit_templates', ''),
-                              link.Link.make_link('bookmark',
-                                                  base_url,
-                                                  'audit_templates', '',
-                                                  bookmark=True)
-                              ]
-        v1.audits = [link.Link.make_link('self', base_url,
-                                         'audits', ''),
-                     link.Link.make_link('bookmark',
-                                         base_url,
-                                         'audits', '',
-                                         bookmark=True)
-                     ]
+        v1.links = [
+            link.Link.make_link('self', base_url, 'v1', '', bookmark=True),
+            link.Link.make_link(
+                'describedby',
+                'http://docs.openstack.org',
+                'developer/watcher/dev',
+                'api-spec-v1.html',
+                bookmark=True,
+                type='text/html',
+            ),
+        ]
+        v1.media_types = [
+            MediaType(
+                'application/json', 'application/vnd.openstack.watcher.v1+json'
+            )
+        ]
+        v1.audit_templates = [
+            link.Link.make_link('self', base_url, 'audit_templates', ''),
+            link.Link.make_link(
+                'bookmark', base_url, 'audit_templates', '', bookmark=True
+            ),
+        ]
+        v1.audits = [
+            link.Link.make_link('self', base_url, 'audits', ''),
+            link.Link.make_link(
+                'bookmark', base_url, 'audits', '', bookmark=True
+            ),
+        ]
         if utils.allow_list_datamodel():
-            v1.data_model = [link.Link.make_link('self', base_url,
-                                                 'data_model', ''),
-                             link.Link.make_link('bookmark',
-                                                 base_url,
-                                                 'data_model', '',
-                                                 bookmark=True)
-                             ]
-        v1.actions = [link.Link.make_link('self', base_url,
-                                          'actions', ''),
-                      link.Link.make_link('bookmark',
-                                          base_url,
-                                          'actions', '',
-                                          bookmark=True)
-                      ]
-        v1.action_plans = [link.Link.make_link(
-            'self', base_url, 'action_plans', ''),
-            link.Link.make_link('bookmark',
-                                base_url,
-                                'action_plans', '',
-                                bookmark=True)
+            v1.data_model = [
+                link.Link.make_link('self', base_url, 'data_model', ''),
+                link.Link.make_link(
+                    'bookmark', base_url, 'data_model', '', bookmark=True
+                ),
             ]
+        v1.actions = [
+            link.Link.make_link('self', base_url, 'actions', ''),
+            link.Link.make_link(
+                'bookmark', base_url, 'actions', '', bookmark=True
+            ),
+        ]
+        v1.action_plans = [
+            link.Link.make_link('self', base_url, 'action_plans', ''),
+            link.Link.make_link(
+                'bookmark', base_url, 'action_plans', '', bookmark=True
+            ),
+        ]
 
-        v1.scoring_engines = [link.Link.make_link(
-            'self', base_url, 'scoring_engines', ''),
-            link.Link.make_link('bookmark',
-                                base_url,
-                                'scoring_engines', '',
-                                bookmark=True)
-            ]
+        v1.scoring_engines = [
+            link.Link.make_link('self', base_url, 'scoring_engines', ''),
+            link.Link.make_link(
+                'bookmark', base_url, 'scoring_engines', '', bookmark=True
+            ),
+        ]
 
-        v1.services = [link.Link.make_link(
-            'self', base_url, 'services', ''),
-            link.Link.make_link('bookmark',
-                                base_url,
-                                'services', '',
-                                bookmark=True)
-            ]
+        v1.services = [
+            link.Link.make_link('self', base_url, 'services', ''),
+            link.Link.make_link(
+                'bookmark', base_url, 'services', '', bookmark=True
+            ),
+        ]
         if utils.allow_webhook_api():
-            v1.webhooks = [link.Link.make_link(
-                'self', base_url, 'webhooks', ''),
-                link.Link.make_link('bookmark',
-                                    base_url,
-                                    'webhooks', '',
-                                    bookmark=True)
-                ]
+            v1.webhooks = [
+                link.Link.make_link('self', base_url, 'webhooks', ''),
+                link.Link.make_link(
+                    'bookmark', base_url, 'webhooks', '', bookmark=True
+                ),
+            ]
         return v1
 
 
@@ -249,7 +256,8 @@ class Controller(rest.RestController):
                 f"Mutually exclusive versions requested. Version {version} "
                 "requested but not supported by this service. The supported "
                 f"version range is: [{min_ver}, {max_ver}].",
-                headers=headers)
+                headers=headers,
+            )
         # ensure the minor version is within the supported range
         if version < min_version() or version > max_version():
             min_ver = versions.min_version_string()
@@ -259,12 +267,16 @@ class Controller(rest.RestController):
                 "not "
                 "supported by this service. The supported version range is: "
                 f"[{min_ver}, {max_ver}].",
-                headers=headers)
+                headers=headers,
+            )
 
     @pecan.expose()
     def _route(self, args, request=None):
-        v = base.Version(pecan.request.headers, versions.min_version_string(),
-                         versions.max_version_string())
+        v = base.Version(
+            pecan.request.headers,
+            versions.min_version_string(),
+            versions.max_version_string(),
+        )
 
         # The Vary header is used as a hint to caching proxies and user agents
         # that the response is also dependent on the OpenStack-API-Version and
@@ -273,17 +285,20 @@ class Controller(rest.RestController):
 
         # Always set the min and max headers
         pecan.response.headers[base.Version.min_string] = (
-            versions.min_version_string())
+            versions.min_version_string()
+        )
         pecan.response.headers[base.Version.max_string] = (
-            versions.max_version_string())
+            versions.max_version_string()
+        )
 
         # assert that requested version is supported
         self._check_version(v, pecan.response.headers)
-        pecan.response.headers[base.Version.string] = (
-            ' '.join([versions.service_type_string(), str(v)]))
+        pecan.response.headers[base.Version.string] = ' '.join(
+            [versions.service_type_string(), str(v)]
+        )
         pecan.request.version = v
 
         return super()._route(args, request)
 
 
-__all__ = ("Controller", )
+__all__ = ("Controller",)
diff --git a/watcher/api/controllers/v1/action.py b/watcher/api/controllers/v1/action.py
index 8178d34c1..64bc656ba 100644
--- a/watcher/api/controllers/v1/action.py
+++ b/watcher/api/controllers/v1/action.py
@@ -89,7 +89,6 @@ def hide_fields_in_newer_versions(obj):
 
 
 class ActionPatchType(types.JsonPatchType):
-
     @staticmethod
     def _validate_state(patch):
         serialized_patch = {'path': patch.path, 'op': patch.op}
@@ -100,7 +99,8 @@ class ActionPatchType(types.JsonPatchType):
         if state_value and not hasattr(objects.action.State, state_value):
             msg = _("Invalid state: %(state)s")
             raise exception.PatchError(
-                patch=serialized_patch, reason=msg % dict(state=state_value))
+                patch=serialized_patch, reason=msg % dict(state=state_value)
+            )
 
     @staticmethod
     def validate(patch):
@@ -126,6 +126,7 @@ class Action(base.APIBase):
     This class enforces type checking and value constraints, and converts
     between the internal object model and the API representation of a action.
     """
+
     _action_plan_uuid = None
 
     def _get_action_plan_uuid(self):
@@ -137,7 +138,8 @@ class Action(base.APIBase):
         elif value and self._action_plan_uuid != value:
             try:
                 action_plan = objects.ActionPlan.get(
-                    pecan.request.context, value)
+                    pecan.request.context, value
+                )
                 self._action_plan_uuid = action_plan.uuid
                 self.action_plan_id = action_plan.id
             except exception.ActionPlanNotFound:
@@ -146,9 +148,12 @@ class Action(base.APIBase):
     uuid = wtypes.wsattr(types.uuid, readonly=True)
     """Unique UUID for this action"""
 
-    action_plan_uuid = wtypes.wsproperty(types.uuid, _get_action_plan_uuid,
-                                         _set_action_plan_uuid,
-                                         mandatory=True)
+    action_plan_uuid = wtypes.wsproperty(
+        types.uuid,
+        _get_action_plan_uuid,
+        _set_action_plan_uuid,
+        mandatory=True,
+    )
     """The action plan this action belongs to """
 
     state = wtypes.text
@@ -187,22 +192,32 @@ class Action(base.APIBase):
 
         self.fields.append('action_plan_id')
         self.fields.append('description')
-        setattr(self, 'action_plan_uuid', kwargs.get('action_plan_id',
-                wtypes.Unset))
+        setattr(
+            self,
+            'action_plan_uuid',
+            kwargs.get('action_plan_id', wtypes.Unset),
+        )
 
     @staticmethod
     def _convert_with_links(action, url, expand=True):
         if not expand:
-            action.unset_fields_except(['uuid', 'state', 'action_plan_uuid',
-                                        'action_plan_id', 'action_type',
-                                        'parents'])
+            action.unset_fields_except(
+                [
+                    'uuid',
+                    'state',
+                    'action_plan_uuid',
+                    'action_plan_id',
+                    'action_type',
+                    'parents',
+                ]
+            )
 
-        action.links = [link.Link.make_link('self', url,
-                                            'actions', action.uuid),
-                        link.Link.make_link('bookmark', url,
-                                            'actions', action.uuid,
-                                            bookmark=True)
-                        ]
+        action.links = [
+            link.Link.make_link('self', url, 'actions', action.uuid),
+            link.Link.make_link(
+                'bookmark', url, 'actions', action.uuid, bookmark=True
+            ),
+        ]
         return action
 
     @classmethod
@@ -210,7 +225,8 @@ class Action(base.APIBase):
         action = Action(**action.as_dict())
         try:
             obj_action_desc = objects.ActionDescription.get_by_type(
-                pecan.request.context, action.action_type)
+                pecan.request.context, action.action_type
+            )
             description = obj_action_desc.description
         except exception.ActionDescriptionNotFound:
             description = ""
@@ -222,13 +238,15 @@ class Action(base.APIBase):
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
-                     description='action description',
-                     state='PENDING',
-                     created_at=timeutils.utcnow(),
-                     deleted_at=None,
-                     updated_at=timeutils.utcnow(),
-                     parents=[])
+        sample = cls(
+            uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
+            description='action description',
+            state='PENDING',
+            created_at=timeutils.utcnow(),
+            deleted_at=None,
+            updated_at=timeutils.utcnow(),
+            parents=[],
+        )
         sample._action_plan_uuid = '7ae81bb3-dec3-4289-8d6c-da80bd8001ae'
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
@@ -243,12 +261,11 @@ class ActionCollection(collection.Collection):
         self._type = 'actions'
 
     @staticmethod
-    def convert_with_links(actions, limit, url=None, expand=False,
-                           **kwargs):
-
+    def convert_with_links(actions, limit, url=None, expand=False, **kwargs):
         collection = ActionCollection()
-        collection.actions = [Action.convert_with_links(p, expand)
-                              for p in actions]
+        collection.actions = [
+            Action.convert_with_links(p, expand) for p in actions
+        ]
         collection.next = collection.get_next(limit, url=url, **kwargs)
         return collection
 
@@ -265,25 +282,32 @@ class ActionsController(rest.RestController):
     def __init__(self):
         super().__init__()
 
-    _custom_actions = {
-        'detail': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET']}
 
-    def _get_actions_collection(self, marker, limit,
-                                sort_key, sort_dir, expand=False,
-                                resource_url=None,
-                                action_plan_uuid=None, audit_uuid=None):
+    def _get_actions_collection(
+        self,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+        action_plan_uuid=None,
+        audit_uuid=None,
+    ):
         additional_fields = ['action_plan_uuid']
 
-        api_utils.validate_sort_key(sort_key, list(objects.Action.fields) +
-                                    additional_fields)
+        api_utils.validate_sort_key(
+            sort_key, list(objects.Action.fields) + additional_fields
+        )
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
-            marker_obj = objects.Action.get_by_uuid(pecan.request.context,
-                                                    marker)
+            marker_obj = objects.Action.get_by_uuid(
+                pecan.request.context, marker
+            )
 
         filters = {}
         if action_plan_uuid:
@@ -292,33 +316,54 @@ class ActionsController(rest.RestController):
         if audit_uuid:
             filters['audit_uuid'] = audit_uuid
 
-        need_api_sort = api_utils.check_need_api_sort(sort_key,
-                                                      additional_fields)
-        sort_db_key = (sort_key if not need_api_sort
-                       else None)
+        need_api_sort = api_utils.check_need_api_sort(
+            sort_key, additional_fields
+        )
+        sort_db_key = sort_key if not need_api_sort else None
 
-        actions = objects.Action.list(pecan.request.context,
-                                      limit,
-                                      marker_obj, sort_key=sort_db_key,
-                                      sort_dir=sort_dir,
-                                      filters=filters)
+        actions = objects.Action.list(
+            pecan.request.context,
+            limit,
+            marker_obj,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+            filters=filters,
+        )
 
         actions_collection = ActionCollection.convert_with_links(
-            actions, limit, url=resource_url, expand=expand,
-            sort_key=sort_key, sort_dir=sort_dir)
+            actions,
+            limit,
+            url=resource_url,
+            expand=expand,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+        )
 
         if need_api_sort:
-            api_utils.make_api_sort(actions_collection.actions,
-                                    sort_key, sort_dir)
+            api_utils.make_api_sort(
+                actions_collection.actions, sort_key, sort_dir
+            )
 
         return actions_collection
 
-    @wsme_pecan.wsexpose(ActionCollection, types.uuid, int,
-                         wtypes.text, wtypes.text, types.uuid,
-                         types.uuid)
-    def get_all(self, marker=None, limit=None,
-                sort_key='id', sort_dir='asc', action_plan_uuid=None,
-                audit_uuid=None):
+    @wsme_pecan.wsexpose(
+        ActionCollection,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+        types.uuid,
+        types.uuid,
+    )
+    def get_all(
+        self,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+        action_plan_uuid=None,
+        audit_uuid=None,
+    ):
         """Retrieve a list of actions.
 
         :param marker: pagination marker for large data sets.
@@ -331,22 +376,38 @@ class ActionsController(rest.RestController):
            to get only actions for that audit.
         """
         context = pecan.request.context
-        policy.enforce(context, 'action:get_all',
-                       action='action:get_all')
+        policy.enforce(context, 'action:get_all', action='action:get_all')
 
         if action_plan_uuid and audit_uuid:
             raise exception.ActionFilterCombinationProhibited
 
         return self._get_actions_collection(
-            marker, limit, sort_key, sort_dir,
-            action_plan_uuid=action_plan_uuid, audit_uuid=audit_uuid)
+            marker,
+            limit,
+            sort_key,
+            sort_dir,
+            action_plan_uuid=action_plan_uuid,
+            audit_uuid=audit_uuid,
+        )
 
-    @wsme_pecan.wsexpose(ActionCollection, types.uuid, int,
-                         wtypes.text, wtypes.text, types.uuid,
-                         types.uuid)
-    def detail(self, marker=None, limit=None,
-               sort_key='id', sort_dir='asc', action_plan_uuid=None,
-               audit_uuid=None):
+    @wsme_pecan.wsexpose(
+        ActionCollection,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+        types.uuid,
+        types.uuid,
+    )
+    def detail(
+        self,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+        action_plan_uuid=None,
+        audit_uuid=None,
+    ):
         """Retrieve a list of actions with detail.
 
         :param marker: pagination marker for large data sets.
@@ -359,8 +420,7 @@ class ActionsController(rest.RestController):
            to get only actions for that audit.
         """
         context = pecan.request.context
-        policy.enforce(context, 'action:detail',
-                       action='action:detail')
+        policy.enforce(context, 'action:detail', action='action:detail')
 
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
@@ -373,8 +433,15 @@ class ActionsController(rest.RestController):
         expand = True
         resource_url = '/'.join(['actions', 'detail'])
         return self._get_actions_collection(
-            marker, limit, sort_key, sort_dir, expand, resource_url,
-            action_plan_uuid=action_plan_uuid, audit_uuid=audit_uuid)
+            marker,
+            limit,
+            sort_key,
+            sort_dir,
+            expand,
+            resource_url,
+            action_plan_uuid=action_plan_uuid,
+            audit_uuid=audit_uuid,
+        )
 
     @wsme_pecan.wsexpose(Action, types.uuid)
     def get_one(self, action_uuid):
@@ -398,13 +465,16 @@ class ActionsController(rest.RestController):
         """
         if not api_utils.allow_skipped_action():
             raise exception.Invalid(
-                _("API microversion 1.5 or higher is required."))
+                _("API microversion 1.5 or higher is required.")
+            )
 
         context = pecan.request.context
         action_to_update = api_utils.get_resource(
-            'Action', action_uuid, eager=True)
-        policy.enforce(context, 'action:update', action_to_update,
-                       action='action:update')
+            'Action', action_uuid, eager=True
+        )
+        policy.enforce(
+            context, 'action:update', action_to_update, action='action:update'
+        )
 
         try:
             action_dict = action_to_update.as_dict()
@@ -414,47 +484,59 @@ class ActionsController(rest.RestController):
 
         # Define allowed state transitions for actions
         allowed_patch_transitions = [
-            (objects.action.State.PENDING, objects.action.State.SKIPPED),
+            (objects.action.State.PENDING, objects.action.State.SKIPPED)
         ]
 
         # Validate state transitions if state is being modified
         if action.state != action_to_update.state:
             transition = (action_to_update.state, action.state)
             if transition not in allowed_patch_transitions:
-                error_message = _("State transition not allowed: "
-                                  "(%(initial_state)s -> %(new_state)s)")
+                error_message = _(
+                    "State transition not allowed: "
+                    "(%(initial_state)s -> %(new_state)s)"
+                )
                 raise exception.Conflict(
                     patch=patch,
-                    message=error_message % dict(
+                    message=error_message
+                    % dict(
                         initial_state=action_to_update.state,
-                        new_state=action.state))
+                        new_state=action.state,
+                    ),
+                )
             action_plan = action_to_update.action_plan
-            if action_plan.state not in [objects.action_plan.State.RECOMMENDED,
-                                         objects.action_plan.State.PENDING]:
-                error_message = _("State update not allowed for actionplan "
-                                  "state: %(ap_state)s")
+            if action_plan.state not in [
+                objects.action_plan.State.RECOMMENDED,
+                objects.action_plan.State.PENDING,
+            ]:
+                error_message = _(
+                    "State update not allowed for actionplan "
+                    "state: %(ap_state)s"
+                )
                 raise exception.Conflict(
                     patch=patch,
-                    message=error_message % dict(
-                        ap_state=action_plan.state))
+                    message=error_message % dict(ap_state=action_plan.state),
+                )
 
         status_message = _("Action skipped by user.")
         # status_message update only allowed with status update or when
         # already SKIPPED
         # NOTE(dviroel): status_message is an exposed field.
         if action.status_message != action_to_update.status_message:
-            if (action.state == action_to_update.state and
-                    action_to_update.state != objects.action.State.SKIPPED):
+            if (
+                action.state == action_to_update.state
+                and action_to_update.state != objects.action.State.SKIPPED
+            ):
                 error_message = _(
                     "status_message update only allowed when action state "
-                    "is SKIPPED")
-                raise exception.Conflict(
-                    patch=patch,
-                    message=error_message)
+                    "is SKIPPED"
+                )
+                raise exception.Conflict(patch=patch, message=error_message)
             else:
-                status_message = (_("%(status_message)s Reason: %(reason)s")
-                                  % dict(status_message=status_message,
-                                         reason=action.status_message))
+                status_message = _(
+                    "%(status_message)s Reason: %(reason)s"
+                ) % dict(
+                    status_message=status_message, reason=action.status_message
+                )
 
         action.status_message = status_message
 
diff --git a/watcher/api/controllers/v1/action_plan.py b/watcher/api/controllers/v1/action_plan.py
index 26fa8d9a5..387d71ef5 100644
--- a/watcher/api/controllers/v1/action_plan.py
+++ b/watcher/api/controllers/v1/action_plan.py
@@ -94,7 +94,6 @@ def hide_fields_in_newer_versions(obj):
 
 
 class ActionPlanPatchType(types.JsonPatchType):
-
     @staticmethod
     def _validate_state(patch):
         serialized_patch = {'path': patch.path, 'op': patch.op}
@@ -105,7 +104,8 @@ class ActionPlanPatchType(types.JsonPatchType):
         if state_value and not hasattr(ap_objects.State, state_value):
             msg = _("Invalid state: %(state)s")
             raise exception.PatchError(
-                patch=serialized_patch, reason=msg % dict(state=state_value))
+                patch=serialized_patch, reason=msg % dict(state=state_value)
+            )
 
     @staticmethod
     def validate(patch):
@@ -164,7 +164,8 @@ class ActionPlan(base.APIBase):
             try:
                 _efficacy_indicators = objects.EfficacyIndicator.list(
                     pecan.request.context,
-                    filters={"action_plan_uuid": self.uuid})
+                    filters={"action_plan_uuid": self.uuid},
+                )
 
                 for indicator in _efficacy_indicators:
                     efficacy_indicator = efficacyindicator.EfficacyIndicator(
@@ -187,11 +188,11 @@ class ActionPlan(base.APIBase):
         strategy = None
         try:
             if utils.is_uuid_like(value) or utils.is_int_like(value):
-                strategy = objects.Strategy.get(
-                    pecan.request.context, value)
+                strategy = objects.Strategy.get(pecan.request.context, value)
             else:
                 strategy = objects.Strategy.get_by_name(
-                    pecan.request.context, value)
+                    pecan.request.context, value
+                )
         except exception.StrategyNotFound:
             pass
         if strategy:
@@ -221,22 +222,27 @@ class ActionPlan(base.APIBase):
     uuid = wtypes.wsattr(types.uuid, readonly=True)
     """Unique UUID for this action plan"""
 
-    audit_uuid = wtypes.wsproperty(types.uuid, _get_audit_uuid,
-                                   _set_audit_uuid,
-                                   mandatory=True)
+    audit_uuid = wtypes.wsproperty(
+        types.uuid, _get_audit_uuid, _set_audit_uuid, mandatory=True
+    )
     """The UUID of the audit this port belongs to"""
 
     strategy_uuid = wtypes.wsproperty(
-        wtypes.text, _get_strategy_uuid, _set_strategy_uuid, mandatory=False)
+        wtypes.text, _get_strategy_uuid, _set_strategy_uuid, mandatory=False
+    )
     """Strategy UUID the action plan refers to"""
 
     strategy_name = wtypes.wsproperty(
-        wtypes.text, _get_strategy_name, _set_strategy_name, mandatory=False)
+        wtypes.text, _get_strategy_name, _set_strategy_name, mandatory=False
+    )
     """The name of the strategy this action plan refers to"""
 
     efficacy_indicators = wtypes.wsproperty(
-        types.jsontype, _get_efficacy_indicators, _set_efficacy_indicators,
-        mandatory=True)
+        types.jsontype,
+        _get_efficacy_indicators,
+        _set_efficacy_indicators,
+        mandatory=True,
+    )
     """The list of efficacy indicators associated to this action plan"""
 
     global_efficacy = wtypes.wsattr(types.jsontype, readonly=True)
@@ -278,40 +284,60 @@ class ActionPlan(base.APIBase):
     def _convert_with_links(action_plan, url, expand=True):
         if not expand:
             action_plan.unset_fields_except(
-                ['uuid', 'state', 'efficacy_indicators', 'global_efficacy',
-                 'updated_at', 'audit_uuid', 'strategy_uuid', 'strategy_name'])
+                [
+                    'uuid',
+                    'state',
+                    'efficacy_indicators',
+                    'global_efficacy',
+                    'updated_at',
+                    'audit_uuid',
+                    'strategy_uuid',
+                    'strategy_name',
+                ]
+            )
 
         action_plan.links = [
+            link.Link.make_link('self', url, 'action_plans', action_plan.uuid),
             link.Link.make_link(
-                'self', url,
-                'action_plans', action_plan.uuid),
-            link.Link.make_link(
-                'bookmark', url,
-                'action_plans', action_plan.uuid,
-                bookmark=True)]
+                'bookmark',
+                url,
+                'action_plans',
+                action_plan.uuid,
+                bookmark=True,
+            ),
+        ]
         return action_plan
 
     @classmethod
     def convert_with_links(cls, rpc_action_plan, expand=True):
         action_plan = ActionPlan(**rpc_action_plan.as_dict())
         hide_fields_in_newer_versions(action_plan)
-        return cls._convert_with_links(action_plan, pecan.request.host_url,
-                                       expand)
+        return cls._convert_with_links(
+            action_plan, pecan.request.host_url, expand
+        )
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(uuid='9ef4d84c-41e8-4418-9220-ce55be0436af',
-                     state='ONGOING',
-                     created_at=timeutils.utcnow(),
-                     deleted_at=None,
-                     updated_at=timeutils.utcnow())
+        sample = cls(
+            uuid='9ef4d84c-41e8-4418-9220-ce55be0436af',
+            state='ONGOING',
+            created_at=timeutils.utcnow(),
+            deleted_at=None,
+            updated_at=timeutils.utcnow(),
+        )
         sample._audit_uuid = 'abcee106-14d3-4515-b744-5a26885cf6f6'
-        sample._efficacy_indicators = [{'description': 'Test indicator',
-                                        'name': 'test_indicator',
-                                        'unit': '%'}]
-        sample._global_efficacy = {'description': 'Global efficacy',
-                                   'name': 'test_global_efficacy',
-                                   'unit': '%'}
+        sample._efficacy_indicators = [
+            {
+                'description': 'Test indicator',
+                'name': 'test_indicator',
+                'unit': '%',
+            }
+        ]
+        sample._global_efficacy = {
+            'description': 'Global efficacy',
+            'name': 'test_global_efficacy',
+            'unit': '%',
+        }
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
 
@@ -325,11 +351,13 @@ class ActionPlanCollection(collection.Collection):
         self._type = 'action_plans'
 
     @staticmethod
-    def convert_with_links(rpc_action_plans, limit, url=None, expand=False,
-                           **kwargs):
+    def convert_with_links(
+        rpc_action_plans, limit, url=None, expand=False, **kwargs
+    ):
         ap_collection = ActionPlanCollection()
-        ap_collection.action_plans = [ActionPlan.convert_with_links(
-            p, expand) for p in rpc_action_plans]
+        ap_collection.action_plans = [
+            ActionPlan.convert_with_links(p, expand) for p in rpc_action_plans
+        ]
         ap_collection.next = ap_collection.get_next(limit, url=url, **kwargs)
         return ap_collection
 
@@ -347,26 +375,32 @@ class ActionPlansController(rest.RestController):
         super().__init__()
         self.applier_client = rpcapi.ApplierAPI()
 
-    _custom_actions = {
-        'start': ['POST'],
-        'detail': ['GET']
-    }
+    _custom_actions = {'start': ['POST'], 'detail': ['GET']}
 
-    def _get_action_plans_collection(self, marker, limit,
-                                     sort_key, sort_dir, expand=False,
-                                     resource_url=None, audit_uuid=None,
-                                     strategy=None):
+    def _get_action_plans_collection(
+        self,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+        audit_uuid=None,
+        strategy=None,
+    ):
         additional_fields = ['audit_uuid', 'strategy_uuid', 'strategy_name']
 
         api_utils.validate_sort_key(
-            sort_key, list(objects.ActionPlan.fields) + additional_fields)
+            sort_key, list(objects.ActionPlan.fields) + additional_fields
+        )
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
             marker_obj = objects.ActionPlan.get_by_uuid(
-                pecan.request.context, marker)
+                pecan.request.context, marker
+            )
 
         filters = {}
         if audit_uuid:
@@ -378,31 +412,54 @@ class ActionPlansController(rest.RestController):
             else:
                 filters['strategy_name'] = strategy
 
-        need_api_sort = api_utils.check_need_api_sort(sort_key,
-                                                      additional_fields)
-        sort_db_key = (sort_key if not need_api_sort
-                       else None)
+        need_api_sort = api_utils.check_need_api_sort(
+            sort_key, additional_fields
+        )
+        sort_db_key = sort_key if not need_api_sort else None
 
         action_plans = objects.ActionPlan.list(
             pecan.request.context,
             limit,
-            marker_obj, sort_key=sort_db_key,
-            sort_dir=sort_dir, filters=filters)
+            marker_obj,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+            filters=filters,
+        )
 
         action_plans_collection = ActionPlanCollection.convert_with_links(
-            action_plans, limit, url=resource_url, expand=expand,
-            sort_key=sort_key, sort_dir=sort_dir)
+            action_plans,
+            limit,
+            url=resource_url,
+            expand=expand,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+        )
 
         if need_api_sort:
-            api_utils.make_api_sort(action_plans_collection.action_plans,
-                                    sort_key, sort_dir)
+            api_utils.make_api_sort(
+                action_plans_collection.action_plans, sort_key, sort_dir
+            )
 
         return action_plans_collection
 
-    @wsme_pecan.wsexpose(ActionPlanCollection, types.uuid, int, wtypes.text,
-                         wtypes.text, types.uuid, wtypes.text)
-    def get_all(self, marker=None, limit=None,
-                sort_key='id', sort_dir='asc', audit_uuid=None, strategy=None):
+    @wsme_pecan.wsexpose(
+        ActionPlanCollection,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+        types.uuid,
+        wtypes.text,
+    )
+    def get_all(
+        self,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+        audit_uuid=None,
+        strategy=None,
+    ):
         """Retrieve a list of action plans.
 
         :param marker: pagination marker for large data sets.
@@ -414,17 +471,37 @@ class ActionPlansController(rest.RestController):
         :param strategy: strategy UUID or name to filter by
         """
         context = pecan.request.context
-        policy.enforce(context, 'action_plan:get_all',
-                       action='action_plan:get_all')
+        policy.enforce(
+            context, 'action_plan:get_all', action='action_plan:get_all'
+        )
 
         return self._get_action_plans_collection(
-            marker, limit, sort_key, sort_dir,
-            audit_uuid=audit_uuid, strategy=strategy)
+            marker,
+            limit,
+            sort_key,
+            sort_dir,
+            audit_uuid=audit_uuid,
+            strategy=strategy,
+        )
 
-    @wsme_pecan.wsexpose(ActionPlanCollection, types.uuid, int, wtypes.text,
-                         wtypes.text, types.uuid, wtypes.text)
-    def detail(self, marker=None, limit=None,
-               sort_key='id', sort_dir='asc', audit_uuid=None, strategy=None):
+    @wsme_pecan.wsexpose(
+        ActionPlanCollection,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+        types.uuid,
+        wtypes.text,
+    )
+    def detail(
+        self,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+        audit_uuid=None,
+        strategy=None,
+    ):
         """Retrieve a list of action_plans with detail.
 
         :param marker: pagination marker for large data sets.
@@ -436,8 +513,9 @@ class ActionPlansController(rest.RestController):
         :param strategy: strategy UUID or name to filter by
         """
         context = pecan.request.context
-        policy.enforce(context, 'action_plan:detail',
-                       action='action_plan:detail')
+        policy.enforce(
+            context, 'action_plan:detail', action='action_plan:detail'
+        )
 
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
@@ -447,8 +525,15 @@ class ActionPlansController(rest.RestController):
         expand = True
         resource_url = '/'.join(['action_plans', 'detail'])
         return self._get_action_plans_collection(
-            marker, limit, sort_key, sort_dir, expand,
-            resource_url, audit_uuid=audit_uuid, strategy=strategy)
+            marker,
+            limit,
+            sort_key,
+            sort_dir,
+            expand,
+            resource_url,
+            audit_uuid=audit_uuid,
+            strategy=strategy,
+        )
 
     @wsme_pecan.wsexpose(ActionPlan, types.uuid)
     def get_one(self, action_plan_uuid):
@@ -459,7 +544,8 @@ class ActionPlansController(rest.RestController):
         context = pecan.request.context
         action_plan = api_utils.get_resource('ActionPlan', action_plan_uuid)
         policy.enforce(
-            context, 'action_plan:get', action_plan, action='action_plan:get')
+            context, 'action_plan:get', action_plan, action='action_plan:get'
+        )
 
         return ActionPlan.convert_with_links(action_plan)
 
@@ -471,24 +557,29 @@ class ActionPlansController(rest.RestController):
         """
         context = pecan.request.context
         action_plan = api_utils.get_resource(
-            'ActionPlan', action_plan_uuid, eager=True)
-        policy.enforce(context, 'action_plan:delete', action_plan,
-                       action='action_plan:delete')
+            'ActionPlan', action_plan_uuid, eager=True
+        )
+        policy.enforce(
+            context,
+            'action_plan:delete',
+            action_plan,
+            action='action_plan:delete',
+        )
 
-        allowed_states = (ap_objects.State.SUCCEEDED,
-                          ap_objects.State.RECOMMENDED,
-                          ap_objects.State.FAILED,
-                          ap_objects.State.SUPERSEDED,
-                          ap_objects.State.CANCELLED)
+        allowed_states = (
+            ap_objects.State.SUCCEEDED,
+            ap_objects.State.RECOMMENDED,
+            ap_objects.State.FAILED,
+            ap_objects.State.SUPERSEDED,
+            ap_objects.State.CANCELLED,
+        )
         if action_plan.state not in allowed_states:
-            raise exception.DeleteError(
-                state=action_plan.state)
+            raise exception.DeleteError(state=action_plan.state)
 
         action_plan.soft_delete()
 
     @wsme.validate(types.uuid, [ActionPlanPatchType])
-    @wsme_pecan.wsexpose(ActionPlan, types.uuid,
-                         body=[ActionPlanPatchType])
+    @wsme_pecan.wsexpose(ActionPlan, types.uuid, body=[ActionPlanPatchType])
     def patch(self, action_plan_uuid, patch):
         """Update an existing action plan.
 
@@ -497,14 +588,20 @@ class ActionPlansController(rest.RestController):
         """
         context = pecan.request.context
         action_plan_to_update = api_utils.get_resource(
-            'ActionPlan', action_plan_uuid, eager=True)
-        policy.enforce(context, 'action_plan:update', action_plan_to_update,
-                       action='action_plan:update')
+            'ActionPlan', action_plan_uuid, eager=True
+        )
+        policy.enforce(
+            context,
+            'action_plan:update',
+            action_plan_to_update,
+            action='action_plan:update',
+        )
 
         try:
             action_plan_dict = action_plan_to_update.as_dict()
-            action_plan = ActionPlan(**api_utils.apply_jsonpatch(
-                action_plan_dict, patch))
+            action_plan = ActionPlan(
+                **api_utils.apply_jsonpatch(action_plan_dict, patch)
+            )
         except api_utils.JSONPATCH_EXCEPTIONS as e:
             raise exception.PatchError(patch=patch, reason=e)
 
@@ -513,27 +610,28 @@ class ActionPlansController(rest.RestController):
 
         # transitions that are allowed via PATCH
         allowed_patch_transitions = [
-            (ap_objects.State.RECOMMENDED,
-             ap_objects.State.PENDING),
-            (ap_objects.State.RECOMMENDED,
-             ap_objects.State.CANCELLED),
-            (ap_objects.State.ONGOING,
-             ap_objects.State.CANCELLING),
-            (ap_objects.State.PENDING,
-             ap_objects.State.CANCELLED),
+            (ap_objects.State.RECOMMENDED, ap_objects.State.PENDING),
+            (ap_objects.State.RECOMMENDED, ap_objects.State.CANCELLED),
+            (ap_objects.State.ONGOING, ap_objects.State.CANCELLING),
+            (ap_objects.State.PENDING, ap_objects.State.CANCELLED),
         ]
 
         # todo: improve this in blueprint watcher-api-validation
         if hasattr(action_plan, 'state'):
             transition = (action_plan_to_update.state, action_plan.state)
             if transition not in allowed_patch_transitions:
-                error_message = _("State transition not allowed: "
-                                  "(%(initial_state)s -> %(new_state)s)")
+                error_message = _(
+                    "State transition not allowed: "
+                    "(%(initial_state)s -> %(new_state)s)"
+                )
                 raise exception.PatchError(
                     patch=patch,
-                    reason=error_message % dict(
+                    reason=error_message
+                    % dict(
                         initial_state=action_plan_to_update.state,
-                        new_state=action_plan.state))
+                        new_state=action_plan.state,
+                    ),
+                )
 
             if action_plan.state == ap_objects.State.PENDING:
                 launch_action_plan = True
@@ -552,8 +650,10 @@ class ActionPlansController(rest.RestController):
             if action_plan_to_update[field] != patch_val:
                 action_plan_to_update[field] = patch_val
 
-            if (field == 'state' and
-                    patch_val == objects.action_plan.State.PENDING):
+            if (
+                field == 'state'
+                and patch_val == objects.action_plan.State.PENDING
+            ):
                 launch_action_plan = True
 
         action_plan_to_update.save()
@@ -562,19 +662,21 @@ class ActionPlansController(rest.RestController):
         # state update action state here only
         if cancel_action_plan:
             filters = {'action_plan_uuid': action_plan.uuid}
-            actions = objects.Action.list(pecan.request.context,
-                                          filters=filters, eager=True)
+            actions = objects.Action.list(
+                pecan.request.context, filters=filters, eager=True
+            )
             for a in actions:
                 a.state = objects.action.State.CANCELLED
                 a.save()
 
         if launch_action_plan:
-            self.applier_client.launch_action_plan(pecan.request.context,
-                                                   action_plan.uuid)
+            self.applier_client.launch_action_plan(
+                pecan.request.context, action_plan.uuid
+            )
 
         action_plan_to_update = objects.ActionPlan.get_by_uuid(
-            pecan.request.context,
-            action_plan_uuid)
+            pecan.request.context, action_plan_uuid
+        )
         return ActionPlan.convert_with_links(action_plan_to_update)
 
     @wsme_pecan.wsexpose(ActionPlan, types.uuid)
@@ -585,23 +687,31 @@ class ActionPlansController(rest.RestController):
         """
 
         action_plan_to_start = api_utils.get_resource(
-            'ActionPlan', action_plan_uuid, eager=True)
+            'ActionPlan', action_plan_uuid, eager=True
+        )
         context = pecan.request.context
 
-        policy.enforce(context, 'action_plan:start', action_plan_to_start,
-                       action='action_plan:start')
+        policy.enforce(
+            context,
+            'action_plan:start',
+            action_plan_to_start,
+            action='action_plan:start',
+        )
 
-        if action_plan_to_start['state'] != \
-                objects.action_plan.State.RECOMMENDED:
-            raise exception.StartError(
-                state=action_plan_to_start.state)
+        if (
+            action_plan_to_start['state']
+            != objects.action_plan.State.RECOMMENDED
+        ):
+            raise exception.StartError(state=action_plan_to_start.state)
 
         action_plan_to_start['state'] = objects.action_plan.State.PENDING
         action_plan_to_start.save()
 
-        self.applier_client.launch_action_plan(pecan.request.context,
-                                               action_plan_uuid)
+        self.applier_client.launch_action_plan(
+            pecan.request.context, action_plan_uuid
+        )
         action_plan_to_start = objects.ActionPlan.get_by_uuid(
-            pecan.request.context, action_plan_uuid)
+            pecan.request.context, action_plan_uuid
+        )
 
         return ActionPlan.convert_with_links(action_plan_to_start)
diff --git a/watcher/api/controllers/v1/audit.py b/watcher/api/controllers/v1/audit.py
index ca7a1e71d..f1ee76313 100644
--- a/watcher/api/controllers/v1/audit.py
+++ b/watcher/api/controllers/v1/audit.py
@@ -84,7 +84,6 @@ def hide_fields_in_newer_versions(obj):
 
 
 class AuditPostType(wtypes.Base):
-
     name = wtypes.wsattr(wtypes.text, mandatory=False)
 
     audit_template_uuid = wtypes.wsattr(types.uuid, mandatory=False)
@@ -95,11 +94,13 @@ class AuditPostType(wtypes.Base):
 
     audit_type = wtypes.wsattr(wtypes.text, mandatory=True)
 
-    state = wtypes.wsattr(wtypes.text, readonly=True,
-                          default=objects.audit.State.PENDING)
+    state = wtypes.wsattr(
+        wtypes.text, readonly=True, default=objects.audit.State.PENDING
+    )
 
-    parameters = wtypes.wsattr({wtypes.text: types.jsontype}, mandatory=False,
-                               default={})
+    parameters = wtypes.wsattr(
+        {wtypes.text: types.jsontype}, mandatory=False, default={}
+    )
     interval = wtypes.wsattr(types.interval_or_cron, mandatory=False)
 
     scope = wtypes.wsattr(types.jsontype, readonly=True)
@@ -120,28 +121,35 @@ class AuditPostType(wtypes.Base):
             raise exception.AuditTypeNotFound(audit_type=self.audit_type)
 
         if not self.audit_template_uuid and not self.goal:
-            message = _(
-                'A valid goal or audit_template_id must be provided')
+            message = _('A valid goal or audit_template_id must be provided')
             raise exception.Invalid(message)
 
-        if (self.audit_type == objects.audit.AuditType.ONESHOT.value and
-                self.interval not in (wtypes.Unset, None)):
+        if (
+            self.audit_type == objects.audit.AuditType.ONESHOT.value
+            and self.interval not in (wtypes.Unset, None)
+        ):
             raise exception.AuditIntervalNotAllowed(audit_type=self.audit_type)
 
-        if (self.audit_type == objects.audit.AuditType.CONTINUOUS.value and
-                self.interval in (wtypes.Unset, None)):
+        if (
+            self.audit_type == objects.audit.AuditType.CONTINUOUS.value
+            and self.interval in (wtypes.Unset, None)
+        ):
             raise exception.AuditIntervalNotSpecified(
-                audit_type=self.audit_type)
+                audit_type=self.audit_type
+            )
 
         if self.audit_template_uuid and self.goal:
-            raise exception.Invalid('Either audit_template_uuid '
-                                    'or goal should be provided.')
+            raise exception.Invalid(
+                'Either audit_template_uuid or goal should be provided.'
+            )
 
-        if (self.audit_type == objects.audit.AuditType.ONESHOT.value and
-                (self.start_time not in (wtypes.Unset, None) or
-                    self.end_time not in (wtypes.Unset, None))):
+        if self.audit_type == objects.audit.AuditType.ONESHOT.value and (
+            self.start_time not in (wtypes.Unset, None)
+            or self.end_time not in (wtypes.Unset, None)
+        ):
             raise exception.AuditStartEndTimeNotAllowed(
-                audit_type=self.audit_type)
+                audit_type=self.audit_type
+            )
 
         if not api_utils.allow_start_end_audit_time():
             for field in ('start_time', 'end_time'):
@@ -154,11 +162,14 @@ class AuditPostType(wtypes.Base):
         if self.audit_template_uuid:
             try:
                 audit_template = objects.AuditTemplate.get(
-                    context, self.audit_template_uuid)
+                    context, self.audit_template_uuid
+                )
             except exception.AuditTemplateNotFound:
                 raise exception.Invalid(
-                    message=_('The audit template UUID or name specified is '
-                              'invalid'))
+                    message=_(
+                        'The audit template UUID or name specified is invalid'
+                    )
+                )
             at2a = {
                 'goal': 'goal_id',
                 'strategy': 'strategy_id',
@@ -178,12 +189,14 @@ class AuditPostType(wtypes.Base):
         # Note: If audit name was not provided, used a default name
         if not self.name:
             if self.strategy:
-                strategy = _get_object_by_value(context, objects.Strategy,
-                                                self.strategy)
+                strategy = _get_object_by_value(
+                    context, objects.Strategy, self.strategy
+                )
                 self.name = f"{strategy.name}-{timeutils.utcnow().isoformat()}"
             elif self.audit_template_uuid:
                 audit_template = objects.AuditTemplate.get(
-                    context, self.audit_template_uuid)
+                    context, self.audit_template_uuid
+                )
                 timestamp = timeutils.utcnow().isoformat()
                 self.name = f"{audit_template.name}-{timestamp}"
             else:
@@ -191,8 +204,7 @@ class AuditPostType(wtypes.Base):
                 self.name = f"{goal.name}-{timeutils.utcnow().isoformat()}"
         # No more than 63 characters
         if len(self.name) > 63:
-            LOG.warning("Audit: %s length exceeds 63 characters",
-                        self.name)
+            LOG.warning("Audit: %s length exceeds 63 characters", self.name)
             self.name = self.name[0:63]
 
         return Audit(
@@ -206,11 +218,11 @@ class AuditPostType(wtypes.Base):
             auto_trigger=self.auto_trigger,
             start_time=self.start_time,
             end_time=self.end_time,
-            force=self.force)
+            force=self.force,
+        )
 
 
 class AuditPatchType(types.JsonPatchType):
-
     @staticmethod
     def mandatory_attrs():
         return ['/audit_template_uuid', '/type']
@@ -225,19 +237,21 @@ class AuditPatchType(types.JsonPatchType):
 
     @staticmethod
     def validate(patch):
-
         def is_new_state_none(p):
             return p.path == '/state' and p.op == 'replace' and p.value is None
 
-        serialized_patch = {'path': patch.path,
-                            'op': patch.op,
-                            'value': patch.value}
-        if (patch.path in AuditPatchType.mandatory_attrs() or
-                is_new_state_none(patch)):
+        serialized_patch = {
+            'path': patch.path,
+            'op': patch.op,
+            'value': patch.value,
+        }
+        if patch.path in AuditPatchType.mandatory_attrs() or is_new_state_none(
+            patch
+        ):
             msg = _("%(field)s can't be updated.")
             raise exception.PatchError(
-                patch=serialized_patch,
-                reason=msg % dict(field=patch.path))
+                patch=serialized_patch, reason=msg % dict(field=patch.path)
+            )
         return types.JsonPatchType.validate(patch)
 
 
@@ -247,6 +261,7 @@ class Audit(base.APIBase):
     This class enforces type checking and value constraints, and converts
     between the internal object model and the API representation of an audit.
     """
+
     _goal_uuid = None
     _goal_name = None
     _strategy_uuid = None
@@ -258,11 +273,9 @@ class Audit(base.APIBase):
         goal = None
         try:
             if utils.is_uuid_like(value) or utils.is_int_like(value):
-                goal = objects.Goal.get(
-                    pecan.request.context, value)
+                goal = objects.Goal.get(pecan.request.context, value)
             else:
-                goal = objects.Goal.get_by_name(
-                    pecan.request.context, value)
+                goal = objects.Goal.get_by_name(pecan.request.context, value)
         except exception.GoalNotFound:
             pass
         if goal:
@@ -295,11 +308,11 @@ class Audit(base.APIBase):
         strategy = None
         try:
             if utils.is_uuid_like(value) or utils.is_int_like(value):
-                strategy = objects.Strategy.get(
-                    pecan.request.context, value)
+                strategy = objects.Strategy.get(pecan.request.context, value)
             else:
                 strategy = objects.Strategy.get_by_name(
-                    pecan.request.context, value)
+                    pecan.request.context, value
+                )
         except exception.StrategyNotFound:
             pass
         if strategy:
@@ -339,19 +352,23 @@ class Audit(base.APIBase):
     """This audit state"""
 
     goal_uuid = wtypes.wsproperty(
-        wtypes.text, _get_goal_uuid, _set_goal_uuid, mandatory=True)
+        wtypes.text, _get_goal_uuid, _set_goal_uuid, mandatory=True
+    )
     """Goal UUID the audit refers to"""
 
     goal_name = wtypes.wsproperty(
-        wtypes.text, _get_goal_name, _set_goal_name, mandatory=False)
+        wtypes.text, _get_goal_name, _set_goal_name, mandatory=False
+    )
     """The name of the goal this audit refers to"""
 
     strategy_uuid = wtypes.wsproperty(
-        wtypes.text, _get_strategy_uuid, _set_strategy_uuid, mandatory=False)
+        wtypes.text, _get_strategy_uuid, _set_strategy_uuid, mandatory=False
+    )
     """Strategy UUID the audit refers to"""
 
     strategy_name = wtypes.wsproperty(
-        wtypes.text, _get_strategy_name, _set_strategy_name, mandatory=False)
+        wtypes.text, _get_strategy_name, _set_strategy_name, mandatory=False
+    )
     """The name of the strategy this audit refers to"""
 
     parameters = {wtypes.text: types.jsontype}
@@ -401,33 +418,40 @@ class Audit(base.APIBase):
         self.fields.append('goal_id')
         self.fields.append('strategy_id')
         fields.append('goal_uuid')
-        setattr(self, 'goal_uuid', kwargs.get('goal_id',
-                wtypes.Unset))
+        setattr(self, 'goal_uuid', kwargs.get('goal_id', wtypes.Unset))
         fields.append('goal_name')
-        setattr(self, 'goal_name', kwargs.get('goal_id',
-                wtypes.Unset))
+        setattr(self, 'goal_name', kwargs.get('goal_id', wtypes.Unset))
         fields.append('strategy_uuid')
-        setattr(self, 'strategy_uuid', kwargs.get('strategy_id',
-                wtypes.Unset))
+        setattr(self, 'strategy_uuid', kwargs.get('strategy_id', wtypes.Unset))
         fields.append('strategy_name')
-        setattr(self, 'strategy_name', kwargs.get('strategy_id',
-                wtypes.Unset))
+        setattr(self, 'strategy_name', kwargs.get('strategy_id', wtypes.Unset))
 
     @staticmethod
     def _convert_with_links(audit, url, expand=True):
         if not expand:
-            audit.unset_fields_except(['uuid', 'name', 'audit_type', 'state',
-                                       'goal_uuid', 'interval', 'scope',
-                                       'strategy_uuid', 'goal_name',
-                                       'strategy_name', 'auto_trigger',
-                                       'next_run_time'])
+            audit.unset_fields_except(
+                [
+                    'uuid',
+                    'name',
+                    'audit_type',
+                    'state',
+                    'goal_uuid',
+                    'interval',
+                    'scope',
+                    'strategy_uuid',
+                    'goal_name',
+                    'strategy_name',
+                    'auto_trigger',
+                    'next_run_time',
+                ]
+            )
 
-        audit.links = [link.Link.make_link('self', url,
-                                           'audits', audit.uuid),
-                       link.Link.make_link('bookmark', url,
-                                           'audits', audit.uuid,
-                                           bookmark=True)
-                       ]
+        audit.links = [
+            link.Link.make_link('self', url, 'audits', audit.uuid),
+            link.Link.make_link(
+                'bookmark', url, 'audits', audit.uuid, bookmark=True
+            ),
+        ]
 
         return audit
 
@@ -439,19 +463,21 @@ class Audit(base.APIBase):
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
-                     name='My Audit',
-                     audit_type='ONESHOT',
-                     state='PENDING',
-                     created_at=timeutils.utcnow(),
-                     deleted_at=None,
-                     updated_at=timeutils.utcnow(),
-                     interval='7200',
-                     scope=[],
-                     auto_trigger=False,
-                     next_run_time=timeutils.utcnow(),
-                     start_time=timeutils.utcnow(),
-                     end_time=timeutils.utcnow())
+        sample = cls(
+            uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
+            name='My Audit',
+            audit_type='ONESHOT',
+            state='PENDING',
+            created_at=timeutils.utcnow(),
+            deleted_at=None,
+            updated_at=timeutils.utcnow(),
+            interval='7200',
+            scope=[],
+            auto_trigger=False,
+            next_run_time=timeutils.utcnow(),
+            start_time=timeutils.utcnow(),
+            end_time=timeutils.utcnow(),
+        )
 
         sample.goal_id = '7ae81bb3-dec3-4289-8d6c-da80bd8001ae'
         sample.strategy_id = '7ae81bb3-dec3-4289-8d6c-da80bd8001ff'
@@ -470,11 +496,13 @@ class AuditCollection(collection.Collection):
         self._type = 'audits'
 
     @staticmethod
-    def convert_with_links(rpc_audits, limit, url=None, expand=False,
-                           **kwargs):
+    def convert_with_links(
+        rpc_audits, limit, url=None, expand=False, **kwargs
+    ):
         collection = AuditCollection()
-        collection.audits = [Audit.convert_with_links(p, expand)
-                             for p in rpc_audits]
+        collection.audits = [
+            Audit.convert_with_links(p, expand) for p in rpc_audits
+        ]
         collection.next = collection.get_next(limit, url=url, **kwargs)
         return collection
 
@@ -492,26 +520,37 @@ class AuditsController(rest.RestController):
         super().__init__()
         self.dc_client = rpcapi.DecisionEngineAPI()
 
-    _custom_actions = {
-        'detail': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET']}
 
-    def _get_audits_collection(self, marker, limit,
-                               sort_key, sort_dir, expand=False,
-                               resource_url=None, goal=None,
-                               strategy=None):
-        additional_fields = ["goal_uuid", "goal_name", "strategy_uuid",
-                             "strategy_name"]
+    def _get_audits_collection(
+        self,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+        goal=None,
+        strategy=None,
+    ):
+        additional_fields = [
+            "goal_uuid",
+            "goal_name",
+            "strategy_uuid",
+            "strategy_name",
+        ]
 
         api_utils.validate_sort_key(
-            sort_key, list(objects.Audit.fields) + additional_fields)
+            sort_key, list(objects.Audit.fields) + additional_fields
+        )
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
-            marker_obj = objects.Audit.get_by_uuid(pecan.request.context,
-                                                   marker)
+            marker_obj = objects.Audit.get_by_uuid(
+                pecan.request.context, marker
+            )
 
         filters = {}
         if goal:
@@ -528,30 +567,54 @@ class AuditsController(rest.RestController):
                 # TODO(michaelgugino): add method to get goal by name.
                 filters['strategy_name'] = strategy
 
-        need_api_sort = api_utils.check_need_api_sort(sort_key,
-                                                      additional_fields)
-        sort_db_key = (sort_key if not need_api_sort
-                       else None)
+        need_api_sort = api_utils.check_need_api_sort(
+            sort_key, additional_fields
+        )
+        sort_db_key = sort_key if not need_api_sort else None
 
-        audits = objects.Audit.list(pecan.request.context,
-                                    limit,
-                                    marker_obj, sort_key=sort_db_key,
-                                    sort_dir=sort_dir, filters=filters)
+        audits = objects.Audit.list(
+            pecan.request.context,
+            limit,
+            marker_obj,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+            filters=filters,
+        )
 
         audits_collection = AuditCollection.convert_with_links(
-            audits, limit, url=resource_url, expand=expand,
-            sort_key=sort_key, sort_dir=sort_dir)
+            audits,
+            limit,
+            url=resource_url,
+            expand=expand,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+        )
 
         if need_api_sort:
-            api_utils.make_api_sort(audits_collection.audits, sort_key,
-                                    sort_dir)
+            api_utils.make_api_sort(
+                audits_collection.audits, sort_key, sort_dir
+            )
 
         return audits_collection
 
-    @wsme_pecan.wsexpose(AuditCollection, types.uuid, int, wtypes.text,
-                         wtypes.text, wtypes.text, wtypes.text)
-    def get_all(self, marker=None, limit=None, sort_key='id', sort_dir='asc',
-                goal=None, strategy=None):
+    @wsme_pecan.wsexpose(
+        AuditCollection,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+        wtypes.text,
+        wtypes.text,
+    )
+    def get_all(
+        self,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+        goal=None,
+        strategy=None,
+    ):
         """Retrieve a list of audits.
 
         :param marker: pagination marker for large data sets.
@@ -563,17 +626,18 @@ class AuditsController(rest.RestController):
         """
 
         context = pecan.request.context
-        policy.enforce(context, 'audit:get_all',
-                       action='audit:get_all')
+        policy.enforce(context, 'audit:get_all', action='audit:get_all')
 
-        return self._get_audits_collection(marker, limit, sort_key,
-                                           sort_dir, goal=goal,
-                                           strategy=strategy)
+        return self._get_audits_collection(
+            marker, limit, sort_key, sort_dir, goal=goal, strategy=strategy
+        )
 
-    @wsme_pecan.wsexpose(AuditCollection, wtypes.text, types.uuid, int,
-                         wtypes.text, wtypes.text)
-    def detail(self, goal=None, marker=None, limit=None,
-               sort_key='id', sort_dir='asc'):
+    @wsme_pecan.wsexpose(
+        AuditCollection, wtypes.text, types.uuid, int, wtypes.text, wtypes.text
+    )
+    def detail(
+        self, goal=None, marker=None, limit=None, sort_key='id', sort_dir='asc'
+    ):
         """Retrieve a list of audits with detail.
 
         :param goal: goal UUID or name to filter by
@@ -583,8 +647,7 @@ class AuditsController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'audit:detail',
-                       action='audit:detail')
+        policy.enforce(context, 'audit:detail', action='audit:detail')
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
         if parent != "audits":
@@ -592,10 +655,9 @@ class AuditsController(rest.RestController):
 
         expand = True
         resource_url = '/'.join(['audits', 'detail'])
-        return self._get_audits_collection(marker, limit,
-                                           sort_key, sort_dir, expand,
-                                           resource_url,
-                                           goal=goal)
+        return self._get_audits_collection(
+            marker, limit, sort_key, sort_dir, expand, resource_url, goal=goal
+        )
 
     @wsme_pecan.wsexpose(Audit, wtypes.text)
     def get_one(self, audit):
@@ -609,39 +671,46 @@ class AuditsController(rest.RestController):
 
         return Audit.convert_with_links(rpc_audit)
 
-    @wsme_pecan.wsexpose(Audit, body=AuditPostType,
-                         status_code=HTTPStatus.CREATED)
+    @wsme_pecan.wsexpose(
+        Audit, body=AuditPostType, status_code=HTTPStatus.CREATED
+    )
     def post(self, audit_p):
         """Create a new audit.
 
         :param audit_p: an audit within the request body.
         """
         context = pecan.request.context
-        policy.enforce(context, 'audit:create',
-                       action='audit:create')
+        policy.enforce(context, 'audit:create', action='audit:create')
         audit = audit_p.as_audit(context)
 
         strategy_uuid = audit.strategy_uuid
         no_schema = True
         if strategy_uuid is not None:
             # validate parameter when predefined strategy in audit template
-            strategy = objects.Strategy.get(pecan.request.context,
-                                            strategy_uuid)
+            strategy = objects.Strategy.get(
+                pecan.request.context, strategy_uuid
+            )
             schema = strategy.parameters_spec
             if schema:
                 # validate input parameter with default value feedback
                 no_schema = False
                 try:
                     utils.StrictDefaultValidatingDraft4Validator(
-                        schema).validate(audit.parameters)
+                        schema
+                    ).validate(audit.parameters)
                 except jsonschema.exceptions.ValidationError as e:
                     raise exception.Invalid(
-                        _('Invalid parameters for strategy: %s') % e)
+                        _('Invalid parameters for strategy: %s') % e
+                    )
 
         if no_schema and audit.parameters:
-            raise exception.Invalid(_('Specify parameters but no predefined '
-                                      'strategy for audit, or no '
-                                      'parameter spec in predefined strategy'))
+            raise exception.Invalid(
+                _(
+                    'Specify parameters but no predefined '
+                    'strategy for audit, or no '
+                    'parameter spec in predefined strategy'
+                )
+            )
 
         audit_dict = audit.as_dict()
         # convert local time to UTC time
@@ -649,10 +718,12 @@ class AuditsController(rest.RestController):
         end_time_value = audit_dict.get('end_time')
         if start_time_value:
             audit_dict['start_time'] = start_time_value.astimezone(
-                timezone.utc).replace(tzinfo=None)
+                timezone.utc
+            ).replace(tzinfo=None)
         if end_time_value:
             audit_dict['end_time'] = end_time_value.astimezone(
-                timezone.utc).replace(tzinfo=None)
+                timezone.utc
+            ).replace(tzinfo=None)
 
         new_audit = objects.Audit(context, **audit_dict)
         new_audit.create()
@@ -675,10 +746,10 @@ class AuditsController(rest.RestController):
         :param patch: a json PATCH document to apply to this audit.
         """
         context = pecan.request.context
-        audit_to_update = api_utils.get_resource(
-            'Audit', audit, eager=True)
-        policy.enforce(context, 'audit:update', audit_to_update,
-                       action='audit:update')
+        audit_to_update = api_utils.get_resource('Audit', audit, eager=True)
+        policy.enforce(
+            context, 'audit:update', audit_to_update, action='audit:update'
+        )
 
         try:
             audit_dict = audit_to_update.as_dict()
@@ -686,21 +757,27 @@ class AuditsController(rest.RestController):
             initial_state = audit_dict['state']
             new_state = api_utils.get_patch_value(patch, 'state')
             if not api_utils.check_audit_state_transition(
-                    patch, initial_state):
-                error_message = _("State transition not allowed: "
-                                  "(%(initial_state)s -> %(new_state)s)")
+                patch, initial_state
+            ):
+                error_message = _(
+                    "State transition not allowed: "
+                    "(%(initial_state)s -> %(new_state)s)"
+                )
                 raise exception.PatchError(
                     patch=patch,
-                    reason=error_message % dict(
-                        initial_state=initial_state, new_state=new_state))
+                    reason=error_message
+                    % dict(initial_state=initial_state, new_state=new_state),
+                )
 
             patch_path = api_utils.get_patch_key(patch, 'path')
             if patch_path in ('start_time', 'end_time'):
                 patch_value = api_utils.get_patch_value(patch, patch_path)
                 # convert string format to UTC time
-                new_patch_value = wutils.parse_isodatetime(
-                    patch_value).astimezone(
-                        timezone.utc).replace(tzinfo=None)
+                new_patch_value = (
+                    wutils.parse_isodatetime(patch_value)
+                    .astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                )
                 api_utils.set_patch_value(patch, patch_path, new_patch_value)
 
             audit = Audit(**api_utils.apply_jsonpatch(audit_dict, patch))
@@ -729,16 +806,16 @@ class AuditsController(rest.RestController):
         :param audit: UUID or name of an audit.
         """
         context = pecan.request.context
-        audit_to_delete = api_utils.get_resource(
-            'Audit', audit, eager=True)
-        policy.enforce(context, 'audit:delete', audit_to_delete,
-                       action='audit:delete')
+        audit_to_delete = api_utils.get_resource('Audit', audit, eager=True)
+        policy.enforce(
+            context, 'audit:delete', audit_to_delete, action='audit:delete'
+        )
 
         initial_state = audit_to_delete.state
         new_state = objects.audit.State.DELETED
-        if not objects.audit.AuditStateTransitionManager(
-                ).check_transition(initial_state, new_state):
-            raise exception.DeleteError(
-                state=initial_state)
+        if not objects.audit.AuditStateTransitionManager().check_transition(
+            initial_state, new_state
+        ):
+            raise exception.DeleteError(state=initial_state)
 
         audit_to_delete.soft_delete()
diff --git a/watcher/api/controllers/v1/audit_template.py b/watcher/api/controllers/v1/audit_template.py
index e04636429..4d6fbed70 100644
--- a/watcher/api/controllers/v1/audit_template.py
+++ b/watcher/api/controllers/v1/audit_template.py
@@ -113,17 +113,19 @@ class AuditTemplatePostType(wtypes.Base):
             "items": {
                 "type": "object",
                 "properties": AuditTemplatePostType._get_schemas(),
-                "additionalProperties": False
-            }
+                "additionalProperties": False,
+            },
         }
         return SCHEMA
 
     @staticmethod
     def _get_schemas():
-        collectors = default_loading.ClusterDataModelCollectorLoader(
-            ).list_available()
-        schemas = {k: c.SCHEMA for k, c
-                   in collectors.items() if hasattr(c, "SCHEMA")}
+        collectors = (
+            default_loading.ClusterDataModelCollectorLoader().list_available()
+        )
+        schemas = {
+            k: c.SCHEMA for k, c in collectors.items() if hasattr(c, "SCHEMA")
+        }
         return schemas
 
     @staticmethod
@@ -144,7 +146,7 @@ class AuditTemplatePostType(wtypes.Base):
                 audit_template.scope = [dict(compute=audit_template.scope)]
             common_utils.Draft4Validator(
                 AuditTemplatePostType._build_schema()
-                ).validate(audit_template.scope)
+            ).validate(audit_template.scope)
 
             include_host_aggregates = False
             exclude_host_aggregates = False
@@ -159,34 +161,47 @@ class AuditTemplatePostType(wtypes.Base):
                 raise exception.Invalid(
                     message=_(
                         "host_aggregates can't be "
-                        "included and excluded together"))
+                        "included and excluded together"
+                    )
+                )
 
         if audit_template.strategy:
             try:
-                if (common_utils.is_uuid_like(audit_template.strategy) or
-                        common_utils.is_int_like(audit_template.strategy)):
+                if common_utils.is_uuid_like(
+                    audit_template.strategy
+                ) or common_utils.is_int_like(audit_template.strategy):
                     strategy = objects.Strategy.get(
-                        AuditTemplatePostType._ctx, audit_template.strategy)
+                        AuditTemplatePostType._ctx, audit_template.strategy
+                    )
                 else:
                     strategy = objects.Strategy.get_by_name(
-                        AuditTemplatePostType._ctx, audit_template.strategy)
+                        AuditTemplatePostType._ctx, audit_template.strategy
+                    )
             except Exception:
                 raise exception.InvalidStrategy(
-                    strategy=audit_template.strategy)
+                    strategy=audit_template.strategy
+                )
 
             # Check that the strategy we indicate is actually related to the
             # specified goal
             if strategy.goal_id != goal.id:
                 available_strategies = objects.Strategy.list(
-                    AuditTemplatePostType._ctx)
-                choices = [f"'{s.uuid}' ({s.name})"
-                           for s in available_strategies]
+                    AuditTemplatePostType._ctx
+                )
+                choices = [
+                    f"'{s.uuid}' ({s.name})" for s in available_strategies
+                ]
                 raise exception.InvalidStrategy(
                     message=_(
                         "'%(strategy)s' strategy does relate to the "
-                        "'%(goal)s' goal. Possible choices: %(choices)s")
-                    % dict(strategy=strategy.name, goal=goal.name,
-                           choices=", ".join(choices)))
+                        "'%(goal)s' goal. Possible choices: %(choices)s"
+                    )
+                    % dict(
+                        strategy=strategy.name,
+                        goal=goal.name,
+                        choices=", ".join(choices),
+                    )
+                )
             audit_template.strategy = strategy.uuid
 
         # We force the UUID so that we do not need to query the DB with the
@@ -197,7 +212,6 @@ class AuditTemplatePostType(wtypes.Base):
 
 
 class AuditTemplatePatchType(types.JsonPatchType):
-
     _ctx = context_utils.make_context()
 
     @staticmethod
@@ -210,8 +224,8 @@ class AuditTemplatePatchType(types.JsonPatchType):
             AuditTemplatePatchType._validate_goal(patch)
         elif patch.path == "/goal" and patch.op == "remove":
             raise wsme.exc.ClientSideError(
-                _("Cannot remove 'goal' attribute "
-                  "from an audit template"))
+                _("Cannot remove 'goal' attribute from an audit template")
+            )
         if patch.path == "/strategy":
             AuditTemplatePatchType._validate_strategy(patch)
         return types.JsonPatchType.validate(patch)
@@ -222,8 +236,7 @@ class AuditTemplatePatchType(types.JsonPatchType):
         goal = patch.value
 
         if goal:
-            available_goals = objects.Goal.list(
-                AuditTemplatePatchType._ctx)
+            available_goals = objects.Goal.list(AuditTemplatePatchType._ctx)
             available_goal_uuids_map = {g.uuid: g for g in available_goals}
             available_goal_names_map = {g.name: g for g in available_goals}
             if goal in available_goal_uuids_map:
@@ -239,11 +252,14 @@ class AuditTemplatePatchType(types.JsonPatchType):
         strategy = patch.value
         if strategy:
             available_strategies = objects.Strategy.list(
-                AuditTemplatePatchType._ctx)
+                AuditTemplatePatchType._ctx
+            )
             available_strategy_uuids_map = {
-                s.uuid: s for s in available_strategies}
+                s.uuid: s for s in available_strategies
+            }
             available_strategy_names_map = {
-                s.name: s for s in available_strategies}
+                s.name: s for s in available_strategies
+            }
             if strategy in available_strategy_uuids_map:
                 patch.value = available_strategy_uuids_map[strategy].id
             elif strategy in available_strategy_names_map:
@@ -271,13 +287,12 @@ class AuditTemplate(base.APIBase):
             return None
         goal = None
         try:
-            if (common_utils.is_uuid_like(value) or
-                    common_utils.is_int_like(value)):
-                goal = objects.Goal.get(
-                    pecan.request.context, value)
+            if common_utils.is_uuid_like(value) or common_utils.is_int_like(
+                value
+            ):
+                goal = objects.Goal.get(pecan.request.context, value)
             else:
-                goal = objects.Goal.get_by_name(
-                    pecan.request.context, value)
+                goal = objects.Goal.get_by_name(pecan.request.context, value)
         except exception.GoalNotFound:
             pass
         if goal:
@@ -289,13 +304,14 @@ class AuditTemplate(base.APIBase):
             return None
         strategy = None
         try:
-            if (common_utils.is_uuid_like(value) or
-                    common_utils.is_int_like(value)):
-                strategy = objects.Strategy.get(
-                    pecan.request.context, value)
+            if common_utils.is_uuid_like(value) or common_utils.is_int_like(
+                value
+            ):
+                strategy = objects.Strategy.get(pecan.request.context, value)
             else:
                 strategy = objects.Strategy.get_by_name(
-                    pecan.request.context, value)
+                    pecan.request.context, value
+                )
         except exception.StrategyNotFound:
             pass
         if strategy:
@@ -352,19 +368,23 @@ class AuditTemplate(base.APIBase):
     """Short description of this audit template"""
 
     goal_uuid = wtypes.wsproperty(
-        wtypes.text, _get_goal_uuid, _set_goal_uuid, mandatory=True)
+        wtypes.text, _get_goal_uuid, _set_goal_uuid, mandatory=True
+    )
     """Goal UUID the audit template refers to"""
 
     goal_name = wtypes.wsproperty(
-        wtypes.text, _get_goal_name, _set_goal_name, mandatory=False)
+        wtypes.text, _get_goal_name, _set_goal_name, mandatory=False
+    )
     """The name of the goal this audit template refers to"""
 
     strategy_uuid = wtypes.wsproperty(
-        wtypes.text, _get_strategy_uuid, _set_strategy_uuid, mandatory=False)
+        wtypes.text, _get_strategy_uuid, _set_strategy_uuid, mandatory=False
+    )
     """Strategy UUID the audit template refers to"""
 
     strategy_name = wtypes.wsproperty(
-        wtypes.text, _get_strategy_name, _set_strategy_name, mandatory=False)
+        wtypes.text, _get_strategy_name, _set_strategy_name, mandatory=False
+    )
     """The name of the strategy this audit template refers to"""
 
     audits = wtypes.wsattr([link.Link], readonly=True)
@@ -400,50 +420,64 @@ class AuditTemplate(base.APIBase):
         self.fields.append('strategy_name')
         setattr(self, 'goal_uuid', kwargs.get('goal_id', wtypes.Unset))
         setattr(self, 'goal_name', kwargs.get('goal_id', wtypes.Unset))
-        setattr(self, 'strategy_uuid',
-                kwargs.get('strategy_id', wtypes.Unset))
-        setattr(self, 'strategy_name',
-                kwargs.get('strategy_id', wtypes.Unset))
+        setattr(self, 'strategy_uuid', kwargs.get('strategy_id', wtypes.Unset))
+        setattr(self, 'strategy_name', kwargs.get('strategy_id', wtypes.Unset))
 
     @staticmethod
     def _convert_with_links(audit_template, url, expand=True):
         if not expand:
             audit_template.unset_fields_except(
-                ['uuid', 'name', 'goal_uuid', 'goal_name',
-                 'scope', 'strategy_uuid', 'strategy_name'])
+                [
+                    'uuid',
+                    'name',
+                    'goal_uuid',
+                    'goal_name',
+                    'scope',
+                    'strategy_uuid',
+                    'strategy_name',
+                ]
+            )
 
         # The numeric ID should not be exposed to
         # the user, it's internal only.
         audit_template.goal_id = wtypes.Unset
         audit_template.strategy_id = wtypes.Unset
 
-        audit_template.links = [link.Link.make_link('self', url,
-                                                    'audit_templates',
-                                                    audit_template.uuid),
-                                link.Link.make_link('bookmark', url,
-                                                    'audit_templates',
-                                                    audit_template.uuid,
-                                                    bookmark=True)]
+        audit_template.links = [
+            link.Link.make_link(
+                'self', url, 'audit_templates', audit_template.uuid
+            ),
+            link.Link.make_link(
+                'bookmark',
+                url,
+                'audit_templates',
+                audit_template.uuid,
+                bookmark=True,
+            ),
+        ]
         return audit_template
 
     @classmethod
     def convert_with_links(cls, rpc_audit_template, expand=True):
         audit_template = AuditTemplate(**rpc_audit_template.as_dict())
         hide_fields_in_newer_versions(audit_template)
-        return cls._convert_with_links(audit_template, pecan.request.host_url,
-                                       expand)
+        return cls._convert_with_links(
+            audit_template, pecan.request.host_url, expand
+        )
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
-                     name='My Audit Template',
-                     description='Description of my audit template',
-                     goal_uuid='83e44733-b640-40e2-8d8a-7dd3be7134e6',
-                     strategy_uuid='367d826e-b6a4-4b70-bc44-c3f6fe1c9986',
-                     created_at=timeutils.utcnow(),
-                     deleted_at=None,
-                     updated_at=timeutils.utcnow(),
-                     scope=[],)
+        sample = cls(
+            uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
+            name='My Audit Template',
+            description='Description of my audit template',
+            goal_uuid='83e44733-b640-40e2-8d8a-7dd3be7134e6',
+            strategy_uuid='367d826e-b6a4-4b70-bc44-c3f6fe1c9986',
+            created_at=timeutils.utcnow(),
+            deleted_at=None,
+            updated_at=timeutils.utcnow(),
+            scope=[],
+        )
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
 
@@ -458,12 +492,14 @@ class AuditTemplateCollection(collection.Collection):
         self._type = 'audit_templates'
 
     @staticmethod
-    def convert_with_links(rpc_audit_templates, limit, url=None, expand=False,
-                           **kwargs):
+    def convert_with_links(
+        rpc_audit_templates, limit, url=None, expand=False, **kwargs
+    ):
         at_collection = AuditTemplateCollection()
         at_collection.audit_templates = [
             AuditTemplate.convert_with_links(p, expand)
-            for p in rpc_audit_templates]
+            for p in rpc_audit_templates
+        ]
         at_collection.next = at_collection.get_next(limit, url=url, **kwargs)
         return at_collection
 
@@ -480,54 +516,90 @@ class AuditTemplatesController(rest.RestController):
     def __init__(self):
         super().__init__()
 
-    _custom_actions = {
-        'detail': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET']}
 
-    def _get_audit_templates_collection(self, filters, marker, limit,
-                                        sort_key, sort_dir, expand=False,
-                                        resource_url=None):
-        additional_fields = ["goal_uuid", "goal_name", "strategy_uuid",
-                             "strategy_name"]
+    def _get_audit_templates_collection(
+        self,
+        filters,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+    ):
+        additional_fields = [
+            "goal_uuid",
+            "goal_name",
+            "strategy_uuid",
+            "strategy_name",
+        ]
 
         api_utils.validate_sort_key(
-            sort_key, list(objects.AuditTemplate.fields) + additional_fields)
+            sort_key, list(objects.AuditTemplate.fields) + additional_fields
+        )
         api_utils.validate_search_filters(
-            filters, list(objects.AuditTemplate.fields) + additional_fields)
+            filters, list(objects.AuditTemplate.fields) + additional_fields
+        )
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
             marker_obj = objects.AuditTemplate.get_by_uuid(
-                pecan.request.context,
-                marker)
+                pecan.request.context, marker
+            )
 
-        need_api_sort = api_utils.check_need_api_sort(sort_key,
-                                                      additional_fields)
-        sort_db_key = (sort_key if not need_api_sort
-                       else None)
+        need_api_sort = api_utils.check_need_api_sort(
+            sort_key, additional_fields
+        )
+        sort_db_key = sort_key if not need_api_sort else None
 
         audit_templates = objects.AuditTemplate.list(
-            pecan.request.context, filters, limit, marker_obj,
-            sort_key=sort_db_key, sort_dir=sort_dir)
+            pecan.request.context,
+            filters,
+            limit,
+            marker_obj,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+        )
 
-        audit_templates_collection = \
+        audit_templates_collection = (
             AuditTemplateCollection.convert_with_links(
-                audit_templates, limit, url=resource_url, expand=expand,
-                sort_key=sort_key, sort_dir=sort_dir)
+                audit_templates,
+                limit,
+                url=resource_url,
+                expand=expand,
+                sort_key=sort_key,
+                sort_dir=sort_dir,
+            )
+        )
 
         if need_api_sort:
             api_utils.make_api_sort(
-                audit_templates_collection.audit_templates, sort_key,
-                sort_dir)
+                audit_templates_collection.audit_templates, sort_key, sort_dir
+            )
 
         return audit_templates_collection
 
-    @wsme_pecan.wsexpose(AuditTemplateCollection, wtypes.text, wtypes.text,
-                         types.uuid, int, wtypes.text, wtypes.text)
-    def get_all(self, goal=None, strategy=None, marker=None,
-                limit=None, sort_key='id', sort_dir='asc'):
+    @wsme_pecan.wsexpose(
+        AuditTemplateCollection,
+        wtypes.text,
+        wtypes.text,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+    )
+    def get_all(
+        self,
+        goal=None,
+        strategy=None,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+    ):
         """Retrieve a list of audit templates.
 
         :param goal: goal UUID or name to filter by
@@ -538,8 +610,9 @@ class AuditTemplatesController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'audit_template:get_all',
-                       action='audit_template:get_all')
+        policy.enforce(
+            context, 'audit_template:get_all', action='audit_template:get_all'
+        )
         filters = {}
         if goal:
             if common_utils.is_uuid_like(goal):
@@ -554,12 +627,27 @@ class AuditTemplatesController(rest.RestController):
                 filters['strategy_name'] = strategy
 
         return self._get_audit_templates_collection(
-            filters, marker, limit, sort_key, sort_dir)
+            filters, marker, limit, sort_key, sort_dir
+        )
 
-    @wsme_pecan.wsexpose(AuditTemplateCollection, wtypes.text, wtypes.text,
-                         types.uuid, int, wtypes.text, wtypes.text)
-    def detail(self, goal=None, strategy=None, marker=None,
-               limit=None, sort_key='id', sort_dir='asc'):
+    @wsme_pecan.wsexpose(
+        AuditTemplateCollection,
+        wtypes.text,
+        wtypes.text,
+        types.uuid,
+        int,
+        wtypes.text,
+        wtypes.text,
+    )
+    def detail(
+        self,
+        goal=None,
+        strategy=None,
+        marker=None,
+        limit=None,
+        sort_key='id',
+        sort_dir='asc',
+    ):
         """Retrieve a list of audit templates with detail.
 
         :param goal: goal UUID or name to filter by
@@ -570,8 +658,9 @@ class AuditTemplatesController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'audit_template:detail',
-                       action='audit_template:detail')
+        policy.enforce(
+            context, 'audit_template:detail', action='audit_template:detail'
+        )
 
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
@@ -593,9 +682,9 @@ class AuditTemplatesController(rest.RestController):
 
         expand = True
         resource_url = '/'.join(['audit_templates', 'detail'])
-        return self._get_audit_templates_collection(filters, marker, limit,
-                                                    sort_key, sort_dir, expand,
-                                                    resource_url)
+        return self._get_audit_templates_collection(
+            filters, marker, limit, sort_key, sort_dir, expand, resource_url
+        )
 
     @wsme_pecan.wsexpose(AuditTemplate, wtypes.text)
     def get_one(self, audit_template):
@@ -604,16 +693,24 @@ class AuditTemplatesController(rest.RestController):
         :param audit_template: UUID or name of an audit template.
         """
         context = pecan.request.context
-        rpc_audit_template = api_utils.get_resource('AuditTemplate',
-                                                    audit_template)
-        policy.enforce(context, 'audit_template:get', rpc_audit_template,
-                       action='audit_template:get')
+        rpc_audit_template = api_utils.get_resource(
+            'AuditTemplate', audit_template
+        )
+        policy.enforce(
+            context,
+            'audit_template:get',
+            rpc_audit_template,
+            action='audit_template:get',
+        )
 
         return AuditTemplate.convert_with_links(rpc_audit_template)
 
     @wsme.validate(types.uuid, AuditTemplatePostType)
-    @wsme_pecan.wsexpose(AuditTemplate, body=AuditTemplatePostType,
-                         status_code=HTTPStatus.CREATED)
+    @wsme_pecan.wsexpose(
+        AuditTemplate,
+        body=AuditTemplatePostType,
+        status_code=HTTPStatus.CREATED,
+    )
     def post(self, audit_template_postdata):
         """Create a new audit template.
 
@@ -621,24 +718,28 @@ class AuditTemplatesController(rest.RestController):
                                         from the request body.
         """
         context = pecan.request.context
-        policy.enforce(context, 'audit_template:create',
-                       action='audit_template:create')
+        policy.enforce(
+            context, 'audit_template:create', action='audit_template:create'
+        )
 
         context = pecan.request.context
         audit_template = audit_template_postdata.as_audit_template()
         audit_template_dict = audit_template.as_dict()
-        new_audit_template = objects.AuditTemplate(context,
-                                                   **audit_template_dict)
+        new_audit_template = objects.AuditTemplate(
+            context, **audit_template_dict
+        )
         new_audit_template.create()
 
         # Set the HTTP Location Header
         pecan.response.location = link.build_url(
-            'audit_templates', new_audit_template.uuid)
+            'audit_templates', new_audit_template.uuid
+        )
         return AuditTemplate.convert_with_links(new_audit_template)
 
     @wsme.validate(types.uuid, [AuditTemplatePatchType])
-    @wsme_pecan.wsexpose(AuditTemplate, wtypes.text,
-                         body=[AuditTemplatePatchType])
+    @wsme_pecan.wsexpose(
+        AuditTemplate, wtypes.text, body=[AuditTemplatePatchType]
+    )
     def patch(self, audit_template, patch):
         """Update an existing audit template.
 
@@ -646,25 +747,30 @@ class AuditTemplatesController(rest.RestController):
         :param patch: a json PATCH document to apply to this audit template.
         """
         context = pecan.request.context
-        audit_template_to_update = api_utils.get_resource('AuditTemplate',
-                                                          audit_template)
-        policy.enforce(context, 'audit_template:update',
-                       audit_template_to_update,
-                       action='audit_template:update')
+        audit_template_to_update = api_utils.get_resource(
+            'AuditTemplate', audit_template
+        )
+        policy.enforce(
+            context,
+            'audit_template:update',
+            audit_template_to_update,
+            action='audit_template:update',
+        )
 
         if common_utils.is_uuid_like(audit_template):
             audit_template_to_update = objects.AuditTemplate.get_by_uuid(
-                pecan.request.context,
-                audit_template)
+                pecan.request.context, audit_template
+            )
         else:
             audit_template_to_update = objects.AuditTemplate.get_by_name(
-                pecan.request.context,
-                audit_template)
+                pecan.request.context, audit_template
+            )
 
         try:
             audit_template_dict = audit_template_to_update.as_dict()
-            audit_template = AuditTemplate(**api_utils.apply_jsonpatch(
-                audit_template_dict, patch))
+            audit_template = AuditTemplate(
+                **api_utils.apply_jsonpatch(audit_template_dict, patch)
+            )
         except api_utils.JSONPATCH_EXCEPTIONS as e:
             raise exception.PatchError(patch=patch, reason=e)
 
@@ -690,10 +796,14 @@ class AuditTemplatesController(rest.RestController):
         :param template_uuid: UUID or name of an audit template.
         """
         context = pecan.request.context
-        audit_template_to_delete = api_utils.get_resource('AuditTemplate',
-                                                          audit_template)
-        policy.enforce(context, 'audit_template:delete',
-                       audit_template_to_delete,
-                       action='audit_template:delete')
+        audit_template_to_delete = api_utils.get_resource(
+            'AuditTemplate', audit_template
+        )
+        policy.enforce(
+            context,
+            'audit_template:delete',
+            audit_template_to_delete,
+            action='audit_template:delete',
+        )
 
         audit_template_to_delete.soft_delete()
diff --git a/watcher/api/controllers/v1/collection.py b/watcher/api/controllers/v1/collection.py
index 39f29c9cc..d6967cc83 100644
--- a/watcher/api/controllers/v1/collection.py
+++ b/watcher/api/controllers/v1/collection.py
@@ -23,7 +23,6 @@ from watcher.api.controllers import link
 
 
 class Collection(base.APIBase):
-
     next = wtypes.text
     """A link to retrieve the next subset of the collection"""
 
@@ -45,5 +44,6 @@ class Collection(base.APIBase):
         marker = getattr(self.collection[-1], marker_field)
         next_args = f'?{q_args}limit={limit:d}&marker={marker}'
 
-        return link.Link.make_link('next', pecan.request.host_url,
-                                   resource_url, next_args).href
+        return link.Link.make_link(
+            'next', pecan.request.host_url, resource_url, next_args
+        ).href
diff --git a/watcher/api/controllers/v1/data_model.py b/watcher/api/controllers/v1/data_model.py
index 15ef8af8c..7716d5673 100644
--- a/watcher/api/controllers/v1/data_model.py
+++ b/watcher/api/controllers/v1/data_model.py
@@ -65,19 +65,18 @@ class DataModelController(rest.RestController):
         """
         if not utils.allow_list_datamodel():
             raise exception.NotAcceptable
-        allowed_data_model_type = [
-            'compute',
-            ]
+        allowed_data_model_type = ['compute']
         if data_model_type not in allowed_data_model_type:
             raise exception.DataModelTypeNotFound(
-                data_model_type=data_model_type)
+                data_model_type=data_model_type
+            )
         context = pecan.request.context
         de_client = rpcapi.DecisionEngineAPI()
-        policy.enforce(context, 'data_model:get_all',
-                       action='data_model:get_all')
+        policy.enforce(
+            context, 'data_model:get_all', action='data_model:get_all'
+        )
         rpc_all_data_model = de_client.get_data_model_info(
-            context,
-            data_model_type,
-            audit_uuid)
+            context, data_model_type, audit_uuid
+        )
         hide_fields_in_newer_versions(rpc_all_data_model)
         return rpc_all_data_model
diff --git a/watcher/api/controllers/v1/goal.py b/watcher/api/controllers/v1/goal.py
index afdec0cdf..ef606ca58 100644
--- a/watcher/api/controllers/v1/goal.py
+++ b/watcher/api/controllers/v1/goal.py
@@ -93,14 +93,16 @@ class Goal(base.APIBase):
     @staticmethod
     def _convert_with_links(goal, url, expand=True):
         if not expand:
-            goal.unset_fields_except(['uuid', 'name', 'display_name',
-                                      'efficacy_specification'])
+            goal.unset_fields_except(
+                ['uuid', 'name', 'display_name', 'efficacy_specification']
+            )
 
-        goal.links = [link.Link.make_link('self', url,
-                                          'goals', goal.uuid),
-                      link.Link.make_link('bookmark', url,
-                                          'goals', goal.uuid,
-                                          bookmark=True)]
+        goal.links = [
+            link.Link.make_link('self', url, 'goals', goal.uuid),
+            link.Link.make_link(
+                'bookmark', url, 'goals', goal.uuid, bookmark=True
+            ),
+        ]
         return goal
 
     @classmethod
@@ -116,11 +118,15 @@ class Goal(base.APIBase):
             name='DUMMY',
             display_name='Dummy strategy',
             efficacy_specification=[
-                {'description': 'Dummy indicator', 'name': 'dummy',
-                 'schema': 'Range(min=0, max=100, min_included=True, '
-                           'max_included=True, msg=None)',
-                 'unit': '%'}
-            ])
+                {
+                    'description': 'Dummy indicator',
+                    'name': 'dummy',
+                    'schema': 'Range(min=0, max=100, min_included=True, '
+                    'max_included=True, msg=None)',
+                    'unit': '%',
+                }
+            ],
+        )
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
 
@@ -135,13 +141,14 @@ class GoalCollection(collection.Collection):
         self._type = 'goals'
 
     @staticmethod
-    def convert_with_links(goals, limit, url=None, expand=False,
-                           **kwargs):
+    def convert_with_links(goals, limit, url=None, expand=False, **kwargs):
         goal_collection = GoalCollection()
         goal_collection.goals = [
-            Goal.convert_with_links(g, expand) for g in goals]
+            Goal.convert_with_links(g, expand) for g in goals
+        ]
         goal_collection.next = goal_collection.get_next(
-            limit, url=url, **kwargs)
+            limit, url=url, **kwargs
+        )
         return goal_collection
 
     @classmethod
@@ -157,36 +164,49 @@ class GoalsController(rest.RestController):
     def __init__(self):
         super().__init__()
 
-    _custom_actions = {
-        'detail': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET']}
 
-    def _get_goals_collection(self, marker, limit, sort_key, sort_dir,
-                              expand=False, resource_url=None):
-        api_utils.validate_sort_key(
-            sort_key, list(objects.Goal.fields))
+    def _get_goals_collection(
+        self,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+    ):
+        api_utils.validate_sort_key(sort_key, list(objects.Goal.fields))
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
             marker_obj = objects.Goal.get_by_uuid(
-                pecan.request.context, marker)
+                pecan.request.context, marker
+            )
 
-        sort_db_key = (sort_key if sort_key in objects.Goal.fields
-                       else None)
+        sort_db_key = sort_key if sort_key in objects.Goal.fields else None
 
-        goals = objects.Goal.list(pecan.request.context, limit, marker_obj,
-                                  sort_key=sort_db_key, sort_dir=sort_dir)
+        goals = objects.Goal.list(
+            pecan.request.context,
+            limit,
+            marker_obj,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+        )
 
-        return GoalCollection.convert_with_links(goals, limit,
-                                                 url=resource_url,
-                                                 expand=expand,
-                                                 sort_key=sort_key,
-                                                 sort_dir=sort_dir)
+        return GoalCollection.convert_with_links(
+            goals,
+            limit,
+            url=resource_url,
+            expand=expand,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+        )
 
-    @wsme_pecan.wsexpose(GoalCollection, wtypes.text,
-                         int, wtypes.text, wtypes.text)
+    @wsme_pecan.wsexpose(
+        GoalCollection, wtypes.text, int, wtypes.text, wtypes.text
+    )
     def get_all(self, marker=None, limit=None, sort_key='id', sort_dir='asc'):
         """Retrieve a list of goals.
 
@@ -196,12 +216,12 @@ class GoalsController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'goal:get_all',
-                       action='goal:get_all')
+        policy.enforce(context, 'goal:get_all', action='goal:get_all')
         return self._get_goals_collection(marker, limit, sort_key, sort_dir)
 
-    @wsme_pecan.wsexpose(GoalCollection, wtypes.text, int,
-                         wtypes.text, wtypes.text)
+    @wsme_pecan.wsexpose(
+        GoalCollection, wtypes.text, int, wtypes.text, wtypes.text
+    )
     def detail(self, marker=None, limit=None, sort_key='id', sort_dir='asc'):
         """Retrieve a list of goals with detail.
 
@@ -211,16 +231,16 @@ class GoalsController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'goal:detail',
-                       action='goal:detail')
+        policy.enforce(context, 'goal:detail', action='goal:detail')
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
         if parent != "goals":
             raise exception.HTTPNotFound
         expand = True
         resource_url = '/'.join(['goals', 'detail'])
-        return self._get_goals_collection(marker, limit, sort_key, sort_dir,
-                                          expand, resource_url)
+        return self._get_goals_collection(
+            marker, limit, sort_key, sort_dir, expand, resource_url
+        )
 
     @wsme_pecan.wsexpose(Goal, wtypes.text)
     def get_one(self, goal):
diff --git a/watcher/api/controllers/v1/scoring_engine.py b/watcher/api/controllers/v1/scoring_engine.py
index 042bd868f..e6b31b3bf 100644
--- a/watcher/api/controllers/v1/scoring_engine.py
+++ b/watcher/api/controllers/v1/scoring_engine.py
@@ -91,14 +91,14 @@ class ScoringEngine(base.APIBase):
     @staticmethod
     def _convert_with_links(se, url, expand=True):
         if not expand:
-            se.unset_fields_except(
-                ['uuid', 'name', 'description'])
+            se.unset_fields_except(['uuid', 'name', 'description'])
 
-        se.links = [link.Link.make_link('self', url,
-                                        'scoring_engines', se.uuid),
-                    link.Link.make_link('bookmark', url,
-                                        'scoring_engines', se.uuid,
-                                        bookmark=True)]
+        se.links = [
+            link.Link.make_link('self', url, 'scoring_engines', se.uuid),
+            link.Link.make_link(
+                'bookmark', url, 'scoring_engines', se.uuid, bookmark=True
+            ),
+        ]
         return se
 
     @classmethod
@@ -106,13 +106,16 @@ class ScoringEngine(base.APIBase):
         scoring_engine = ScoringEngine(**scoring_engine.as_dict())
         hide_fields_in_newer_versions(scoring_engine)
         return cls._convert_with_links(
-            scoring_engine, pecan.request.host_url, expand)
+            scoring_engine, pecan.request.host_url, expand
+        )
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(uuid='81bbd3c7-3b08-4d12-a268-99354dbf7b71',
-                     name='sample-se-123',
-                     description='Sample Scoring Engine 123 just for testing')
+        sample = cls(
+            uuid='81bbd3c7-3b08-4d12-a268-99354dbf7b71',
+            name='sample-se-123',
+            description='Sample Scoring Engine 123 just for testing',
+        )
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
 
@@ -127,12 +130,14 @@ class ScoringEngineCollection(collection.Collection):
         self._type = 'scoring_engines'
 
     @staticmethod
-    def convert_with_links(scoring_engines, limit, url=None, expand=False,
-                           **kwargs):
-
+    def convert_with_links(
+        scoring_engines, limit, url=None, expand=False, **kwargs
+    ):
         collection = ScoringEngineCollection()
-        collection.scoring_engines = [ScoringEngine.convert_with_links(
-            se, expand) for se in scoring_engines]
+        collection.scoring_engines = [
+            ScoringEngine.convert_with_links(se, expand)
+            for se in scoring_engines
+        ]
         collection.next = collection.get_next(limit, url=url, **kwargs)
         return collection
 
@@ -149,27 +154,34 @@ class ScoringEngineController(rest.RestController):
     def __init__(self):
         super().__init__()
 
-    _custom_actions = {
-        'detail': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET']}
 
-    def _get_scoring_engines_collection(self, marker, limit,
-                                        sort_key, sort_dir, expand=False,
-                                        resource_url=None):
+    def _get_scoring_engines_collection(
+        self,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+    ):
         api_utils.validate_sort_key(
-            sort_key, list(objects.ScoringEngine.fields))
+            sort_key, list(objects.ScoringEngine.fields)
+        )
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
             marker_obj = objects.ScoringEngine.get_by_uuid(
-                pecan.request.context, marker)
+                pecan.request.context, marker
+            )
 
         filters = {}
 
-        sort_db_key = (sort_key if sort_key in objects.ScoringEngine.fields
-                       else None)
+        sort_db_key = (
+            sort_key if sort_key in objects.ScoringEngine.fields else None
+        )
 
         scoring_engines = objects.ScoringEngine.list(
             context=pecan.request.context,
@@ -177,7 +189,8 @@ class ScoringEngineController(rest.RestController):
             marker=marker_obj,
             sort_key=sort_db_key,
             sort_dir=sort_dir,
-            filters=filters)
+            filters=filters,
+        )
 
         return ScoringEngineCollection.convert_with_links(
             scoring_engines,
@@ -185,12 +198,13 @@ class ScoringEngineController(rest.RestController):
             url=resource_url,
             expand=expand,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+        )
 
-    @wsme_pecan.wsexpose(ScoringEngineCollection, wtypes.text,
-                         int, wtypes.text, wtypes.text)
-    def get_all(self, marker=None, limit=None, sort_key='id',
-                sort_dir='asc'):
+    @wsme_pecan.wsexpose(
+        ScoringEngineCollection, wtypes.text, int, wtypes.text, wtypes.text
+    )
+    def get_all(self, marker=None, limit=None, sort_key='id', sort_dir='asc'):
         """Retrieve a list of Scoring Engines.
 
         :param marker: pagination marker for large data sets.
@@ -199,14 +213,17 @@ class ScoringEngineController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'scoring_engine:get_all',
-                       action='scoring_engine:get_all')
+        policy.enforce(
+            context, 'scoring_engine:get_all', action='scoring_engine:get_all'
+        )
 
         return self._get_scoring_engines_collection(
-            marker, limit, sort_key, sort_dir)
+            marker, limit, sort_key, sort_dir
+        )
 
-    @wsme_pecan.wsexpose(ScoringEngineCollection, wtypes.text,
-                         int, wtypes.text, wtypes.text)
+    @wsme_pecan.wsexpose(
+        ScoringEngineCollection, wtypes.text, int, wtypes.text, wtypes.text
+    )
     def detail(self, marker=None, limit=None, sort_key='id', sort_dir='asc'):
         """Retrieve a list of Scoring Engines with detail.
 
@@ -216,8 +233,9 @@ class ScoringEngineController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'scoring_engine:detail',
-                       action='scoring_engine:detail')
+        policy.enforce(
+            context, 'scoring_engine:detail', action='scoring_engine:detail'
+        )
 
         parent = pecan.request.path.split('/')[:-1][-1]
         if parent != "scoring_engines":
@@ -225,7 +243,8 @@ class ScoringEngineController(rest.RestController):
         expand = True
         resource_url = '/'.join(['scoring_engines', 'detail'])
         return self._get_scoring_engines_collection(
-            marker, limit, sort_key, sort_dir, expand, resource_url)
+            marker, limit, sort_key, sort_dir, expand, resource_url
+        )
 
     @wsme_pecan.wsexpose(ScoringEngine, wtypes.text)
     def get_one(self, scoring_engine):
@@ -234,9 +253,11 @@ class ScoringEngineController(rest.RestController):
         :param scoring_engine_name: The name of the Scoring Engine.
         """
         context = pecan.request.context
-        policy.enforce(context, 'scoring_engine:get',
-                       action='scoring_engine:get')
+        policy.enforce(
+            context, 'scoring_engine:get', action='scoring_engine:get'
+        )
         rpc_scoring_engine = api_utils.get_resource(
-            'ScoringEngine', scoring_engine)
+            'ScoringEngine', scoring_engine
+        )
 
         return ScoringEngine.convert_with_links(rpc_scoring_engine)
diff --git a/watcher/api/controllers/v1/service.py b/watcher/api/controllers/v1/service.py
index d1d8251ce..0caf86f03 100644
--- a/watcher/api/controllers/v1/service.py
+++ b/watcher/api/controllers/v1/service.py
@@ -67,8 +67,9 @@ class Service(base.APIBase):
 
     def _set_status(self, id):
         service = objects.Service.get(pecan.request.context, id)
-        last_heartbeat = (service.last_seen_up or service.updated_at or
-                          service.created_at)
+        last_heartbeat = (
+            service.last_seen_up or service.updated_at or service.created_at
+        )
         if isinstance(last_heartbeat, str):
             # NOTE(russellb) If this service came in over rpc via
             # conductor, then the timestamp will be a string and needs to be
@@ -81,12 +82,17 @@ class Service(base.APIBase):
         elapsed = timeutils.delta_seconds(last_heartbeat, timeutils.utcnow())
         is_up = abs(elapsed) <= CONF.service_down_time
         if not is_up:
-            LOG.warning('Seems service %(name)s on host %(host)s is down. '
-                        'Last heartbeat was %(lhb)s.'
-                        'Elapsed time is %(el)s',
-                        {'name': service.name,
-                         'host': service.host,
-                         'lhb': str(last_heartbeat), 'el': str(elapsed)})
+            LOG.warning(
+                'Seems service %(name)s on host %(host)s is down. '
+                'Last heartbeat was %(lhb)s.'
+                'Elapsed time is %(el)s',
+                {
+                    'name': service.name,
+                    'host': service.host,
+                    'lhb': str(last_heartbeat),
+                    'el': str(elapsed),
+                },
+            )
             self._status = objects.service.ServiceStatus.FAILED
         else:
             self._status = objects.service.ServiceStatus.ACTIVE
@@ -103,8 +109,9 @@ class Service(base.APIBase):
     last_seen_up = wtypes.wsattr(datetime.datetime, readonly=True)
     """Time when Watcher service sent latest heartbeat."""
 
-    status = wtypes.wsproperty(wtypes.text, _get_status, _set_status,
-                               mandatory=True)
+    status = wtypes.wsproperty(
+        wtypes.text, _get_status, _set_status, mandatory=True
+    )
 
     links = wtypes.wsattr([link.Link], readonly=True)
     """A list containing a self link."""
@@ -116,34 +123,39 @@ class Service(base.APIBase):
         self.fields = []
         for field in fields:
             self.fields.append(field)
-            setattr(self, field, kwargs.get(
-                field if field != 'status' else 'id', wtypes.Unset))
+            setattr(
+                self,
+                field,
+                kwargs.get(field if field != 'status' else 'id', wtypes.Unset),
+            )
 
     @staticmethod
     def _convert_with_links(service, url, expand=True):
         if not expand:
-            service.unset_fields_except(
-                ['id', 'name', 'host', 'status'])
+            service.unset_fields_except(['id', 'name', 'host', 'status'])
 
         service.links = [
             link.Link.make_link('self', url, 'services', str(service.id)),
-            link.Link.make_link('bookmark', url, 'services', str(service.id),
-                                bookmark=True)]
+            link.Link.make_link(
+                'bookmark', url, 'services', str(service.id), bookmark=True
+            ),
+        ]
         return service
 
     @classmethod
     def convert_with_links(cls, service, expand=True):
         service = Service(**service.as_dict())
         hide_fields_in_newer_versions(service)
-        return cls._convert_with_links(
-            service, pecan.request.host_url, expand)
+        return cls._convert_with_links(service, pecan.request.host_url, expand)
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(id=1,
-                     name='watcher-applier',
-                     host='Controller',
-                     last_seen_up=datetime.datetime(2016, 1, 1))
+        sample = cls(
+            id=1,
+            name='watcher-applier',
+            host='Controller',
+            last_seen_up=datetime.datetime(2016, 1, 1),
+        )
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
 
@@ -158,13 +170,14 @@ class ServiceCollection(collection.Collection):
         self._type = 'services'
 
     @staticmethod
-    def convert_with_links(services, limit, url=None, expand=False,
-                           **kwargs):
+    def convert_with_links(services, limit, url=None, expand=False, **kwargs):
         service_collection = ServiceCollection()
         service_collection.services = [
-            Service.convert_with_links(g, expand) for g in services]
+            Service.convert_with_links(g, expand) for g in services
+        ]
         service_collection.next = service_collection.get_next(
-            limit, url=url, marker_field='id', **kwargs)
+            limit, url=url, marker_field='id', **kwargs
+        )
         return service_collection
 
     @classmethod
@@ -180,32 +193,43 @@ class ServicesController(rest.RestController):
     def __init__(self):
         super().__init__()
 
-    _custom_actions = {
-        'detail': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET']}
 
-    def _get_services_collection(self, marker, limit, sort_key, sort_dir,
-                                 expand=False, resource_url=None):
-        api_utils.validate_sort_key(
-            sort_key, list(objects.Service.fields))
+    def _get_services_collection(
+        self,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+    ):
+        api_utils.validate_sort_key(sort_key, list(objects.Service.fields))
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
-            marker_obj = objects.Service.get(
-                pecan.request.context, marker)
+            marker_obj = objects.Service.get(pecan.request.context, marker)
 
-        sort_db_key = (sort_key if sort_key in objects.Service.fields
-                       else None)
+        sort_db_key = sort_key if sort_key in objects.Service.fields else None
 
         services = objects.Service.list(
-            pecan.request.context, limit, marker_obj,
-            sort_key=sort_db_key, sort_dir=sort_dir)
+            pecan.request.context,
+            limit,
+            marker_obj,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+        )
 
         return ServiceCollection.convert_with_links(
-            services, limit, url=resource_url, expand=expand,
-            sort_key=sort_key, sort_dir=sort_dir)
+            services,
+            limit,
+            url=resource_url,
+            expand=expand,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+        )
 
     @wsme_pecan.wsexpose(ServiceCollection, int, int, wtypes.text, wtypes.text)
     def get_all(self, marker=None, limit=None, sort_key='id', sort_dir='asc'):
@@ -217,8 +241,7 @@ class ServicesController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'service:get_all',
-                       action='service:get_all')
+        policy.enforce(context, 'service:get_all', action='service:get_all')
 
         return self._get_services_collection(marker, limit, sort_key, sort_dir)
 
@@ -232,8 +255,7 @@ class ServicesController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'service:detail',
-                       action='service:detail')
+        policy.enforce(context, 'service:detail', action='service:detail')
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
         if parent != "services":
@@ -242,7 +264,8 @@ class ServicesController(rest.RestController):
         resource_url = '/'.join(['services', 'detail'])
 
         return self._get_services_collection(
-            marker, limit, sort_key, sort_dir, expand, resource_url)
+            marker, limit, sort_key, sort_dir, expand, resource_url
+        )
 
     @wsme_pecan.wsexpose(Service, wtypes.text)
     def get_one(self, service):
@@ -252,7 +275,8 @@ class ServicesController(rest.RestController):
         """
         context = pecan.request.context
         rpc_service = api_utils.get_resource('Service', service)
-        policy.enforce(context, 'service:get', rpc_service,
-                       action='service:get')
+        policy.enforce(
+            context, 'service:get', rpc_service, action='service:get'
+        )
 
         return Service.convert_with_links(rpc_service)
diff --git a/watcher/api/controllers/v1/strategy.py b/watcher/api/controllers/v1/strategy.py
index 4d24969c8..5b2d0f998 100644
--- a/watcher/api/controllers/v1/strategy.py
+++ b/watcher/api/controllers/v1/strategy.py
@@ -60,6 +60,7 @@ class Strategy(base.APIBase):
     This class enforces type checking and value constraints, and converts
     between the internal object model and the API representation of a strategy.
     """
+
     _goal_uuid = None
     _goal_name = None
 
@@ -68,8 +69,9 @@ class Strategy(base.APIBase):
             return None
         goal = None
         try:
-            if (common_utils.is_uuid_like(value) or
-                    common_utils.is_int_like(value)):
+            if common_utils.is_uuid_like(value) or common_utils.is_int_like(
+                value
+            ):
                 goal = objects.Goal.get(pecan.request.context, value)
             else:
                 goal = objects.Goal.get_by_name(pecan.request.context, value)
@@ -111,12 +113,14 @@ class Strategy(base.APIBase):
     links = wtypes.wsattr([link.Link], readonly=True)
     """A list containing a self link and associated goal links"""
 
-    goal_uuid = wtypes.wsproperty(wtypes.text, _get_goal_uuid, _set_goal_uuid,
-                                  mandatory=True)
+    goal_uuid = wtypes.wsproperty(
+        wtypes.text, _get_goal_uuid, _set_goal_uuid, mandatory=True
+    )
     """The UUID of the goal this audit refers to"""
 
-    goal_name = wtypes.wsproperty(wtypes.text, _get_goal_name, _set_goal_name,
-                                  mandatory=False)
+    goal_name = wtypes.wsproperty(
+        wtypes.text, _get_goal_name, _set_goal_name, mandatory=False
+    )
     """The name of the goal this audit refers to"""
 
     parameters_spec = {wtypes.text: types.jsontype}
@@ -137,19 +141,25 @@ class Strategy(base.APIBase):
         setattr(self, 'display_name', kwargs.get('display_name', wtypes.Unset))
         setattr(self, 'goal_uuid', kwargs.get('goal_id', wtypes.Unset))
         setattr(self, 'goal_name', kwargs.get('goal_id', wtypes.Unset))
-        setattr(self, 'parameters_spec', kwargs.get('parameters_spec',
-                wtypes.Unset))
+        setattr(
+            self,
+            'parameters_spec',
+            kwargs.get('parameters_spec', wtypes.Unset),
+        )
 
     @staticmethod
     def _convert_with_links(strategy, url, expand=True):
         if not expand:
             strategy.unset_fields_except(
-                ['uuid', 'name', 'display_name', 'goal_uuid', 'goal_name'])
+                ['uuid', 'name', 'display_name', 'goal_uuid', 'goal_name']
+            )
 
         strategy.links = [
             link.Link.make_link('self', url, 'strategies', strategy.uuid),
-            link.Link.make_link('bookmark', url, 'strategies', strategy.uuid,
-                                bookmark=True)]
+            link.Link.make_link(
+                'bookmark', url, 'strategies', strategy.uuid, bookmark=True
+            ),
+        ]
         return strategy
 
     @classmethod
@@ -157,13 +167,16 @@ class Strategy(base.APIBase):
         strategy = Strategy(**strategy.as_dict())
         hide_fields_in_newer_versions(strategy)
         return cls._convert_with_links(
-            strategy, pecan.request.host_url, expand)
+            strategy, pecan.request.host_url, expand
+        )
 
     @classmethod
     def sample(cls, expand=True):
-        sample = cls(uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
-                     name='DUMMY',
-                     display_name='Dummy strategy')
+        sample = cls(
+            uuid='27e3153e-d5bf-4b7e-b517-fb518e17f34c',
+            name='DUMMY',
+            display_name='Dummy strategy',
+        )
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
 
@@ -178,13 +191,16 @@ class StrategyCollection(collection.Collection):
         self._type = 'strategies'
 
     @staticmethod
-    def convert_with_links(strategies, limit, url=None, expand=False,
-                           **kwargs):
+    def convert_with_links(
+        strategies, limit, url=None, expand=False, **kwargs
+    ):
         strategy_collection = StrategyCollection()
         strategy_collection.strategies = [
-            Strategy.convert_with_links(g, expand) for g in strategies]
+            Strategy.convert_with_links(g, expand) for g in strategies
+        ]
         strategy_collection.next = strategy_collection.get_next(
-            limit, url=url, **kwargs)
+            limit, url=url, **kwargs
+        )
         return strategy_collection
 
     @classmethod
@@ -200,50 +216,76 @@ class StrategiesController(rest.RestController):
     def __init__(self):
         super().__init__()
 
-    _custom_actions = {
-        'detail': ['GET'],
-        'state': ['GET'],
-    }
+    _custom_actions = {'detail': ['GET'], 'state': ['GET']}
 
-    def _get_strategies_collection(self, filters, marker, limit, sort_key,
-                                   sort_dir, expand=False, resource_url=None):
+    def _get_strategies_collection(
+        self,
+        filters,
+        marker,
+        limit,
+        sort_key,
+        sort_dir,
+        expand=False,
+        resource_url=None,
+    ):
         additional_fields = ["goal_uuid", "goal_name"]
 
         api_utils.validate_sort_key(
-            sort_key, list(objects.Strategy.fields) + additional_fields)
+            sort_key, list(objects.Strategy.fields) + additional_fields
+        )
         api_utils.validate_search_filters(
-            filters, list(objects.Strategy.fields) + additional_fields)
+            filters, list(objects.Strategy.fields) + additional_fields
+        )
         limit = api_utils.validate_limit(limit)
         api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
             marker_obj = objects.Strategy.get_by_uuid(
-                pecan.request.context, marker)
+                pecan.request.context, marker
+            )
 
-        need_api_sort = api_utils.check_need_api_sort(sort_key,
-                                                      additional_fields)
-        sort_db_key = (sort_key if not need_api_sort
-                       else None)
+        need_api_sort = api_utils.check_need_api_sort(
+            sort_key, additional_fields
+        )
+        sort_db_key = sort_key if not need_api_sort else None
 
         strategies = objects.Strategy.list(
-            pecan.request.context, limit, marker_obj, filters=filters,
-            sort_key=sort_db_key, sort_dir=sort_dir)
+            pecan.request.context,
+            limit,
+            marker_obj,
+            filters=filters,
+            sort_key=sort_db_key,
+            sort_dir=sort_dir,
+        )
 
         strategies_collection = StrategyCollection.convert_with_links(
-            strategies, limit, url=resource_url, expand=expand,
-            sort_key=sort_key, sort_dir=sort_dir)
+            strategies,
+            limit,
+            url=resource_url,
+            expand=expand,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+        )
 
         if need_api_sort:
-            api_utils.make_api_sort(strategies_collection.strategies,
-                                    sort_key, sort_dir)
+            api_utils.make_api_sort(
+                strategies_collection.strategies, sort_key, sort_dir
+            )
 
         return strategies_collection
 
-    @wsme_pecan.wsexpose(StrategyCollection, wtypes.text, wtypes.text,
-                         int, wtypes.text, wtypes.text)
-    def get_all(self, goal=None, marker=None, limit=None,
-                sort_key='id', sort_dir='asc'):
+    @wsme_pecan.wsexpose(
+        StrategyCollection,
+        wtypes.text,
+        wtypes.text,
+        int,
+        wtypes.text,
+        wtypes.text,
+    )
+    def get_all(
+        self, goal=None, marker=None, limit=None, sort_key='id', sort_dir='asc'
+    ):
         """Retrieve a list of strategies.
 
         :param goal: goal UUID or name to filter by.
@@ -253,8 +295,7 @@ class StrategiesController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'strategy:get_all',
-                       action='strategy:get_all')
+        policy.enforce(context, 'strategy:get_all', action='strategy:get_all')
         filters = {}
         if goal:
             if common_utils.is_uuid_like(goal):
@@ -263,12 +304,20 @@ class StrategiesController(rest.RestController):
                 filters['goal_name'] = goal
 
         return self._get_strategies_collection(
-            filters, marker, limit, sort_key, sort_dir)
+            filters, marker, limit, sort_key, sort_dir
+        )
 
-    @wsme_pecan.wsexpose(StrategyCollection, wtypes.text, wtypes.text, int,
-                         wtypes.text, wtypes.text)
-    def detail(self, goal=None, marker=None, limit=None,
-               sort_key='id', sort_dir='asc'):
+    @wsme_pecan.wsexpose(
+        StrategyCollection,
+        wtypes.text,
+        wtypes.text,
+        int,
+        wtypes.text,
+        wtypes.text,
+    )
+    def detail(
+        self, goal=None, marker=None, limit=None, sort_key='id', sort_dir='asc'
+    ):
         """Retrieve a list of strategies with detail.
 
         :param goal: goal UUID or name to filter by.
@@ -278,8 +327,7 @@ class StrategiesController(rest.RestController):
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
         context = pecan.request.context
-        policy.enforce(context, 'strategy:detail',
-                       action='strategy:detail')
+        policy.enforce(context, 'strategy:detail', action='strategy:detail')
         # NOTE(lucasagomes): /detail should only work against collections
         parent = pecan.request.path.split('/')[:-1][-1]
         if parent != "strategies":
@@ -295,7 +343,8 @@ class StrategiesController(rest.RestController):
                 filters['goal_name'] = goal
 
         return self._get_strategies_collection(
-            filters, marker, limit, sort_key, sort_dir, expand, resource_url)
+            filters, marker, limit, sort_key, sort_dir, expand, resource_url
+        )
 
     @wsme_pecan.wsexpose(wtypes.text, wtypes.text)
     def state(self, strategy):
@@ -310,11 +359,19 @@ class StrategiesController(rest.RestController):
             raise exception.HTTPNotFound
         rpc_strategy = api_utils.get_resource('Strategy', strategy)
         de_client = rpcapi.DecisionEngineAPI()
-        strategy_state = de_client.get_strategy_info(context,
-                                                     rpc_strategy.name)
-        strategy_state.extend([{
-            'type': 'Name', 'state': rpc_strategy.name,
-            'mandatory': '', 'comment': ''}])
+        strategy_state = de_client.get_strategy_info(
+            context, rpc_strategy.name
+        )
+        strategy_state.extend(
+            [
+                {
+                    'type': 'Name',
+                    'state': rpc_strategy.name,
+                    'mandatory': '',
+                    'comment': '',
+                }
+            ]
+        )
         return strategy_state
 
     @wsme_pecan.wsexpose(Strategy, wtypes.text)
@@ -325,7 +382,8 @@ class StrategiesController(rest.RestController):
         """
         context = pecan.request.context
         rpc_strategy = api_utils.get_resource('Strategy', strategy)
-        policy.enforce(context, 'strategy:get', rpc_strategy,
-                       action='strategy:get')
+        policy.enforce(
+            context, 'strategy:get', rpc_strategy, action='strategy:get'
+        )
 
         return Strategy.convert_with_links(rpc_strategy)
diff --git a/watcher/api/controllers/v1/types.py b/watcher/api/controllers/v1/types.py
index af9755c62..704799aad 100644
--- a/watcher/api/controllers/v1/types.py
+++ b/watcher/api/controllers/v1/types.py
@@ -132,8 +132,9 @@ class JsonType(wtypes.UserType):
 
     def __str__(self):
         # These are the json serializable native types
-        return ' | '.join(map(str, (wtypes.text, int, float,
-                                    BooleanType, list, dict, None)))
+        return ' | '.join(
+            map(str, (wtypes.text, int, float, BooleanType, list, dict, None))
+        )
 
     @staticmethod
     def validate(value):
@@ -178,17 +179,20 @@ class MultiType(wtypes.UserType):
         else:
             raise ValueError(
                 _("Wrong type. Expected '%(type)s', got '%(value)s'"),
-                type=self.types, value=type(value)
+                type=self.types,
+                value=type(value),
             )
 
 
 class JsonPatchType(wtypes.Base):
     """A complex type that represents a single json-patch operation."""
 
-    path = wtypes.wsattr(wtypes.StringType(pattern=r'^(/[\w-]+)+$'),
-                         mandatory=True)
-    op = wtypes.wsattr(wtypes.Enum(str, 'add', 'replace', 'remove'),
-                       mandatory=True)
+    path = wtypes.wsattr(
+        wtypes.StringType(pattern=r'^(/[\w-]+)+$'), mandatory=True
+    )
+    op = wtypes.wsattr(
+        wtypes.Enum(str, 'add', 'replace', 'remove'), mandatory=True
+    )
     value = wsme.wsattr(jsontype, default=wtypes.Unset)
 
     @staticmethod
@@ -199,8 +203,14 @@ class JsonPatchType(wtypes.Base):
         method may be overwritten by derived class.
 
         """
-        return ['/created_at', '/id', '/links', '/updated_at',
-                '/deleted_at', '/uuid']
+        return [
+            '/created_at',
+            '/id',
+            '/links',
+            '/updated_at',
+            '/deleted_at',
+            '/uuid',
+        ]
 
     @staticmethod
     def mandatory_attrs():
@@ -222,8 +232,9 @@ class JsonPatchType(wtypes.Base):
         _path = '/{}'.format(patch.path.split('/')[1])
         if len(patch.allowed_attrs()) > 0:
             if _path not in patch.allowed_attrs():
-                msg = _("'%s' is not an allowed attribute and can not be "
-                        "updated")
+                msg = _(
+                    "'%s' is not an allowed attribute and can not be updated"
+                )
                 raise wsme.exc.ClientSideError(msg % patch.path)
 
         if _path in patch.internal_attrs():
diff --git a/watcher/api/controllers/v1/utils.py b/watcher/api/controllers/v1/utils.py
index d255e497b..aa88afb14 100644
--- a/watcher/api/controllers/v1/utils.py
+++ b/watcher/api/controllers/v1/utils.py
@@ -32,9 +32,11 @@ from watcher.common import utils
 CONF = cfg.CONF
 
 
-JSONPATCH_EXCEPTIONS = (jsonpatch.JsonPatchException,
-                        jsonpatch.JsonPointerException,
-                        KeyError)
+JSONPATCH_EXCEPTIONS = (
+    jsonpatch.JsonPatchException,
+    jsonpatch.JsonPointerException,
+    KeyError,
+)
 
 
 def validate_limit(limit):
@@ -54,16 +56,20 @@ def validate_limit(limit):
 
 def validate_sort_dir(sort_dir):
     if sort_dir not in ['asc', 'desc']:
-        raise wsme.exc.ClientSideError(_("Invalid sort direction: %s. "
-                                         "Acceptable values are "
-                                         "'asc' or 'desc'") % sort_dir)
+        raise wsme.exc.ClientSideError(
+            _(
+                "Invalid sort direction: %s. "
+                "Acceptable values are "
+                "'asc' or 'desc'"
+            )
+            % sort_dir
+        )
 
 
 def validate_sort_key(sort_key, allowed_fields):
     # Very lightweight validation for now
     if sort_key not in allowed_fields:
-        raise wsme.exc.ClientSideError(
-            _("Invalid sort key: %s") % sort_key)
+        raise wsme.exc.ClientSideError(_("Invalid sort key: %s") % sort_key)
 
 
 def validate_search_filters(filters, allowed_fields):
@@ -72,7 +78,8 @@ def validate_search_filters(filters, allowed_fields):
     for filter_name in filters:
         if filter_name not in allowed_fields:
             raise wsme.exc.ClientSideError(
-                _("Invalid filter: %s") % filter_name)
+                _("Invalid filter: %s") % filter_name
+            )
 
 
 def check_need_api_sort(sort_key, additional_fields):
@@ -83,7 +90,7 @@ def make_api_sort(sorting_list, sort_key, sort_dir):
     # First sort by uuid field, than sort by sort_key
     # sort() ensures stable sorting, so we could
     # make lexicographical sort
-    reverse_direction = (sort_dir == 'desc')
+    reverse_direction = sort_dir == 'desc'
     sorting_list.sort(key=attrgetter('uuid'), reverse=reverse_direction)
     sorting_list.sort(key=attrgetter(sort_key), reverse=reverse_direction)
 
@@ -92,8 +99,10 @@ def apply_jsonpatch(doc, patch):
     for p in patch:
         if p['op'] == 'add' and p['path'].count('/') == 1:
             if p['path'].lstrip('/') not in doc:
-                msg = _('Adding a new attribute (%s) to the root of '
-                        ' the resource is not allowed')
+                msg = _(
+                    'Adding a new attribute (%s) to the root of '
+                    ' the resource is not allowed'
+                )
                 raise wsme.exc.ClientSideError(msg % p['path'])
     return jsonpatch.apply_patch(doc, jsonpatch.JsonPatch(patch))
 
@@ -120,8 +129,11 @@ def check_audit_state_transition(patch, initial):
     is_transition_valid = True
     state_value = get_patch_value(patch, "state")
     if state_value is not None:
-        is_transition_valid = objects.audit.AuditStateTransitionManager(
-            ).check_transition(initial, state_value)
+        is_transition_valid = (
+            objects.audit.AuditStateTransitionManager().check_transition(
+                initial, state_value
+            )
+        )
     return is_transition_valid
 
 
@@ -167,7 +179,8 @@ def allow_start_end_audit_time():
     audits.
     """
     return pecan.request.version.minor >= (
-        versions.VERSIONS.MINOR_1_START_END_TIMING.value)
+        versions.VERSIONS.MINOR_1_START_END_TIMING.value
+    )
 
 
 def allow_force():
@@ -177,7 +190,8 @@ def allow_force():
     launch audit when other action plan is ongoing.
     """
     return pecan.request.version.minor >= (
-        versions.VERSIONS.MINOR_2_FORCE.value)
+        versions.VERSIONS.MINOR_2_FORCE.value
+    )
 
 
 def allow_list_datamodel():
@@ -186,7 +200,8 @@ def allow_list_datamodel():
     Version 1.3 of the API added support to list data model.
     """
     return pecan.request.version.minor >= (
-        versions.VERSIONS.MINOR_3_DATAMODEL.value)
+        versions.VERSIONS.MINOR_3_DATAMODEL.value
+    )
 
 
 def allow_webhook_api():
@@ -195,7 +210,8 @@ def allow_webhook_api():
     Version 1.4 of the API added support to trigger webhook.
     """
     return pecan.request.version.minor >= (
-        versions.VERSIONS.MINOR_4_WEBHOOK_API.value)
+        versions.VERSIONS.MINOR_4_WEBHOOK_API.value
+    )
 
 
 def allow_skipped_action():
@@ -204,7 +220,8 @@ def allow_skipped_action():
     Version 1.5 of the API added support to skipped actions.
     """
     return pecan.request.version.minor >= (
-        versions.VERSIONS.MINOR_5_SKIPPED_ACTION.value)
+        versions.VERSIONS.MINOR_5_SKIPPED_ACTION.value
+    )
 
 
 def allow_list_extend_compute_model():
@@ -214,4 +231,5 @@ def allow_list_extend_compute_model():
     to the compute data model.
     """
     return pecan.request.version.minor >= (
-        versions.VERSIONS.MINOR_6_EXT_COMPUTE_MODEL.value)
+        versions.VERSIONS.MINOR_6_EXT_COMPUTE_MODEL.value
+    )
diff --git a/watcher/api/controllers/v1/webhooks.py b/watcher/api/controllers/v1/webhooks.py
index ad025735f..27e10e1d8 100644
--- a/watcher/api/controllers/v1/webhooks.py
+++ b/watcher/api/controllers/v1/webhooks.py
@@ -40,8 +40,9 @@ class WebhookController(rest.RestController):
         super().__init__()
         self.dc_client = rpcapi.DecisionEngineAPI()
 
-    @wsme_pecan.wsexpose(None, wtypes.text, body=types.jsontype,
-                         status_code=HTTPStatus.ACCEPTED)
+    @wsme_pecan.wsexpose(
+        None, wtypes.text, body=types.jsontype, status_code=HTTPStatus.ACCEPTED
+    )
     def post(self, audit_ident, body):
         """Trigger the given audit.
 
@@ -59,7 +60,7 @@ class WebhookController(rest.RestController):
         allowed_state = (
             objects.audit.State.PENDING,
             objects.audit.State.SUCCEEDED,
-            )
+        )
         if audit.state not in allowed_state:
             raise exception.AuditStateNotAllowed(state=audit.state)
 
diff --git a/watcher/api/hooks.py b/watcher/api/hooks.py
index 0611b8d5f..e251152b2 100644
--- a/watcher/api/hooks.py
+++ b/watcher/api/hooks.py
@@ -56,8 +56,9 @@ class ContextHook(hooks.PecanHook):
         auth_token = headers.get('X-Auth-Token', auth_token)
         show_deleted = headers.get('X-Show-Deleted')
         auth_token_info = state.request.environ.get('keystone.token_info')
-        roles = (headers.get('X-Roles', None) and
-                 headers.get('X-Roles').split(','))
+        roles = headers.get('X-Roles', None) and headers.get('X-Roles').split(
+            ','
+        )
 
         state.request.context = context.make_context(
             auth_token=auth_token,
@@ -69,7 +70,8 @@ class ContextHook(hooks.PecanHook):
             domain_id=domain_id,
             domain_name=domain_name,
             show_deleted=show_deleted,
-            roles=roles)
+            roles=roles,
+        )
 
 
 class NoExceptionTracebackHook(hooks.PecanHook):
@@ -79,6 +81,7 @@ class NoExceptionTracebackHook(hooks.PecanHook):
     message which is then sent to the client. Such behavior is a security
     concern so this hook is aimed to cut-off traceback from the error message.
     """
+
     # NOTE(max_lobur): 'after' hook used instead of 'on_error' because
     # 'on_error' never fired for wsme+pecan pair. wsme @wsexpose decorator
     # catches and handles all the errors, so 'on_error' dedicated for unhandled
@@ -92,8 +95,7 @@ class NoExceptionTracebackHook(hooks.PecanHook):
         # Do nothing if there is no error.
         # Status codes in the range 200 (OK) to 399 (400 = BAD_REQUEST) are not
         # an error.
-        if (HTTPStatus.OK <= state.response.status_int <
-                HTTPStatus.BAD_REQUEST):
+        if HTTPStatus.OK <= state.response.status_int < HTTPStatus.BAD_REQUEST:
             return
 
         json_body = state.response.json
diff --git a/watcher/api/middleware/auth_token.py b/watcher/api/middleware/auth_token.py
index 0fd3f50a2..857166b2f 100644
--- a/watcher/api/middleware/auth_token.py
+++ b/watcher/api/middleware/auth_token.py
@@ -37,12 +37,15 @@ class AuthTokenMiddleware(auth_token.AuthProtocol):
         route_pattern_tpl = r'%s(\.json|\.xml)?$'
 
         try:
-            self.public_api_routes = [re.compile(route_pattern_tpl % route_tpl)
-                                      for route_tpl in public_api_routes]
+            self.public_api_routes = [
+                re.compile(route_pattern_tpl % route_tpl)
+                for route_tpl in public_api_routes
+            ]
         except re.error as e:
             LOG.exception(e)
             raise exception.ConfigInvalid(
-                error_msg=_('Cannot compile public API routes'))
+                error_msg=_('Cannot compile public API routes')
+            )
 
         super().__init__(app, conf)
 
@@ -52,8 +55,9 @@ class AuthTokenMiddleware(auth_token.AuthProtocol):
         # The information whether the API call is being performed against the
         # public API is required for some other components. Saving it to the
         # WSGI environment is reasonable thereby.
-        env['is_public_api'] = any(re.match(pattern, path)
-                                   for pattern in self.public_api_routes)
+        env['is_public_api'] = any(
+            re.match(pattern, path) for pattern in self.public_api_routes
+        )
 
         if env['is_public_api']:
             return self._app(env, start_response)
diff --git a/watcher/api/middleware/parsable_error.py b/watcher/api/middleware/parsable_error.py
index fb1820b11..fa244d4c4 100644
--- a/watcher/api/middleware/parsable_error.py
+++ b/watcher/api/middleware/parsable_error.py
@@ -49,17 +49,20 @@ class ParsableErrorMiddleware:
                 status_code = int(status.split(' ')[0])
                 state['status_code'] = status_code
             except (ValueError, TypeError):  # pragma: nocover
-                raise Exception(_(
-                    'ErrorDocumentMiddleware received an invalid '
-                    'status %s') % status)
+                raise Exception(
+                    _('ErrorDocumentMiddleware received an invalid status %s')
+                    % status
+                )
             else:
                 if (state['status_code'] // 100) not in (2, 3):
                     # Remove some headers so we can replace them later
                     # when we have the full error message and can
                     # compute the length.
-                    headers = [(h, v)
-                               for (h, v) in headers
-                               if h not in ('Content-Length', 'Content-Type')]
+                    headers = [
+                        (h, v)
+                        for (h, v) in headers
+                        if h not in ('Content-Length', 'Content-Type')
+                    ]
                 # Save the headers in case we need to modify them.
                 state['headers'] = headers
                 return start_response(status, headers, exc_info)
@@ -68,25 +71,31 @@ class ParsableErrorMiddleware:
         if (state['status_code'] // 100) not in (2, 3):
             req = webob.Request(environ)
             if (
-                    req.accept.best_match(
-                        ['application/json',
-                         'application/xml']) == 'application/xml'
+                req.accept.best_match(['application/json', 'application/xml'])
+                == 'application/xml'
             ):
                 try:
                     # simple check xml is valid
                     body = [
                         et.ElementTree.tostring(
                             et.ElementTree.Element(
-                                'error_message', text='\n'.join(app_iter)))]
+                                'error_message', text='\n'.join(app_iter)
+                            )
+                        )
+                    ]
                 except et.ElementTree.ParseError as err:
                     LOG.error('Error parsing HTTP response: %s', err)
-                    body = ['<error_message>{}'
-                            '</error_message>'.format(state['status_code'])]
+                    body = [
+                        '<error_message>{}</error_message>'.format(
+                            state['status_code']
+                        )
+                    ]
                 state['headers'].append(('Content-Type', 'application/xml'))
             else:
                 app_iter = [i.decode('utf-8') for i in app_iter]
-                body = [jsonutils.dumps(
-                    {'error_message': '\n'.join(app_iter)})]
+                body = [
+                    jsonutils.dumps({'error_message': '\n'.join(app_iter)})
+                ]
                 body = [item.encode('utf-8') for item in body]
                 state['headers'].append(('Content-Type', 'application/json'))
             state['headers'].append(('Content-Length', str(len(body[0]))))
diff --git a/watcher/api/wsgi.py b/watcher/api/wsgi.py
index 9ea96dc5c..fd84f0824 100644
--- a/watcher/api/wsgi.py
+++ b/watcher/api/wsgi.py
@@ -35,8 +35,10 @@ def initialize_wsgi_app(show_deprecated=False):
     CONF.log_opt_values(LOG, log.DEBUG)
 
     if show_deprecated:
-        LOG.warning("Using watcher/api/app.wsgi is deprecated and it will "
-                    "be removed in U release. Please use automatically "
-                    "generated watcher-api-wsgi instead.")
+        LOG.warning(
+            "Using watcher/api/app.wsgi is deprecated and it will "
+            "be removed in U release. Please use automatically "
+            "generated watcher-api-wsgi instead."
+        )
 
     return app.VersionSelectorApplication()
diff --git a/watcher/applier/action_plan/default.py b/watcher/applier/action_plan/default.py
index a5c397d87..0b8dee024 100644
--- a/watcher/applier/action_plan/default.py
+++ b/watcher/applier/action_plan/default.py
@@ -32,7 +32,6 @@ LOG = log.getLogger(__name__)
 
 
 class DefaultActionPlanHandler(base.BaseActionPlanHandler):
-
     def __init__(self, context, service, action_plan_uuid):
         super().__init__()
         self.ctx = context
@@ -42,16 +41,19 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler):
     def execute(self):
         try:
             action_plan = objects.ActionPlan.get_by_uuid(
-                self.ctx, self.action_plan_uuid, eager=True)
+                self.ctx, self.action_plan_uuid, eager=True
+            )
             if action_plan.state == objects.action_plan.State.CANCELLED:
                 self._update_action_from_pending_to_cancelled()
                 return
             action_plan.state = objects.action_plan.State.ONGOING
             action_plan.save()
             notifications.action_plan.send_action_notification(
-                self.ctx, action_plan,
+                self.ctx,
+                action_plan,
                 action=fields.NotificationAction.EXECUTION,
-                phase=fields.NotificationPhase.START)
+                phase=fields.NotificationPhase.START,
+            )
 
             applier = default.DefaultApplier(self.ctx, self.service)
             applier.execute(self.action_plan_uuid)
@@ -59,25 +61,29 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler):
             # If any action has failed the action plan should be FAILED
             # Define default values for successful execution
             ap_state = objects.action_plan.State.SUCCEEDED
-            notification_kwargs = {
-                'phase': fields.NotificationPhase.END
-            }
+            notification_kwargs = {'phase': fields.NotificationPhase.END}
 
-            failed_filter = {'action_plan_uuid': self.action_plan_uuid,
-                             'state': objects.action.State.FAILED}
+            failed_filter = {
+                'action_plan_uuid': self.action_plan_uuid,
+                'state': objects.action.State.FAILED,
+            }
             failed_actions = objects.Action.list(
-                self.ctx, filters=failed_filter, eager=True)
+                self.ctx, filters=failed_filter, eager=True
+            )
             if failed_actions:
                 ap_state = objects.action_plan.State.FAILED
                 notification_kwargs = {
                     'phase': fields.NotificationPhase.ERROR,
-                    'priority': fields.NotificationPriority.ERROR
+                    'priority': fields.NotificationPriority.ERROR,
                 }
 
-            skipped_filter = {'action_plan_uuid': self.action_plan_uuid,
-                              'state': objects.action.State.SKIPPED}
+            skipped_filter = {
+                'action_plan_uuid': self.action_plan_uuid,
+                'state': objects.action.State.SKIPPED,
+            }
             skipped_actions = objects.Action.list(
-                self.ctx, filters=skipped_filter, eager=True)
+                self.ctx, filters=skipped_filter, eager=True
+            )
             if skipped_actions:
                 status_message = _("One or more actions were skipped.")
                 action_plan.status_message = status_message
@@ -85,9 +91,11 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler):
             action_plan.state = ap_state
             action_plan.save()
             notifications.action_plan.send_action_notification(
-                self.ctx, action_plan,
+                self.ctx,
+                action_plan,
                 action=fields.NotificationAction.EXECUTION,
-                **notification_kwargs)
+                **notification_kwargs,
+            )
 
         except exception.ActionPlanCancelled as e:
             LOG.exception(e)
@@ -95,34 +103,43 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler):
             self._update_action_from_pending_to_cancelled()
             action_plan.save()
             notifications.action_plan.send_cancel_notification(
-                self.ctx, action_plan,
+                self.ctx,
+                action_plan,
                 action=fields.NotificationAction.CANCEL,
-                phase=fields.NotificationPhase.END)
+                phase=fields.NotificationPhase.END,
+            )
 
         except Exception as e:
             LOG.exception(e)
             action_plan = objects.ActionPlan.get_by_uuid(
-                self.ctx, self.action_plan_uuid, eager=True)
+                self.ctx, self.action_plan_uuid, eager=True
+            )
             if action_plan.state == objects.action_plan.State.CANCELLING:
                 action_plan.state = objects.action_plan.State.FAILED
                 action_plan.save()
                 notifications.action_plan.send_cancel_notification(
-                    self.ctx, action_plan,
+                    self.ctx,
+                    action_plan,
                     action=fields.NotificationAction.CANCEL,
                     priority=fields.NotificationPriority.ERROR,
-                    phase=fields.NotificationPhase.ERROR)
+                    phase=fields.NotificationPhase.ERROR,
+                )
             else:
                 action_plan.state = objects.action_plan.State.FAILED
                 action_plan.save()
                 notifications.action_plan.send_action_notification(
-                    self.ctx, action_plan,
+                    self.ctx,
+                    action_plan,
                     action=fields.NotificationAction.EXECUTION,
                     priority=fields.NotificationPriority.ERROR,
-                    phase=fields.NotificationPhase.ERROR)
+                    phase=fields.NotificationPhase.ERROR,
+                )
 
     def _update_action_from_pending_to_cancelled(self):
-        filters = {'action_plan_uuid': self.action_plan_uuid,
-                   'state': objects.action.State.PENDING}
+        filters = {
+            'action_plan_uuid': self.action_plan_uuid,
+            'state': objects.action.State.PENDING,
+        }
         actions = objects.Action.list(self.ctx, filters=filters, eager=True)
         if actions:
             for a in actions:
diff --git a/watcher/applier/actions/change_node_power_state.py b/watcher/applier/actions/change_node_power_state.py
index 0a1e2b7c4..137641c40 100644
--- a/watcher/applier/actions/change_node_power_state.py
+++ b/watcher/applier/actions/change_node_power_state.py
@@ -38,10 +38,7 @@ class ChangeNodePowerState(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'resource_id': str,
-         'state': str,
-        })
+        schema = Schema({'resource_id': str, 'state': str})
 
     The `resource_id` references a baremetal node id (list of available
     ironic nodes is returned by this command: ``ironic node-list``).
@@ -55,19 +52,15 @@ class ChangeNodePowerState(base.BaseAction):
         return {
             'type': 'object',
             'properties': {
-                'resource_id': {
-                    'type': 'string',
-                    "minlength": 1
-                },
-                'resource_name': {
-                    'type': 'string',
-                    "minlength": 1
-                },
+                'resource_id': {'type': 'string', "minlength": 1},
+                'resource_name': {'type': 'string', "minlength": 1},
                 'state': {
                     'type': 'string',
-                    'enum': [metal_constants.PowerState.ON.value,
-                             metal_constants.PowerState.OFF.value]
-                }
+                    'enum': [
+                        metal_constants.PowerState.ON.value,
+                        metal_constants.PowerState.OFF.value,
+                    ],
+                },
             },
             'required': ['resource_id', 'state'],
             'additionalProperties': False,
@@ -95,7 +88,8 @@ class ChangeNodePowerState(base.BaseAction):
     def _node_manage_power(self, state, retry=60):
         if state is None:
             raise exception.IllegalArgumentException(
-                message=_("The target state is not defined"))
+                message=_("The target state is not defined")
+            )
 
         metal_helper = metal_helper_factory.get_helper(self.osc)
         node = metal_helper.get_node(self.node_uuid)
@@ -106,14 +100,15 @@ class ChangeNodePowerState(base.BaseAction):
 
         if state == metal_constants.PowerState.OFF.value:
             compute_node = node.get_hypervisor_node().to_dict()
-            if (compute_node['running_vms'] == 0):
+            if compute_node['running_vms'] == 0:
                 node.set_power_state(state)
             else:
                 LOG.warning(
                     "Compute node %s has %s running vms and will "
                     "NOT be shut off.",
                     compute_node["hypervisor_hostname"],
-                    compute_node['running_vms'])
+                    compute_node['running_vms'],
+                )
                 return False
         else:
             node.set_power_state(state)
@@ -136,4 +131,4 @@ class ChangeNodePowerState(base.BaseAction):
 
     def get_description(self):
         """Description of the action"""
-        return ("Compute node power on/off through Ironic or MaaS.")
+        return "Compute node power on/off through Ironic or MaaS."
diff --git a/watcher/applier/actions/change_nova_service_state.py b/watcher/applier/actions/change_nova_service_state.py
index a4379ea70..b5423549a 100644
--- a/watcher/applier/actions/change_nova_service_state.py
+++ b/watcher/applier/actions/change_nova_service_state.py
@@ -32,11 +32,9 @@ class ChangeNovaServiceState(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'resource_id': str,
-         'state': str,
-         'disabled_reason': str,
-        })
+        schema = Schema(
+            {'resource_id': str, 'state': str, 'disabled_reason': str}
+        )
 
     The `resource_id` references a nova-compute service name.
     The `state` value should either be `up` or `down`.
@@ -54,25 +52,18 @@ class ChangeNovaServiceState(base.BaseAction):
         return {
             'type': 'object',
             'properties': {
-                'resource_id': {
-                    'type': 'string',
-                    "minlength": 1
-                },
-                'resource_name': {
-                    'type': 'string',
-                    "minlength": 1
-                },
+                'resource_id': {'type': 'string', "minlength": 1},
+                'resource_name': {'type': 'string', "minlength": 1},
                 'state': {
                     'type': 'string',
-                    'enum': [element.ServiceState.ONLINE.value,
-                             element.ServiceState.OFFLINE.value,
-                             element.ServiceState.ENABLED.value,
-                             element.ServiceState.DISABLED.value]
+                    'enum': [
+                        element.ServiceState.ONLINE.value,
+                        element.ServiceState.OFFLINE.value,
+                        element.ServiceState.ENABLED.value,
+                        element.ServiceState.DISABLED.value,
+                    ],
                 },
-                'disabled_reason': {
-                    'type': 'string',
-                    "minlength": 1
-                }
+                'disabled_reason': {'type': 'string', "minlength": 1},
             },
             'required': ['resource_id', 'state'],
             'additionalProperties': False,
@@ -109,7 +100,8 @@ class ChangeNovaServiceState(base.BaseAction):
     def _nova_manage_service(self, state):
         if state is None:
             raise exception.IllegalArgumentException(
-                message=_("The target state is not defined"))
+                message=_("The target state is not defined")
+            )
 
         nova = nova_helper.NovaHelper(osc=self.osc)
         if state is True:
@@ -129,17 +121,24 @@ class ChangeNovaServiceState(base.BaseAction):
         service = next((s for s in services if s.host == self.host), None)
         if service is None:
             raise exception.ActionSkipped(
-                _("nova-compute service %s not found") % self.host)
+                _("nova-compute service %s not found") % self.host
+            )
         if service.status == self.state:
             raise exception.ActionSkipped(
-                _("nova-compute service %s is already in state %s") %
-                (self.host, self.state))
+                _(
+                    "nova-compute service %(service)s is already in "
+                    "state %(state)s"
+                )
+                % {'service': self.host, 'state': self.state}
+            )
 
     def post_condition(self):
         pass
 
     def get_description(self):
         """Description of the action"""
-        return ("Disables or enables the nova-compute service."
-                "A disabled nova-compute service can not be selected "
-                "by the nova for future deployment of new server.")
+        return (
+            "Disables or enables the nova-compute service."
+            "A disabled nova-compute service can not be selected "
+            "by the nova for future deployment of new server."
+        )
diff --git a/watcher/applier/actions/factory.py b/watcher/applier/actions/factory.py
index dccb85a13..e748b65a0 100644
--- a/watcher/applier/actions/factory.py
+++ b/watcher/applier/actions/factory.py
@@ -28,8 +28,9 @@ class ActionFactory:
 
     def make_action(self, object_action, osc=None):
         LOG.debug("Creating instance of %s", object_action.action_type)
-        loaded_action = self.action_loader.load(name=object_action.action_type,
-                                                osc=osc)
+        loaded_action = self.action_loader.load(
+            name=object_action.action_type, osc=osc
+        )
         loaded_action.input_parameters = object_action.input_parameters
         LOG.debug("Checking the input parameters")
         # NOTE(jed) if we change the schema of an action and we try to reload
diff --git a/watcher/applier/actions/migration.py b/watcher/applier/actions/migration.py
index f4ddb9dd4..ec2bc500d 100644
--- a/watcher/applier/actions/migration.py
+++ b/watcher/applier/actions/migration.py
@@ -39,12 +39,14 @@ class Migrate(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'resource_id': str,  # should be a UUID
-         'migration_type': str,  # choices -> "live", "cold"
-         'destination_node': str,
-         'source_node': str,
-        })
+        schema = Schema(
+            {
+                'resource_id': str,  # should be a UUID
+                'migration_type': str,  # choices -> "live", "cold"
+                'destination_node': str,
+                'source_node': str,
+            }
+        )
 
     The `resource_id` is the UUID of the server to migrate.
     The `source_node` and `destination_node` parameters are respectively the
@@ -72,28 +74,21 @@ class Migrate(base.BaseAction):
                 'destination_node': {
                     "anyof": [
                         {'type': 'string', "minLength": 1},
-                        {'type': 'None'}
-                        ]
-                },
-                'migration_type': {
-                    'type': 'string',
-                    "enum": ["live", "cold"]
+                        {'type': 'None'},
+                    ]
                 },
+                'migration_type': {'type': 'string', "enum": ["live", "cold"]},
                 'resource_id': {
                     'type': 'string',
                     "minlength": 1,
-                    "pattern": ("^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-"
-                                "([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-"
-                                "([a-fA-F0-9]){12}$")
+                    "pattern": (
+                        "^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-"
+                        "([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-"
+                        "([a-fA-F0-9]){12}$"
+                    ),
                 },
-                'resource_name': {
-                    'type': 'string',
-                    "minlength": 1
-                },
-                'source_node': {
-                    'type': 'string',
-                    "minLength": 1
-                    }
+                'resource_name': {'type': 'string', "minlength": 1},
+                'source_node': {'type': 'string', "minLength": 1},
             },
             'required': ['migration_type', 'resource_id', 'source_node'],
             'additionalProperties': False,
@@ -118,19 +113,25 @@ class Migrate(base.BaseAction):
     def _live_migrate_instance(self, nova, destination):
         result = None
         try:
-            result = nova.live_migrate_instance(instance_id=self.instance_uuid,
-                                                dest_hostname=destination)
+            result = nova.live_migrate_instance(
+                instance_id=self.instance_uuid, dest_hostname=destination
+            )
         except exception.NovaClientError as e:
-            LOG.debug("Nova client exception occurred while live "
-                      "migrating instance "
-                      "%(instance)s.Exception: %(exception)s",
-                      {'instance': self.instance_uuid, 'exception': e})
+            LOG.debug(
+                "Nova client exception occurred while live "
+                "migrating instance "
+                "%(instance)s.Exception: %(exception)s",
+                {'instance': self.instance_uuid, 'exception': e},
+            )
 
         except Exception as e:
             LOG.exception(e)
-            LOG.critical("Unexpected error occurred. Migration failed for "
-                         "instance %s. Leaving instance on previous "
-                         "host.", self.instance_uuid)
+            LOG.critical(
+                "Unexpected error occurred. Migration failed for "
+                "instance %s. Leaving instance on previous "
+                "host.",
+                self.instance_uuid,
+            )
 
         return result
 
@@ -138,13 +139,16 @@ class Migrate(base.BaseAction):
         result = None
         try:
             result = nova.watcher_non_live_migrate_instance(
-                instance_id=self.instance_uuid,
-                dest_hostname=destination)
+                instance_id=self.instance_uuid, dest_hostname=destination
+            )
         except Exception as exc:
             LOG.exception(exc)
-            LOG.critical("Unexpected error occurred. Migration failed for "
-                         "instance %s. Leaving instance on previous "
-                         "host.", self.instance_uuid)
+            LOG.critical(
+                "Unexpected error occurred. Migration failed for "
+                "instance %s. Leaving instance on previous "
+                "host.",
+                self.instance_uuid,
+            )
         return result
 
     def _abort_cold_migrate(self, nova):
@@ -156,17 +160,24 @@ class Migrate(base.BaseAction):
         LOG.warning("Abort operation for cold migration is not implemented")
 
     def _abort_live_migrate(self, nova, source, destination):
-        return nova.abort_live_migrate(instance_id=self.instance_uuid,
-                                       source=source, destination=destination)
+        return nova.abort_live_migrate(
+            instance_id=self.instance_uuid,
+            source=source,
+            destination=destination,
+        )
 
     def migrate(self, destination=None):
         nova = nova_helper.NovaHelper(osc=self.osc)
         if destination is None:
-            LOG.debug("Migrating instance %s, destination node will be "
-                      "determined by nova-scheduler", self.instance_uuid)
+            LOG.debug(
+                "Migrating instance %s, destination node will be "
+                "determined by nova-scheduler",
+                self.instance_uuid,
+            )
         else:
-            LOG.debug("Migrate instance %s to %s", self.instance_uuid,
-                      destination)
+            LOG.debug(
+                "Migrate instance %s to %s", self.instance_uuid, destination
+            )
         try:
             nova.find_instance(self.instance_uuid)
         except exception.ComputeResourceNotFound:
@@ -178,9 +189,14 @@ class Migrate(base.BaseAction):
             return self._cold_migrate_instance(nova, destination)
         else:
             raise exception.Invalid(
-                message=(_("Migration of type '%(migration_type)s' is not "
-                           "supported.") %
-                         {'migration_type': self.migration_type}))
+                message=(
+                    _(
+                        "Migration of type '%(migration_type)s' is not "
+                        "supported."
+                    )
+                    % {'migration_type': self.migration_type}
+                )
+            )
 
     def execute(self):
         return self.migrate(destination=self.destination_node)
@@ -199,8 +215,10 @@ class Migrate(base.BaseAction):
             return self._abort_cold_migrate(nova)
         elif self.migration_type == self.LIVE_MIGRATION:
             return self._abort_live_migrate(
-                nova, source=self.source_node,
-                destination=self.destination_node)
+                nova,
+                source=self.source_node,
+                destination=self.destination_node,
+            )
 
     def pre_condition(self):
         """Check migration preconditions
@@ -219,44 +237,57 @@ class Migrate(base.BaseAction):
             instance = nova.find_instance(self.instance_uuid)
         except exception.ComputeResourceNotFound:
             raise exception.ActionSkipped(
-                _("Instance %s not found") % self.instance_uuid)
+                _("Instance %s not found") % self.instance_uuid
+            )
 
         # Check that the instance is running on source_node
         instance_host = instance.host
         if instance_host != self.source_node:
             raise exception.ActionSkipped(
-                _("Instance %(instance)s is not running on source node "
-                  "%(source)s (currently on %(current)s)") %
-                {'instance': self.instance_uuid,
-                 'source': self.source_node,
-                 'current': instance_host})
+                _(
+                    "Instance %(instance)s is not running on source node "
+                    "%(source)s (currently on %(current)s)"
+                )
+                % {
+                    'instance': self.instance_uuid,
+                    'source': self.source_node,
+                    'current': instance_host,
+                }
+            )
 
         # Check destination node if specified
         if self.destination_node:
             try:
                 # Find the compute node and check if service is enabled
                 dest_node = nova.get_compute_node_by_hostname(
-                    self.destination_node)
+                    self.destination_node
+                )
 
                 # Check if compute service is enabled
                 if dest_node.status != 'enabled':
                     raise exception.ActionExecutionFailure(
-                        _("Destination node %s is not in enabled state") %
-                        self.destination_node)
+                        _("Destination node %s is not in enabled state")
+                        % self.destination_node
+                    )
             except exception.ComputeNodeNotFound:
                 raise exception.ActionExecutionFailure(
-                    _("Destination node %s not found") %
-                    self.destination_node)
+                    _("Destination node %s not found") % self.destination_node
+                )
 
         # Check instance status based on migration type
         instance_status = instance.status
         if self.migration_type == self.LIVE_MIGRATION:
             if instance_status != 'ACTIVE':
                 raise exception.ActionExecutionFailure(
-                    _("Live migration requires instance %(instance)s to be "
-                      "in ACTIVE status (current status: %(status)s)") %
-                    {'instance': self.instance_uuid,
-                     'status': instance_status})
+                    _(
+                        "Live migration requires instance %(instance)s to be "
+                        "in ACTIVE status (current status: %(status)s)"
+                    )
+                    % {
+                        'instance': self.instance_uuid,
+                        'status': instance_status,
+                    }
+                )
 
     def post_condition(self):
         # TODO(jed): check extra parameters (network response, etc.)
diff --git a/watcher/applier/actions/nop.py b/watcher/applier/actions/nop.py
index 5407333a6..6f8a166ac 100644
--- a/watcher/applier/actions/nop.py
+++ b/watcher/applier/actions/nop.py
@@ -30,9 +30,7 @@ class Nop(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'message': str,
-        })
+        schema = Schema({'message': str})
 
     The `message` is the actual message that will be logged.
     """
@@ -44,25 +42,11 @@ class Nop(base.BaseAction):
         return {
             'type': 'object',
             'properties': {
-                'message': {
-                    'type': ['string', 'null']
-                },
-                'skip_pre_condition': {
-                    'type': 'boolean',
-                    'default': False
-                },
-                'fail_pre_condition': {
-                    'type': 'boolean',
-                    'default': False
-                },
-                'fail_execute': {
-                    'type': 'boolean',
-                    'default': False
-                },
-                'fail_post_condition': {
-                    'type': 'boolean',
-                    'default': False
-                }
+                'message': {'type': ['string', 'null']},
+                'skip_pre_condition': {'type': 'boolean', 'default': False},
+                'fail_pre_condition': {'type': 'boolean', 'default': False},
+                'fail_execute': {'type': 'boolean', 'default': False},
+                'fail_post_condition': {'type': 'boolean', 'default': False},
             },
             'required': ['message'],
             'additionalProperties': False,
diff --git a/watcher/applier/actions/resize.py b/watcher/applier/actions/resize.py
index 4339e2a57..7bef25bb4 100644
--- a/watcher/applier/actions/resize.py
+++ b/watcher/applier/actions/resize.py
@@ -34,10 +34,12 @@ class Resize(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'resource_id': str,  # should be a UUID
-         'flavor': str,  # should be either ID or Name of Flavor
-        })
+        schema = Schema(
+            {
+                'resource_id': str,  # should be a UUID
+                'flavor': str,  # should be either ID or Name of Flavor
+            }
+        )
 
     The `resource_id` is the UUID of the server to resize.
     The `flavor` is the ID or Name of Flavor (Nova accepts either ID or Name
@@ -55,14 +57,13 @@ class Resize(base.BaseAction):
                 'resource_id': {
                     'type': 'string',
                     'minlength': 1,
-                    'pattern': ('^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-'
-                                '([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-'
-                                '([a-fA-F0-9]){12}$')
-                },
-                'flavor': {
-                    'type': 'string',
-                    'minlength': 1,
+                    'pattern': (
+                        '^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-'
+                        '([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-'
+                        '([a-fA-F0-9]){12}$'
+                    ),
                 },
+                'flavor': {'type': 'string', 'minlength': 1},
             },
             'required': ['resource_id', 'flavor'],
             'additionalProperties': False,
@@ -78,24 +79,28 @@ class Resize(base.BaseAction):
 
     def resize(self):
         nova = nova_helper.NovaHelper(osc=self.osc)
-        LOG.debug("Resize instance %s to %s flavor", self.instance_uuid,
-                  self.flavor)
+        LOG.debug(
+            "Resize instance %s to %s flavor", self.instance_uuid, self.flavor
+        )
         try:
             nova.find_instance(self.instance_uuid)
         except exception.ComputeResourceNotFound:
-            LOG.warning("Instance %s not found, skipping resize",
-                        self.instance_uuid)
+            LOG.warning(
+                "Instance %s not found, skipping resize", self.instance_uuid
+            )
             raise exception.InstanceNotFound(name=self.instance_uuid)
 
         result = None
         try:
             result = nova.resize_instance(
-                instance_id=self.instance_uuid, flavor=self.flavor)
+                instance_id=self.instance_uuid, flavor=self.flavor
+            )
         except Exception as exc:
             LOG.exception(exc)
             LOG.critical(
-                "Unexpected error occurred. Resizing failed for "
-                "instance %s.", self.instance_uuid)
+                "Unexpected error occurred. Resizing failed for instance %s.",
+                self.instance_uuid,
+            )
             return False
         return result
 
@@ -120,13 +125,15 @@ class Resize(base.BaseAction):
             nova.find_instance(self.instance_uuid)
         except exception.ComputeResourceNotFound:
             raise exception.ActionSkipped(
-                _("Instance %s not found") % self.instance_uuid)
+                _("Instance %s not found") % self.instance_uuid
+            )
 
         try:
             nova.get_flavor_id(self.flavor)
         except exception.ComputeResourceNotFound:
             raise exception.ActionExecutionFailure(
-                _("Flavor %s not found") % self.flavor)
+                _("Flavor %s not found") % self.flavor
+            )
 
     def post_condition(self):
         # TODO(jed): check extra parameters (network response, etc.)
diff --git a/watcher/applier/actions/sleep.py b/watcher/applier/actions/sleep.py
index b645d5f59..21e7e2a7c 100644
--- a/watcher/applier/actions/sleep.py
+++ b/watcher/applier/actions/sleep.py
@@ -31,9 +31,7 @@ class Sleep(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'duration': float,
-        })
+        schema = Schema({'duration': float})
 
     The `duration` is expressed in seconds.
     """
@@ -44,12 +42,7 @@ class Sleep(base.BaseAction):
     def schema(self):
         return {
             'type': 'object',
-            'properties': {
-                'duration': {
-                    'type': 'number',
-                    'minimum': 0
-                },
-            },
+            'properties': {'duration': {'type': 'number', 'minimum': 0}},
             'required': ['duration'],
             'additionalProperties': False,
         }
diff --git a/watcher/applier/actions/stop.py b/watcher/applier/actions/stop.py
index a90053251..dfccbdffd 100644
--- a/watcher/applier/actions/stop.py
+++ b/watcher/applier/actions/stop.py
@@ -31,9 +31,11 @@ class Stop(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-         'resource_id': str,  # should be a UUID
-        })
+        schema = Schema(
+            {
+                'resource_id': str  # should be a UUID
+            }
+        )
 
     The `resource_id` is the UUID of the server instance to stop.
     The action will check if the instance exists, verify its current state,
@@ -48,10 +50,12 @@ class Stop(base.BaseAction):
                 'resource_id': {
                     'type': 'string',
                     "minlength": 1,
-                    "pattern": ("^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-"
-                                "([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-"
-                                "([a-fA-F0-9]){12}$")
-                },
+                    "pattern": (
+                        "^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-"
+                        "([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-"
+                        "([a-fA-F0-9]){12}$"
+                    ),
+                }
             },
             'required': ['resource_id'],
             'additionalProperties': False,
@@ -68,19 +72,24 @@ class Stop(base.BaseAction):
         try:
             result = nova.stop_instance(instance_id=self.instance_uuid)
         except exception.NovaClientError as e:
-            LOG.debug("Nova client exception occurred while stopping "
-                      "instance %(instance)s. Exception: %(exception)s",
-                      {'instance': self.instance_uuid, 'exception': e})
+            LOG.debug(
+                "Nova client exception occurred while stopping "
+                "instance %(instance)s. Exception: %(exception)s",
+                {'instance': self.instance_uuid, 'exception': e},
+            )
             return False
         except Exception as e:
-            LOG.debug("An unexpected error occurred while stopping "
-                      "instance %s: %s", self.instance_uuid, str(e))
+            LOG.debug(
+                "An unexpected error occurred while stopping instance %s: %s",
+                self.instance_uuid,
+                str(e),
+            )
             return False
 
         if result:
             LOG.debug(
                 "Successfully stopped instance %(uuid)s",
-                {'uuid': self.instance_uuid}
+                {'uuid': self.instance_uuid},
             )
             return True
         else:
@@ -91,13 +100,13 @@ class Stop(base.BaseAction):
                 LOG.info(
                     "Instance %(uuid)s not found, "
                     "considering stop operation successful",
-                    {'uuid': self.instance_uuid}
+                    {'uuid': self.instance_uuid},
                 )
                 return True
 
             LOG.error(
                 "Failed to stop instance %(uuid)s",
-                {'uuid': self.instance_uuid}
+                {'uuid': self.instance_uuid},
             )
             return False
 
@@ -115,20 +124,20 @@ class Stop(base.BaseAction):
                 LOG.debug(
                     "Successfully reverted stop action and started instance "
                     "%(uuid)s",
-                    {'uuid': self.instance_uuid}
+                    {'uuid': self.instance_uuid},
                 )
                 return result
             else:
                 LOG.info(
                     "Failed to start instance %(uuid)s during revert. "
                     "This may be normal for instances with special configs.",
-                    {'uuid': self.instance_uuid}
+                    {'uuid': self.instance_uuid},
                 )
         except Exception as exc:
             LOG.info(
                 "Could not start instance %(uuid)s during revert: %(error)s. "
                 "This may be normal for instances with special configs.",
-                {'uuid': self.instance_uuid, 'error': str(exc)}
+                {'uuid': self.instance_uuid, 'error': str(exc)},
             )
         return False
 
@@ -138,8 +147,11 @@ class Stop(base.BaseAction):
 
     def abort(self):
         """Abort the stop action - not applicable for stop operations"""
-        LOG.info("Abort operation is not applicable for stop action on "
-                 " instance %s", self.instance_uuid)
+        LOG.info(
+            "Abort operation is not applicable for stop action on "
+            " instance %s",
+            self.instance_uuid,
+        )
         return False
 
     def pre_condition(self):
@@ -156,14 +168,19 @@ class Stop(base.BaseAction):
             instance = nova.find_instance(self.instance_uuid)
         except exception.ComputeResourceNotFound:
             raise exception.ActionSkipped(
-                _("Instance %s not found") % self.instance_uuid)
+                _("Instance %s not found") % self.instance_uuid
+            )
 
         current_state = instance.status
-        LOG.debug("Instance %s pre-condition check: state=%s",
-                  self.instance_uuid, current_state)
+        LOG.debug(
+            "Instance %s pre-condition check: state=%s",
+            self.instance_uuid,
+            current_state,
+        )
         if current_state == 'SHUTOFF':
             raise exception.ActionSkipped(
-                _("Instance %s is already stopped") % self.instance_uuid)
+                _("Instance %s is already stopped") % self.instance_uuid
+            )
 
     def post_condition(self):
         pass
diff --git a/watcher/applier/actions/volume_migration.py b/watcher/applier/actions/volume_migration.py
index 8f5141f47..497d70ec3 100644
--- a/watcher/applier/actions/volume_migration.py
+++ b/watcher/applier/actions/volume_migration.py
@@ -42,12 +42,14 @@ class VolumeMigrate(base.BaseAction):
 
     The action schema is::
 
-        schema = Schema({
-            'resource_id': str,  # should be a UUID
-            'migration_type': str,  # choices -> "swap", "migrate","retype"
-            'destination_node': str,
-            'destination_type': str,
-        })
+        schema = Schema(
+            {
+                'resource_id': str,  # should be a UUID
+                'migration_type': str,  # choices -> "swap", "migrate","retype"
+                'destination_node': str,
+                'destination_type': str,
+            }
+        )
 
     The `resource_id` is the UUID of cinder volume to migrate.
     The `destination_node` is the destination block storage pool name.
@@ -80,30 +82,29 @@ class VolumeMigrate(base.BaseAction):
                 'resource_id': {
                     'type': 'string',
                     "minlength": 1,
-                    "pattern": ("^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-"
-                                "([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-"
-                                "([a-fA-F0-9]){12}$")
-                },
-                'resource_name': {
-                    'type': 'string',
-                    "minlength": 1
+                    "pattern": (
+                        "^([a-fA-F0-9]){8}-([a-fA-F0-9]){4}-"
+                        "([a-fA-F0-9]){4}-([a-fA-F0-9]){4}-"
+                        "([a-fA-F0-9]){12}$"
+                    ),
                 },
+                'resource_name': {'type': 'string', "minlength": 1},
                 'migration_type': {
                     'type': 'string',
-                    "enum": ["swap", "retype", "migrate"]
+                    "enum": ["swap", "retype", "migrate"],
                 },
                 'destination_node': {
                     "anyof": [
                         {'type': 'string', "minLength": 1},
-                        {'type': 'None'}
-                        ]
+                        {'type': 'None'},
+                    ]
                 },
                 'destination_type': {
                     "anyof": [
                         {'type': 'string', "minLength": 1},
-                        {'type': 'None'}
-                        ]
-                }
+                        {'type': 'None'},
+                    ]
+                },
             },
             'required': ['resource_id', 'migration_type'],
             'additionalProperties': False,
@@ -149,21 +150,26 @@ class VolumeMigrate(base.BaseAction):
         except exception.ComputeResourceNotFound:
             LOG.debug(
                 "Could not find instance %s, could not determine whether"
-                "it's safe to migrate", instance_id
+                "it's safe to migrate",
+                instance_id,
             )
             return False
         instance_status = instance.status
         LOG.debug(
-            "volume: %s is attached to instance: %s "
-            "in instance status: %s",
-            volume.id, instance_id, instance_status)
+            "volume: %s is attached to instance: %s in instance status: %s",
+            volume.id,
+            instance_id,
+            instance_status,
+        )
         # NOTE(sean-k-mooney): This used to allow RESIZED which
         # is the resize_verify task state, that is not an acceptable time
         # to migrate volumes, if nova does not block this in the API
         # today that is probably a bug. PAUSED is also questionable but
         # it should generally be safe.
-        return (volume.status == 'in-use' and
-                instance_status in ('ACTIVE', 'PAUSED'))
+        return volume.status == 'in-use' and instance_status in (
+            'ACTIVE',
+            'PAUSED',
+        )
 
     def _migrate(self, volume_id, dest_node, dest_type):
         try:
@@ -172,15 +178,21 @@ class VolumeMigrate(base.BaseAction):
             if self.migration_type in (self.SWAP, self.MIGRATE):
                 if not self._can_swap(volume):
                     raise exception.Invalid(
-                        message=(_("Invalid state for swapping volume")))
+                        message=(_("Invalid state for swapping volume"))
+                    )
                 return self.cinder_util.migrate(volume, dest_node)
             elif self.migration_type == self.RETYPE:
                 return self.cinder_util.retype(volume, dest_type)
             else:
                 raise exception.Invalid(
-                    message=(_("Migration of type '%(migration_type)s' is not "
-                               "supported.") %
-                             {'migration_type': self.migration_type}))
+                    message=(
+                        _(
+                            "Migration of type '%(migration_type)s' is not "
+                            "supported."
+                        )
+                        % {'migration_type': self.migration_type}
+                    )
+                )
         except exception.Invalid as ei:
             LOG.exception(ei)
             return False
@@ -190,9 +202,9 @@ class VolumeMigrate(base.BaseAction):
             return False
 
     def execute(self):
-        return self._migrate(self.volume_id,
-                             self.destination_node,
-                             self.destination_type)
+        return self._migrate(
+            self.volume_id, self.destination_node, self.destination_type
+        )
 
     def revert(self):
         LOG.warning("revert not supported")
@@ -215,7 +227,8 @@ class VolumeMigrate(base.BaseAction):
             volume = self.cinder_util.get_volume(self.volume_id)
         except cinder_exception.NotFound:
             raise exception.ActionSkipped(
-                _("Volume %s not found") % self.volume_id)
+                _("Volume %s not found") % self.volume_id
+            )
 
         # Check if destination_type exists (if specified)
         if self.destination_type:
@@ -223,31 +236,40 @@ class VolumeMigrate(base.BaseAction):
             type_names = [vt.name for vt in volume_types]
             if self.destination_type not in type_names:
                 raise exception.ActionExecutionFailure(
-                    _("Volume type %s not found") % self.destination_type)
+                    _("Volume type %s not found") % self.destination_type
+                )
 
         # Check if destination_node (pool) exists (if specified)
         if self.destination_node:
             try:
                 self.cinder_util.get_storage_pool_by_name(
-                    self.destination_node)
+                    self.destination_node
+                )
             except exception.PoolNotFound:
                 raise exception.ActionExecutionFailure(
-                    _("Pool %s not found") % self.destination_node)
+                    _("Pool %s not found") % self.destination_node
+                )
 
         # Check if retype to same type
-        if (self.migration_type == self.RETYPE and
-                self.destination_type and
-                volume.volume_type == self.destination_type):
+        if (
+            self.migration_type == self.RETYPE
+            and self.destination_type
+            and volume.volume_type == self.destination_type
+        ):
             raise exception.ActionSkipped(
-                _("Volume type is already %s") % self.destination_type)
+                _("Volume type is already %s") % self.destination_type
+            )
 
         # Check if migrate to same node
-        if (self.migration_type in (self.SWAP, self.MIGRATE) and
-                self.destination_node):
+        if (
+            self.migration_type in (self.SWAP, self.MIGRATE)
+            and self.destination_node
+        ):
             current_host = getattr(volume, 'os-vol-host-attr:host')
             if current_host == self.destination_node:
                 raise exception.ActionSkipped(
-                    _("Volume is already on node %s") % self.destination_node)
+                    _("Volume is already on node %s") % self.destination_node
+                )
 
     def post_condition(self):
         pass
diff --git a/watcher/applier/default.py b/watcher/applier/default.py
index 191bb7d21..fe8aed48b 100644
--- a/watcher/applier/default.py
+++ b/watcher/applier/default.py
@@ -51,13 +51,15 @@ class DefaultApplier(base.BaseApplier):
             self._engine = self._loader.load(
                 name=selected_workflow_engine,
                 context=self.context,
-                applier_manager=self.applier_manager)
+                applier_manager=self.applier_manager,
+            )
         return self._engine
 
     def execute(self, action_plan_uuid):
         LOG.debug("Executing action plan %s ", action_plan_uuid)
 
         filters = {'action_plan_uuid': action_plan_uuid}
-        actions = objects.Action.list(self.context, filters=filters,
-                                      eager=True)
+        actions = objects.Action.list(
+            self.context, filters=filters, eager=True
+        )
         return self.engine.execute(actions)
diff --git a/watcher/applier/loading/default.py b/watcher/applier/loading/default.py
index bfce51a34..61e908816 100644
--- a/watcher/applier/loading/default.py
+++ b/watcher/applier/loading/default.py
@@ -16,11 +16,9 @@ from watcher.common.loader import default
 
 class DefaultWorkFlowEngineLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_workflow_engines')
+        super().__init__(namespace='watcher_workflow_engines')
 
 
 class DefaultActionLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_actions')
+        super().__init__(namespace='watcher_actions')
diff --git a/watcher/applier/manager.py b/watcher/applier/manager.py
index 4944c661b..eab37d3bd 100644
--- a/watcher/applier/manager.py
+++ b/watcher/applier/manager.py
@@ -26,7 +26,6 @@ CONF = conf.CONF
 
 
 class ApplierManager(service_manager.ServiceManager):
-
     @property
     def service_name(self):
         return 'watcher-applier'
diff --git a/watcher/applier/messaging/trigger.py b/watcher/applier/messaging/trigger.py
index 12299e838..fbad657c8 100644
--- a/watcher/applier/messaging/trigger.py
+++ b/watcher/applier/messaging/trigger.py
@@ -32,13 +32,14 @@ class TriggerActionPlan:
         self.applier_manager = applier_manager
         workers = CONF.watcher_applier.workers
         self.executor = executor.get_futurist_pool_executor(
-            max_workers=workers)
+            max_workers=workers
+        )
 
     def do_launch_action_plan(self, context, action_plan_uuid):
         try:
-            cmd = default.DefaultActionPlanHandler(context,
-                                                   self.applier_manager,
-                                                   action_plan_uuid)
+            cmd = default.DefaultActionPlanHandler(
+                context, self.applier_manager, action_plan_uuid
+            )
             cmd.execute()
         except Exception as e:
             LOG.exception(e)
@@ -46,12 +47,14 @@ class TriggerActionPlan:
     def launch_action_plan(self, context, action_plan_uuid):
         LOG.debug("Trigger ActionPlan %s", action_plan_uuid)
         action_plan = objects.ActionPlan.get_by_uuid(
-            context, action_plan_uuid, eager=True)
+            context, action_plan_uuid, eager=True
+        )
         action_plan.hostname = CONF.host
         action_plan.save()
 
         # submit
         executor.log_executor_stats(self.executor, name="action-plan-pool")
-        self.executor.submit(self.do_launch_action_plan, context,
-                             action_plan_uuid)
+        self.executor.submit(
+            self.do_launch_action_plan, context, action_plan_uuid
+        )
         return action_plan_uuid
diff --git a/watcher/applier/rpcapi.py b/watcher/applier/rpcapi.py
index ebf8df75d..dfa487981 100644
--- a/watcher/applier/rpcapi.py
+++ b/watcher/applier/rpcapi.py
@@ -27,7 +27,6 @@ CONF = conf.CONF
 
 
 class ApplierAPI(service.Service):
-
     def __init__(self):
         super().__init__(ApplierAPIManager)
 
@@ -36,11 +35,11 @@ class ApplierAPI(service.Service):
             raise exception.InvalidUuidOrName(name=action_plan_uuid)
 
         self.conductor_client.cast(
-            context, 'launch_action_plan', action_plan_uuid=action_plan_uuid)
+            context, 'launch_action_plan', action_plan_uuid=action_plan_uuid
+        )
 
 
 class ApplierAPIManager(service_manager.ServiceManager):
-
     @property
     def service_name(self):
         return None
diff --git a/watcher/applier/service_monitor.py b/watcher/applier/service_monitor.py
index a910c036c..e1fc5b223 100644
--- a/watcher/applier/service_monitor.py
+++ b/watcher/applier/service_monitor.py
@@ -44,12 +44,19 @@ class ApplierMonitor(service.ServiceMonitoringBase):
 
         pending_actionplans = objects.ActionPlan.list(
             context,
-            filters={'state': objects.action_plan.State.PENDING,
-                     'hostname': host},
-            eager=True)
+            filters={
+                'state': objects.action_plan.State.PENDING,
+                'hostname': host,
+            },
+            eager=True,
+        )
         for actionplan in pending_actionplans:
-            LOG.warning("Retriggering action plan %s in Pending state on "
-                        "failed host %s", actionplan.uuid, host)
+            LOG.warning(
+                "Retriggering action plan %s in Pending state on "
+                "failed host %s",
+                actionplan.uuid,
+                host,
+            )
             actionplan.hostname = None
             actionplan.save()
             self.applier_client.launch_action_plan(context, actionplan.uuid)
@@ -75,16 +82,18 @@ class ApplierMonitor(service.ServiceMonitoringBase):
                     # on services status changes
                     continue
                 if changed:
-                    notifications.service.send_service_update(context,
-                                                              watcher_service,
-                                                              state=result)
+                    notifications.service.send_service_update(
+                        context, watcher_service, state=result
+                    )
                 if result == failed_s:
                     # Cancel ongoing action plans on the failed service using
                     # the existing startup sync method
                     syncer = sync.Syncer()
-                    syncer._cancel_ongoing_actionplans(context,
-                                                       watcher_service.host)
+                    syncer._cancel_ongoing_actionplans(
+                        context, watcher_service.host
+                    )
                     # Pending action plans should be unassigned and
                     # re-triggered
-                    self._retrigger_pending_actionplans(context,
-                                                        watcher_service.host)
+                    self._retrigger_pending_actionplans(
+                        context, watcher_service.host
+                    )
diff --git a/watcher/applier/sync.py b/watcher/applier/sync.py
index 2dfca073c..9282a9c6b 100644
--- a/watcher/applier/sync.py
+++ b/watcher/applier/sync.py
@@ -39,7 +39,8 @@ class Syncer:
             load_description = load_action.get_description()
             try:
                 action_desc = objects.ActionDescription.get_by_type(
-                    ctx, action_type)
+                    ctx, action_type
+                )
                 if action_desc.description != load_description:
                     action_desc.description = load_description
                     action_desc.save()
@@ -54,28 +55,43 @@ class Syncer:
         hostname = host or CONF.host
         actions_plans = objects.ActionPlan.list(
             context,
-            filters={'state': objects.action_plan.State.ONGOING,
-                     'hostname': hostname},
-            eager=True)
+            filters={
+                'state': objects.action_plan.State.ONGOING,
+                'hostname': hostname,
+            },
+            eager=True,
+        )
         for ap in actions_plans:
             ap.state = objects.action_plan.State.CANCELLED
-            ap.status_message = ("Action plan was cancelled because Applier "
-                                 f"{hostname} was stopped while the action "
-                                 "plan was ongoing.")
+            ap.status_message = (
+                "Action plan was cancelled because Applier "
+                f"{hostname} was stopped while the action "
+                "plan was ongoing."
+            )
             ap.save()
-            filters = {'action_plan_uuid': ap.uuid,
-                       'state__in': (objects.action.State.PENDING,
-                                     objects.action.State.ONGOING)}
+            filters = {
+                'action_plan_uuid': ap.uuid,
+                'state__in': (
+                    objects.action.State.PENDING,
+                    objects.action.State.ONGOING,
+                ),
+            }
             actions = objects.Action.list(context, filters=filters, eager=True)
             for a in actions:
                 a.state = objects.action.State.CANCELLED
-                a.status_message = ("Action was cancelled because Applier "
-                                    f"{hostname} was stopped while the "
-                                    "action plan was ongoing.")
+                a.status_message = (
+                    "Action was cancelled because Applier "
+                    f"{hostname} was stopped while the "
+                    "action plan was ongoing."
+                )
                 a.save()
-            LOG.info("Action Plan %(uuid)s along with appropriate Actions "
-                     "has been cancelled because it was in %(state)s state "
-                     "when Applier had been stopped on %(hostname)s host.",
-                     {'uuid': ap.uuid,
-                      'state': objects.action_plan.State.ONGOING,
-                      'hostname': ap.hostname})
+            LOG.info(
+                "Action Plan %(uuid)s along with appropriate Actions "
+                "has been cancelled because it was in %(state)s state "
+                "when Applier had been stopped on %(hostname)s host.",
+                {
+                    'uuid': ap.uuid,
+                    'state': objects.action_plan.State.ONGOING,
+                    'hostname': ap.hostname,
+                },
+            )
diff --git a/watcher/applier/workflow_engine/base.py b/watcher/applier/workflow_engine/base.py
index 77494ac22..af39b8886 100644
--- a/watcher/applier/workflow_engine/base.py
+++ b/watcher/applier/workflow_engine/base.py
@@ -34,7 +34,6 @@ LOG = log.getLogger(__name__)
 
 
 class BaseWorkFlowEngine(loadable.Loadable, metaclass=abc.ABCMeta):
-
     def __init__(self, config, context=None, applier_manager=None):
         """Constructor
 
@@ -80,8 +79,9 @@ class BaseWorkFlowEngine(loadable.Loadable, metaclass=abc.ABCMeta):
         return self._action_factory
 
     def notify(self, action, state, status_message=None):
-        db_action = objects.Action.get_by_uuid(self.context, action.uuid,
-                                               eager=True)
+        db_action = objects.Action.get_by_uuid(
+            self.context, action.uuid, eager=True
+        )
         db_action.state = state
         if status_message:
             db_action.status_message = status_message
@@ -89,15 +89,17 @@ class BaseWorkFlowEngine(loadable.Loadable, metaclass=abc.ABCMeta):
         return db_action
 
     def notify_cancel_start(self, action_plan_uuid):
-        action_plan = objects.ActionPlan.get_by_uuid(self.context,
-                                                     action_plan_uuid,
-                                                     eager=True)
+        action_plan = objects.ActionPlan.get_by_uuid(
+            self.context, action_plan_uuid, eager=True
+        )
         if not self._is_notified:
             self._is_notified = True
             notifications.action_plan.send_cancel_notification(
-                self._context, action_plan,
+                self._context,
+                action_plan,
                 action=fields.NotificationAction.CANCEL,
-                phase=fields.NotificationPhase.START)
+                phase=fields.NotificationPhase.START,
+            )
 
     @abc.abstractmethod
     def execute(self, actions):
@@ -105,7 +107,6 @@ class BaseWorkFlowEngine(loadable.Loadable, metaclass=abc.ABCMeta):
 
 
 class BaseTaskFlowActionContainer(flow_task.Task):
-
     def __init__(self, name, db_action, engine, **kwargs):
         super().__init__(name=name)
         self._db_action = db_action
@@ -120,8 +121,8 @@ class BaseTaskFlowActionContainer(flow_task.Task):
     def action(self):
         if self.loaded_action is None:
             action = self.engine.action_factory.make_action(
-                self._db_action,
-                osc=self._engine.osc)
+                self._db_action, osc=self._engine.osc
+            )
             self.loaded_action = action
         return self.loaded_action
 
@@ -148,20 +149,25 @@ class BaseTaskFlowActionContainer(flow_task.Task):
     def _fail_action(self, phase, reason=None):
         # Fail action and send notification to the user.
         # If a reason is given, it will be used to set the status_message.
-        LOG.error('The workflow engine has failed '
-                  'to execute the action: %s', self._db_action.uuid)
+        LOG.error(
+            'The workflow engine has failed to execute the action: %s',
+            self._db_action.uuid,
+        )
         kwargs = {}
         if reason:
-            kwargs["status_message"] = (_(
-                "Action failed in %s: %s") % (phase, reason))
-        db_action = self.engine.notify(self._db_action,
-                                       objects.action.State.FAILED,
-                                       **kwargs)
+            kwargs["status_message"] = _(
+                "Action failed in %(phase)s: %(reason)s"
+            ) % {'phase': phase, 'reason': reason}
+        db_action = self.engine.notify(
+            self._db_action, objects.action.State.FAILED, **kwargs
+        )
         notifications.action.send_execution_notification(
-            self.engine.context, db_action,
+            self.engine.context,
+            db_action,
             fields.NotificationAction.EXECUTION,
             fields.NotificationPhase.ERROR,
-            priority=fields.NotificationPriority.ERROR)
+            priority=fields.NotificationPriority.ERROR,
+        )
 
     # NOTE(alexchadin): taskflow does 3 method calls (pre_execute, execute,
     # post_execute) independently. We want to support notifications in base
@@ -172,33 +178,43 @@ class BaseTaskFlowActionContainer(flow_task.Task):
             # next action, if action plan is cancelled raise the exceptions
             # so that taskflow does not schedule further actions.
             action_plan = objects.ActionPlan.get_by_id(
-                self.engine.context, self._db_action.action_plan_id)
+                self.engine.context, self._db_action.action_plan_id
+            )
             if action_plan.state in objects.action_plan.State.CANCEL_STATES:
                 raise exception.ActionPlanCancelled(uuid=action_plan.uuid)
             if self._db_action.state == objects.action.State.SKIPPED:
-                LOG.debug("Action %s is skipped manually",
-                          self._db_action.uuid)
+                LOG.debug(
+                    "Action %s is skipped manually", self._db_action.uuid
+                )
                 return
             db_action = self.do_pre_execute()
             notifications.action.send_execution_notification(
-                self.engine.context, db_action,
+                self.engine.context,
+                db_action,
                 fields.NotificationAction.EXECUTION,
-                fields.NotificationPhase.START)
+                fields.NotificationPhase.START,
+            )
         except exception.ActionPlanCancelled as e:
             LOG.exception(e)
             self.engine.notify_cancel_start(action_plan.uuid)
             raise
         except exception.ActionSkipped as e:
-            LOG.info("Action %s was skipped automatically: %s",
-                     self._db_action.uuid, str(e))
-            status_message = (_(
-                "Action was skipped automatically: %s") % str(e))
-            db_action = self.engine.notify(self._db_action,
-                                           objects.action.State.SKIPPED,
-                                           status_message=status_message)
+            LOG.info(
+                "Action %s was skipped automatically: %s",
+                self._db_action.uuid,
+                str(e),
+            )
+            status_message = _("Action was skipped automatically: %s") % str(e)
+            db_action = self.engine.notify(
+                self._db_action,
+                objects.action.State.SKIPPED,
+                status_message=status_message,
+            )
             notifications.action.send_update(
-                self.engine.context, db_action,
-                old_state=objects.action.State.PENDING)
+                self.engine.context,
+                db_action,
+                old_state=objects.action.State.PENDING,
+            )
         except exception.WatcherException as e:
             LOG.exception(e)
             self._fail_action("pre_condition", reason=str(e))
@@ -208,19 +224,25 @@ class BaseTaskFlowActionContainer(flow_task.Task):
 
     def execute(self, *args, **kwargs):
         action_object = objects.Action.get_by_uuid(
-            self.engine.context, self._db_action.uuid, eager=True)
-        if action_object.state in [objects.action.State.SKIPPED,
-                                   objects.action.State.FAILED]:
+            self.engine.context, self._db_action.uuid, eager=True
+        )
+        if action_object.state in [
+            objects.action.State.SKIPPED,
+            objects.action.State.FAILED,
+        ]:
             return True
 
         try:
             db_action = self.do_execute(*args, **kwargs)
             notifications.action.send_execution_notification(
-                self.engine.context, db_action,
+                self.engine.context,
+                db_action,
                 fields.NotificationAction.EXECUTION,
-                fields.NotificationPhase.END)
+                fields.NotificationPhase.END,
+            )
             action_object = objects.Action.get_by_uuid(
-                self.engine.context, self._db_action.uuid, eager=True)
+                self.engine.context, self._db_action.uuid, eager=True
+            )
             if action_object.state == objects.action.State.SUCCEEDED:
                 return True
             else:
@@ -236,7 +258,8 @@ class BaseTaskFlowActionContainer(flow_task.Task):
 
     def post_execute(self):
         action_object = objects.Action.get_by_uuid(
-            self.engine.context, self._db_action.uuid, eager=True)
+            self.engine.context, self._db_action.uuid, eager=True
+        )
         if action_object.state == objects.action.State.SKIPPED:
             return
         try:
@@ -264,18 +287,21 @@ class BaseTaskFlowActionContainer(flow_task.Task):
 
     def revert(self, *args, **kwargs):
         action_plan = objects.ActionPlan.get_by_id(
-            self.engine.context, self._db_action.action_plan_id, eager=True)
+            self.engine.context, self._db_action.action_plan_id, eager=True
+        )
         action_object = objects.Action.get_by_uuid(
-            self.engine.context, self._db_action.uuid, eager=True)
+            self.engine.context, self._db_action.uuid, eager=True
+        )
 
         # NOTE: check if revert cause by cancel action plan or
         # some other exception occurred during action plan execution
         # if due to some other exception keep the flow intact.
         # NOTE(dviroel): If the action was skipped, we should not
         # revert it.
-        if (action_plan.state not in
-                objects.action_plan.State.CANCEL_STATES and
-                action_object.state != objects.action.State.SKIPPED):
+        if (
+            action_plan.state not in objects.action_plan.State.CANCEL_STATES
+            and action_object.state != objects.action.State.SKIPPED
+        ):
             self.do_revert()
             return
 
@@ -284,37 +310,47 @@ class BaseTaskFlowActionContainer(flow_task.Task):
                 action_object.state = objects.action.State.CANCELLING
                 action_object.save()
                 notifications.action.send_cancel_notification(
-                    self.engine.context, action_object,
+                    self.engine.context,
+                    action_object,
                     fields.NotificationAction.CANCEL,
-                    fields.NotificationPhase.START)
+                    fields.NotificationPhase.START,
+                )
                 action_object = self.abort()
 
                 notifications.action.send_cancel_notification(
-                    self.engine.context, action_object,
+                    self.engine.context,
+                    action_object,
                     fields.NotificationAction.CANCEL,
-                    fields.NotificationPhase.END)
+                    fields.NotificationPhase.END,
+                )
 
             if action_object.state == objects.action.State.PENDING:
                 notifications.action.send_cancel_notification(
-                    self.engine.context, action_object,
+                    self.engine.context,
+                    action_object,
                     fields.NotificationAction.CANCEL,
-                    fields.NotificationPhase.START)
+                    fields.NotificationPhase.START,
+                )
                 action_object.state = objects.action.State.CANCELLED
                 action_object.save()
                 notifications.action.send_cancel_notification(
-                    self.engine.context, action_object,
+                    self.engine.context,
+                    action_object,
                     fields.NotificationAction.CANCEL,
-                    fields.NotificationPhase.END)
+                    fields.NotificationPhase.END,
+                )
 
         except Exception as e:
             LOG.exception(e)
             action_object.state = objects.action.State.FAILED
             action_object.save()
             notifications.action.send_cancel_notification(
-                self.engine.context, action_object,
+                self.engine.context,
+                action_object,
                 fields.NotificationAction.CANCEL,
                 fields.NotificationPhase.ERROR,
-                priority=fields.NotificationPriority.ERROR)
+                priority=fields.NotificationPriority.ERROR,
+            )
 
     def abort(self, *args, **kwargs):
         # NOTE(dviroel): only ONGOING actions are called
diff --git a/watcher/applier/workflow_engine/default.py b/watcher/applier/workflow_engine/default.py
index fde913487..f5f654f46 100644
--- a/watcher/applier/workflow_engine/default.py
+++ b/watcher/applier/workflow_engine/default.py
@@ -65,26 +65,29 @@ class DefaultWorkFlowEngine(base.BaseWorkFlowEngine):
                 min=1,
                 required=True,
                 help='Number of workers for taskflow engine '
-                     'to execute actions.'),
+                'to execute actions.',
+            ),
             cfg.DictOpt(
                 'action_execution_rule',
                 default={},
                 help='The execution rule for linked actions,'
-                     'the key is strategy name and '
-                     'value ALWAYS means all actions will be executed,'
-                     'value ANY means if previous action executes '
-                     'success, the next action will be ignored.'
-                     'None means ALWAYS.')
-            ]
+                'the key is strategy name and '
+                'value ALWAYS means all actions will be executed,'
+                'value ANY means if previous action executes '
+                'success, the next action will be ignored.'
+                'None means ALWAYS.',
+            ),
+        ]
 
     def get_execution_rule(self, actions):
         if actions:
             actionplan_object = objects.ActionPlan.get_by_id(
-                self.context, actions[0].action_plan_id)
+                self.context, actions[0].action_plan_id
+            )
             strategy_object = objects.Strategy.get_by_id(
-                self.context, actionplan_object.strategy_id)
-            return self.config.action_execution_rule.get(
-                strategy_object.name)
+                self.context, actionplan_object.strategy_id
+            )
+            return self.config.action_execution_rule.get(strategy_object.name)
 
     def execute(self, actions):
         try:
@@ -106,20 +109,28 @@ class DefaultWorkFlowEngine(base.BaseWorkFlowEngine):
 
             for a in actions:
                 for parent_id in a.parents:
-                    flow.link(actions_uuid[parent_id], actions_uuid[a.uuid],
-                              decider=self.decider)
+                    flow.link(
+                        actions_uuid[parent_id],
+                        actions_uuid[a.uuid],
+                        decider=self.decider,
+                    )
 
             e = None
             engine_type = "parallel"
             if eventlet_helper.is_patched():
                 executor_type = "greenthreaded"
             else:
-                LOG.info("Using Taskflow parallel engine when running "
-                         "in native threading mode.")
+                LOG.info(
+                    "Using Taskflow parallel engine when running "
+                    "in native threading mode."
+                )
                 executor_type = "threaded"
             e = engines.load(
-                flow, executor=executor_type, engine=engine_type,
-                max_workers=self.config.max_workers)
+                flow,
+                executor=executor_type,
+                engine=engine_type,
+                max_workers=self.config.max_workers,
+            )
 
             e.run()
 
@@ -131,23 +142,23 @@ class DefaultWorkFlowEngine(base.BaseWorkFlowEngine):
         except tf_exception.WrappedFailure as e:
             if e.check("watcher.common.exception.ActionPlanCancelled"):
                 raise exception.ActionPlanCancelled(
-                    uuid=actions[0].action_plan_id)
+                    uuid=actions[0].action_plan_id
+                )
             else:
                 raise exception.WorkflowExecutionException(
-                    error=type(e).__name__)
+                    error=type(e).__name__
+                )
 
         except Exception as e:
-            raise exception.WorkflowExecutionException(
-                error=type(e).__name__)
+            raise exception.WorkflowExecutionException(error=type(e).__name__)
 
 
 class TaskFlowActionContainer(base.BaseTaskFlowActionContainer):
     def __init__(self, db_action, engine):
-        self.name = (f"action_type:{db_action.action_type} "
-                     f"uuid:{db_action.uuid}")
-        super().__init__(self.name,
-                         db_action,
-                         engine)
+        self.name = (
+            f"action_type:{db_action.action_type} uuid:{db_action.uuid}"
+        )
+        super().__init__(self.name, db_action, engine)
 
     def do_pre_execute(self):
         LOG.debug("Pre-condition action: %s", self.name)
@@ -162,13 +173,14 @@ class TaskFlowActionContainer(base.BaseTaskFlowActionContainer):
         #      Only when True is returned, the action state is set to SUCCEEDED
         result = self.action.execute()
         if result is True:
-            return self.engine.notify(self._db_action,
-                                      objects.action.State.SUCCEEDED)
+            return self.engine.notify(
+                self._db_action, objects.action.State.SUCCEEDED
+            )
         else:
-            self.engine.notify(self._db_action,
-                               objects.action.State.FAILED)
+            self.engine.notify(self._db_action, objects.action.State.FAILED)
             raise exception.ActionExecutionFailure(
-                action_id=self._db_action.uuid)
+                action_id=self._db_action.uuid
+            )
 
     def do_post_execute(self):
         LOG.debug("Post-condition action: %s", self.name)
@@ -177,8 +189,11 @@ class TaskFlowActionContainer(base.BaseTaskFlowActionContainer):
     def do_revert(self, *args, **kwargs):
         # NOTE: Not rollback action plan
         if not CONF.watcher_applier.rollback_when_actionplan_failed:
-            LOG.info("Failed actionplan rollback option is turned off, and "
-                     "the following action will be skipped: %s", self.name)
+            LOG.info(
+                "Failed actionplan rollback option is turned off, and "
+                "the following action will be skipped: %s",
+                self.name,
+            )
             return
 
         LOG.warning("Revert action: %s", self.name)
@@ -195,15 +210,18 @@ class TaskFlowActionContainer(base.BaseTaskFlowActionContainer):
             result = self.action.abort()
             if result:
                 # Aborted the action.
-                return self.engine.notify(self._db_action,
-                                          objects.action.State.CANCELLED)
+                return self.engine.notify(
+                    self._db_action, objects.action.State.CANCELLED
+                )
             else:
-                return self.engine.notify(self._db_action,
-                                          objects.action.State.SUCCEEDED)
+                return self.engine.notify(
+                    self._db_action, objects.action.State.SUCCEEDED
+                )
         except Exception as e:
             LOG.exception(e)
-            return self.engine.notify(self._db_action,
-                                      objects.action.State.FAILED)
+            return self.engine.notify(
+                self._db_action, objects.action.State.FAILED
+            )
 
 
 class TaskFlowNop(flow_task.Task):
diff --git a/watcher/cmd/dbmanage.py b/watcher/cmd/dbmanage.py
index 84d05161d..4adb5ba71 100644
--- a/watcher/cmd/dbmanage.py
+++ b/watcher/cmd/dbmanage.py
@@ -32,7 +32,6 @@ CONF = conf.CONF
 
 
 class DBCommand:
-
     @staticmethod
     def upgrade():
         migration.upgrade(CONF.command.revision)
@@ -59,25 +58,31 @@ class DBCommand:
 
     @staticmethod
     def purge():
-        purge.purge(CONF.command.age_in_days, CONF.command.max_number,
-                    CONF.command.goal, CONF.command.exclude_orphans,
-                    CONF.command.dry_run)
+        purge.purge(
+            CONF.command.age_in_days,
+            CONF.command.max_number,
+            CONF.command.goal,
+            CONF.command.exclude_orphans,
+            CONF.command.dry_run,
+        )
 
 
 def add_command_parsers(subparsers):
     parser = subparsers.add_parser(
         'upgrade',
         help="Upgrade the database schema to the latest version. "
-             "Optionally, use --revision to specify an alembic revision "
-             "string to upgrade to.")
+        "Optionally, use --revision to specify an alembic revision "
+        "string to upgrade to.",
+    )
     parser.set_defaults(func=DBCommand.upgrade)
     parser.add_argument('--revision', nargs='?')
 
     parser = subparsers.add_parser(
         'downgrade',
         help="Downgrade the database schema to the oldest revision. "
-             "While optional, one should generally use --revision to "
-             "specify the alembic revision string to downgrade to.")
+        "While optional, one should generally use --revision to "
+        "specify the alembic revision string to downgrade to.",
+    )
     parser.set_defaults(func=DBCommand.downgrade)
     parser.add_argument('--revision', nargs='?')
 
@@ -88,53 +93,76 @@ def add_command_parsers(subparsers):
     parser = subparsers.add_parser(
         'revision',
         help="Create a new alembic revision. "
-             "Use --message to set the message string.")
+        "Use --message to set the message string.",
+    )
     parser.add_argument('-m', '--message')
     parser.add_argument('--autogenerate', action='store_true')
     parser.set_defaults(func=DBCommand.revision)
 
     parser = subparsers.add_parser(
-        'version',
-        help="Print the current version information and exit.")
+        'version', help="Print the current version information and exit."
+    )
     parser.set_defaults(func=DBCommand.version)
 
     parser = subparsers.add_parser(
-        'create_schema',
-        help="Create the database schema.")
+        'create_schema', help="Create the database schema."
+    )
     parser.set_defaults(func=DBCommand.create_schema)
 
-    parser = subparsers.add_parser(
-        'purge',
-        help="Purge the database.")
-    parser.add_argument('-d', '--age-in-days',
-                        help="Number of days since deletion (from today) "
-                             "to exclude from the purge. If None, everything "
-                             "will be purged.",
-                        type=int, default=None, nargs='?')
-    parser.add_argument('-n', '--max-number',
-                        help="Max number of objects expected to be deleted. "
-                             "Prevents the deletion if exceeded. No limit if "
-                             "set to None.",
-                        type=int, default=None, nargs='?')
-    parser.add_argument('-t', '--goal',
-                        help="UUID or name of the goal to purge.",
-                        type=str, default=None, nargs='?')
-    parser.add_argument('-e', '--exclude-orphans', action='store_true',
-                        help="Flag to indicate whether or not you want to "
-                             "exclude orphans from deletion (default: False).",
-                        default=False)
-    parser.add_argument('--dry-run', action='store_true',
-                        help="Flag to indicate whether or not you want to "
-                             "perform a dry run (no deletion).",
-                        default=False)
+    parser = subparsers.add_parser('purge', help="Purge the database.")
+    parser.add_argument(
+        '-d',
+        '--age-in-days',
+        help="Number of days since deletion (from today) "
+        "to exclude from the purge. If None, everything "
+        "will be purged.",
+        type=int,
+        default=None,
+        nargs='?',
+    )
+    parser.add_argument(
+        '-n',
+        '--max-number',
+        help="Max number of objects expected to be deleted. "
+        "Prevents the deletion if exceeded. No limit if "
+        "set to None.",
+        type=int,
+        default=None,
+        nargs='?',
+    )
+    parser.add_argument(
+        '-t',
+        '--goal',
+        help="UUID or name of the goal to purge.",
+        type=str,
+        default=None,
+        nargs='?',
+    )
+    parser.add_argument(
+        '-e',
+        '--exclude-orphans',
+        action='store_true',
+        help="Flag to indicate whether or not you want to "
+        "exclude orphans from deletion (default: False).",
+        default=False,
+    )
+    parser.add_argument(
+        '--dry-run',
+        action='store_true',
+        help="Flag to indicate whether or not you want to "
+        "perform a dry run (no deletion).",
+        default=False,
+    )
 
     parser.set_defaults(func=DBCommand.purge)
 
 
-command_opt = cfg.SubCommandOpt('command',
-                                title='Command',
-                                help='Available commands',
-                                handler=add_command_parsers)
+command_opt = cfg.SubCommandOpt(
+    'command',
+    title='Command',
+    help='Available commands',
+    handler=add_command_parsers,
+)
 
 
 def register_sub_command_opts():
@@ -146,8 +174,12 @@ def main():
     # this is hack to work with previous usage of watcher-dbsync
     # pls change it to watcher-dbsync upgrade
     valid_commands = {
-        'upgrade', 'downgrade', 'revision',
-        'version', 'stamp', 'create_schema',
+        'upgrade',
+        'downgrade',
+        'revision',
+        'version',
+        'stamp',
+        'create_schema',
         'purge',
     }
     if not set(sys.argv).intersection(valid_commands):
diff --git a/watcher/cmd/eventlet/api.py b/watcher/cmd/eventlet/api.py
index 521be40de..ce07e2ff9 100644
--- a/watcher/cmd/eventlet/api.py
+++ b/watcher/cmd/eventlet/api.py
@@ -38,12 +38,16 @@ def main():
     server = service.WSGIService('watcher-api', CONF.api.enable_ssl_api)
 
     if host == '127.0.0.1':
-        LOG.info('serving on 127.0.0.1:%(port)s, '
-                 'view at %(protocol)s://127.0.0.1:%(port)s',
-                 dict(protocol=protocol, port=port))
+        LOG.info(
+            'serving on 127.0.0.1:%(port)s, '
+            'view at %(protocol)s://127.0.0.1:%(port)s',
+            dict(protocol=protocol, port=port),
+        )
     else:
-        LOG.info('serving on %(protocol)s://%(host)s:%(port)s',
-                 dict(protocol=protocol, host=host, port=port))
+        LOG.info(
+            'serving on %(protocol)s://%(host)s:%(port)s',
+            dict(protocol=protocol, host=host, port=port),
+        )
 
     launcher = service.launch(CONF, server, workers=server.workers)
     launcher.wait()
diff --git a/watcher/cmd/eventlet/decisionengine.py b/watcher/cmd/eventlet/decisionengine.py
index 4951e7180..b8efc172b 100644
--- a/watcher/cmd/eventlet/decisionengine.py
+++ b/watcher/cmd/eventlet/decisionengine.py
@@ -36,8 +36,7 @@ def main():
     watcher_service.prepare_service(sys.argv, CONF)
     gmr.register_gmr_plugins()
 
-    LOG.info('Starting Watcher Decision Engine service in PID %s',
-             os.getpid())
+    LOG.info('Starting Watcher Decision Engine service in PID %s', os.getpid())
 
     syncer = sync.Syncer()
     syncer.sync()
diff --git a/watcher/cmd/status.py b/watcher/cmd/status.py
index 5928c8bcc..597dbf5d5 100644
--- a/watcher/cmd/status.py
+++ b/watcher/cmd/status.py
@@ -26,7 +26,6 @@ CONF = conf.CONF
 
 
 class Checks(upgradecheck.UpgradeCommands):
-
     """Contains upgrade checks
 
     Various upgrade checks should be added as separate methods in this class
@@ -38,23 +37,22 @@ class Checks(upgradecheck.UpgradeCommands):
         try:
             clients.check_min_nova_api_version(CONF.nova.api_version)
         except ValueError as e:
-            return upgradecheck.Result(
-                upgradecheck.Code.FAILURE, str(e))
+            return upgradecheck.Result(upgradecheck.Code.FAILURE, str(e))
         return upgradecheck.Result(upgradecheck.Code.SUCCESS)
 
     _upgrade_checks = (
         # Added in Train.
         (_('Minimum Nova API Version'), _minimum_nova_api_version),
         # Added in Wallaby.
-        (_("Policy File JSON to YAML Migration"),
-         (common_checks.check_policy_json, {'conf': CONF})),
-
+        (
+            _("Policy File JSON to YAML Migration"),
+            (common_checks.check_policy_json, {'conf': CONF}),
+        ),
     )
 
 
 def main():
-    return upgradecheck.main(
-        CONF, project='watcher', upgrade_command=Checks())
+    return upgradecheck.main(CONF, project='watcher', upgrade_command=Checks())
 
 
 if __name__ == '__main__':
diff --git a/watcher/common/cinder_helper.py b/watcher/common/cinder_helper.py
index c722915eb..2aa60e5b0 100644
--- a/watcher/common/cinder_helper.py
+++ b/watcher/common/cinder_helper.py
@@ -29,7 +29,6 @@ LOG = log.getLogger(__name__)
 
 
 class CinderHelper:
-
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
         self.osc = osc if osc else clients.OpenStackClients()
@@ -41,8 +40,11 @@ class CinderHelper:
     def get_storage_node_by_name(self, name):
         """Get storage node by name(host@backendname)"""
         try:
-            storages = [storage for storage in self.get_storage_node_list()
-                        if storage.host == name]
+            storages = [
+                storage
+                for storage in self.get_storage_node_list()
+                if storage.host == name
+            ]
             if len(storages) != 1:
                 raise exception.StorageNodeNotFound(name=name)
             return storages[0]
@@ -56,8 +58,11 @@ class CinderHelper:
     def get_storage_pool_by_name(self, name):
         """Get pool by name(host@backend#poolname)"""
         try:
-            pools = [pool for pool in self.get_storage_pool_list()
-                     if pool.name == name]
+            pools = [
+                pool
+                for pool in self.get_storage_pool_list()
+                if pool.name == name
+            ]
             if len(pools) != 1:
                 raise exception.PoolNotFound(name=name)
             return pools[0]
@@ -73,19 +78,22 @@ class CinderHelper:
 
     def get_volume_snapshots_list(self):
         return self.cinder.volume_snapshots.list(
-            search_opts={'all_tenants': True})
+            search_opts={'all_tenants': True}
+        )
 
     def get_volume_type_by_backendname(self, backendname):
         """Return a list of volume type"""
         volume_type_list = self.get_volume_type_list()
 
-        volume_type = [volume_type.name for volume_type in volume_type_list
-                       if volume_type.extra_specs.get(
-                           'volume_backend_name') == backendname]
+        volume_type = [
+            volume_type.name
+            for volume_type in volume_type_list
+            if volume_type.extra_specs.get('volume_backend_name')
+            == backendname
+        ]
         return volume_type
 
     def get_volume(self, volume):
-
         if isinstance(volume, Volume):
             volume = volume.id
 
@@ -141,7 +149,10 @@ class CinderHelper:
                 LOG.debug(
                     "property %s with value %s does not match value "
                     "%s from pool %s",
-                    field_name, field_value, pool_value, pool['name']
+                    field_name,
+                    field_value,
+                    pool_value,
+                    pool['name'],
                 )
                 return False
         return True
@@ -191,9 +202,11 @@ class CinderHelper:
             time.sleep(retry_interval)
             if getattr(volume, 'migration_status') == 'error':
                 host_name = getattr(volume, 'os-vol-host-attr:host')
-                error_msg = ("Volume migration error : "
-                             f"volume {volume.id} is now on host "
-                             f"'{host_name}'.")
+                error_msg = (
+                    "Volume migration error : "
+                    f"volume {volume.id} is now on host "
+                    f"'{host_name}'."
+                )
                 LOG.error(error_msg)
                 return False
 
@@ -207,14 +220,17 @@ class CinderHelper:
                     return False
         else:
             host_name = getattr(volume, 'os-vol-host-attr:host')
-            error_msg = ("Volume migration error : "
-                         f"volume {volume.id} is now on host '{host_name}'.")
+            error_msg = (
+                "Volume migration error : "
+                f"volume {volume.id} is now on host '{host_name}'."
+            )
             LOG.error(error_msg)
             return False
         LOG.debug(
             "Volume migration succeeded : "
             "volume %(volume)s is now on host '%(host)s'.",
-            {'volume': volume.id, 'host': host_name})
+            {'volume': volume.id, 'host': host_name},
+        )
         return True
 
     def check_retyped(self, volume, dst_type, retry_interval=10):
@@ -223,8 +239,9 @@ class CinderHelper:
         # A volume retype is correct when the type is the dst_type
         # and the status is available or in-use. Otherwise, it is
         # in retyping status or the action failed
-        while (volume.volume_type != dst_type or
-               volume.status not in valid_status):
+        while (
+            volume.volume_type != dst_type or volume.status not in valid_status
+        ):
             # Retype is not finished successfully, checking if the
             # retype is still ongoing or failed. If status is not
             # `retyping` it means something went wrong.
@@ -233,14 +250,20 @@ class CinderHelper:
                     "Volume retype failed : "
                     "volume %(volume)s has now type '%(type)s' and "
                     "status %(status)s",
-                    {'volume': volume.id, 'type': volume.volume_type,
-                     'status': volume.status})
+                    {
+                        'volume': volume.id,
+                        'type': volume.volume_type,
+                        'status': volume.status,
+                    },
+                )
                 # If migration_status is in error, a likely reason why the
                 # retype failed is some problem in the migration. Report it in
                 # the logs if migration_status is error.
                 if volume.migration_status == 'error':
-                    LOG.error("Volume migration error on volume %(volume)s.",
-                              {'volume': volume.id})
+                    LOG.error(
+                        "Volume migration error on volume %(volume)s.",
+                        {'volume': volume.id},
+                    )
                 return False
 
             LOG.debug('Waiting the retype of %s', volume)
@@ -250,7 +273,8 @@ class CinderHelper:
         LOG.debug(
             "Volume retype succeeded : "
             "volume %(volume)s has now type '%(type)s'.",
-            {'volume': volume.id, 'type': dst_type})
+            {'volume': volume.id, 'type': dst_type},
+        )
 
         return True
 
@@ -265,19 +289,21 @@ class CinderHelper:
                     _(
                         "Volume type '%(volume_type)s' is not compatible with "
                         "destination pool '%(pool_name)s'"
-                    ) % {
+                    )
+                    % {
                         'volume_type': volume.volume_type,
-                        'pool_name': dest_node
-                        }
+                        'pool_name': dest_node,
+                    }
                 )
             )
 
         source_node = getattr(volume, 'os-vol-host-attr:host')
-        LOG.debug("Volume %(volume)s found on host '%(host)s'.",
-                  {'volume': volume.id, 'host': source_node})
+        LOG.debug(
+            "Volume %(volume)s found on host '%(host)s'.",
+            {'volume': volume.id, 'host': source_node},
+        )
 
-        self.cinder.volumes.migrate_volume(
-            volume, dest_node, False, True)
+        self.cinder.volumes.migrate_volume(volume, dest_node, False, True)
 
         return self.check_migrated(volume)
 
@@ -286,20 +312,22 @@ class CinderHelper:
         volume = self.get_volume(volume)
         if volume.volume_type == dest_type:
             raise exception.Invalid(
-                message=(_("Volume type must be different for retyping")))
+                message=(_("Volume type must be different for retyping"))
+            )
 
         source_node = getattr(volume, 'os-vol-host-attr:host')
         LOG.debug(
             "Volume %(volume)s found on host '%(host)s'.",
-            {'volume': volume.id, 'host': source_node})
+            {'volume': volume.id, 'host': source_node},
+        )
 
-        self.cinder.volumes.retype(
-            volume, dest_type, "on-demand")
+        self.cinder.volumes.retype(volume, dest_type, "on-demand")
 
         return self.check_retyped(volume, dest_type)
 
-    def create_volume(self, cinder, volume,
-                      dest_type, retry=120, retry_interval=10):
+    def create_volume(
+        self, cinder, volume, dest_type, retry=120, retry_interval=10
+    ):
         """Create volume of volume with dest_type using cinder"""
         volume = self.get_volume(volume)
         LOG.debug("start creating new volume")
@@ -307,7 +335,8 @@ class CinderHelper:
             getattr(volume, 'size'),
             name=getattr(volume, 'name'),
             volume_type=dest_type,
-            availability_zone=getattr(volume, 'availability_zone'))
+            availability_zone=getattr(volume, 'availability_zone'),
+        )
         while getattr(new_volume, 'status') != 'available' and retry:
             new_volume = cinder.volumes.get(new_volume.id)
             LOG.debug('Waiting volume creation of %s', new_volume)
@@ -316,8 +345,9 @@ class CinderHelper:
             LOG.debug("retry count: %s", retry)
 
         if getattr(new_volume, 'status') != 'available':
-            error_msg = (_("Failed to create volume '%(volume)s. ") %
-                         {'volume': new_volume.id})
+            error_msg = _("Failed to create volume '%(volume)s. ") % {
+                'volume': new_volume.id
+            }
             raise Exception(error_msg)
 
         LOG.debug("Volume %s was created successfully.", new_volume)
@@ -329,6 +359,7 @@ class CinderHelper:
         self.cinder.volumes.delete(volume)
         result = self.check_volume_deleted(volume)
         if not result:
-            error_msg = (_("Failed to delete volume '%(volume)s. ") %
-                         {'volume': volume.id})
+            error_msg = _("Failed to delete volume '%(volume)s. ") % {
+                'volume': volume.id
+            }
             raise Exception(error_msg)
diff --git a/watcher/common/clients.py b/watcher/common/clients.py
index 3b4b4c578..70f6cfeab 100644
--- a/watcher/common/clients.py
+++ b/watcher/common/clients.py
@@ -50,10 +50,12 @@ warnings.simplefilter("once")
 
 
 def get_sdk_connection(
-        conf_group: str, session: ka_session.Session | None = None,
-        context: context.RequestContext | None = None,
-        interface: str | None = None, region_name: str | None = None
-        ) -> connection.Connection:
+    conf_group: str,
+    session: ka_session.Session | None = None,
+    context: context.RequestContext | None = None,
+    interface: str | None = None,
+    region_name: str | None = None,
+) -> connection.Connection:
     """Create and return an OpenStackSDK Connection object.
 
     :param conf_group: String name of the conf group to get connection
@@ -70,9 +72,7 @@ def get_sdk_connection(
     # been loaded before. The auth plugin is only used when creating a new
     # session, but we need to ensure the auth_url config value is set to use
     # the user token from the context object
-    auth = ka_loading.load_auth_from_conf_options(
-        CONF, conf_group
-    )
+    auth = ka_loading.load_auth_from_conf_options(CONF, conf_group)
     if context is not None:
         if interface is None:
             if "valid_interfaces" in CONF[conf_group]:
@@ -90,7 +90,7 @@ def get_sdk_connection(
             project_domain_id=context.project_domain_id,
             auth_url=CONF[conf_group].auth_url,
             region_name=region_name,
-            interface=interface
+            interface=interface,
         )
         return conn
 
@@ -116,8 +116,10 @@ def check_min_nova_api_version(config_version):
     )
 
     if microversion_parse.parse_version_string(config_version) < min_required:
-        raise ValueError(f'Invalid nova.api_version {config_version}. '
-                         f'{MIN_NOVA_API_VERSION} or greater is required.')
+        raise ValueError(
+            f'Invalid nova.api_version {config_version}. '
+            f'{MIN_NOVA_API_VERSION} or greater is required.'
+        )
 
 
 class OpenStackClients:
@@ -136,11 +138,12 @@ class OpenStackClients:
         self._placement = None
 
     def _get_keystone_session(self):
-        auth = ka_loading.load_auth_from_conf_options(CONF,
-                                                      _CLIENTS_AUTH_GROUP)
-        sess = ka_loading.load_session_from_conf_options(CONF,
-                                                         _CLIENTS_AUTH_GROUP,
-                                                         auth=auth)
+        auth = ka_loading.load_auth_from_conf_options(
+            CONF, _CLIENTS_AUTH_GROUP
+        )
+        sess = ka_loading.load_session_from_conf_options(
+            CONF, _CLIENTS_AUTH_GROUP, auth=auth
+        )
         return sess
 
     @property
@@ -160,14 +163,15 @@ class OpenStackClients:
     def keystone(self):
         if self._keystone:
             return self._keystone
-        keystone_interface = self._get_client_option('keystone',
-                                                     'interface')
-        keystone_region_name = self._get_client_option('keystone',
-                                                       'region_name')
+        keystone_interface = self._get_client_option('keystone', 'interface')
+        keystone_region_name = self._get_client_option(
+            'keystone', 'region_name'
+        )
         self._keystone = keyclient.Client(
             interface=keystone_interface,
             region_name=keystone_region_name,
-            session=self.session)
+            session=self.session,
+        )
 
         return self._keystone
 
@@ -176,20 +180,25 @@ class OpenStackClients:
         if self._gnocchi:
             return self._gnocchi
 
-        gnocchiclient_version = self._get_client_option('gnocchi',
-                                                        'api_version')
-        gnocchiclient_interface = self._get_client_option('gnocchi',
-                                                          'endpoint_type')
-        gnocchiclient_region_name = self._get_client_option('gnocchi',
-                                                            'region_name')
+        gnocchiclient_version = self._get_client_option(
+            'gnocchi', 'api_version'
+        )
+        gnocchiclient_interface = self._get_client_option(
+            'gnocchi', 'endpoint_type'
+        )
+        gnocchiclient_region_name = self._get_client_option(
+            'gnocchi', 'region_name'
+        )
         adapter_options = {
             "interface": gnocchiclient_interface,
-            "region_name": gnocchiclient_region_name
+            "region_name": gnocchiclient_region_name,
         }
 
-        self._gnocchi = gnclient.Client(gnocchiclient_version,
-                                        adapter_options=adapter_options,
-                                        session=self.session)
+        self._gnocchi = gnclient.Client(
+            gnocchiclient_version,
+            adapter_options=adapter_options,
+            session=self.session,
+        )
         return self._gnocchi
 
     @exception.wrap_keystone_exception
@@ -198,13 +207,16 @@ class OpenStackClients:
             return self._cinder
 
         cinderclient_version = self._get_client_option('cinder', 'api_version')
-        cinder_endpoint_type = self._get_client_option('cinder',
-                                                       'endpoint_type')
+        cinder_endpoint_type = self._get_client_option(
+            'cinder', 'endpoint_type'
+        )
         cinder_region_name = self._get_client_option('cinder', 'region_name')
-        self._cinder = ciclient.Client(cinderclient_version,
-                                       endpoint_type=cinder_endpoint_type,
-                                       region_name=cinder_region_name,
-                                       session=self.session)
+        self._cinder = ciclient.Client(
+            cinderclient_version,
+            endpoint_type=cinder_endpoint_type,
+            region_name=cinder_region_name,
+            session=self.session,
+        )
         return self._cinder
 
     @exception.wrap_keystone_exception
@@ -216,17 +228,23 @@ class OpenStackClients:
         # the lack of documentation and CI testing. It can be marked as
         # supported or deprecated in future releases, based on improvements.
         debtcollector.deprecate(
-            ("Ironic is an experimental integration and may be "
-             "deprecated in future releases."),
-            version="2025.2", category=PendingDeprecationWarning)
+            (
+                "Ironic is an experimental integration and may be "
+                "deprecated in future releases."
+            ),
+            version="2025.2",
+            category=PendingDeprecationWarning,
+        )
 
         ironicclient_version = self._get_client_option('ironic', 'api_version')
         endpoint_type = self._get_client_option('ironic', 'endpoint_type')
         ironic_region_name = self._get_client_option('ironic', 'region_name')
-        self._ironic = irclient.get_client(ironicclient_version,
-                                           interface=endpoint_type,
-                                           region_name=ironic_region_name,
-                                           session=self.session)
+        self._ironic = irclient.get_client(
+            ironicclient_version,
+            interface=endpoint_type,
+            region_name=ironic_region_name,
+            session=self.session,
+        )
         return self._ironic
 
     def maas(self):
@@ -237,20 +255,25 @@ class OpenStackClients:
         # maintenance and support. It has eventlet code that is required to be
         # removed/replaced in future releases.
         debtcollector.deprecate(
-            ("MAAS integration is deprecated and it will be removed in a "
-             "future release."), version="2026.1", category=DeprecationWarning)
+            (
+                "MAAS integration is deprecated and it will be removed in a "
+                "future release."
+            ),
+            version="2026.1",
+            category=DeprecationWarning,
+        )
 
         if not maas_client:
             raise exception.UnsupportedError(
-                "MAAS client unavailable. Please install python-libmaas.")
+                "MAAS client unavailable. Please install python-libmaas."
+            )
 
         url = self._get_client_option('maas', 'url')
         api_key = self._get_client_option('maas', 'api_key')
         timeout = self._get_client_option('maas', 'timeout')
         self._maas = utils.async_compat_call(
-            maas_client.connect,
-            url, apikey=api_key,
-            timeout=timeout)
+            maas_client.connect, url, apikey=api_key, timeout=timeout
+        )
         return self._maas
 
     @exception.wrap_keystone_exception
@@ -258,12 +281,11 @@ class OpenStackClients:
         if self._placement:
             return self._placement
 
-        placement_version = self._get_client_option('placement',
-                                                    'api_version')
-        placement_interface = self._get_client_option('placement',
-                                                      'interface')
-        placement_region_name = self._get_client_option('placement',
-                                                        'region_name')
+        placement_version = self._get_client_option('placement', 'api_version')
+        placement_interface = self._get_client_option('placement', 'interface')
+        placement_region_name = self._get_client_option(
+            'placement', 'region_name'
+        )
         # Set accept header on every request to ensure we notify placement
         # service of our response body media type preferences.
         headers = {'accept': 'application/json'}
@@ -273,6 +295,7 @@ class OpenStackClients:
             default_microversion=placement_version,
             interface=placement_interface,
             region_name=placement_region_name,
-            additional_headers=headers)
+            additional_headers=headers,
+        )
 
         return self._placement
diff --git a/watcher/common/config.py b/watcher/common/config.py
index 8bcc004ef..1e865202a 100644
--- a/watcher/common/config.py
+++ b/watcher/common/config.py
@@ -24,34 +24,38 @@ from watcher.common import rpc
 
 def set_lib_defaults():
     cors.set_defaults(
-        allow_headers=['X-Auth-Token',
-                       'X-Identity-Status',
-                       'X-Roles',
-                       'X-Service-Catalog',
-                       'X-User-Id',
-                       'X-Tenant-Id',
-                       'X-OpenStack-Request-ID'],
-        expose_headers=['X-Auth-Token',
-                        'X-Subject-Token',
-                        'X-Service-Token',
-                        'X-OpenStack-Request-ID'],
-        allow_methods=['GET',
-                       'PUT',
-                       'POST',
-                       'DELETE',
-                       'PATCH']
+        allow_headers=[
+            'X-Auth-Token',
+            'X-Identity-Status',
+            'X-Roles',
+            'X-Service-Catalog',
+            'X-User-Id',
+            'X-Tenant-Id',
+            'X-OpenStack-Request-ID',
+        ],
+        expose_headers=[
+            'X-Auth-Token',
+            'X-Subject-Token',
+            'X-Service-Token',
+            'X-OpenStack-Request-ID',
+        ],
+        allow_methods=['GET', 'PUT', 'POST', 'DELETE', 'PATCH'],
     )
 
 
 def parse_args(argv, default_config_files=None, default_config_dirs=None):
-    default_config_files = (default_config_files or
-                            cfg.find_config_files(project='watcher'))
-    default_config_dirs = (default_config_dirs or
-                           cfg.find_config_dirs(project='watcher'))
+    default_config_files = default_config_files or cfg.find_config_files(
+        project='watcher'
+    )
+    default_config_dirs = default_config_dirs or cfg.find_config_dirs(
+        project='watcher'
+    )
     rpc.set_defaults(control_exchange='watcher')
-    cfg.CONF(argv[1:],
-             project='watcher',
-             version=version.version_info.release_string(),
-             default_config_dirs=default_config_dirs,
-             default_config_files=default_config_files)
+    cfg.CONF(
+        argv[1:],
+        project='watcher',
+        version=version.version_info.release_string(),
+        default_config_dirs=default_config_dirs,
+        default_config_files=default_config_files,
+    )
     rpc.init(cfg.CONF)
diff --git a/watcher/common/context.py b/watcher/common/context.py
index 4f624f368..e4bddb7d1 100644
--- a/watcher/common/context.py
+++ b/watcher/common/context.py
@@ -23,11 +23,23 @@ LOG = log.getLogger(__name__)
 class RequestContext(context.RequestContext):
     """Extends security contexts from the OpenStack common library."""
 
-    def __init__(self, user_id=None, project_id=None, is_admin=None,
-                 roles=None, timestamp=None, request_id=None, auth_token=None,
-                 overwrite=True, user_name=None, project_name=None,
-                 domain_name=None, domain_id=None, auth_token_info=None,
-                 **kwargs):
+    def __init__(
+        self,
+        user_id=None,
+        project_id=None,
+        is_admin=None,
+        roles=None,
+        timestamp=None,
+        request_id=None,
+        auth_token=None,
+        overwrite=True,
+        user_name=None,
+        project_name=None,
+        domain_name=None,
+        domain_id=None,
+        auth_token_info=None,
+        **kwargs,
+    ):
         """Stores several additional request parameters:
 
         :param domain_id: The ID of the domain.
@@ -54,7 +66,8 @@ class RequestContext(context.RequestContext):
             overwrite=overwrite,
             roles=roles,
             global_request_id=kwargs.pop('global_request_id', None),
-            system_scope=kwargs.pop('system_scope', None))
+            system_scope=kwargs.pop('system_scope', None),
+        )
 
         # Note(sean-k-mooney): we should audit what we are using
         # this for and possibly remove it or document it.
@@ -68,10 +81,12 @@ class RequestContext(context.RequestContext):
 
     def to_dict(self):
         values = super().to_dict()
-        values.update({
-            'auth_token_info': getattr(self, 'auth_token_info', None),
-            'timestamp': self.timestamp.isoformat(),
-        })
+        values.update(
+            {
+                'auth_token_info': getattr(self, 'auth_token_info', None),
+                'timestamp': self.timestamp.isoformat(),
+            }
+        )
         return values
 
     def __str__(self):
diff --git a/watcher/common/exception.py b/watcher/common/exception.py
index 60a3b38ac..fa1995f46 100644
--- a/watcher/common/exception.py
+++ b/watcher/common/exception.py
@@ -40,18 +40,24 @@ CONF = cfg.CONF
 
 def wrap_keystone_exception(func):
     """Wrap keystone exceptions and throw Watcher specific exceptions."""
+
     @functools.wraps(func)
     def wrapped(*args, **kw):
         try:
             return func(*args, **kw)
         except keystone_exceptions.AuthorizationFailure:
             raise AuthorizationFailure(
-                client=func.__name__, reason=sys.exc_info()[1])
+                client=func.__name__, reason=sys.exc_info()[1]
+            )
         except keystone_exceptions.ClientException:
             raise AuthorizationFailure(
                 client=func.__name__,
-                reason=(_('Unexpected keystone client error occurred: %s')
-                        % sys.exc_info()[1]))
+                reason=(
+                    _('Unexpected keystone client error occurred: %s')
+                    % sys.exc_info()[1]
+                ),
+            )
+
     return wrapped
 
 
@@ -63,6 +69,7 @@ class WatcherException(Exception):
     with the keyword arguments provided to the constructor.
 
     """
+
     msg_fmt = _("An unknown exception occurred")
     code = HTTPStatus.INTERNAL_SERVER_ERROR
     headers = {}
@@ -85,8 +92,9 @@ class WatcherException(Exception):
                 # log the issue and the kwargs
                 LOG.exception('Exception in string format operation')
                 for name, value in kwargs.items():
-                    LOG.error("%(name)s: %(value)s",
-                              {'name': name, 'value': value})
+                    LOG.error(
+                        "%(name)s: %(value)s", {'name': name, 'value': value}
+                    )
 
                 if CONF.fatal_exception_format_errors:
                     raise
@@ -160,8 +168,9 @@ class InvalidIdentity(Invalid):
 
 
 class InvalidOperator(Invalid):
-    msg_fmt = _("Filter operator is not valid: %(operator)s not "
-                "in %(valid_operators)s")
+    msg_fmt = _(
+        "Filter operator is not valid: %(operator)s not in %(valid_operators)s"
+    )
 
 
 class InvalidGoal(Invalid):
@@ -233,8 +242,9 @@ class AuditTemplateNotFound(ResourceNotFound):
 
 
 class AuditTemplateAlreadyExists(Conflict):
-    msg_fmt = _("An audit_template with UUID or name %(audit_template)s "
-                "already exists")
+    msg_fmt = _(
+        "An audit_template with UUID or name %(audit_template)s already exists"
+    )
 
 
 class AuditTypeNotFound(Invalid):
@@ -270,13 +280,15 @@ class AuditIntervalNotAllowed(Invalid):
 
 
 class AuditStartEndTimeNotAllowed(Invalid):
-    msg_fmt = _("Start or End time of audit must not be set for "
-                "%(audit_type)s.")
+    msg_fmt = _(
+        "Start or End time of audit must not be set for %(audit_type)s."
+    )
 
 
 class AuditReferenced(Invalid):
-    msg_fmt = _("Audit %(audit)s is referenced by one or multiple action "
-                "plans")
+    msg_fmt = _(
+        "Audit %(audit)s is referenced by one or multiple action plans"
+    )
 
 
 class AuditCancelled(WatcherException):
@@ -296,8 +308,9 @@ class ActionPlanAlreadyExists(Conflict):
 
 
 class ActionPlanReferenced(Invalid):
-    msg_fmt = _("Action Plan %(action_plan)s is referenced by one or "
-                "multiple actions")
+    msg_fmt = _(
+        "Action Plan %(action_plan)s is referenced by one or multiple actions"
+    )
 
 
 class ActionPlanCancelled(WatcherException):
@@ -317,13 +330,15 @@ class ActionAlreadyExists(Conflict):
 
 
 class ActionReferenced(Invalid):
-    msg_fmt = _("Action plan %(action_plan)s is referenced by one or "
-                "multiple goals")
+    msg_fmt = _(
+        "Action plan %(action_plan)s is referenced by one or multiple goals"
+    )
 
 
 class ActionFilterCombinationProhibited(Invalid):
-    msg_fmt = _("Filtering actions on both audit and action-plan is "
-                "prohibited")
+    msg_fmt = _(
+        "Filtering actions on both audit and action-plan is prohibited"
+    )
 
 
 class UnsupportedActionType(UnsupportedError):
@@ -364,6 +379,7 @@ class StartError(Invalid):
 
 # decision engine
 
+
 class WorkflowExecutionException(WatcherException):
     msg_fmt = _('Workflow execution error: %(error)s')
 
@@ -393,18 +409,23 @@ class NoAvailableStrategyForGoal(WatcherException):
 
 
 class InvalidIndicatorValue(WatcherException):
-    msg_fmt = _("The indicator '%(name)s' with value '%(value)s' "
-                "and spec type '%(spec_type)s' is invalid.")
+    msg_fmt = _(
+        "The indicator '%(name)s' with value '%(value)s' "
+        "and spec type '%(spec_type)s' is invalid."
+    )
 
 
 class GlobalEfficacyComputationError(WatcherException):
-    msg_fmt = _("Could not compute the global efficacy for the '%(goal)s' "
-                "goal using the '%(strategy)s' strategy.")
+    msg_fmt = _(
+        "Could not compute the global efficacy for the '%(goal)s' "
+        "goal using the '%(strategy)s' strategy."
+    )
 
 
 class UnsupportedDataSource(UnsupportedError):
-    msg_fmt = _("Datasource %(datasource)s is not supported "
-                "by strategy %(strategy)s")
+    msg_fmt = _(
+        "Datasource %(datasource)s is not supported by strategy %(strategy)s"
+    )
 
 
 class DataSourceNotAvailable(WatcherException):
@@ -413,11 +434,13 @@ class DataSourceNotAvailable(WatcherException):
 
 class MetricNotAvailable(WatcherException):
     """Indicate that a metric is not configured or does not exists"""
+
     msg_fmt = _('Metric: %(metric)s not available')
 
 
 class NoDatasourceAvailable(WatcherException):
     """No datasources have been configured"""
+
     msg_fmt = _('No datasources available')
 
 
@@ -434,8 +457,10 @@ class ServiceNotFound(ResourceNotFound):
 
 
 class WildcardCharacterIsUsed(WatcherException):
-    msg_fmt = _("You shouldn't use any other IDs of %(resource)s if you use "
-                "wildcard character.")
+    msg_fmt = _(
+        "You shouldn't use any other IDs of %(resource)s if you use "
+        "wildcard character."
+    )
 
 
 class CronFormatIsInvalid(WatcherException):
@@ -443,8 +468,9 @@ class CronFormatIsInvalid(WatcherException):
 
 
 class ActionDescriptionAlreadyExists(Conflict):
-    msg_fmt = _("An action description with type %(action_type)s is "
-                "already exist.")
+    msg_fmt = _(
+        "An action description with type %(action_type)s is already exist."
+    )
 
 
 class ActionDescriptionNotFound(ResourceNotFound):
@@ -457,6 +483,7 @@ class ActionExecutionFailure(WatcherException):
 
 # Model
 
+
 class ComputeResourceNotFound(WatcherException):
     msg_fmt = _("The compute resource '%(name)s' could not be found")
 
@@ -466,8 +493,9 @@ class InstanceNotFound(ComputeResourceNotFound):
 
 
 class InstanceNotMapped(ComputeResourceNotFound):
-    msg_fmt = _("The mapped compute node for instance '%(uuid)s' "
-                "could not be found.")
+    msg_fmt = _(
+        "The mapped compute node for instance '%(uuid)s' could not be found."
+    )
 
 
 class ComputeNodeNotFound(ComputeResourceNotFound):
@@ -519,8 +547,10 @@ class NegativeLimitError(WatcherException):
 
 
 class NotificationPayloadError(WatcherException):
-    msg_fmt = _("Payload not populated when trying to send notification "
-                "\"%(class_name)s\"")
+    msg_fmt = _(
+        "Payload not populated when trying to send notification "
+        "\"%(class_name)s\""
+    )
 
 
 class InvalidPoolAttributeValue(Invalid):
@@ -528,13 +558,17 @@ class InvalidPoolAttributeValue(Invalid):
 
 
 class DataSourceConfigConflict(UnsupportedError):
-    msg_fmt = _("Datasource %(datasource_one)s is not supported "
-                "when datasource %(datasource_two)s is also enabled.")
+    msg_fmt = _(
+        "Datasource %(datasource_one)s is not supported "
+        "when datasource %(datasource_two)s is also enabled."
+    )
 
 
 class LiveMigrationFailed(WatcherException):
-    msg_fmt = _("Live migration execution and abort both failed "
-                "for the instance %(name)s.")
+    msg_fmt = _(
+        "Live migration execution and abort both failed "
+        "for the instance %(name)s."
+    )
 
 
 class NovaClientError(WatcherException):
diff --git a/watcher/common/executor.py b/watcher/common/executor.py
index 8d83a07be..b2839239c 100644
--- a/watcher/common/executor.py
+++ b/watcher/common/executor.py
@@ -55,17 +55,24 @@ def log_executor_stats(executor, name="unknown"):
                 "State of %s ThreadPoolExecutor when submitting a new "
                 "task: max_workers: %d, workers: %d, idle workers: %d, "
                 "queued work: %d, stats: %s",
-                name, executor._max_workers, len(executor._workers),
+                name,
+                executor._max_workers,
+                len(executor._workers),
                 len([w for w in executor._workers if w.idle]),
-                executor._work_queue.qsize(), stats)
+                executor._work_queue.qsize(),
+                stats,
+            )
         elif isinstance(executor, futurist.GreenThreadPoolExecutor):
             LOG.debug(
                 "State of %s GreenThreadPoolExecutor when submitting a "
                 "new task: workers: %d, max_workers: %d, "
                 "work queued length: %d, stats: %s",
-                name, len(executor._pool.coroutines_running),
+                name,
+                len(executor._pool.coroutines_running),
                 executor._pool.size,
-                executor._delayed_work.unfinished_tasks, stats)
+                executor._delayed_work.unfinished_tasks,
+                stats,
+            )
     except Exception as e:
         LOG.debug("Failed to log executor stats for %s: %s", name, e)
 
diff --git a/watcher/common/ironic_helper.py b/watcher/common/ironic_helper.py
index 4f14bc24d..4eed653f5 100644
--- a/watcher/common/ironic_helper.py
+++ b/watcher/common/ironic_helper.py
@@ -27,7 +27,6 @@ LOG = log.getLogger(__name__)
 
 
 class IronicHelper:
-
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
         self.osc = osc if osc else clients.OpenStackClients()
diff --git a/watcher/common/keystone_helper.py b/watcher/common/keystone_helper.py
index a40d65e22..414053dc8 100644
--- a/watcher/common/keystone_helper.py
+++ b/watcher/common/keystone_helper.py
@@ -26,7 +26,6 @@ LOG = log.getLogger(__name__)
 
 
 class KeystoneHelper:
-
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
         self.osc = osc if osc else clients.OpenStackClients()
@@ -40,10 +39,12 @@ class KeystoneHelper:
             roles = self.keystone.roles.list(name=name_or_id)
             if len(roles) == 0:
                 raise exception.Invalid(
-                    message=(_("Role not Found: %s") % name_or_id))
+                    message=(_("Role not Found: %s") % name_or_id)
+                )
             if len(roles) > 1:
                 raise exception.Invalid(
-                    message=(_("Role name seems ambiguous: %s") % name_or_id))
+                    message=(_("Role name seems ambiguous: %s") % name_or_id)
+                )
         return roles[0]
 
     def get_user(self, name_or_id):
@@ -54,10 +55,12 @@ class KeystoneHelper:
             users = self.keystone.users.list(name=name_or_id)
             if len(users) == 0:
                 raise exception.Invalid(
-                    message=(_("User not Found: %s") % name_or_id))
+                    message=(_("User not Found: %s") % name_or_id)
+                )
             if len(users) > 1:
                 raise exception.Invalid(
-                    message=(_("User name seems ambiguous: %s") % name_or_id))
+                    message=(_("User name seems ambiguous: %s") % name_or_id)
+                )
             return users[0]
 
     def get_project(self, name_or_id):
@@ -68,11 +71,14 @@ class KeystoneHelper:
             projects = self.keystone.projects.list(name=name_or_id)
             if len(projects) == 0:
                 raise exception.Invalid(
-                    message=(_("Project not Found: %s") % name_or_id))
+                    message=(_("Project not Found: %s") % name_or_id)
+                )
             if len(projects) > 1:
                 raise exception.Invalid(
-                    message=(_("Project name seems ambiguous: %s") %
-                             name_or_id))
+                    message=(
+                        _("Project name seems ambiguous: %s") % name_or_id
+                    )
+                )
             return projects[0]
 
     def get_domain(self, name_or_id):
@@ -83,11 +89,12 @@ class KeystoneHelper:
             domains = self.keystone.domains.list(name=name_or_id)
             if len(domains) == 0:
                 raise exception.Invalid(
-                    message=(_("Domain not Found: %s") % name_or_id))
+                    message=(_("Domain not Found: %s") % name_or_id)
+                )
             if len(domains) > 1:
                 raise exception.Invalid(
-                    message=(_("Domain name seems ambiguous: %s") %
-                             name_or_id))
+                    message=(_("Domain name seems ambiguous: %s") % name_or_id)
+                )
             return domains[0]
 
     def is_service_enabled_by_type(self, svc_type):
diff --git a/watcher/common/loader/base.py b/watcher/common/loader/base.py
index b86943c76..48abc8f8d 100644
--- a/watcher/common/loader/base.py
+++ b/watcher/common/loader/base.py
@@ -17,7 +17,6 @@ import abc
 
 
 class BaseLoader(metaclass=abc.ABCMeta):
-
     @abc.abstractmethod
     def list_available(self):
         raise NotImplementedError()
diff --git a/watcher/common/loader/default.py b/watcher/common/loader/default.py
index 1b99fd38c..15583729e 100644
--- a/watcher/common/loader/default.py
+++ b/watcher/common/loader/default.py
@@ -27,7 +27,6 @@ LOG = log.getLogger(__name__)
 
 
 class DefaultLoader(base.BaseLoader):
-
     def __init__(self, namespace, conf=cfg.CONF):
         """Entry point loader for Watcher using Stevedore
 
@@ -43,9 +42,7 @@ class DefaultLoader(base.BaseLoader):
         try:
             LOG.debug("Loading in namespace %s => %s ", self.namespace, name)
             driver_manager = drivermanager.DriverManager(
-                namespace=self.namespace,
-                name=name,
-                invoke_on_load=False,
+                namespace=self.namespace, name=name, invoke_on_load=False
             )
 
             driver_cls = driver_manager.driver
@@ -82,13 +79,12 @@ class DefaultLoader(base.BaseLoader):
         if not config_group:
             raise exception.LoadingError(name=name)
 
-        config.update({
-            name: value for name, value in config_group.items()
-        })
+        config.update({name: value for name, value in config_group.items()})
 
         return config
 
     def list_available(self):
         extension_manager = extensionmanager.ExtensionManager(
-            namespace=self.namespace)
+            namespace=self.namespace
+        )
         return {ext.name: ext.plugin for ext in extension_manager.extensions}
diff --git a/watcher/common/loader/loadable.py b/watcher/common/loader/loadable.py
index b7bae5fee..54eb8026b 100644
--- a/watcher/common/loader/loadable.py
+++ b/watcher/common/loader/loadable.py
@@ -41,7 +41,8 @@ class Loadable(metaclass=abc.ABCMeta):
 
 
 LoadableSingletonMeta = type(
-    "LoadableSingletonMeta", (abc.ABCMeta, service.Singleton), {})
+    "LoadableSingletonMeta", (abc.ABCMeta, service.Singleton), {}
+)
 
 
 class LoadableSingleton(metaclass=LoadableSingletonMeta):
diff --git a/watcher/common/metal_helper/base.py b/watcher/common/metal_helper/base.py
index 6ac5e5c2f..d1c84b0b6 100644
--- a/watcher/common/metal_helper/base.py
+++ b/watcher/common/metal_helper/base.py
@@ -60,7 +60,8 @@ class BaseMetalNode(abc.ABC):
             self.power_off()
         else:
             raise exception.UnsupportedActionType(
-                f"Cannot set power state: {state}")
+                f"Cannot set power state: {state}"
+            )
 
 
 class BaseMetalHelper(abc.ABC):
diff --git a/watcher/common/metal_helper/ironic.py b/watcher/common/metal_helper/ironic.py
index ca6470e8a..2d92f7b2b 100644
--- a/watcher/common/metal_helper/ironic.py
+++ b/watcher/common/metal_helper/ironic.py
@@ -41,8 +41,9 @@ class IronicNode(base.BaseMetalNode):
         self._ironic_node = ironic_node
 
     def get_power_state(self):
-        return POWER_STATES_MAP.get(self._ironic_node.power_state,
-                                    metal_constants.PowerState.UNKNOWN)
+        return POWER_STATES_MAP.get(
+            self._ironic_node.power_state, metal_constants.PowerState.UNKNOWN
+        )
 
     def get_id(self):
         return self._ironic_node.uuid
@@ -71,8 +72,10 @@ class IronicHelper(base.BaseMetalHelper):
             node_info = self._client.node.get(node.uuid)
             hypervisor_id = node_info.extra.get('compute_node_id', None)
             if hypervisor_id is None:
-                LOG.warning('Cannot find compute_node_id in extra '
-                            'of ironic node %s', node.uuid)
+                LOG.warning(
+                    'Cannot find compute_node_id in extra of ironic node %s',
+                    node.uuid,
+                )
                 continue
 
             hypervisor_node = self.nova_client.get_compute_node_by_uuid(
diff --git a/watcher/common/metal_helper/maas.py b/watcher/common/metal_helper/maas.py
index 9f22e3a59..36809b5d5 100644
--- a/watcher/common/metal_helper/maas.py
+++ b/watcher/common/metal_helper/maas.py
@@ -42,8 +42,8 @@ class MaasNode(base.BaseMetalNode):
 
     def get_power_state(self):
         maas_state = utils.async_compat_call(
-            self._maas_node.query_power_state,
-            timeout=CONF.maas_client.timeout)
+            self._maas_node.query_power_state, timeout=CONF.maas_client.timeout
+        )
 
         # python-libmaas may not be available, so we'll avoid a global
         # variable.
@@ -53,27 +53,32 @@ class MaasNode(base.BaseMetalNode):
             maas_enum.PowerState.ERROR: metal_constants.PowerState.ERROR,
             maas_enum.PowerState.UNKNOWN: metal_constants.PowerState.UNKNOWN,
         }
-        return power_states_map.get(maas_state,
-                                    metal_constants.PowerState.UNKNOWN)
+        return power_states_map.get(
+            maas_state, metal_constants.PowerState.UNKNOWN
+        )
 
     def get_id(self):
         return self._maas_node.system_id
 
     def power_on(self):
-        LOG.info("Powering on MAAS node: %s %s",
-                 self._maas_node.fqdn,
-                 self._maas_node.system_id)
+        LOG.info(
+            "Powering on MAAS node: %s %s",
+            self._maas_node.fqdn,
+            self._maas_node.system_id,
+        )
         utils.async_compat_call(
-            self._maas_node.power_on,
-            timeout=CONF.maas_client.timeout)
+            self._maas_node.power_on, timeout=CONF.maas_client.timeout
+        )
 
     def power_off(self):
-        LOG.info("Powering off MAAS node: %s %s",
-                 self._maas_node.fqdn,
-                 self._maas_node.system_id)
+        LOG.info(
+            "Powering off MAAS node: %s %s",
+            self._maas_node.fqdn,
+            self._maas_node.system_id,
+        )
         utils.async_compat_call(
-            self._maas_node.power_off,
-            timeout=CONF.maas_client.timeout)
+            self._maas_node.power_off, timeout=CONF.maas_client.timeout
+        )
 
 
 class MaasHelper(base.BaseMetalHelper):
@@ -81,7 +86,8 @@ class MaasHelper(base.BaseMetalHelper):
         super().__init__(*args, **kwargs)
         if not maas_enum:
             raise exception.UnsupportedError(
-                "MAAS client unavailable. Please install python-libmaas.")
+                "MAAS client unavailable. Please install python-libmaas."
+            )
 
     @property
     def _client(self):
@@ -92,8 +98,8 @@ class MaasHelper(base.BaseMetalHelper):
     def list_compute_nodes(self):
         out_list = []
         node_list = utils.async_compat_call(
-            self._client.machines.list,
-            timeout=CONF.maas_client.timeout)
+            self._client.machines.list, timeout=CONF.maas_client.timeout
+        )
 
         compute_nodes = self.nova_client.get_compute_node_list(
             filter_ironic_nodes=False
@@ -116,14 +122,17 @@ class MaasHelper(base.BaseMetalHelper):
 
     def _get_compute_node_by_hostname(self, hostname):
         compute_nodes = self.nova_client.get_compute_node_by_hostname(
-            hostname, detailed=True)
+            hostname, detailed=True
+        )
         for compute_node in compute_nodes:
             if compute_node.hypervisor_hostname == hostname:
                 return compute_node
 
     def get_node(self, node_id):
         maas_node = utils.async_compat_call(
-            self._client.machines.get, node_id,
-            timeout=CONF.maas_client.timeout)
+            self._client.machines.get,
+            node_id,
+            timeout=CONF.maas_client.timeout,
+        )
         compute_node = self._get_compute_node_by_hostname(maas_node.fqdn)
         return MaasNode(maas_node, compute_node, self._client)
diff --git a/watcher/common/nova_helper.py b/watcher/common/nova_helper.py
index 50a2122f5..f122b5404 100644
--- a/watcher/common/nova_helper.py
+++ b/watcher/common/nova_helper.py
@@ -55,8 +55,10 @@ def nova_retries(call):
                 else:
                     LOG.error(
                         'Failed to connect to Nova service after %d attempts',
-                        retries + 1)
+                        retries + 1,
+                    )
                     raise
+
     return wrapper
 
 
@@ -76,6 +78,7 @@ def handle_nova_error(resource_type, id_arg_index=1):
         (default 1, which is the first argument after self)
     :returns: Decorator function
     """
+
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
@@ -92,7 +95,9 @@ def handle_nova_error(resource_type, id_arg_index=1):
             except sdk_exc.SDKException as e:
                 LOG.error("Nova client error: %s", e)
                 raise exception.NovaClientError(reason=str(e))
+
         return wrapper
+
     return decorator
 
 
@@ -148,7 +153,7 @@ class Server:
             locked=nova_server.is_locked,
             metadata=nova_server.metadata,
             availability_zone=nova_server.availability_zone,
-            pinned_availability_zone=nova_server.pinned_availability_zone
+            pinned_availability_zone=nova_server.pinned_availability_zone,
         )
 
 
@@ -260,7 +265,7 @@ class Flavor:
             ephemeral=nova_flavor.ephemeral,
             swap=nova_flavor.swap,
             is_public=nova_flavor.is_public,
-            extra_specs=nova_flavor.extra_specs
+            extra_specs=nova_flavor.extra_specs,
         )
 
 
@@ -359,13 +364,10 @@ class ServerMigration:
         :param nova_migration: OpenStackSDK ServerMigration
         :returns: ServerMigration dataclass instance
         """
-        return cls(
-            id=nova_migration.id,
-        )
+        return cls(id=nova_migration.id)
 
 
 class NovaHelper:
-
     def __init__(self, osc=None, session=None, context=None):
         """Create and return a helper to call the nova service
 
@@ -380,9 +382,7 @@ class NovaHelper:
         clients.check_min_nova_api_version(CONF.nova.api_version)
         self.osc = osc if osc else clients.OpenStackClients()
         self.cinder = self.osc.cinder()
-        self._create_sdk_connection(
-            context=context, session=session
-        )
+        self._create_sdk_connection(context=context, session=session)
         self._is_pinned_az_available = None
 
     def _override_deprecated_configs(self):
@@ -413,14 +413,17 @@ class NovaHelper:
             # [nova], use [watcher_clients_auth] as fallback
             LOG.debug(
                 "could not load auth plugin from [nova] section, using %s "
-                "as fallback", clients_auth.WATCHER_CLIENTS_AUTH
+                "as fallback",
+                clients_auth.WATCHER_CLIENTS_AUTH,
             )
             auth_group = clients_auth.WATCHER_CLIENTS_AUTH
 
         self.connection = clients.get_sdk_connection(
-            auth_group, context=context, session=session,
+            auth_group,
+            context=context,
+            session=session,
             interface=CONF.nova.valid_interfaces,
-            region_name=CONF.nova.region_name
+            region_name=CONF.nova.region_name,
         )
 
     def is_pinned_az_available(self):
@@ -452,15 +455,17 @@ class NovaHelper:
         ]
         if filter_ironic_nodes:
             compute_nodes = [
-                node for node in compute_nodes
+                node
+                for node in compute_nodes
                 if node.hypervisor_type != 'ironic'
             ]
         return compute_nodes
 
     @nova_retries
     @handle_nova_error("Compute node")
-    def get_compute_node_by_name(self, node_name, servers=False,
-                                 detailed=False):
+    def get_compute_node_by_name(
+        self, node_name, servers=False, detailed=False
+    ):
         """Search for a hypervisor (compute node) by hypervisor_hostname
 
         :param node_name: The hypervisor_hostname to search
@@ -473,8 +478,10 @@ class NovaHelper:
         """
         # SDK hypervisors() method returns all hypervisors, filter by name
         hypervisors = self.connection.compute.hypervisors(
-            hypervisor_hostname_pattern=node_name, with_servers=servers,
-            details=detailed)
+            hypervisor_hostname_pattern=node_name,
+            with_servers=servers,
+            details=detailed,
+        )
         return [Hypervisor.from_openstacksdk(h) for h in hypervisors]
 
     def get_compute_node_by_hostname(self, node_hostname):
@@ -490,7 +497,8 @@ class NovaHelper:
             # more than one compute node. If so, match on the compute service
             # hostname.
             compute_nodes = self.get_compute_node_by_name(
-                node_hostname, detailed=True)
+                node_hostname, detailed=True
+            )
             if compute_nodes:
                 for cn in compute_nodes:
                     if cn.service_host == node_hostname:
@@ -528,9 +536,7 @@ class NovaHelper:
                       https://bugs.launchpad.net/watcher/+bug/1834679
         :returns: list of Server wrapper objects
         """
-        query_params = {
-            'all_projects': True, 'marker': marker
-        }
+        query_params = {'all_projects': True, 'marker': marker}
         if limit != -1:
             query_params['limit'] = limit
         if filters:
@@ -540,8 +546,7 @@ class NovaHelper:
                 # passing 'host' is simply ignored
                 filters['compute_host'] = filters.pop('host')
             query_params.update(filters)
-        servers = self.connection.compute.servers(details=True,
-                                                  **query_params)
+        servers = self.connection.compute.servers(details=True, **query_params)
         return [Server.from_openstacksdk(s) for s in servers]
 
     @nova_retries
@@ -553,9 +558,9 @@ class NovaHelper:
         :returns: Server wrapper object matching the UUID
         :raises: ComputeResourceNotFound if no instance was found
         """
-        servers = self.connection.compute.servers(details=True,
-                                                  all_projects=True,
-                                                  uuid=instance_uuid)
+        servers = self.connection.compute.servers(
+            details=True, all_projects=True, uuid=instance_uuid
+        )
         if servers:
             return Server.from_openstacksdk(servers[0])
         else:
@@ -586,8 +591,14 @@ class NovaHelper:
             flavor_obj = self._get_flavor(flavor)
             return flavor_obj.id
         except exception.ComputeResourceNotFound:
-            flavor_id = next((f.id for f in self.get_flavor_list() if
-                              f.flavor_name == flavor), None)
+            flavor_id = next(
+                (
+                    f.id
+                    for f in self.get_flavor_list()
+                    if f.flavor_name == flavor
+                ),
+                None,
+            )
             if flavor_id:
                 return flavor_id
 
@@ -732,7 +743,7 @@ class NovaHelper:
         except exception.ComputeResourceNotFound:
             LOG.debug(
                 "Instance %s was not found, could not confirm its resize",
-                instance_id
+                instance_id,
             )
             return False
 
@@ -742,7 +753,7 @@ class NovaHelper:
             except exception.ComputeResourceNotFound:
                 LOG.debug(
                     "Instance %s was not found, could not confirm its resize",
-                    instance_id
+                    instance_id,
                 )
                 return False
             retry -= 1
@@ -750,12 +761,12 @@ class NovaHelper:
         if instance.status == previous_status:
             return True
         else:
-            LOG.debug("confirm resize failed for the "
-                      "instance %s", instance_id)
+            LOG.debug("confirm resize failed for the instance %s", instance_id)
             return False
 
-    def watcher_non_live_migrate_instance(self, instance_id, dest_hostname,
-                                          retry=None, interval=None):
+    def watcher_non_live_migrate_instance(
+        self, instance_id, dest_hostname, retry=None, interval=None
+    ):
         """This method migrates a given instance
 
         This method uses the Nova built-in migrate()
@@ -775,8 +786,7 @@ class NovaHelper:
         :raises: NovaClientError if there is any problem while calling the Nova
         api
         """
-        LOG.debug(
-            "Trying a cold migrate of instance '%s' ", instance_id)
+        LOG.debug("Trying a cold migrate of instance '%s' ", instance_id)
 
         # Use config defaults if not provided in method parameters
         retry = retry or CONF.nova.migration_max_retries
@@ -790,8 +800,7 @@ class NovaHelper:
             )
             return False
         host_name = instance.host
-        LOG.debug(
-            {'instance': instance_id, 'host': host_name})
+        LOG.debug({'instance': instance_id, 'host': host_name})
 
         previous_status = instance.status
         self._instance_migrate(instance_id, dest_hostname)
@@ -803,32 +812,30 @@ class NovaHelper:
             )
             return False
 
-        while (instance.status not in
-                ["VERIFY_RESIZE", "ERROR"] and retry):
+        while instance.status not in ["VERIFY_RESIZE", "ERROR"] and retry:
             try:
                 instance = self.find_instance(instance_id)
             except exception.ComputeResourceNotFound:
                 LOG.debug(
                     "Instance %s not found, can't cold migrate it.",
-                    instance_id
+                    instance_id,
                 )
                 return False
             time.sleep(interval)
             retry -= 1
         new_hostname = instance.host
 
-        if (host_name != new_hostname and
-                instance.status == 'VERIFY_RESIZE'):
+        if host_name != new_hostname and instance.status == 'VERIFY_RESIZE':
             if not self.confirm_resize(instance, previous_status):
                 return False
             LOG.debug(
                 "cold migration succeeded : "
                 "instance %(instance)s is now on host '%(host)s'.",
-                {'instance': instance_id, 'host': new_hostname})
+                {'instance': instance_id, 'host': new_hostname},
+            )
             return True
         else:
-            LOG.debug(
-                "cold migration for instance %s failed", instance_id)
+            LOG.debug("cold migration for instance %s failed", instance_id)
             return False
 
     def resize_instance(self, instance_id, flavor, retry=None, interval=None):
@@ -848,9 +855,9 @@ class NovaHelper:
         api
         """
         LOG.debug(
-            "Trying a resize of instance %(instance)s to "
-            "flavor '%(flavor)s'",
-            {'instance': instance_id, 'flavor': flavor})
+            "Trying a resize of instance %(instance)s to flavor '%(flavor)s'",
+            {'instance': instance_id, 'flavor': flavor},
+        )
 
         # Use config defaults if not provided in method parameters
         retry = retry or CONF.nova.migration_max_retries
@@ -871,14 +878,19 @@ class NovaHelper:
             LOG.debug("Flavor not found: %s, could not resize", flavor)
             return False
         except exception.NovaClientError as e:
-            LOG.debug("Nova client exception occurred while resizing "
-                      "instance %s. Exception: %s", instance_id, e)
+            LOG.debug(
+                "Nova client exception occurred while resizing "
+                "instance %s. Exception: %s",
+                instance_id,
+                e,
+            )
             return False
 
         instance_status = instance.vm_state
         LOG.debug(
             "Instance %(id)s is in '%(status)s' status.",
-            {'id': instance_id, 'status': instance_status})
+            {'id': instance_id, 'status': instance_status},
+        )
 
         self._instance_resize(instance_id, flavor_id)
         while instance.vm_state != 'resized' and retry:
@@ -899,13 +911,17 @@ class NovaHelper:
 
         self._instance_confirm_resize(instance_id)
 
-        LOG.debug("Resizing succeeded : instance %s is now on flavor "
-                  "'%s'.", instance_id, flavor_id)
+        LOG.debug(
+            "Resizing succeeded : instance %s is now on flavor '%s'.",
+            instance_id,
+            flavor_id,
+        )
 
         return True
 
-    def live_migrate_instance(self, instance_id, dest_hostname, retry=None,
-                              interval=None):
+    def live_migrate_instance(
+        self, instance_id, dest_hostname, retry=None, interval=None
+    ):
         """This method does a live migration of a given instance
 
         This method uses the Nova built-in live_migrate()
@@ -925,7 +941,8 @@ class NovaHelper:
         """
         LOG.debug(
             "Trying a live migrate instance %(instance)s ",
-            {'instance': instance_id})
+            {'instance': instance_id},
+        )
 
         # Use config defaults if not provided in method parameters
         retry = retry or CONF.nova.migration_max_retries
@@ -940,7 +957,8 @@ class NovaHelper:
         host_name = instance.host
         LOG.debug(
             "Instance %(instance)s found on host '%(host)s'.",
-            {'instance': instance_id, 'host': host_name})
+            {'instance': instance_id, 'host': host_name},
+        )
 
         self._instance_live_migrate(instance_id, dest_hostname)
 
@@ -953,13 +971,13 @@ class NovaHelper:
         # NOTE: If destination host is not specified for live migration
         # let nova scheduler choose the destination host.
         if dest_hostname is None:
-            while (instance.status not in ['ACTIVE', 'ERROR'] and retry):
+            while instance.status not in ['ACTIVE', 'ERROR'] and retry:
                 try:
                     instance = self.find_instance(instance_id)
                 except exception.ComputeResourceNotFound:
                     LOG.debug(
                         "Instance %s not found, can't live migrate",
-                        instance_id
+                        instance_id,
                     )
                     return False
                 LOG.debug('Waiting the migration of %s', instance_id)
@@ -971,7 +989,8 @@ class NovaHelper:
                 LOG.debug(
                     "Live migration succeeded : "
                     "instance %(instance)s is now on host '%(host)s'.",
-                    {'instance': instance_id, 'host': new_hostname})
+                    {'instance': instance_id, 'host': new_hostname},
+                )
                 return True
             else:
                 return False
@@ -987,7 +1006,7 @@ class NovaHelper:
                 break
             LOG.debug(
                 'Waiting the migration of %s to %s', instance, instance.host
-                )
+            )
             time.sleep(interval)
             retry -= 1
 
@@ -998,7 +1017,8 @@ class NovaHelper:
         LOG.debug(
             "Live migration succeeded : "
             "instance %(instance)s is now on host '%(host)s'.",
-            {'instance': instance_id, 'host': host_name})
+            {'instance': instance_id, 'host': host_name},
+        )
 
         return True
 
@@ -1022,13 +1042,16 @@ class NovaHelper:
         except exception.ComputeResourceNotFound:
             # failed to abort the migration since the migration does not exist
             LOG.debug(
-                "No running migrations found for instance %s", instance_id)
+                "No running migrations found for instance %s", instance_id
+            )
         if migration:
             migration_id = migration[0].id
             try:
                 self._live_migration_abort(instance_id, migration_id)
-            except (exception.ComputeResourceNotFound,
-                    exception.NovaClientError) as e:
+            except (
+                exception.ComputeResourceNotFound,
+                exception.NovaClientError,
+            ) as e:
                 # Note: Does not return from here, as abort request can't be
                 # accepted but migration still going on.
                 LOG.exception(e)
@@ -1039,11 +1062,13 @@ class NovaHelper:
             except exception.ComputeResourceNotFound:
                 LOG.debug(
                     "Instance %s not found, can't abort live migrate",
-                    instance_id
+                    instance_id,
                 )
                 return False
-            if (instance.task_state is None and
-               instance.status in ['ACTIVE', 'ERROR']):
+            if instance.task_state is None and instance.status in [
+                'ACTIVE',
+                'ERROR',
+            ]:
                 break
             time.sleep(2)
             retry -= 1
diff --git a/watcher/common/oslo_service_helper.py b/watcher/common/oslo_service_helper.py
index e516f21d3..427d69b3c 100644
--- a/watcher/common/oslo_service_helper.py
+++ b/watcher/common/oslo_service_helper.py
@@ -24,10 +24,10 @@ LOG = log.getLogger(__name__)
 def init_oslo_service_backend():
     if eventlet_helper.is_patched():
         backend.init_backend(backend.BackendType.EVENTLET)
-        LOG.warning(
-            "Service is starting with Eventlet based service backend.")
+        LOG.warning("Service is starting with Eventlet based service backend.")
     else:
         backend.init_backend(backend.BackendType.THREADING)
         LOG.warning(
             "Service is starting with Threading based service backend. "
-            "This is an experimental feature, do not use it in production.")
+            "This is an experimental feature, do not use it in production."
+        )
diff --git a/watcher/common/placement_helper.py b/watcher/common/placement_helper.py
index 0296b801b..f685c42e6 100644
--- a/watcher/common/placement_helper.py
+++ b/watcher/common/placement_helper.py
@@ -24,7 +24,6 @@ LOG = logging.getLogger(__name__)
 
 
 class PlacementHelper:
-
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
         self.osc = osc if osc else clients.OpenStackClients()
@@ -83,8 +82,10 @@ class PlacementHelper:
         if resp.status_code == HTTPStatus.OK:
             json = resp.json()
             return json['inventories']
-        msg = ("Failed to get resource provider %(rp_uuid)s inventories. "
-               "Got %(status_code)d: %(err_text)s.")
+        msg = (
+            "Failed to get resource provider %(rp_uuid)s inventories. "
+            "Got %(status_code)d: %(err_text)s."
+        )
         args = {
             'rp_uuid': rp_uuid,
             'status_code': resp.status_code,
@@ -103,8 +104,10 @@ class PlacementHelper:
         if resp.status_code == HTTPStatus.OK:
             json = resp.json()
             return json['traits']
-        msg = ("Failed to get resource provider %(rp_uuid)s traits. "
-               "Got %(status_code)d: %(err_text)s.")
+        msg = (
+            "Failed to get resource provider %(rp_uuid)s traits. "
+            "Got %(status_code)d: %(err_text)s."
+        )
         args = {
             'rp_uuid': rp_uuid,
             'status_code': resp.status_code,
@@ -124,8 +127,10 @@ class PlacementHelper:
         if resp.status_code == HTTPStatus.OK:
             json = resp.json()
             return json['allocations']
-        msg = ("Failed to get allocations for consumer %(c_uuid)s. "
-               "Got %(status_code)d: %(err_text)s.")
+        msg = (
+            "Failed to get allocations for consumer %(c_uuid)s. "
+            "Got %(status_code)d: %(err_text)s."
+        )
         args = {
             'c_uuid': consumer_uuid,
             'status_code': resp.status_code,
@@ -145,8 +150,10 @@ class PlacementHelper:
         if resp.status_code == HTTPStatus.OK:
             json = resp.json()
             return json['usages']
-        msg = ("Failed to get resource provider %(rp_uuid)s usages. "
-               "Got %(status_code)d: %(err_text)s.")
+        msg = (
+            "Failed to get resource provider %(rp_uuid)s usages. "
+            "Got %(status_code)d: %(err_text)s."
+        )
         args = {
             'rp_uuid': rp_uuid,
             'status_code': resp.status_code,
@@ -176,7 +183,9 @@ class PlacementHelper:
             'status_code': resp.status_code,
             'err_text': self.get_error_msg(resp),
         }
-        msg = ("Failed to get allocation candidates from placement "
-               "API for resources: %(resource_request)s\n"
-               "Got %(status_code)d: %(err_text)s.")
+        msg = (
+            "Failed to get allocation candidates from placement "
+            "API for resources: %(resource_request)s\n"
+            "Got %(status_code)d: %(err_text)s."
+        )
         LOG.error(msg, args)
diff --git a/watcher/common/policies/action.py b/watcher/common/policies/action.py
index 277832e63..ee62aa4de 100644
--- a/watcher/common/policies/action.py
+++ b/watcher/common/policies/action.py
@@ -22,46 +22,26 @@ rules = [
         name=ACTION % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve a list of actions with detail.',
-        operations=[
-            {
-                'path': '/v1/actions/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/actions/detail', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION % 'get',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve information about a given action.',
-        operations=[
-            {
-                'path': '/v1/actions/{action_id}',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/actions/{action_id}', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve a list of all actions.',
-        operations=[
-            {
-                'path': '/v1/actions',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/actions', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION % 'update',
         check_str=base.RULE_ADMIN_API,
         description='Update an action.',
-        operations=[
-            {
-                'path': '/v1/actions/{action_id}',
-                'method': 'PATCH'
-            }
-        ]
-    )
+        operations=[{'path': '/v1/actions/{action_id}', 'method': 'PATCH'}],
+    ),
 ]
 
 
diff --git a/watcher/common/policies/action_plan.py b/watcher/common/policies/action_plan.py
index c3420fc88..2225a9877 100644
--- a/watcher/common/policies/action_plan.py
+++ b/watcher/common/policies/action_plan.py
@@ -23,55 +23,36 @@ rules = [
         check_str=base.RULE_ADMIN_API,
         description='Delete an action plan.',
         operations=[
-            {
-                'path': '/v1/action_plans/{action_plan_uuid}',
-                'method': 'DELETE'
-            }
-        ]
+            {'path': '/v1/action_plans/{action_plan_uuid}', 'method': 'DELETE'}
+        ],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION_PLAN % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve a list of action plans with detail.',
-        operations=[
-            {
-                'path': '/v1/action_plans/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/action_plans/detail', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION_PLAN % 'get',
         check_str=base.RULE_ADMIN_API,
         description='Get an action plan.',
         operations=[
-            {
-                'path': '/v1/action_plans/{action_plan_id}',
-                'method': 'GET'
-            }
-        ]
+            {'path': '/v1/action_plans/{action_plan_id}', 'method': 'GET'}
+        ],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION_PLAN % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='Get all action plans.',
-        operations=[
-            {
-                'path': '/v1/action_plans',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/action_plans', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION_PLAN % 'update',
         check_str=base.RULE_ADMIN_API,
         description='Update an action plans.',
         operations=[
-            {
-                'path': '/v1/action_plans/{action_plan_uuid}',
-                'method': 'PATCH'
-            }
-        ]
+            {'path': '/v1/action_plans/{action_plan_uuid}', 'method': 'PATCH'}
+        ],
     ),
     policy.DocumentedRuleDefault(
         name=ACTION_PLAN % 'start',
@@ -80,10 +61,10 @@ rules = [
         operations=[
             {
                 'path': '/v1/action_plans/{action_plan_uuid}/start',
-                'method': 'POST'
+                'method': 'POST',
             }
-        ]
-    )
+        ],
+    ),
 ]
 
 
diff --git a/watcher/common/policies/audit.py b/watcher/common/policies/audit.py
index b4207a764..9eb4cff23 100644
--- a/watcher/common/policies/audit.py
+++ b/watcher/common/policies/audit.py
@@ -22,68 +22,38 @@ rules = [
         name=AUDIT % 'create',
         check_str=base.RULE_ADMIN_API,
         description='Create a new audit.',
-        operations=[
-            {
-                'path': '/v1/audits',
-                'method': 'POST'
-            }
-        ]
+        operations=[{'path': '/v1/audits', 'method': 'POST'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT % 'delete',
         check_str=base.RULE_ADMIN_API,
         description='Delete an audit.',
-        operations=[
-            {
-                'path': '/v1/audits/{audit_uuid}',
-                'method': 'DELETE'
-            }
-        ]
+        operations=[{'path': '/v1/audits/{audit_uuid}', 'method': 'DELETE'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve audit list with details.',
-        operations=[
-            {
-                'path': '/v1/audits/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/audits/detail', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT % 'get',
         check_str=base.RULE_ADMIN_API,
         description='Get an audit.',
-        operations=[
-            {
-                'path': '/v1/audits/{audit_uuid}',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/audits/{audit_uuid}', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='Get all audits.',
-        operations=[
-            {
-                'path': '/v1/audits',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/audits', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT % 'update',
         check_str=base.RULE_ADMIN_API,
         description='Update an audit.',
-        operations=[
-            {
-                'path': '/v1/audits/{audit_uuid}',
-                'method': 'PATCH'
-            }
-        ]
-    )
+        operations=[{'path': '/v1/audits/{audit_uuid}', 'method': 'PATCH'}],
+    ),
 ]
 
 
diff --git a/watcher/common/policies/audit_template.py b/watcher/common/policies/audit_template.py
index 677ceb1e1..607e1ab05 100644
--- a/watcher/common/policies/audit_template.py
+++ b/watcher/common/policies/audit_template.py
@@ -22,12 +22,7 @@ rules = [
         name=AUDIT_TEMPLATE % 'create',
         check_str=base.RULE_ADMIN_API,
         description='Create an audit template.',
-        operations=[
-            {
-                'path': '/v1/audit_templates',
-                'method': 'POST'
-            }
-        ]
+        operations=[{'path': '/v1/audit_templates', 'method': 'POST'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT_TEMPLATE % 'delete',
@@ -36,20 +31,15 @@ rules = [
         operations=[
             {
                 'path': '/v1/audit_templates/{audit_template_uuid}',
-                'method': 'DELETE'
+                'method': 'DELETE',
             }
-        ]
+        ],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT_TEMPLATE % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve a list of audit templates with details.',
-        operations=[
-            {
-                'path': '/v1/audit_templates/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/audit_templates/detail', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT_TEMPLATE % 'get',
@@ -58,20 +48,15 @@ rules = [
         operations=[
             {
                 'path': '/v1/audit_templates/{audit_template_uuid}',
-                'method': 'GET'
+                'method': 'GET',
             }
-        ]
+        ],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT_TEMPLATE % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='Get a list of all audit templates.',
-        operations=[
-            {
-                'path': '/v1/audit_templates',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/audit_templates', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=AUDIT_TEMPLATE % 'update',
@@ -80,10 +65,10 @@ rules = [
         operations=[
             {
                 'path': '/v1/audit_templates/{audit_template_uuid}',
-                'method': 'PATCH'
+                'method': 'PATCH',
             }
-        ]
-    )
+        ],
+    ),
 ]
 
 
diff --git a/watcher/common/policies/base.py b/watcher/common/policies/base.py
index 94ba77b12..1a3918431 100644
--- a/watcher/common/policies/base.py
+++ b/watcher/common/policies/base.py
@@ -19,13 +19,9 @@ ALWAYS_DENY = '!'
 
 rules = [
     policy.RuleDefault(
-        name='admin_api',
-        check_str=ROLE_ADMIN_OR_ADMINISTRATOR
+        name='admin_api', check_str=ROLE_ADMIN_OR_ADMINISTRATOR
     ),
-    policy.RuleDefault(
-        name='show_password',
-        check_str=ALWAYS_DENY
-    )
+    policy.RuleDefault(name='show_password', check_str=ALWAYS_DENY),
 ]
 
 
diff --git a/watcher/common/policies/data_model.py b/watcher/common/policies/data_model.py
index e442c5c3e..62a50c609 100644
--- a/watcher/common/policies/data_model.py
+++ b/watcher/common/policies/data_model.py
@@ -24,13 +24,8 @@ rules = [
         name=DATA_MODEL % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='List data model.',
-        operations=[
-            {
-                'path': '/v1/data_model',
-                'method': 'GET'
-            }
-        ]
-    ),
+        operations=[{'path': '/v1/data_model', 'method': 'GET'}],
+    )
 ]
 
 
diff --git a/watcher/common/policies/goal.py b/watcher/common/policies/goal.py
index 8bcc7182e..8bc7adc6d 100644
--- a/watcher/common/policies/goal.py
+++ b/watcher/common/policies/goal.py
@@ -22,35 +22,20 @@ rules = [
         name=GOAL % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='Retrieve a list of goals with detail.',
-        operations=[
-            {
-                'path': '/v1/goals/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/goals/detail', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=GOAL % 'get',
         check_str=base.RULE_ADMIN_API,
         description='Get a goal.',
-        operations=[
-            {
-                'path': '/v1/goals/{goal_uuid}',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/goals/{goal_uuid}', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=GOAL % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='Get all goals.',
-        operations=[
-            {
-                'path': '/v1/goals',
-                'method': 'GET'
-            }
-        ]
-    )
+        operations=[{'path': '/v1/goals', 'method': 'GET'}],
+    ),
 ]
 
 
diff --git a/watcher/common/policies/scoring_engine.py b/watcher/common/policies/scoring_engine.py
index fe7ff8e63..e3883056c 100644
--- a/watcher/common/policies/scoring_engine.py
+++ b/watcher/common/policies/scoring_engine.py
@@ -25,12 +25,7 @@ rules = [
         name=SCORING_ENGINE % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='List scoring engines with details.',
-        operations=[
-            {
-                'path': '/v1/scoring_engines/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/scoring_engines/detail', 'method': 'GET'}],
     ),
     # FIXME(lbragstad): Find someone from watcher to double check this
     # information. This API isn't listed in watcher's API reference
@@ -42,9 +37,9 @@ rules = [
         operations=[
             {
                 'path': '/v1/scoring_engines/{scoring_engine_id}',
-                'method': 'GET'
+                'method': 'GET',
             }
-        ]
+        ],
     ),
     # FIXME(lbragstad): Find someone from watcher to double check this
     # information. This API isn't listed in watcher's API reference
@@ -53,13 +48,8 @@ rules = [
         name=SCORING_ENGINE % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='Get all scoring engines.',
-        operations=[
-            {
-                'path': '/v1/scoring_engines',
-                'method': 'GET'
-            }
-        ]
-    )
+        operations=[{'path': '/v1/scoring_engines', 'method': 'GET'}],
+    ),
 ]
 
 
diff --git a/watcher/common/policies/service.py b/watcher/common/policies/service.py
index f72d13a46..6080c5178 100644
--- a/watcher/common/policies/service.py
+++ b/watcher/common/policies/service.py
@@ -22,34 +22,19 @@ rules = [
         name=SERVICE % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='List services with detail.',
-        operations=[
-            {
-                'path': '/v1/services/',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/services/', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=SERVICE % 'get',
         check_str=base.RULE_ADMIN_API,
         description='Get a specific service.',
-        operations=[
-            {
-                'path': '/v1/services/{service_id}',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/services/{service_id}', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=SERVICE % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='List all services.',
-        operations=[
-            {
-                'path': '/v1/services/',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/services/', 'method': 'GET'}],
     ),
 ]
 
diff --git a/watcher/common/policies/strategy.py b/watcher/common/policies/strategy.py
index 656bc68e3..48eff1365 100644
--- a/watcher/common/policies/strategy.py
+++ b/watcher/common/policies/strategy.py
@@ -22,46 +22,30 @@ rules = [
         name=STRATEGY % 'detail',
         check_str=base.RULE_ADMIN_API,
         description='List strategies with detail.',
-        operations=[
-            {
-                'path': '/v1/strategies/detail',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/strategies/detail', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=STRATEGY % 'get',
         check_str=base.RULE_ADMIN_API,
         description='Get a strategy.',
         operations=[
-            {
-                'path': '/v1/strategies/{strategy_uuid}',
-                'method': 'GET'
-            }
-        ]
+            {'path': '/v1/strategies/{strategy_uuid}', 'method': 'GET'}
+        ],
     ),
     policy.DocumentedRuleDefault(
         name=STRATEGY % 'get_all',
         check_str=base.RULE_ADMIN_API,
         description='List all strategies.',
-        operations=[
-            {
-                'path': '/v1/strategies',
-                'method': 'GET'
-            }
-        ]
+        operations=[{'path': '/v1/strategies', 'method': 'GET'}],
     ),
     policy.DocumentedRuleDefault(
         name=STRATEGY % 'state',
         check_str=base.RULE_ADMIN_API,
         description='Get state of strategy.',
         operations=[
-            {
-                'path': '/v1/strategies{strategy_uuid}/state',
-                'method': 'GET'
-            }
-        ]
-    )
+            {'path': '/v1/strategies{strategy_uuid}/state', 'method': 'GET'}
+        ],
+    ),
 ]
 
 
diff --git a/watcher/common/policy.py b/watcher/common/policy.py
index 4b6a7c95c..0b965db37 100644
--- a/watcher/common/policy.py
+++ b/watcher/common/policy.py
@@ -32,69 +32,77 @@ CONF = cfg.CONF
 # oslo policy support change policy rule dynamically.
 # at present, policy.enforce will reload the policy rules when it checks
 # the policy files have been touched.
-def init(policy_file=None, rules=None,
-         default_rule=None, use_conf=True, overwrite=True):
+def init(
+    policy_file=None,
+    rules=None,
+    default_rule=None,
+    use_conf=True,
+    overwrite=True,
+):
     """Init an Enforcer class.
 
-        :param policy_file: Custom policy file to use, if none is
-                            specified, ``conf.policy_file`` will be
-                            used.
-        :param rules: Default dictionary / Rules to use. It will be
-                      considered just in the first instantiation. If
-                      :meth:`load_rules` with ``force_reload=True``,
-                      :meth:`clear` or :meth:`set_rules` with
-                      ``overwrite=True`` is called this will be overwritten.
-        :param default_rule: Default rule to use, conf.default_rule will
-                             be used if none is specified.
-        :param use_conf: Whether to load rules from cache or config file.
-        :param overwrite: Whether to overwrite existing rules when reload rules
-                          from config file.
+    :param policy_file: Custom policy file to use, if none is
+                        specified, ``conf.policy_file`` will be
+                        used.
+    :param rules: Default dictionary / Rules to use. It will be
+                  considered just in the first instantiation. If
+                  :meth:`load_rules` with ``force_reload=True``,
+                  :meth:`clear` or :meth:`set_rules` with
+                  ``overwrite=True`` is called this will be overwritten.
+    :param default_rule: Default rule to use, conf.default_rule will
+                         be used if none is specified.
+    :param use_conf: Whether to load rules from cache or config file.
+    :param overwrite: Whether to overwrite existing rules when reload rules
+                      from config file.
     """
     global _ENFORCER
     if not _ENFORCER:
         # https://docs.openstack.org/oslo.policy/latest/admin/index.html
-        _ENFORCER = policy.Enforcer(CONF,
-                                    policy_file=policy_file,
-                                    rules=rules,
-                                    default_rule=default_rule,
-                                    use_conf=use_conf,
-                                    overwrite=overwrite)
+        _ENFORCER = policy.Enforcer(
+            CONF,
+            policy_file=policy_file,
+            rules=rules,
+            default_rule=default_rule,
+            use_conf=use_conf,
+            overwrite=overwrite,
+        )
         _ENFORCER.register_defaults(policies.list_rules())
     return _ENFORCER
 
 
-def enforce(context, rule=None, target=None,
-            do_raise=True, exc=None, *args, **kwargs):
+def enforce(
+    context, rule=None, target=None, do_raise=True, exc=None, *args, **kwargs
+):
     """Checks authorization of a rule against the target and credentials.
 
-        :param dict context: As much information about the user performing the
-                             action as possible.
-        :param rule: The rule to evaluate.
-        :param dict target: As much information about the object being operated
-                            on as possible.
-        :param do_raise: Whether to raise an exception or not if check
-                         fails.
-        :param exc: Class of the exception to raise if the check fails.
-                    Any remaining arguments passed to :meth:`enforce` (both
-                    positional and keyword arguments) will be passed to
-                    the exception class. If not specified,
-                    :class:`PolicyNotAuthorized` will be used.
+    :param dict context: As much information about the user performing the
+                         action as possible.
+    :param rule: The rule to evaluate.
+    :param dict target: As much information about the object being operated
+                        on as possible.
+    :param do_raise: Whether to raise an exception or not if check
+                     fails.
+    :param exc: Class of the exception to raise if the check fails.
+                Any remaining arguments passed to :meth:`enforce` (both
+                positional and keyword arguments) will be passed to
+                the exception class. If not specified,
+                :class:`PolicyNotAuthorized` will be used.
 
-        :return: ``False`` if the policy does not allow the action and `exc` is
-                 not provided; otherwise, returns a value that evaluates to
-                 ``True``.  Note: for rules using the "case" expression, this
-                 ``True`` value will be the specified string from the
-                 expression.
+    :return: ``False`` if the policy does not allow the action and `exc` is
+             not provided; otherwise, returns a value that evaluates to
+             ``True``.  Note: for rules using the "case" expression, this
+             ``True`` value will be the specified string from the
+             expression.
     """
     enforcer = init()
     credentials = context.to_dict()
     if not exc:
         exc = exception.PolicyNotAuthorized
     if target is None:
-        target = {'project_id': context.project_id,
-                  'user_id': context.user_id}
-    return enforcer.enforce(rule, target, credentials,
-                            do_raise=do_raise, exc=exc, *args, **kwargs)
+        target = {'project_id': context.project_id, 'user_id': context.user_id}
+    return enforcer.enforce(
+        rule, target, credentials, do_raise=do_raise, exc=exc, *args, **kwargs
+    )
 
 
 def get_enforcer():
diff --git a/watcher/common/rpc.py b/watcher/common/rpc.py
index 4881f1e1f..7cad7a47a 100644
--- a/watcher/common/rpc.py
+++ b/watcher/common/rpc.py
@@ -42,9 +42,7 @@ TRANSPORT = None
 NOTIFICATION_TRANSPORT = None
 NOTIFIER = None
 
-ALLOWED_EXMODS = [
-    exception.__name__,
-]
+ALLOWED_EXMODS = [exception.__name__]
 EXTRA_EXMODS = []
 
 
@@ -54,18 +52,20 @@ JsonPayloadSerializer = messaging.JsonPayloadSerializer
 def init(conf):
     global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER
     exmods = get_allowed_exmods()
-    TRANSPORT = messaging.get_rpc_transport(
-        conf, allowed_remote_exmods=exmods)
+    TRANSPORT = messaging.get_rpc_transport(conf, allowed_remote_exmods=exmods)
     NOTIFICATION_TRANSPORT = messaging.get_notification_transport(
-        conf, allowed_remote_exmods=exmods)
+        conf, allowed_remote_exmods=exmods
+    )
 
     serializer = RequestContextSerializer(JsonPayloadSerializer())
     if not conf.notification_level:
         NOTIFIER = messaging.Notifier(
-            NOTIFICATION_TRANSPORT, serializer=serializer, driver='noop')
+            NOTIFICATION_TRANSPORT, serializer=serializer, driver='noop'
+        )
     else:
-        NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT,
-                                      serializer=serializer)
+        NOTIFIER = messaging.Notifier(
+            NOTIFICATION_TRANSPORT, serializer=serializer
+        )
 
 
 def initialized():
@@ -98,7 +98,6 @@ def get_allowed_exmods():
 
 
 class RequestContextSerializer(messaging.Serializer):
-
     def __init__(self, base):
         self._base = base
 
@@ -123,10 +122,7 @@ def get_client(target, version_cap=None, serializer=None):
     assert TRANSPORT is not None
     serializer = RequestContextSerializer(serializer)
     return messaging.get_rpc_client(
-        TRANSPORT,
-        target,
-        version_cap=version_cap,
-        serializer=serializer
+        TRANSPORT, target, version_cap=version_cap, serializer=serializer
     )
 
 
@@ -139,7 +135,7 @@ def get_server(target, endpoints, serializer=None):
         target,
         endpoints,
         serializer=serializer,
-        access_policy=access_policy
+        access_policy=access_policy,
     )
 
 
@@ -152,7 +148,7 @@ def get_notification_listener(targets, endpoints, serializer=None, pool=None):
         endpoints,
         allow_requeue=False,
         pool=pool,
-        serializer=serializer
+        serializer=serializer,
     )
 
 
diff --git a/watcher/common/scheduling.py b/watcher/common/scheduling.py
index 4fbbeace0..1c0961c27 100644
--- a/watcher/common/scheduling.py
+++ b/watcher/common/scheduling.py
@@ -25,13 +25,12 @@ from watcher.common import executor
 
 job_events = events
 
-executors = {
-    'default': executor.APSchedulerThreadPoolExecutor(),
-}
+executors = {'default': executor.APSchedulerThreadPoolExecutor()}
 
 
 class BackgroundSchedulerService(
-        service.ServiceBase, background.BackgroundScheduler):
+    service.ServiceBase, background.BackgroundScheduler
+):
     def __init__(self, gconfig=None, **options):
         if options is None:
             options = {'executors': executors}
@@ -48,8 +47,9 @@ class BackgroundSchedulerService(
         super()._main_loop()
 
     def add_job(self, *args, **kwargs):
-        executor.log_executor_stats(executors['default'].executor,
-                                    name="background-scheduler-pool")
+        executor.log_executor_stats(
+            executors['default'].executor, name="background-scheduler-pool"
+        )
         return super().add_job(*args, **kwargs)
 
     def start(self):
diff --git a/watcher/common/service.py b/watcher/common/service.py
index 9707910e3..818db83ed 100644
--- a/watcher/common/service.py
+++ b/watcher/common/service.py
@@ -43,13 +43,17 @@ from watcher.objects import fields as wfields
 
 
 NOTIFICATION_OPTS = [
-    cfg.StrOpt('notification_level',
-               choices=[''] + list(wfields.NotificationPriority.ALL),
-               default=wfields.NotificationPriority.INFO,
-               help=_('Specifies the minimum level for which to send '
-                      'notifications. If not set, no notifications will '
-                      'be sent. The default is for this option to be at the '
-                      '`INFO` level.'))
+    cfg.StrOpt(
+        'notification_level',
+        choices=[''] + list(wfields.NotificationPriority.ALL),
+        default=wfields.NotificationPriority.INFO,
+        help=_(
+            'Specifies the minimum level for which to send '
+            'notifications. If not set, no notifications will '
+            'be sent. The default is for this option to be at the '
+            '`INFO` level.'
+        ),
+    )
 ]
 cfg.CONF.register_opts(NOTIFICATION_OPTS)
 
@@ -57,12 +61,20 @@ cfg.CONF.register_opts(NOTIFICATION_OPTS)
 CONF = cfg.CONF
 LOG = log.getLogger(__name__)
 
-_DEFAULT_LOG_LEVELS = ['amqp=WARN', 'amqplib=WARN', 'qpid.messaging=INFO',
-                       'oslo.messaging=INFO', 'sqlalchemy=WARN',
-                       'keystoneclient=INFO', 'stevedore=INFO',
-                       'eventlet.wsgi.server=WARN', 'iso8601=WARN',
-                       'requests=WARN', 'neutronclient=WARN',
-                       'apscheduler=WARN']
+_DEFAULT_LOG_LEVELS = [
+    'amqp=WARN',
+    'amqplib=WARN',
+    'qpid.messaging=INFO',
+    'oslo.messaging=INFO',
+    'sqlalchemy=WARN',
+    'keystoneclient=INFO',
+    'stevedore=INFO',
+    'eventlet.wsgi.server=WARN',
+    'iso8601=WARN',
+    'requests=WARN',
+    'neutronclient=WARN',
+    'apscheduler=WARN',
+]
 
 Singleton = service.Singleton
 
@@ -78,13 +90,16 @@ class WSGIService(service.ServiceBase):
         """
         self.service_name = service_name
         self.app = app.VersionSelectorApplication()
-        self.workers = (CONF.api.workers or
-                        processutils.get_worker_count())
-        self.server = wsgi.Server(CONF, self.service_name, self.app,
-                                  host=CONF.api.host,
-                                  port=CONF.api.port,
-                                  use_ssl=use_ssl,
-                                  logger_name=self.service_name)
+        self.workers = CONF.api.workers or processutils.get_worker_count()
+        self.server = wsgi.Server(
+            CONF,
+            self.service_name,
+            self.app,
+            host=CONF.api.host,
+            port=CONF.api.port,
+            use_ssl=use_ssl,
+            logger_name=self.service_name,
+        )
 
     def start(self):
         """Start serving this service using loaded configuration"""
@@ -104,7 +119,6 @@ class WSGIService(service.ServiceBase):
 
 
 class ServiceHeartbeat(scheduling.BackgroundSchedulerService):
-
     service_name = None
 
     def __init__(self, gconfig=None, service_name=None, **kwargs):
@@ -117,8 +131,9 @@ class ServiceHeartbeat(scheduling.BackgroundSchedulerService):
     def send_beat(self):
         host = CONF.host
         watcher_list = objects.Service.list(
-            self.context, filters={'name': ServiceHeartbeat.service_name,
-                                   'host': host})
+            self.context,
+            filters={'name': ServiceHeartbeat.service_name, 'host': host},
+        )
         if watcher_list:
             watcher_service = watcher_list[0]
             watcher_service.last_seen_up = timeutils.utcnow()
@@ -130,8 +145,12 @@ class ServiceHeartbeat(scheduling.BackgroundSchedulerService):
             watcher_service.create()
 
     def add_heartbeat_job(self):
-        self.add_job(self.send_beat, 'interval', seconds=60,
-                     next_run_time=datetime.datetime.now())
+        self.add_job(
+            self.send_beat,
+            'interval',
+            seconds=60,
+            next_run_time=datetime.datetime.now(),
+        )
 
     @classmethod
     def get_service_name(cls):
@@ -157,7 +176,6 @@ class ServiceHeartbeat(scheduling.BackgroundSchedulerService):
 
 
 class Service(service.ServiceBase):
-
     API_VERSION = '1.0'
 
     def __init__(self, manager_class):
@@ -175,7 +193,8 @@ class Service(service.ServiceBase):
         self.service_name = self.manager.service_name
         if self.service_name:
             self.heartbeat = ServiceHeartbeat(
-                service_name=self.manager.service_name)
+                service_name=self.manager.service_name
+            )
 
         self.conductor_endpoints = [
             ep(self) for ep in self.manager.conductor_endpoints
@@ -189,7 +208,8 @@ class Service(service.ServiceBase):
 
         if self.conductor_topic and self.conductor_endpoints:
             self.conductor_topic_handler = self.build_topic_handler(
-                self.conductor_topic, self.conductor_endpoints)
+                self.conductor_topic, self.conductor_endpoints
+            )
         if self.notification_topics and self.notification_endpoints:
             self.notification_handler = self.build_notification_handler(
                 self.notification_topics, self.notification_endpoints
@@ -199,12 +219,10 @@ class Service(service.ServiceBase):
     def conductor_client(self):
         if self._conductor_client is None:
             target = messaging.Target(
-                topic=self.conductor_topic,
-                version=self.API_VERSION,
+                topic=self.conductor_topic, version=self.API_VERSION
             )
             self._conductor_client = rpc.get_client(
-                target,
-                serializer=base.WatcherObjectSerializer()
+                target, serializer=base.WatcherObjectSerializer()
             )
         return self._conductor_client
 
@@ -220,8 +238,7 @@ class Service(service.ServiceBase):
             version=self.api_version,
         )
         return rpc.get_server(
-            target, endpoints,
-            serializer=rpc.JsonPayloadSerializer()
+            target, endpoints, serializer=rpc.JsonPayloadSerializer()
         )
 
     def build_notification_handler(self, topic_names, endpoints=()):
@@ -235,9 +252,10 @@ class Service(service.ServiceBase):
             targets.append(messaging.Target(**kwargs))
 
         return rpc.get_notification_listener(
-            targets, endpoints,
+            targets,
+            endpoints,
             serializer=rpc.JsonPayloadSerializer(),
-            pool=CONF.host
+            pool=CONF.host,
         )
 
     def start(self):
@@ -266,12 +284,14 @@ class Service(service.ServiceBase):
 
     def check_api_version(self, ctx):
         api_manager_version = self.conductor_client.call(
-            ctx, 'check_api_version', api_version=self.api_version)
+            ctx, 'check_api_version', api_version=self.api_version
+        )
         return api_manager_version
 
 
-class ServiceMonitoringBase(scheduling.BackgroundSchedulerService,
-                            metaclass=abc.ABCMeta):
+class ServiceMonitoringBase(
+    scheduling.BackgroundSchedulerService, metaclass=abc.ABCMeta
+):
     """Base Service to monitor the status of Watcher services.
 
     This class is intended to be used as a base class to monitore the
@@ -297,9 +317,15 @@ class ServiceMonitoringBase(scheduling.BackgroundSchedulerService,
 
     def _am_i_leader(self, services):
         active_hosts = sorted(
-            [s.host for s in services
-             if (s.state == objects.service.ServiceStatus.ACTIVE and
-                 s.name == self.service_name)])
+            [
+                s.host
+                for s in services
+                if (
+                    s.state == objects.service.ServiceStatus.ACTIVE
+                    and s.name == self.service_name
+                )
+            ]
+        )
         if not active_hosts:
             LOG.info("No active services found for %s", self.service_name)
             self.last_leader = None
@@ -309,10 +335,14 @@ class ServiceMonitoringBase(scheduling.BackgroundSchedulerService,
         if leader != self.last_leader:
             LOG.info(
                 "Leader election completed for %s: %s -> %s. "
-                "Selected as leader: %s", self.service_name, self.last_leader,
-                leader, CONF.host == leader)
+                "Selected as leader: %s",
+                self.service_name,
+                self.last_leader,
+                leader,
+                CONF.host == leader,
+            )
             self.last_leader = leader
-        return (CONF.host == leader)
+        return CONF.host == leader
 
     @abc.abstractmethod
     def monitor_services_status(self, context):
@@ -320,9 +350,11 @@ class ServiceMonitoringBase(scheduling.BackgroundSchedulerService,
 
     def get_service_status(self, context, service_id):
         watcher_service = objects.Service.get(context, service_id)
-        last_heartbeat = (watcher_service.last_seen_up or
-                          watcher_service.updated_at or
-                          watcher_service.created_at)
+        last_heartbeat = (
+            watcher_service.last_seen_up
+            or watcher_service.updated_at
+            or watcher_service.created_at
+        )
         if isinstance(last_heartbeat, str):
             # NOTE(russellb) If this service came in over rpc via
             # conductor, then the timestamp will be a string and needs to be
@@ -335,11 +367,16 @@ class ServiceMonitoringBase(scheduling.BackgroundSchedulerService,
         elapsed = timeutils.delta_seconds(last_heartbeat, timeutils.utcnow())
         is_up = abs(elapsed) <= CONF.service_down_time
         if not is_up:
-            LOG.warning('Seems service %(name)s on host %(host)s is down. '
-                        'Last heartbeat was %(lhb)s. Elapsed time is %(el)s',
-                        {'name': watcher_service.name,
-                         'host': watcher_service.host,
-                         'lhb': str(last_heartbeat), 'el': str(elapsed)})
+            LOG.warning(
+                'Seems service %(name)s on host %(host)s is down. '
+                'Last heartbeat was %(lhb)s. Elapsed time is %(el)s',
+                {
+                    'name': watcher_service.name,
+                    'host': watcher_service.host,
+                    'lhb': str(last_heartbeat),
+                    'el': str(elapsed),
+                },
+            )
             return objects.service.ServiceStatus.FAILED
 
         return objects.service.ServiceStatus.ACTIVE
@@ -347,13 +384,18 @@ class ServiceMonitoringBase(scheduling.BackgroundSchedulerService,
     def start(self):
         """Start service."""
         admin_context = context.make_context(is_admin=True)
-        LOG.info('Starting service monitoring service for %s',
-                 self.service_name)
-        self.add_job(self.monitor_services_status,
-                     name='service_status', trigger='interval',
-                     jobstore='default', args=[admin_context],
-                     next_run_time=datetime.datetime.now(),
-                     seconds=CONF.periodic_interval)
+        LOG.info(
+            'Starting service monitoring service for %s', self.service_name
+        )
+        self.add_job(
+            self.monitor_services_status,
+            name='service_status',
+            trigger='interval',
+            jobstore='default',
+            args=[admin_context],
+            next_run_time=datetime.datetime.now(),
+            seconds=CONF.periodic_interval,
+        )
         super().start()
 
     def stop(self):
@@ -379,13 +421,13 @@ def prepare_service(argv=(), conf=cfg.CONF):
     gmr_opts.set_defaults(conf)
 
     config.parse_args(argv)
-    cfg.set_defaults(_options.log_opts,
-                     default_log_levels=_DEFAULT_LOG_LEVELS)
+    cfg.set_defaults(_options.log_opts, default_log_levels=_DEFAULT_LOG_LEVELS)
     config.set_lib_defaults()
     log.setup(conf, 'python-watcher')
     conf.log_opt_values(LOG, log.DEBUG)
     objects.register_all()
 
     gmr.TextGuruMeditation.register_section(
-        _('Plugins'), plugins_conf.show_plugins)
+        _('Plugins'), plugins_conf.show_plugins
+    )
     gmr.TextGuruMeditation.setup_autorun(version, conf=conf)
diff --git a/watcher/common/service_manager.py b/watcher/common/service_manager.py
index 1272562e8..750ba461d 100644
--- a/watcher/common/service_manager.py
+++ b/watcher/common/service_manager.py
@@ -17,7 +17,6 @@ import abc
 
 
 class ServiceManager(metaclass=abc.ABCMeta):
-
     @property
     @abc.abstractmethod
     def service_name(self):
diff --git a/watcher/common/utils.py b/watcher/common/utils.py
index 150f3e2c0..ab109916f 100644
--- a/watcher/common/utils.py
+++ b/watcher/common/utils.py
@@ -86,7 +86,9 @@ def safe_rstrip(value, chars=None):
     if not isinstance(value, str):
         LOG.warning(
             "Failed to remove trailing character. Returning original object."
-            "Supplied object is not a string: %s,", value)
+            "Supplied object is not a string: %s,",
+            value,
+        )
         return value
 
     return value.rstrip(chars) or value
@@ -105,8 +107,7 @@ def is_hostname_safe(hostname):
 
     """
     m = r'^[a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?$'
-    return (isinstance(hostname, str) and
-            (re.match(m, hostname) is not None))
+    return isinstance(hostname, str) and (re.match(m, hostname) is not None)
 
 
 def get_cls_import_path(cls):
@@ -130,8 +131,7 @@ def extend_with_default(validator_class):
                 validator, properties, instance, schema
             )
 
-    return validators.extend(validator_class,
-                             {"properties": set_defaults})
+    return validators.extend(validator_class, {"properties": set_defaults})
 
 
 # Parameter strict check extension as jsonschema doesn't support it
@@ -154,7 +154,8 @@ def extend_with_strict_schema(validator_class):
 
 
 StrictDefaultValidatingDraft4Validator = extend_with_default(
-    extend_with_strict_schema(validators.Draft4Validator))
+    extend_with_strict_schema(validators.Draft4Validator)
+)
 
 
 Draft4Validator = validators.Draft4Validator
@@ -189,6 +190,6 @@ def async_compat_call(f, *args, **kwargs):
     # to avoid lingering threads. For consistency, we'll convert eventlet
     # timeout exceptions to asyncio timeout errors.
     with eventlet.timeout.Timeout(
-            seconds=timeout,
-            exception=asyncio.TimeoutError(f"Timeout: {timeout}s")):
+        seconds=timeout, exception=asyncio.TimeoutError(f"Timeout: {timeout}s")
+    ):
         return tpool.execute(tpool_wrapper)
diff --git a/watcher/conf/aetos_client.py b/watcher/conf/aetos_client.py
index 879265b1a..ed63088d0 100644
--- a/watcher/conf/aetos_client.py
+++ b/watcher/conf/aetos_client.py
@@ -16,29 +16,45 @@
 from oslo_config import cfg
 
 
-aetos_client = cfg.OptGroup(name='aetos_client',
-                            title='Configuration Options for Aetos',
-                            help="See https://docs.openstack.org/watcher/"
-                                 "latest/datasources/aetos.html for "
-                                 "details on how these options are used.")
+aetos_client = cfg.OptGroup(
+    name='aetos_client',
+    title='Configuration Options for Aetos',
+    help="See https://docs.openstack.org/watcher/"
+    "latest/datasources/aetos.html for "
+    "details on how these options are used.",
+)
 
 AETOS_CLIENT_OPTS = [
-    cfg.StrOpt('interface',
-               default='public',
-               choices=['public', 'internal', 'admin',
-                        'publicURL', 'internalURL', 'adminURL'],
-               help="Type of endpoint to use in keystoneclient."),
-    cfg.StrOpt('region_name',
-               help="Region in Identity service catalog to use for "
-                    "communication with the OpenStack service."),
-    cfg.StrOpt('fqdn_label',
-               default='fqdn',
-               help="The label that Prometheus uses to store the fqdn of "
-                    "exporters. Defaults to 'fqdn'."),
-    cfg.StrOpt('instance_uuid_label',
-               default='resource',
-               help="The label that Prometheus uses to store the uuid of "
-                    "OpenStack instances. Defaults to 'resource'."),
+    cfg.StrOpt(
+        'interface',
+        default='public',
+        choices=[
+            'public',
+            'internal',
+            'admin',
+            'publicURL',
+            'internalURL',
+            'adminURL',
+        ],
+        help="Type of endpoint to use in keystoneclient.",
+    ),
+    cfg.StrOpt(
+        'region_name',
+        help="Region in Identity service catalog to use for "
+        "communication with the OpenStack service.",
+    ),
+    cfg.StrOpt(
+        'fqdn_label',
+        default='fqdn',
+        help="The label that Prometheus uses to store the fqdn of "
+        "exporters. Defaults to 'fqdn'.",
+    ),
+    cfg.StrOpt(
+        'instance_uuid_label',
+        default='resource',
+        help="The label that Prometheus uses to store the uuid of "
+        "OpenStack instances. Defaults to 'resource'.",
+    ),
 ]
 
 
diff --git a/watcher/conf/api.py b/watcher/conf/api.py
index f48dd5ad8..2bad0ce1b 100644
--- a/watcher/conf/api.py
+++ b/watcher/conf/api.py
@@ -18,48 +18,56 @@
 from oslo_config import cfg
 
 
-api = cfg.OptGroup(name='api',
-                   title='Options for the Watcher API service')
+api = cfg.OptGroup(name='api', title='Options for the Watcher API service')
 
 AUTH_OPTS = [
-    cfg.BoolOpt('enable_authentication',
-                default=True,
-                help='This option enables or disables user authentication '
-                'via keystone. Default value is True.'),
+    cfg.BoolOpt(
+        'enable_authentication',
+        default=True,
+        help='This option enables or disables user authentication '
+        'via keystone. Default value is True.',
+    )
 ]
 
 API_SERVICE_OPTS = [
-    cfg.PortOpt('port',
-                default=9322,
-                help='The port for the watcher API server'),
-    cfg.HostAddressOpt('host',
-                       default='127.0.0.1',
-                       help='The listen IP address for the watcher API server'
-                       ),
-    cfg.IntOpt('max_limit',
-               default=1000,
-               help='The maximum number of items returned in a single '
-                    'response from a collection resource'),
-    cfg.IntOpt('workers',
-               min=1,
-               help='Number of workers for Watcher API service. '
-                    'The default is equal to the number of CPUs available '
-                    'if that can be determined, else a default worker '
-                    'count of 1 is returned.'),
-
-    cfg.BoolOpt('enable_ssl_api',
-                default=False,
-                help="Enable the integrated stand-alone API to service "
-                     "requests via HTTPS instead of HTTP. If there is a "
-                     "front-end service performing HTTPS offloading from "
-                     "the service, this option should be False; note, you "
-                     "will want to change public API endpoint to represent "
-                     "SSL termination URL with 'public_endpoint' option."),
-
-    cfg.BoolOpt('enable_webhooks_auth',
-                default=True,
-                help='This option enables or disables webhook request '
-                     'authentication via keystone. Default value is True.'),
+    cfg.PortOpt(
+        'port', default=9322, help='The port for the watcher API server'
+    ),
+    cfg.HostAddressOpt(
+        'host',
+        default='127.0.0.1',
+        help='The listen IP address for the watcher API server',
+    ),
+    cfg.IntOpt(
+        'max_limit',
+        default=1000,
+        help='The maximum number of items returned in a single '
+        'response from a collection resource',
+    ),
+    cfg.IntOpt(
+        'workers',
+        min=1,
+        help='Number of workers for Watcher API service. '
+        'The default is equal to the number of CPUs available '
+        'if that can be determined, else a default worker '
+        'count of 1 is returned.',
+    ),
+    cfg.BoolOpt(
+        'enable_ssl_api',
+        default=False,
+        help="Enable the integrated stand-alone API to service "
+        "requests via HTTPS instead of HTTP. If there is a "
+        "front-end service performing HTTPS offloading from "
+        "the service, this option should be False; note, you "
+        "will want to change public API endpoint to represent "
+        "SSL termination URL with 'public_endpoint' option.",
+    ),
+    cfg.BoolOpt(
+        'enable_webhooks_auth',
+        default=True,
+        help='This option enables or disables webhook request '
+        'authentication via keystone. Default value is True.',
+    ),
 ]
 
 
diff --git a/watcher/conf/applier.py b/watcher/conf/applier.py
index 4bef1ee95..ab4375e1c 100644
--- a/watcher/conf/applier.py
+++ b/watcher/conf/applier.py
@@ -18,40 +18,49 @@
 from oslo_config import cfg
 
 
-watcher_applier = cfg.OptGroup(name='watcher_applier',
-                               title='Options for the Applier messaging '
-                               'core')
+watcher_applier = cfg.OptGroup(
+    name='watcher_applier', title='Options for the Applier messaging core'
+)
 
 APPLIER_MANAGER_OPTS = [
-    cfg.IntOpt('workers',
-               default=1,
-               min=1,
-               required=True,
-               help='Number of workers for applier, default value is 1.'),
-    cfg.StrOpt('conductor_topic',
-               default='watcher.applier.control',
-               help='The topic name used for '
-                    'control events, this topic '
-                    'used for rpc call '),
-    cfg.StrOpt('publisher_id',
-               default='watcher.applier.api',
-               help='The identifier used by watcher '
-                    'module on the message broker'),
-    cfg.StrOpt('workflow_engine',
-               default='taskflow',
-               required=True,
-               help='Select the engine to use to execute the workflow'),
+    cfg.IntOpt(
+        'workers',
+        default=1,
+        min=1,
+        required=True,
+        help='Number of workers for applier, default value is 1.',
+    ),
+    cfg.StrOpt(
+        'conductor_topic',
+        default='watcher.applier.control',
+        help='The topic name used for '
+        'control events, this topic '
+        'used for rpc call ',
+    ),
+    cfg.StrOpt(
+        'publisher_id',
+        default='watcher.applier.api',
+        help='The identifier used by watcher module on the message broker',
+    ),
+    cfg.StrOpt(
+        'workflow_engine',
+        default='taskflow',
+        required=True,
+        help='Select the engine to use to execute the workflow',
+    ),
 ]
 
 APPLIER_OPTS = [
-    cfg.BoolOpt('rollback_when_actionplan_failed',
-                default=False,
-                help='If set True, the failed actionplan will rollback '
-                     'when executing. Default value is False.',
-                deprecated_for_removal=True,
-                deprecated_since='2026.1',
-                deprecated_reason='This feature does not work and is planned '
-                                 'to be removed in future releases.'),
+    cfg.BoolOpt(
+        'rollback_when_actionplan_failed',
+        default=False,
+        help='If set True, the failed actionplan will rollback '
+        'when executing. Default value is False.',
+        deprecated_for_removal=True,
+        deprecated_since='2026.1',
+        deprecated_reason='This feature does not work and is planned '
+        'to be removed in future releases.',
+    )
 ]
 
 
@@ -62,5 +71,7 @@ def register_opts(conf):
 
 
 def list_opts():
-    return [(watcher_applier, APPLIER_MANAGER_OPTS),
-            (watcher_applier, APPLIER_OPTS)]
+    return [
+        (watcher_applier, APPLIER_MANAGER_OPTS),
+        (watcher_applier, APPLIER_OPTS),
+    ]
diff --git a/watcher/conf/cinder_client.py b/watcher/conf/cinder_client.py
index 2af1de45b..ea882b151 100644
--- a/watcher/conf/cinder_client.py
+++ b/watcher/conf/cinder_client.py
@@ -18,21 +18,35 @@
 from oslo_config import cfg
 
 
-cinder_client = cfg.OptGroup(name='cinder_client',
-                             title='Configuration Options for Cinder')
+cinder_client = cfg.OptGroup(
+    name='cinder_client', title='Configuration Options for Cinder'
+)
 
 CINDER_CLIENT_OPTS = [
-    cfg.StrOpt('api_version',
-               default='3',
-               help='Version of Cinder API to use in cinderclient.'),
-    cfg.StrOpt('endpoint_type',
-               default='publicURL',
-               choices=['public', 'internal', 'admin',
-                        'publicURL', 'internalURL', 'adminURL'],
-               help='Type of endpoint to use in cinderclient.'),
-    cfg.StrOpt('region_name',
-               help='Region in Identity service catalog to use for '
-                    'communication with the OpenStack service.')]
+    cfg.StrOpt(
+        'api_version',
+        default='3',
+        help='Version of Cinder API to use in cinderclient.',
+    ),
+    cfg.StrOpt(
+        'endpoint_type',
+        default='publicURL',
+        choices=[
+            'public',
+            'internal',
+            'admin',
+            'publicURL',
+            'internalURL',
+            'adminURL',
+        ],
+        help='Type of endpoint to use in cinderclient.',
+    ),
+    cfg.StrOpt(
+        'region_name',
+        help='Region in Identity service catalog to use for '
+        'communication with the OpenStack service.',
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/clients_auth.py b/watcher/conf/clients_auth.py
index 9571399ca..70a696057 100644
--- a/watcher/conf/clients_auth.py
+++ b/watcher/conf/clients_auth.py
@@ -27,5 +27,10 @@ def register_opts(conf):
 
 
 def list_opts():
-    return [(WATCHER_CLIENTS_AUTH, ka_loading.get_session_conf_options() +
-            ka_loading.get_auth_common_conf_options())]
+    return [
+        (
+            WATCHER_CLIENTS_AUTH,
+            ka_loading.get_session_conf_options()
+            + ka_loading.get_auth_common_conf_options(),
+        )
+    ]
diff --git a/watcher/conf/collector.py b/watcher/conf/collector.py
index 8c7c4e268..4a82377c5 100644
--- a/watcher/conf/collector.py
+++ b/watcher/conf/collector.py
@@ -16,14 +16,16 @@
 from oslo_config import cfg
 
 
-collector = cfg.OptGroup(name='collector',
-                         title='Defines the parameters of '
-                         'the module model collectors')
+collector = cfg.OptGroup(
+    name='collector',
+    title='Defines the parameters of the module model collectors',
+)
 
 COLLECTOR_OPTS = [
-    cfg.ListOpt('collector_plugins',
-                default=['compute', 'storage'],
-                help="""
+    cfg.ListOpt(
+        'collector_plugins',
+        default=['compute', 'storage'],
+        help="""
 The cluster data model plugin names.
 
 Supported in-tree collectors include:
@@ -34,34 +36,39 @@ Supported in-tree collectors include:
 
 Custom data model collector plugins can be defined with the
 ``watcher_cluster_data_model_collectors`` extension point.
-"""),
-    cfg.IntOpt('api_query_max_retries',
-               min=1,
-               default=10,
-               help="Number of retries before giving up on query to "
-                    "external service.",
-               deprecated_name="api_call_retries"),
-    cfg.IntOpt('api_query_interval',
-               min=0,
-               default=1,
-               help="Time before retry after failed query to "
-                    "external service.",
-               deprecated_name="api_query_timeout"),
-    cfg.IntOpt("compute_resources_collector_timeout",
-               min=30,
-               default=600,
-               help="Timeout in seconds for collecting multiple compute "
-                    "resources from nova. Note that this timeout does not "
-                    "represent the total time for collecting all resources. "
-                    "Setting this value to 0 or small values will cause the "
-                    "collector to abort and stop the collection process."),
+""",
+    ),
+    cfg.IntOpt(
+        'api_query_max_retries',
+        min=1,
+        default=10,
+        help="Number of retries before giving up on query to "
+        "external service.",
+        deprecated_name="api_call_retries",
+    ),
+    cfg.IntOpt(
+        'api_query_interval',
+        min=0,
+        default=1,
+        help="Time before retry after failed query to external service.",
+        deprecated_name="api_query_timeout",
+    ),
+    cfg.IntOpt(
+        "compute_resources_collector_timeout",
+        min=30,
+        default=600,
+        help="Timeout in seconds for collecting multiple compute "
+        "resources from nova. Note that this timeout does not "
+        "represent the total time for collecting all resources. "
+        "Setting this value to 0 or small values will cause the "
+        "collector to abort and stop the collection process.",
+    ),
 ]
 
 
 def register_opts(conf):
     conf.register_group(collector)
-    conf.register_opts(COLLECTOR_OPTS,
-                       group=collector)
+    conf.register_opts(COLLECTOR_OPTS, group=collector)
 
 
 def list_opts():
diff --git a/watcher/conf/datasources.py b/watcher/conf/datasources.py
index 90aeed830..b7ca052b0 100644
--- a/watcher/conf/datasources.py
+++ b/watcher/conf/datasources.py
@@ -21,9 +21,10 @@ from watcher.decision_engine.datasources import manager
 from watcher.decision_engine.datasources import prometheus
 
 
-datasources = cfg.OptGroup(name='watcher_datasources',
-                           title='Configuration Options for watcher'
-                                 ' datasources')
+datasources = cfg.OptGroup(
+    name='watcher_datasources',
+    title='Configuration Options for watcher datasources',
+)
 
 possible_datasources = list(manager.DataSourceManager.metric_map.keys())
 
@@ -35,26 +36,32 @@ default_datasources = list(possible_datasources)
 default_datasources.remove(prometheus.PrometheusHelper.NAME)
 
 DATASOURCES_OPTS = [
-    cfg.ListOpt("datasources",
-                help="Datasources to use in order to query the needed metrics."
-                     " If one of strategy metric is not available in the first"
-                     " datasource, the next datasource will be chosen. This is"
-                     " the default for all strategies unless a strategy has a"
-                     " specific override.",
-                item_type=cfg.types.String(choices=possible_datasources),
-                default=default_datasources),
-    cfg.IntOpt('query_max_retries',
-               min=1,
-               default=10,
-               mutable=True,
-               help='How many times Watcher is trying to query again'),
-    cfg.IntOpt('query_interval',
-               min=0,
-               default=1,
-               mutable=True,
-               help='How many seconds Watcher should wait to do query again',
-               deprecated_name="query_timeout")
-    ]
+    cfg.ListOpt(
+        "datasources",
+        help="Datasources to use in order to query the needed metrics."
+        " If one of strategy metric is not available in the first"
+        " datasource, the next datasource will be chosen. This is"
+        " the default for all strategies unless a strategy has a"
+        " specific override.",
+        item_type=cfg.types.String(choices=possible_datasources),
+        default=default_datasources,
+    ),
+    cfg.IntOpt(
+        'query_max_retries',
+        min=1,
+        default=10,
+        mutable=True,
+        help='How many times Watcher is trying to query again',
+    ),
+    cfg.IntOpt(
+        'query_interval',
+        min=0,
+        default=1,
+        mutable=True,
+        help='How many seconds Watcher should wait to do query again',
+        deprecated_name="query_timeout",
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/db.py b/watcher/conf/db.py
index bcae58232..001b68db3 100644
--- a/watcher/conf/db.py
+++ b/watcher/conf/db.py
@@ -22,15 +22,15 @@ from watcher.conf import paths
 
 
 _DEFAULT_SQL_CONNECTION = 'sqlite:///{}'.format(
-    paths.state_path_def('watcher.sqlite'))
+    paths.state_path_def('watcher.sqlite')
+)
 
-database = cfg.OptGroup(name='database',
-                        title='Configuration Options for database')
+database = cfg.OptGroup(
+    name='database', title='Configuration Options for database'
+)
 
 SQL_OPTS = [
-    cfg.StrOpt('mysql_engine',
-               default='InnoDB',
-               help='MySQL engine to use.')
+    cfg.StrOpt('mysql_engine', default='InnoDB', help='MySQL engine to use.')
 ]
 
 
diff --git a/watcher/conf/decision_engine.py b/watcher/conf/decision_engine.py
index 4cff74150..f90f0d177 100644
--- a/watcher/conf/decision_engine.py
+++ b/watcher/conf/decision_engine.py
@@ -18,74 +18,93 @@
 from oslo_config import cfg
 
 
-watcher_decision_engine = cfg.OptGroup(name='watcher_decision_engine',
-                                       title='Defines the parameters of '
-                                             'the module decision engine')
+watcher_decision_engine = cfg.OptGroup(
+    name='watcher_decision_engine',
+    title='Defines the parameters of the module decision engine',
+)
 
 WATCHER_DECISION_ENGINE_OPTS = [
-    cfg.StrOpt('conductor_topic',
-               default='watcher.decision.control',
-               help='The topic name used for '
-                    'control events, this topic '
-                    'used for RPC calls'),
-    cfg.ListOpt('notification_topics',
-                default=['nova.versioned_notifications',
-                         'openstack.notifications'],
-                help='The exchange and topic names from which '
-                     'notification events will be listened to. '
-                     'The exchange should be specified to get '
-                     'an ability to use pools.'),
-    cfg.StrOpt('publisher_id',
-               default='watcher.decision.api',
-               help='The identifier used by the Watcher '
-                    'module on the message broker'),
-    cfg.IntOpt('max_audit_workers',
-               default=2,
-               required=True,
-               help='The maximum number of threads that can be used to '
-                    'execute audits in parallel.'),
-    cfg.IntOpt('max_general_workers',
-               default=4,
-               required=True,
-               help='The maximum number of threads that can be used to '
-                    'execute general tasks in parallel. The number of general '
-                    'workers will not increase depending on the number of '
-                    'audit workers!'),
-    cfg.IntOpt('action_plan_expiry',
-               default=24,
-               mutable=True,
-               help='An expiry timespan(hours). Watcher invalidates any '
-                    'action plan for which its creation time '
-                    '-whose number of hours has been offset by this value-'
-                    ' is older that the current time.'),
-    cfg.IntOpt('check_periodic_interval',
-               default=30 * 60,
-               mutable=True,
-               help='Interval (in seconds) for checking action plan expiry.'),
-    cfg.StrOpt('metric_map_path',
-               default='/etc/watcher/metric_map.yaml',
-               help='Path to metric map yaml formatted file. '
-                    ' '
-                    'The file contains a map per datasource whose keys '
-                    'are the metric names as recognized by watcher and the '
-                    'value is the real name of the metric in the datasource. '
-                    'For example:: \n\n'
-                    '  gnocchi:\n'
-                    '    instance_cpu_usage: cpu_vm_util\n'
-                    '  aetos:\n'
-                    '    instance_cpu_usage: ceilometer_cpu\n\n'
-                    'This file is optional.'),
-    cfg.IntOpt('continuous_audit_interval',
-               default=10,
-               mutable=True,
-               help='Interval (in seconds) for checking newly created '
-                    'continuous audits.')]
+    cfg.StrOpt(
+        'conductor_topic',
+        default='watcher.decision.control',
+        help='The topic name used for '
+        'control events, this topic '
+        'used for RPC calls',
+    ),
+    cfg.ListOpt(
+        'notification_topics',
+        default=['nova.versioned_notifications', 'openstack.notifications'],
+        help='The exchange and topic names from which '
+        'notification events will be listened to. '
+        'The exchange should be specified to get '
+        'an ability to use pools.',
+    ),
+    cfg.StrOpt(
+        'publisher_id',
+        default='watcher.decision.api',
+        help='The identifier used by the Watcher module on the message broker',
+    ),
+    cfg.IntOpt(
+        'max_audit_workers',
+        default=2,
+        required=True,
+        help='The maximum number of threads that can be used to '
+        'execute audits in parallel.',
+    ),
+    cfg.IntOpt(
+        'max_general_workers',
+        default=4,
+        required=True,
+        help='The maximum number of threads that can be used to '
+        'execute general tasks in parallel. The number of general '
+        'workers will not increase depending on the number of '
+        'audit workers!',
+    ),
+    cfg.IntOpt(
+        'action_plan_expiry',
+        default=24,
+        mutable=True,
+        help='An expiry timespan(hours). Watcher invalidates any '
+        'action plan for which its creation time '
+        '-whose number of hours has been offset by this value-'
+        ' is older that the current time.',
+    ),
+    cfg.IntOpt(
+        'check_periodic_interval',
+        default=30 * 60,
+        mutable=True,
+        help='Interval (in seconds) for checking action plan expiry.',
+    ),
+    cfg.StrOpt(
+        'metric_map_path',
+        default='/etc/watcher/metric_map.yaml',
+        help='Path to metric map yaml formatted file. '
+        ' '
+        'The file contains a map per datasource whose keys '
+        'are the metric names as recognized by watcher and the '
+        'value is the real name of the metric in the datasource. '
+        'For example:: \n\n'
+        '  gnocchi:\n'
+        '    instance_cpu_usage: cpu_vm_util\n'
+        '  aetos:\n'
+        '    instance_cpu_usage: ceilometer_cpu\n\n'
+        'This file is optional.',
+    ),
+    cfg.IntOpt(
+        'continuous_audit_interval',
+        default=10,
+        mutable=True,
+        help='Interval (in seconds) for checking newly created '
+        'continuous audits.',
+    ),
+]
 
 
 def register_opts(conf):
     conf.register_group(watcher_decision_engine)
-    conf.register_opts(WATCHER_DECISION_ENGINE_OPTS,
-                       group=watcher_decision_engine)
+    conf.register_opts(
+        WATCHER_DECISION_ENGINE_OPTS, group=watcher_decision_engine
+    )
 
 
 def list_opts():
diff --git a/watcher/conf/exception.py b/watcher/conf/exception.py
index 1abd2d159..3e9b43ba1 100644
--- a/watcher/conf/exception.py
+++ b/watcher/conf/exception.py
@@ -19,9 +19,11 @@ from oslo_config import cfg
 
 
 EXC_LOG_OPTS = [
-    cfg.BoolOpt('fatal_exception_format_errors',
-                default=False,
-                help='Make exception message format errors fatal.'),
+    cfg.BoolOpt(
+        'fatal_exception_format_errors',
+        default=False,
+        help='Make exception message format errors fatal.',
+    )
 ]
 
 
diff --git a/watcher/conf/gnocchi_client.py b/watcher/conf/gnocchi_client.py
index 20de5b4a6..8730c2bc5 100644
--- a/watcher/conf/gnocchi_client.py
+++ b/watcher/conf/gnocchi_client.py
@@ -18,21 +18,34 @@
 from oslo_config import cfg
 
 
-gnocchi_client = cfg.OptGroup(name='gnocchi_client',
-                              title='Configuration Options for Gnocchi')
+gnocchi_client = cfg.OptGroup(
+    name='gnocchi_client', title='Configuration Options for Gnocchi'
+)
 
 GNOCCHI_CLIENT_OPTS = [
-    cfg.StrOpt('api_version',
-               default='1',
-               help='Version of Gnocchi API to use in gnocchiclient.'),
-    cfg.StrOpt('endpoint_type',
-               default='public',
-               choices=['public', 'internal', 'admin',
-                        'publicURL', 'internalURL', 'adminURL'],
-               help='Type of endpoint to use in gnocchi client.'),
-    cfg.StrOpt('region_name',
-               help='Region in Identity service catalog to use for '
-                    'communication with the OpenStack service.')
+    cfg.StrOpt(
+        'api_version',
+        default='1',
+        help='Version of Gnocchi API to use in gnocchiclient.',
+    ),
+    cfg.StrOpt(
+        'endpoint_type',
+        default='public',
+        choices=[
+            'public',
+            'internal',
+            'admin',
+            'publicURL',
+            'internalURL',
+            'adminURL',
+        ],
+        help='Type of endpoint to use in gnocchi client.',
+    ),
+    cfg.StrOpt(
+        'region_name',
+        help='Region in Identity service catalog to use for '
+        'communication with the OpenStack service.',
+    ),
 ]
 
 
diff --git a/watcher/conf/grafana_client.py b/watcher/conf/grafana_client.py
index 78e1aeeaa..0fc5176e3 100644
--- a/watcher/conf/grafana_client.py
+++ b/watcher/conf/grafana_client.py
@@ -18,128 +18,144 @@
 from oslo_config import cfg
 
 
-grafana_client = cfg.OptGroup(name='grafana_client',
-                              title='Configuration Options for Grafana',
-                              help="See https://docs.openstack.org/watcher/lat"
-                                   "est/datasources/grafana.html for details "
-                                   "on how these options are used.")
+grafana_client = cfg.OptGroup(
+    name='grafana_client',
+    title='Configuration Options for Grafana',
+    help="See https://docs.openstack.org/watcher/lat"
+    "est/datasources/grafana.html for details "
+    "on how these options are used.",
+)
 
 GRAFANA_CLIENT_OPTS = [
     # TODO(Dantali0n) each individual metric could have its own token.
     # A similar structure to the database_map would solve this.
-    cfg.StrOpt('token',
-               default=None,
-               help="Authentication token to gain access"),
+    cfg.StrOpt(
+        'token', default=None, help="Authentication token to gain access"
+    ),
     # TODO(Dantali0n) each individual metric could have its own base url.
     # A similar structure to the database_map would solve this.
-    cfg.StrOpt('base_url',
-               default=None,
-               help="First part of the url (including https:// or http://) up "
-                    "until project id part. "
-                    "Example: https://secure.org/api/datasource/proxy/"),
-    cfg.DictOpt('project_id_map',
-                default={
-                    'host_cpu_usage': None,
-                    'host_ram_usage': None,
-                    'host_outlet_temp': None,
-                    'host_inlet_temp': None,
-                    'host_airflow': None,
-                    'host_power': None,
-                    'instance_cpu_usage': None,
-                    'instance_ram_usage': None,
-                    'instance_ram_allocated': None,
-                    'instance_l3_cache_usage': None,
-                    'instance_root_disk_size': None,
-                },
-                help="Mapping of datasource metrics to grafana project ids. "
-                     "Dictionary values should be positive integers. "
-                     "Example: 7465"),
-    cfg.DictOpt('database_map',
-                default={
-                    'host_cpu_usage': None,
-                    'host_ram_usage': None,
-                    'host_outlet_temp': None,
-                    'host_inlet_temp': None,
-                    'host_airflow': None,
-                    'host_power': None,
-                    'instance_cpu_usage': None,
-                    'instance_ram_usage': None,
-                    'instance_ram_allocated': None,
-                    'instance_l3_cache_usage': None,
-                    'instance_root_disk_size': None,
-                },
-                help="Mapping of datasource metrics to grafana databases. "
-                     "Values should be strings. Example: influx_production"),
-    cfg.DictOpt('attribute_map',
-                default={
-                    'host_cpu_usage': None,
-                    'host_ram_usage': None,
-                    'host_outlet_temp': None,
-                    'host_inlet_temp': None,
-                    'host_airflow': None,
-                    'host_power': None,
-                    'instance_cpu_usage': None,
-                    'instance_ram_usage': None,
-                    'instance_ram_allocated': None,
-                    'instance_l3_cache_usage': None,
-                    'instance_root_disk_size': None,
-                },
-                help="Mapping of datasource metrics to resource attributes. "
-                     "For a complete list of available attributes see "
-                     "https://docs.openstack.org/watcher/latest/datasources/gr"
-                     "afana.html#attribute "
-                     "Values should be strings. Example: hostname"),
-    cfg.DictOpt('translator_map',
-                default={
-                    'host_cpu_usage': None,
-                    'host_ram_usage': None,
-                    'host_outlet_temp': None,
-                    'host_inlet_temp': None,
-                    'host_airflow': None,
-                    'host_power': None,
-                    'instance_cpu_usage': None,
-                    'instance_ram_usage': None,
-                    'instance_ram_allocated': None,
-                    'instance_l3_cache_usage': None,
-                    'instance_root_disk_size': None,
-                },
-                help="Mapping of datasource metrics to grafana translators. "
-                     "Values should be strings. Example: influxdb"),
-    cfg.DictOpt('query_map',
-                # {0} = aggregate
-                # {1} = attribute
-                # {2} = period
-                # {3} = granularity
-                # {4} = { influxdb: retention_period, }
-                default={
-                    'host_cpu_usage': None,
-                    'host_ram_usage': None,
-                    'host_outlet_temp': None,
-                    'host_inlet_temp': None,
-                    'host_airflow': None,
-                    'host_power': None,
-                    'instance_cpu_usage': None,
-                    'instance_ram_usage': None,
-                    'instance_ram_allocated': None,
-                    'instance_l3_cache_usage': None,
-                    'instance_root_disk_size': None,
-                },
-                help="Mapping of datasource metrics to grafana queries. "
-                     "Values should be strings for which the .format method "
-                     "will transform it. The transformation offers five "
-                     "parameters to the query labeled {0} to {4}. {0} will be "
-                     "replaced with the aggregate, {1} with the resource "
-                     "attribute, {2} with the period, {3} with the "
-                     "granularity and {4} with translator specifics for "
-                     "InfluxDB this will be the retention period. "
-                     "These queries will need to be constructed using tools "
-                     "such as Postman. Example: SELECT cpu FROM {4}."
-                     "cpu_percent WHERE host == '{1}' AND time > now()-{2}s"),
-    cfg.IntOpt('http_timeout',
-               min=0,
-               default=60,
-               mutable=True,
-               help='Timeout for Grafana request')
+    cfg.StrOpt(
+        'base_url',
+        default=None,
+        help="First part of the url (including https:// or http://) up "
+        "until project id part. "
+        "Example: https://secure.org/api/datasource/proxy/",
+    ),
+    cfg.DictOpt(
+        'project_id_map',
+        default={
+            'host_cpu_usage': None,
+            'host_ram_usage': None,
+            'host_outlet_temp': None,
+            'host_inlet_temp': None,
+            'host_airflow': None,
+            'host_power': None,
+            'instance_cpu_usage': None,
+            'instance_ram_usage': None,
+            'instance_ram_allocated': None,
+            'instance_l3_cache_usage': None,
+            'instance_root_disk_size': None,
+        },
+        help="Mapping of datasource metrics to grafana project ids. "
+        "Dictionary values should be positive integers. "
+        "Example: 7465",
+    ),
+    cfg.DictOpt(
+        'database_map',
+        default={
+            'host_cpu_usage': None,
+            'host_ram_usage': None,
+            'host_outlet_temp': None,
+            'host_inlet_temp': None,
+            'host_airflow': None,
+            'host_power': None,
+            'instance_cpu_usage': None,
+            'instance_ram_usage': None,
+            'instance_ram_allocated': None,
+            'instance_l3_cache_usage': None,
+            'instance_root_disk_size': None,
+        },
+        help="Mapping of datasource metrics to grafana databases. "
+        "Values should be strings. Example: influx_production",
+    ),
+    cfg.DictOpt(
+        'attribute_map',
+        default={
+            'host_cpu_usage': None,
+            'host_ram_usage': None,
+            'host_outlet_temp': None,
+            'host_inlet_temp': None,
+            'host_airflow': None,
+            'host_power': None,
+            'instance_cpu_usage': None,
+            'instance_ram_usage': None,
+            'instance_ram_allocated': None,
+            'instance_l3_cache_usage': None,
+            'instance_root_disk_size': None,
+        },
+        help="Mapping of datasource metrics to resource attributes. "
+        "For a complete list of available attributes see "
+        "https://docs.openstack.org/watcher/latest/datasources/gr"
+        "afana.html#attribute "
+        "Values should be strings. Example: hostname",
+    ),
+    cfg.DictOpt(
+        'translator_map',
+        default={
+            'host_cpu_usage': None,
+            'host_ram_usage': None,
+            'host_outlet_temp': None,
+            'host_inlet_temp': None,
+            'host_airflow': None,
+            'host_power': None,
+            'instance_cpu_usage': None,
+            'instance_ram_usage': None,
+            'instance_ram_allocated': None,
+            'instance_l3_cache_usage': None,
+            'instance_root_disk_size': None,
+        },
+        help="Mapping of datasource metrics to grafana translators. "
+        "Values should be strings. Example: influxdb",
+    ),
+    cfg.DictOpt(
+        'query_map',
+        # {0} = aggregate
+        # {1} = attribute
+        # {2} = period
+        # {3} = granularity
+        # {4} = { influxdb: retention_period, }
+        default={
+            'host_cpu_usage': None,
+            'host_ram_usage': None,
+            'host_outlet_temp': None,
+            'host_inlet_temp': None,
+            'host_airflow': None,
+            'host_power': None,
+            'instance_cpu_usage': None,
+            'instance_ram_usage': None,
+            'instance_ram_allocated': None,
+            'instance_l3_cache_usage': None,
+            'instance_root_disk_size': None,
+        },
+        help="Mapping of datasource metrics to grafana queries. "
+        "Values should be strings for which the .format method "
+        "will transform it. The transformation offers five "
+        "parameters to the query labeled {0} to {4}. {0} will be "
+        "replaced with the aggregate, {1} with the resource "
+        "attribute, {2} with the period, {3} with the "
+        "granularity and {4} with translator specifics for "
+        "InfluxDB this will be the retention period. "
+        "These queries will need to be constructed using tools "
+        "such as Postman. Example: SELECT cpu FROM {4}."
+        "cpu_percent WHERE host == '{1}' AND time > now()-{2}s",
+    ),
+    cfg.IntOpt(
+        'http_timeout',
+        min=0,
+        default=60,
+        mutable=True,
+        help='Timeout for Grafana request',
+    ),
 ]
 
 
diff --git a/watcher/conf/grafana_translators.py b/watcher/conf/grafana_translators.py
index b84691338..14c7ee9e5 100644
--- a/watcher/conf/grafana_translators.py
+++ b/watcher/conf/grafana_translators.py
@@ -18,26 +18,31 @@
 from oslo_config import cfg
 
 
-grafana_translators = cfg.OptGroup(name='grafana_translators',
-                                   title='Configuration Options for Grafana '
-                                   'transalators')
+grafana_translators = cfg.OptGroup(
+    name='grafana_translators',
+    title='Configuration Options for Grafana transalators',
+)
 
 GRAFANA_TRANSLATOR_INFLUX_OPTS = [
-    cfg.DictOpt('retention_periods',
-                default={
-                    'one_week': 604800,
-                    'one_month': 2592000,
-                    'five_years': 31556952
-                },
-                help="Keys are the names of retention periods in InfluxDB and "
-                     "the values should correspond with the maximum time they "
-                     "can retain in seconds. Example: {'one_day': 86400}")]
+    cfg.DictOpt(
+        'retention_periods',
+        default={
+            'one_week': 604800,
+            'one_month': 2592000,
+            'five_years': 31556952,
+        },
+        help="Keys are the names of retention periods in InfluxDB and "
+        "the values should correspond with the maximum time they "
+        "can retain in seconds. Example: {'one_day': 86400}",
+    )
+]
 
 
 def register_opts(conf):
     conf.register_group(grafana_translators)
-    conf.register_opts(GRAFANA_TRANSLATOR_INFLUX_OPTS,
-                       group=grafana_translators)
+    conf.register_opts(
+        GRAFANA_TRANSLATOR_INFLUX_OPTS, group=grafana_translators
+    )
 
 
 def list_opts():
diff --git a/watcher/conf/ironic_client.py b/watcher/conf/ironic_client.py
index a16644a79..48c488471 100644
--- a/watcher/conf/ironic_client.py
+++ b/watcher/conf/ironic_client.py
@@ -18,21 +18,35 @@
 from oslo_config import cfg
 
 
-ironic_client = cfg.OptGroup(name='ironic_client',
-                             title='Configuration Options for Ironic')
+ironic_client = cfg.OptGroup(
+    name='ironic_client', title='Configuration Options for Ironic'
+)
 
 IRONIC_CLIENT_OPTS = [
-    cfg.StrOpt('api_version',
-               default='1',
-               help='Version of Ironic API to use in ironicclient.'),
-    cfg.StrOpt('endpoint_type',
-               default='publicURL',
-               choices=['public', 'internal', 'admin',
-                        'publicURL', 'internalURL', 'adminURL'],
-               help='Type of endpoint to use in ironicclient.'),
-    cfg.StrOpt('region_name',
-               help='Region in Identity service catalog to use for '
-                    'communication with the OpenStack service.')]
+    cfg.StrOpt(
+        'api_version',
+        default='1',
+        help='Version of Ironic API to use in ironicclient.',
+    ),
+    cfg.StrOpt(
+        'endpoint_type',
+        default='publicURL',
+        choices=[
+            'public',
+            'internal',
+            'admin',
+            'publicURL',
+            'internalURL',
+            'adminURL',
+        ],
+        help='Type of endpoint to use in ironicclient.',
+    ),
+    cfg.StrOpt(
+        'region_name',
+        help='Region in Identity service catalog to use for '
+        'communication with the OpenStack service.',
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/keystone_client.py b/watcher/conf/keystone_client.py
index fb6325cf2..e1dd34207 100644
--- a/watcher/conf/keystone_client.py
+++ b/watcher/conf/keystone_client.py
@@ -16,17 +16,23 @@
 from oslo_config import cfg
 
 
-keystone_client = cfg.OptGroup(name='keystone_client',
-                               title='Configuration Options for Keystone')
+keystone_client = cfg.OptGroup(
+    name='keystone_client', title='Configuration Options for Keystone'
+)
 
 KEYSTONE_CLIENT_OPTS = [
-    cfg.StrOpt('interface',
-               default='public',
-               choices=['internal', 'public', 'admin'],
-               help='Type of endpoint to use in keystoneclient.'),
-    cfg.StrOpt('region_name',
-               help='Region in Identity service catalog to use for '
-                    'communication with the OpenStack service.')]
+    cfg.StrOpt(
+        'interface',
+        default='public',
+        choices=['internal', 'public', 'admin'],
+        help='Type of endpoint to use in keystoneclient.',
+    ),
+    cfg.StrOpt(
+        'region_name',
+        help='Region in Identity service catalog to use for '
+        'communication with the OpenStack service.',
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/maas_client.py b/watcher/conf/maas_client.py
index b6ef97281..bf0d78f19 100644
--- a/watcher/conf/maas_client.py
+++ b/watcher/conf/maas_client.py
@@ -17,17 +17,17 @@
 from oslo_config import cfg
 
 
-maas_client = cfg.OptGroup(name='maas_client',
-                           title='Configuration Options for MaaS')
+maas_client = cfg.OptGroup(
+    name='maas_client', title='Configuration Options for MaaS'
+)
 
 MAAS_CLIENT_OPTS = [
-    cfg.StrOpt('url',
-               help='MaaS URL, example: http://1.2.3.4:5240/MAAS'),
-    cfg.StrOpt('api_key',
-               help='MaaS API authentication key.'),
-    cfg.IntOpt('timeout',
-               default=60,
-               help='MaaS client operation timeout in seconds.')]
+    cfg.StrOpt('url', help='MaaS URL, example: http://1.2.3.4:5240/MAAS'),
+    cfg.StrOpt('api_key', help='MaaS API authentication key.'),
+    cfg.IntOpt(
+        'timeout', default=60, help='MaaS client operation timeout in seconds.'
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/models.py b/watcher/conf/models.py
index e29d9c056..9371a2401 100644
--- a/watcher/conf/models.py
+++ b/watcher/conf/models.py
@@ -16,19 +16,20 @@
 from oslo_config import cfg
 
 
-compute_model = cfg.OptGroup(name='compute_model',
-                             title='Configuration Options for Compute Model',
-                             help="Additional configuration options for the "
-                                  "compute model.")
+compute_model = cfg.OptGroup(
+    name='compute_model',
+    title='Configuration Options for Compute Model',
+    help="Additional configuration options for the compute model.",
+)
 
 COMPUTE_MODEL_OPTS = [
     cfg.BoolOpt(
         'enable_extended_attributes',
         default=False,
         help="Enable the collection of compute model extended attributes. "
-             "Note that some attributes require a more recent api "
-             "microversion to be configured in nova_client section."
-    ),
+        "Note that some attributes require a more recent api "
+        "microversion to be configured in nova_client section.",
+    )
 ]
 
 
diff --git a/watcher/conf/nova.py b/watcher/conf/nova.py
index b0cb3471a..3da533db1 100644
--- a/watcher/conf/nova.py
+++ b/watcher/conf/nova.py
@@ -19,45 +19,54 @@ from oslo_config import cfg
 from watcher.common import clients
 
 
-nova = cfg.OptGroup(name='nova',
-                    title='Options for the Nova integration '
-                    'configuration')
+nova = cfg.OptGroup(
+    name='nova', title='Options for the Nova integration configuration'
+)
 
 NOVA_OPTS = [
-    cfg.IntOpt('migration_max_retries',
-               default=180,
-               min=1,
-               help='Maximum number of retries for Nova migrations '
-                    'before giving up and considering the operation failed. '
-                    'Default value is 180, which for the default '
-                    'migration_interval (5 seconds), makes a default '
-                    'migration timeout of 900 seconds (15 minutes).'
-                    'This is an upper bound on the maximum expected. This '
-                    'should not be decreased or increased over 3600s '
-                    '(one hour). Shorter values may cause the actions to '
-                    'fail and higher values may hide infrastructure issues.'),
-    cfg.FloatOpt('migration_interval',
-                 default=5.0,
-                 min=0.1,
-                 help='Interval in seconds to check the status in Nova VM '
-                      'migrations (value is float). Default value is 5.0 '
-                      'seconds.'),
-    cfg.IntOpt('http_retries',
-               default=3,
-               min=1,
-               help='Maximum number of retries for HTTP requests to the Nova '
-                    'service when connection errors occur. Default is 3'),
-    cfg.FloatOpt('http_retry_interval',
-                 default=2.0,
-                 min=0.1,
-                 help='Interval in seconds to retry HTTP requests to the Nova '
-                      'service when connection errors occur. Default is 2 '
-                      'seconds.'),
+    cfg.IntOpt(
+        'migration_max_retries',
+        default=180,
+        min=1,
+        help='Maximum number of retries for Nova migrations '
+        'before giving up and considering the operation failed. '
+        'Default value is 180, which for the default '
+        'migration_interval (5 seconds), makes a default '
+        'migration timeout of 900 seconds (15 minutes).'
+        'This is an upper bound on the maximum expected. This '
+        'should not be decreased or increased over 3600s '
+        '(one hour). Shorter values may cause the actions to '
+        'fail and higher values may hide infrastructure issues.',
+    ),
+    cfg.FloatOpt(
+        'migration_interval',
+        default=5.0,
+        min=0.1,
+        help='Interval in seconds to check the status in Nova VM '
+        'migrations (value is float). Default value is 5.0 '
+        'seconds.',
+    ),
+    cfg.IntOpt(
+        'http_retries',
+        default=3,
+        min=1,
+        help='Maximum number of retries for HTTP requests to the Nova '
+        'service when connection errors occur. Default is 3',
+    ),
+    cfg.FloatOpt(
+        'http_retry_interval',
+        default=2.0,
+        min=0.1,
+        help='Interval in seconds to retry HTTP requests to the Nova '
+        'service when connection errors occur. Default is 2 '
+        'seconds.',
+    ),
     # Options migrated from nova_client group (deprecated in 2026.1)
-    cfg.StrOpt('api_version',
-               default='2.56',
-               deprecated_group='nova_client',
-               help=f"""
+    cfg.StrOpt(
+        'api_version',
+        default='2.56',
+        deprecated_group='nova_client',
+        help=f"""
 Version of Nova API to use in novaclient.
 
 Minimum required version: {clients.MIN_NOVA_API_VERSION}
@@ -66,7 +75,8 @@ Certain Watcher features depend on a minimum version of the compute
 API being available which is enforced with this option. See
 https://docs.openstack.org/nova/latest/reference/api-microversion-history.html
 for the compute API microversion history.
-"""),
+""",
+    ),
 ]
 
 
@@ -87,21 +97,22 @@ def register_opts(conf):
     conf.register_opts(NOVA_OPTS, group=nova)
     deprecated_opts = _deprecations()
     ks_loading.register_adapter_conf_options(
-        conf, nova.name,
-        deprecated_opts=deprecated_opts
+        conf, nova.name, deprecated_opts=deprecated_opts
     )
-    ks_loading.register_session_conf_options(conf, nova.name,)
+    ks_loading.register_session_conf_options(conf, nova.name)
     ks_loading.register_auth_conf_options(conf, nova.name)
 
 
 def list_opts():
     deprecated_opts = _deprecations()
-    return [(
-        nova,
-        NOVA_OPTS +
-        ks_loading.get_adapter_conf_options(
-            include_deprecated=False, deprecated_opts=deprecated_opts
-        ) +
-        ks_loading.get_session_conf_options() +
-        ks_loading.get_auth_common_conf_options()
-    )]
+    return [
+        (
+            nova,
+            NOVA_OPTS
+            + ks_loading.get_adapter_conf_options(
+                include_deprecated=False, deprecated_opts=deprecated_opts
+            )
+            + ks_loading.get_session_conf_options()
+            + ks_loading.get_auth_common_conf_options(),
+        )
+    ]
diff --git a/watcher/conf/nova_client.py b/watcher/conf/nova_client.py
index 7830e9295..2a1aa3b3e 100644
--- a/watcher/conf/nova_client.py
+++ b/watcher/conf/nova_client.py
@@ -21,20 +21,22 @@ from watcher._i18n import _
 from watcher.common import clients
 
 
-nova_client = cfg.OptGroup(name='nova_client',
-                           title='Configuration Options for Nova')
+nova_client = cfg.OptGroup(
+    name='nova_client', title='Configuration Options for Nova'
+)
 
 NOVA_CLIENT_OPTS = [
-    cfg.StrOpt('api_version',
-               default='2.56',
-               deprecated_for_removal=True,
-               deprecated_reason=_(
-                   'To replace the frozen novaclient with the '
-                   'openstacksdk compute proxy, the options need to '
-                   'be under the [nova] group.'
-               ),
-               deprecated_since='2026.1',
-               help=f"""
+    cfg.StrOpt(
+        'api_version',
+        default='2.56',
+        deprecated_for_removal=True,
+        deprecated_reason=_(
+            'To replace the frozen novaclient with the '
+            'openstacksdk compute proxy, the options need to '
+            'be under the [nova] group.'
+        ),
+        deprecated_since='2026.1',
+        help=f"""
 Version of Nova API to use in novaclient.
 
 Minimum required version: {clients.MIN_NOVA_API_VERSION}
@@ -43,27 +45,39 @@ Certain Watcher features depend on a minimum version of the compute
 API being available which is enforced with this option. See
 https://docs.openstack.org/nova/latest/reference/api-microversion-history.html
 for the compute API microversion history.
-"""),
-    cfg.StrOpt('endpoint_type',
-               default='publicURL',
-               deprecated_for_removal=True,
-               deprecated_reason=_(
-                   'This option was replaced by the valid_interfaces '
-                   'option defined by keystoneauth.'
-               ),
-               deprecated_since='2026.1',
-               choices=['public', 'internal', 'admin',
-                        'publicURL', 'internalURL', 'adminURL'],
-               help='Type of endpoint to use in novaclient.'),
-    cfg.StrOpt('region_name',
-               deprecated_for_removal=True,
-               deprecated_reason=_(
-                   'This option was replaced by the region_name '
-                   'option defined by keystoneauth.'
-               ),
-               deprecated_since='2026.1',
-               help='Region in Identity service catalog to use for '
-                    'communication with the OpenStack service.')]
+""",
+    ),
+    cfg.StrOpt(
+        'endpoint_type',
+        default='publicURL',
+        deprecated_for_removal=True,
+        deprecated_reason=_(
+            'This option was replaced by the valid_interfaces '
+            'option defined by keystoneauth.'
+        ),
+        deprecated_since='2026.1',
+        choices=[
+            'public',
+            'internal',
+            'admin',
+            'publicURL',
+            'internalURL',
+            'adminURL',
+        ],
+        help='Type of endpoint to use in novaclient.',
+    ),
+    cfg.StrOpt(
+        'region_name',
+        deprecated_for_removal=True,
+        deprecated_reason=_(
+            'This option was replaced by the region_name '
+            'option defined by keystoneauth.'
+        ),
+        deprecated_since='2026.1',
+        help='Region in Identity service catalog to use for '
+        'communication with the OpenStack service.',
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/opts.py b/watcher/conf/opts.py
index 934339299..33618d376 100644
--- a/watcher/conf/opts.py
+++ b/watcher/conf/opts.py
@@ -64,9 +64,11 @@ def _import_modules(module_names):
     for modname in module_names:
         mod = importlib.import_module("watcher.conf." + modname)
         if not hasattr(mod, LIST_OPTS_FUNC_NAME):
-            msg = (f"The module 'watcher.conf.{modname}' should have a "
-                   f"'{LIST_OPTS_FUNC_NAME}' function which returns the "
-                   "config options.")
+            msg = (
+                f"The module 'watcher.conf.{modname}' should have a "
+                f"'{LIST_OPTS_FUNC_NAME}' function which returns the "
+                "config options."
+            )
             raise Exception(msg)
         else:
             imported_modules.append(mod)
diff --git a/watcher/conf/paths.py b/watcher/conf/paths.py
index c81a8dba4..f36f5c917 100644
--- a/watcher/conf/paths.py
+++ b/watcher/conf/paths.py
@@ -21,18 +21,25 @@ from oslo_config import cfg
 
 
 PATH_OPTS = [
-    cfg.StrOpt('pybasedir',
-               default=os.path.abspath(os.path.join(os.path.dirname(__file__),
-                                                    '../')),
-               help='Directory where the watcher python module is installed.'),
-    cfg.StrOpt('bindir',
-               default='$pybasedir/bin',
-               help='Directory where watcher binaries are installed.',
-               deprecated_for_removal=True,
-               deprecated_reason='This option has no effect'),
-    cfg.StrOpt('state_path',
-               default='$pybasedir',
-               help="Top-level directory for maintaining watcher's state."),
+    cfg.StrOpt(
+        'pybasedir',
+        default=os.path.abspath(
+            os.path.join(os.path.dirname(__file__), '../')
+        ),
+        help='Directory where the watcher python module is installed.',
+    ),
+    cfg.StrOpt(
+        'bindir',
+        default='$pybasedir/bin',
+        help='Directory where watcher binaries are installed.',
+        deprecated_for_removal=True,
+        deprecated_reason='This option has no effect',
+    ),
+    cfg.StrOpt(
+        'state_path',
+        default='$pybasedir',
+        help="Top-level directory for maintaining watcher's state.",
+    ),
 ]
 
 
diff --git a/watcher/conf/placement_client.py b/watcher/conf/placement_client.py
index 81d89a6e8..49ce57c20 100644
--- a/watcher/conf/placement_client.py
+++ b/watcher/conf/placement_client.py
@@ -16,20 +16,27 @@ from oslo_config import cfg
 placement_group = cfg.OptGroup(
     'placement_client',
     title='Placement Service Options',
-    help="Configuration options for connecting to the placement API service")
+    help="Configuration options for connecting to the placement API service",
+)
 
 placement_opts = [
-    cfg.StrOpt('api_version',
-               default='1.29',
-               help='microversion of placement API when using '
-                    'placement service.'),
-    cfg.StrOpt('interface',
-               default='public',
-               choices=['internal', 'public', 'admin'],
-               help='Type of endpoint when using placement service.'),
-    cfg.StrOpt('region_name',
-               help='Region in Identity service catalog to use for '
-                    'communication with the OpenStack service.')]
+    cfg.StrOpt(
+        'api_version',
+        default='1.29',
+        help='microversion of placement API when using placement service.',
+    ),
+    cfg.StrOpt(
+        'interface',
+        default='public',
+        choices=['internal', 'public', 'admin'],
+        help='Type of endpoint when using placement service.',
+    ),
+    cfg.StrOpt(
+        'region_name',
+        help='Region in Identity service catalog to use for '
+        'communication with the OpenStack service.',
+    ),
+]
 
 
 def register_opts(conf):
diff --git a/watcher/conf/planner.py b/watcher/conf/planner.py
index 0508aedcb..233970bbe 100644
--- a/watcher/conf/planner.py
+++ b/watcher/conf/planner.py
@@ -18,17 +18,19 @@
 from oslo_config import cfg
 
 
-watcher_planner = cfg.OptGroup(name='watcher_planner',
-                               title='Defines the parameters of '
-                                     'the planner')
+watcher_planner = cfg.OptGroup(
+    name='watcher_planner', title='Defines the parameters of the planner'
+)
 
 default_planner = 'weight'
 
 WATCHER_PLANNER_OPTS = {
-    cfg.StrOpt('planner',
-               default=default_planner,
-               required=True,
-               help='The selected planner used to schedule the actions')
+    cfg.StrOpt(
+        'planner',
+        default=default_planner,
+        required=True,
+        help='The selected planner used to schedule the actions',
+    )
 }
 
 
diff --git a/watcher/conf/plugins.py b/watcher/conf/plugins.py
index 6c89dbb36..da7732433 100644
--- a/watcher/conf/plugins.py
+++ b/watcher/conf/plugins.py
@@ -44,7 +44,8 @@ def list_opts():
             plugin_opts = plugin_cls.get_config_opts()
             if plugin_opts:
                 plugins_opts.append(
-                    (plugin_loader.get_entry_name(plugin_name), plugin_opts))
+                    (plugin_loader.get_entry_name(plugin_name), plugin_opts)
+                )
 
     return plugins_opts
 
@@ -64,9 +65,12 @@ def show_plugins():
         plugins_map = plugin_loader.list_available()
 
         rows += [
-            (plugin_loader.get_entry_name(plugin_name),
-             plugin_name,
-             utils.get_cls_import_path(plugin_cls))
-            for plugin_name, plugin_cls in plugins_map.items()]
+            (
+                plugin_loader.get_entry_name(plugin_name),
+                plugin_name,
+                utils.get_cls_import_path(plugin_cls),
+            )
+            for plugin_name, plugin_cls in plugins_map.items()
+        ]
 
     return _show_plugins_ascii_table(rows)
diff --git a/watcher/conf/prometheus_client.py b/watcher/conf/prometheus_client.py
index 7254ae2b2..be747446c 100644
--- a/watcher/conf/prometheus_client.py
+++ b/watcher/conf/prometheus_client.py
@@ -20,94 +20,104 @@ prometheus_client = cfg.OptGroup(
     name='prometheus_client',
     title='Configuration Options for Prometheus (DEPRECATED)',
     help="DEPRECATED: The Prometheus datasource is deprecated in favor "
-         "of the Aetos datasource. See https://docs.openstack.org/"
-         "watcher/latest/datasources/migrate-prometheus-to-aetos.html "
-         "for migration instructions.")
+    "of the Aetos datasource. See https://docs.openstack.org/"
+    "watcher/latest/datasources/migrate-prometheus-to-aetos.html "
+    "for migration instructions.",
+)
 
 PROMETHEUS_CLIENT_OPTS = [
     cfg.HostAddressOpt(
         'host',
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="The hostname or IP address for the prometheus server. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
     cfg.PortOpt(
         'port',
         default=9090,
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="The port number used by the prometheus server. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
     cfg.StrOpt(
         'fqdn_label',
         default="fqdn",
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="The label that Prometheus uses to store the fqdn of "
-             "exporters. Defaults to 'fqdn'. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "exporters. Defaults to 'fqdn'. "
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
     cfg.StrOpt(
         'instance_uuid_label',
         default="resource",
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="The label that Prometheus uses to store the uuid of "
-             "OpenStack instances. Defaults to 'resource'. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "OpenStack instances. Defaults to 'resource'. "
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
     cfg.StrOpt(
         'username',
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="The basic_auth username to use to authenticate with the "
-             "Prometheus server. DEPRECATED: Use Aetos datasource "
-             "instead."),
+        "Prometheus server. DEPRECATED: Use Aetos datasource "
+        "instead.",
+    ),
     cfg.StrOpt(
         'password',
         secret=True,
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="The basic_auth password to use to authenticate with the "
-             "Prometheus server. DEPRECATED: Use Aetos datasource "
-             "instead."),
+        "Prometheus server. DEPRECATED: Use Aetos datasource "
+        "instead.",
+    ),
     cfg.StrOpt(
         'cafile',
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="Path to the CA certificate for establishing a TLS "
-             "connection with the Prometheus server. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "connection with the Prometheus server. "
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
     cfg.StrOpt(
         'certfile',
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="Path to the client certificate for establishing a TLS "
-             "connection with the Prometheus server. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "connection with the Prometheus server. "
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
     cfg.StrOpt(
         'keyfile',
         deprecated_for_removal=True,
         deprecated_reason='Prometheus datasource is deprecated in favor '
-                          'of Aetos datasource',
+        'of Aetos datasource',
         deprecated_since='2026.1',
         help="Path to the client key for establishing a TLS "
-             "connection with the Prometheus server. "
-             "DEPRECATED: Use Aetos datasource instead."),
+        "connection with the Prometheus server. "
+        "DEPRECATED: Use Aetos datasource instead.",
+    ),
 ]
 
 
diff --git a/watcher/conf/service.py b/watcher/conf/service.py
index 1ced1182a..f7665532d 100644
--- a/watcher/conf/service.py
+++ b/watcher/conf/service.py
@@ -23,27 +23,38 @@ from watcher._i18n import _
 
 
 SERVICE_OPTS = [
-    cfg.IntOpt('periodic_interval',
-               default=60,
-               mutable=True,
-               help=_('Seconds between running periodic tasks.')),
-    cfg.HostAddressOpt('host',
-                       default=socket.gethostname(),
-                       help=_('Name of this node. This can be an opaque '
-                              'identifier. It is not necessarily a hostname, '
-                              'FQDN, or IP address. However, the node name '
-                              'must be valid within an AMQP key.')
-                       ),
-    cfg.IntOpt('service_down_time',
-               default=90,
-               help=_('Maximum time since last check-in for up service.')),
-    cfg.BoolOpt('print_thread_pool_stats',
-                default=False,
-                help=_('Enable logging of thread pool executor statistics '
-                       'when submitting tasks. Logs current queue length, '
-                       'number of workers (total, idle or running) and '
-                       'executor runtime statistics. Useful for diagnosing '
-                       'contention and performance issues.'))
+    cfg.IntOpt(
+        'periodic_interval',
+        default=60,
+        mutable=True,
+        help=_('Seconds between running periodic tasks.'),
+    ),
+    cfg.HostAddressOpt(
+        'host',
+        default=socket.gethostname(),
+        help=_(
+            'Name of this node. This can be an opaque '
+            'identifier. It is not necessarily a hostname, '
+            'FQDN, or IP address. However, the node name '
+            'must be valid within an AMQP key.'
+        ),
+    ),
+    cfg.IntOpt(
+        'service_down_time',
+        default=90,
+        help=_('Maximum time since last check-in for up service.'),
+    ),
+    cfg.BoolOpt(
+        'print_thread_pool_stats',
+        default=False,
+        help=_(
+            'Enable logging of thread pool executor statistics '
+            'when submitting tasks. Logs current queue length, '
+            'number of workers (total, idle or running) and '
+            'executor runtime statistics. Useful for diagnosing '
+            'contention and performance issues.'
+        ),
+    ),
 ]
 
 
@@ -52,6 +63,4 @@ def register_opts(conf):
 
 
 def list_opts():
-    return [
-        ('DEFAULT', SERVICE_OPTS),
-    ]
+    return [('DEFAULT', SERVICE_OPTS)]
diff --git a/watcher/db/api.py b/watcher/db/api.py
index a5f4e59c1..875a6d1d0 100644
--- a/watcher/db/api.py
+++ b/watcher/db/api.py
@@ -22,8 +22,9 @@ from oslo_db import api as db_api
 
 
 _BACKEND_MAPPING = {'sqlalchemy': 'watcher.db.sqlalchemy.api'}
-IMPL = db_api.DBAPI.from_config(cfg.CONF, backend_mapping=_BACKEND_MAPPING,
-                                lazy=True)
+IMPL = db_api.DBAPI.from_config(
+    cfg.CONF, backend_mapping=_BACKEND_MAPPING, lazy=True
+)
 
 
 def get_instance():
@@ -35,8 +36,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
     """Base class for storage system connections."""
 
     @abc.abstractmethod
-    def get_goal_list(self, context, filters=None, limit=None,
-                      marker=None, sort_key=None, sort_dir=None, eager=False):
+    def get_goal_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching goals.
 
         Return a list of the specified columns for all goals that
@@ -141,9 +150,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_strategy_list(self, context, filters=None, limit=None,
-                          marker=None, sort_key=None, sort_dir=None,
-                          eager=True):
+    def get_strategy_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=True,
+    ):
         """Get specific columns for matching strategies.
 
         Return a list of the specified columns for all strategies that
@@ -241,9 +257,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_audit_template_list(self, context, filters=None,
-                                limit=None, marker=None, sort_key=None,
-                                sort_dir=None, eager=False):
+    def get_audit_template_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching audit templates.
 
         Return a list of the specified columns for all audit templates that
@@ -281,8 +304,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_audit_template_by_id(self, context, audit_template_id,
-                                 eager=False):
+    def get_audit_template_by_id(
+        self, context, audit_template_id, eager=False
+    ):
         """Return an audit template.
 
         :param context: The security context
@@ -293,8 +317,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_audit_template_by_uuid(self, context, audit_template_uuid,
-                                   eager=False):
+    def get_audit_template_by_uuid(
+        self, context, audit_template_uuid, eager=False
+    ):
         """Return an audit template.
 
         :param context: The security context
@@ -304,8 +329,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         :raises: :py:class:`~.AuditTemplateNotFound`
         """
 
-    def get_audit_template_by_name(self, context, audit_template_name,
-                                   eager=False):
+    def get_audit_template_by_name(
+        self, context, audit_template_name, eager=False
+    ):
         """Return an audit template.
 
         :param context: The security context
@@ -342,8 +368,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_audit_list(self, context, filters=None, limit=None,
-                       marker=None, sort_key=None, sort_dir=None, eager=False):
+    def get_audit_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching audits.
 
         Return a list of the specified columns for all audits that match the
@@ -437,9 +471,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_action_list(self, context, filters=None, limit=None,
-                        marker=None, sort_key=None, sort_dir=None,
-                        eager=False):
+    def get_action_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching actions.
 
         Return a list of the specified columns for all actions that match the
@@ -528,8 +569,15 @@ class BaseConnection(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def get_action_plan_list(
-            self, context, filters=None, limit=None,
-            marker=None, sort_key=None, sort_dir=None, eager=False):
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching action plans.
 
         Return a list of the specified columns for all action plans that
@@ -607,9 +655,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_efficacy_indicator_list(self, context, filters=None, limit=None,
-                                    marker=None, sort_key=None, sort_dir=None,
-                                    eager=False):
+    def get_efficacy_indicator_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching efficacy indicators.
 
         Return a list of the specified columns for all efficacy indicators that
@@ -651,8 +706,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_efficacy_indicator_by_id(self, context, efficacy_indicator_id,
-                                     eager=False):
+    def get_efficacy_indicator_by_id(
+        self, context, efficacy_indicator_id, eager=False
+    ):
         """Return an efficacy indicator given its ID.
 
         :param context: The security context
@@ -663,8 +719,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_efficacy_indicator_by_uuid(self, context, efficacy_indicator_uuid,
-                                       eager=False):
+    def get_efficacy_indicator_by_uuid(
+        self, context, efficacy_indicator_uuid, eager=False
+    ):
         """Return an efficacy indicator given its UUID.
 
         :param context: The security context
@@ -675,8 +732,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_efficacy_indicator_by_name(self, context, efficacy_indicator_name,
-                                       eager=False):
+    def get_efficacy_indicator_by_name(
+        self, context, efficacy_indicator_name, eager=False
+    ):
         """Return an efficacy indicator given its name.
 
         :param context: The security context
@@ -706,8 +764,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def get_scoring_engine_list(
-            self, context, columns=None, filters=None, limit=None,
-            marker=None, sort_key=None, sort_dir=None, eager=False):
+        self,
+        context,
+        columns=None,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching scoring engines.
 
         Return a list of the specified columns for all scoring engines that
@@ -738,8 +804,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_scoring_engine_by_id(self, context, scoring_engine_id,
-                                 eager=False):
+    def get_scoring_engine_by_id(
+        self, context, scoring_engine_id, eager=False
+    ):
         """Return a scoring engine by its id.
 
         :param context: The security context
@@ -750,8 +817,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_scoring_engine_by_uuid(self, context, scoring_engine_uuid,
-                                   eager=False):
+    def get_scoring_engine_by_uuid(
+        self, context, scoring_engine_uuid, eager=False
+    ):
         """Return a scoring engine by its uuid.
 
         :param context: The security context
@@ -762,8 +830,9 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_scoring_engine_by_name(self, context, scoring_engine_name,
-                                   eager=False):
+    def get_scoring_engine_by_name(
+        self, context, scoring_engine_name, eager=False
+    ):
         """Return a scoring engine by its name.
 
         :param context: The security context
@@ -792,8 +861,16 @@ class BaseConnection(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def get_service_list(self, context, filters=None, limit=None, marker=None,
-                         sort_key=None, sort_dir=None, eager=False):
+    def get_service_list(
+        self,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Get specific columns for matching services.
 
         Return a list of the specified columns for all services that
diff --git a/watcher/db/migration.py b/watcher/db/migration.py
index 810aa8166..bdda08666 100644
--- a/watcher/db/migration.py
+++ b/watcher/db/migration.py
@@ -27,8 +27,9 @@ def get_backend():
     global _IMPL
     if not _IMPL:
         cfg.CONF.import_opt('backend', 'oslo_db.options', group='database')
-        _IMPL = driver.DriverManager("watcher.database.migration_backend",
-                                     cfg.CONF.database.backend).driver
+        _IMPL = driver.DriverManager(
+            "watcher.database.migration_backend", cfg.CONF.database.backend
+        ).driver
     return _IMPL
 
 
diff --git a/watcher/db/purge.py b/watcher/db/purge.py
index 772b99e7d..fb0648e22 100644
--- a/watcher/db/purge.py
+++ b/watcher/db/purge.py
@@ -45,14 +45,16 @@ class WatcherObjectsMap:
     """
 
     # This is for generating the .pot translations
-    keymap = collections.OrderedDict([
-        ("goals", _("Goals")),
-        ("strategies", _("Strategies")),
-        ("audit_templates", _("Audit Templates")),
-        ("audits", _("Audits")),
-        ("action_plans", _("Action Plans")),
-        ("actions", _("Actions")),
-    ])
+    keymap = collections.OrderedDict(
+        [
+            ("goals", _("Goals")),
+            ("strategies", _("Strategies")),
+            ("audit_templates", _("Audit Templates")),
+            ("audits", _("Audits")),
+            ("action_plans", _("Action Plans")),
+            ("actions", _("Actions")),
+        ]
+    )
 
     def __init__(self):
         for attr_name in self.keys():
@@ -72,13 +74,15 @@ class WatcherObjectsMap:
         new_map = self.__class__()
 
         # Merge the 2 items dicts into a new object (and avoid dupes)
-        for attr_name, initials, others in zip(self.keys(), self.values(),
-                                               other.values()):
+        for attr_name, initials, others in zip(
+            self.keys(), self.values(), other.values()
+        ):
             # Creates a copy
             merged = initials[:]
             initials_ids = [item.id for item in initials]
-            non_dupes = [item for item in others
-                         if item.id not in initials_ids]
+            non_dupes = [
+                item for item in others if item.id not in initials_ids
+            ]
             merged += non_dupes
 
             setattr(new_map, attr_name, merged)
@@ -100,8 +104,7 @@ class WatcherObjectsMap:
         headers = list(self.keymap.values())
         headers.append(_("Total"))  # We also add a total count
         translated_headers = [
-            h.translate() if lazy_translation_enabled() else h
-            for h in headers
+            h.translate() if lazy_translation_enabled() else h for h in headers
         ]
 
         counters = [len(cat_vals) for cat_vals in self.values()] + [len(self)]
@@ -124,8 +127,14 @@ class PurgeCommand:
 
     ctx = context.make_context(show_deleted=True)
 
-    def __init__(self, age_in_days=None, max_number=None,
-                 uuid=None, exclude_orphans=False, dry_run=None):
+    def __init__(
+        self,
+        age_in_days=None,
+        max_number=None,
+        uuid=None,
+        exclude_orphans=False,
+        dry_run=None,
+    ):
         self.age_in_days = age_in_days
         self.max_number = max_number
         self.uuid = uuid
@@ -161,7 +170,8 @@ class PurgeCommand:
 
         if not goal.deleted_at:
             raise exception.NotSoftDeletedStateError(
-                name=_('Goal'), id=uuid_or_name)
+                name=_('Goal'), id=uuid_or_name
+            )
 
         return goal.uuid
 
@@ -196,37 +206,52 @@ class PurgeCommand:
 
         goal_ids = {g.id for g in goals}
         orphans.strategies = [
-            strategy for strategy in strategies
-            if strategy.goal_id not in goal_ids]
+            strategy
+            for strategy in strategies
+            if strategy.goal_id not in goal_ids
+        ]
 
-        strategy_ids = [s.id for s in (s for s in strategies
-                                       if s not in orphans.strategies)]
+        strategy_ids = [
+            s.id
+            for s in (s for s in strategies if s not in orphans.strategies)
+        ]
         orphans.audit_templates = [
-            audit_template for audit_template in audit_templates
-            if audit_template.goal_id not in goal_ids or
-            (audit_template.strategy_id and
-             audit_template.strategy_id not in strategy_ids)]
+            audit_template
+            for audit_template in audit_templates
+            if audit_template.goal_id not in goal_ids
+            or (
+                audit_template.strategy_id
+                and audit_template.strategy_id not in strategy_ids
+            )
+        ]
 
         orphans.audits = [
-            audit for audit in audits
-            if audit.goal_id not in goal_ids or
-            (audit.strategy_id and
-             audit.strategy_id not in strategy_ids)]
+            audit
+            for audit in audits
+            if audit.goal_id not in goal_ids
+            or (audit.strategy_id and audit.strategy_id not in strategy_ids)
+        ]
 
         # Objects with orphan parents are themselves orphans
-        audit_ids = [audit.id for audit in audits
-                     if audit not in orphans.audits]
+        audit_ids = [
+            audit.id for audit in audits if audit not in orphans.audits
+        ]
         orphans.action_plans = [
-            ap for ap in action_plans
-            if ap.audit_id not in audit_ids or
-            ap.strategy_id not in strategy_ids]
+            ap
+            for ap in action_plans
+            if ap.audit_id not in audit_ids
+            or ap.strategy_id not in strategy_ids
+        ]
 
         # Objects with orphan parents are themselves orphans
-        action_plan_ids = [ap.id for ap in action_plans
-                           if ap not in orphans.action_plans]
+        action_plan_ids = [
+            ap.id for ap in action_plans if ap not in orphans.action_plans
+        ]
         orphans.actions = [
-            action for action in actions
-            if action.action_plan_id not in action_plan_ids]
+            action
+            for action in actions
+            if action.action_plan_id not in action_plan_ids
+        ]
 
         LOG.debug("Orphans found:\n%s", orphans)
         LOG.info("Orphans found:\n%s", orphans.get_count_table())
@@ -246,14 +271,15 @@ class PurgeCommand:
         to_be_deleted.goals.extend(self._find_goals(filters))
         to_be_deleted.strategies.extend(self._find_strategies(filters))
         to_be_deleted.audit_templates.extend(
-            self._find_audit_templates(filters))
+            self._find_audit_templates(filters)
+        )
         to_be_deleted.audits.extend(self._find_audits(filters))
-        to_be_deleted.action_plans.extend(
-            self._find_action_plans(filters))
+        to_be_deleted.action_plans.extend(self._find_action_plans(filters))
         to_be_deleted.actions.extend(self._find_actions(filters))
 
         soft_deleted_objs = self._find_related_objects(
-            to_be_deleted, base_filters=dict(deleted=True))
+            to_be_deleted, base_filters=dict(deleted=True)
+        )
 
         LOG.debug("Soft deleted objects:\n%s", soft_deleted_objs)
 
@@ -302,20 +328,28 @@ class PurgeCommand:
     def confirmation_prompt(self):
         print(self._objects_map.get_count_table())
         raw_val = input(
-            _("There are %(count)d objects set for deletion. "
-              "Continue? [y/N]") % dict(count=len(self._objects_map)))
+            _("There are %(count)d objects set for deletion. Continue? [y/N]")
+            % dict(count=len(self._objects_map))
+        )
 
         return strutils.bool_from_string(raw_val)
 
     def delete_up_to_max_prompt(self, objects_map):
         print(objects_map.get_count_table())
-        print(_("The number of objects (%(num)s) to delete from the database "
+        print(
+            _(
+                "The number of objects (%(num)s) to delete from the database "
                 "exceeds the maximum number of objects (%(max_number)s) "
-                "specified.") % dict(max_number=self.max_number,
-                                     num=len(objects_map)))
+                "specified."
+            )
+            % dict(max_number=self.max_number, num=len(objects_map))
+        )
         raw_val = input(
-            _("Do you want to delete objects up to the specified maximum "
-              "number? [y/N]"))
+            _(
+                "Do you want to delete objects up to the specified maximum "
+                "number? [y/N]"
+            )
+        )
 
         self._delete_up_to_max = strutils.bool_from_string(raw_val)
 
@@ -334,29 +368,34 @@ class PurgeCommand:
             # strategies
             goal_ids = [goal.id]
             related_objs.strategies = [
-                strategy for strategy in self._objects_map.strategies
+                strategy
+                for strategy in self._objects_map.strategies
                 if strategy.goal_id in goal_ids
             ]
 
             # audit templates
             strategy_ids = [
-                strategy.id for strategy in related_objs.strategies]
+                strategy.id for strategy in related_objs.strategies
+            ]
             related_objs.audit_templates = [
-                at for at in self._objects_map.audit_templates
-                if at.goal_id in goal_ids or
-                (at.strategy_id and at.strategy_id in strategy_ids)
+                at
+                for at in self._objects_map.audit_templates
+                if at.goal_id in goal_ids
+                or (at.strategy_id and at.strategy_id in strategy_ids)
             ]
 
             # audits
             related_objs.audits = [
-                audit for audit in self._objects_map.audits
+                audit
+                for audit in self._objects_map.audits
                 if audit.goal_id in goal_ids
             ]
 
             # action plans
             audit_ids = [audit.id for audit in related_objs.audits]
             related_objs.action_plans = [
-                action_plan for action_plan in self._objects_map.action_plans
+                action_plan
+                for action_plan in self._objects_map.action_plans
                 if action_plan.audit_id in audit_ids
             ]
 
@@ -365,7 +404,8 @@ class PurgeCommand:
                 action_plan.id for action_plan in related_objs.action_plans
             ]
             related_objs.actions = [
-                action for action in self._objects_map.actions
+                action
+                for action in self._objects_map.actions
                 if action.action_plan_id in action_plan_ids
             ]
             aggregate.append(related_objs)
@@ -410,23 +450,33 @@ class PurgeCommand:
         LOG.info("Starting purge command")
         self._objects_map = self.find_objects_to_delete()
 
-        if (self.max_number is not None and
-                len(self._objects_map) > self.max_number):
+        if (
+            self.max_number is not None
+            and len(self._objects_map) > self.max_number
+        ):
             if self.delete_up_to_max_prompt(self._objects_map):
                 self._objects_map = self._get_objects_up_to_limit()
             else:
                 return
 
-        _orphans_note = (_(" (orphans excluded)") if self.exclude_orphans
-                         else _(" (may include orphans)"))
+        _orphans_note = (
+            _(" (orphans excluded)")
+            if self.exclude_orphans
+            else _(" (may include orphans)")
+        )
         if not self.dry_run and self.confirmation_prompt():
             self.do_delete()
             print(_("Purge results summary%s:") % _orphans_note)
             LOG.info("Purge results summary%s:", _orphans_note)
         else:
             LOG.debug(self._objects_map)
-            print(_("Here below is a table containing the objects "
-                    "that can be purged%s:") % _orphans_note)
+            print(
+                _(
+                    "Here below is a table containing the objects "
+                    "that can be purged%s:"
+                )
+                % _orphans_note
+            )
 
         LOG.info("\n%s", self._objects_map.get_count_table())
         print(self._objects_map.get_count_table())
@@ -463,8 +513,9 @@ def purge(age_in_days, max_number, goal, exclude_orphans, dry_run):
 
         uuid = PurgeCommand.get_goal_uuid(goal)
 
-        cmd = PurgeCommand(age_in_days, max_number, uuid,
-                           exclude_orphans, dry_run)
+        cmd = PurgeCommand(
+            age_in_days, max_number, uuid, exclude_orphans, dry_run
+        )
 
         cmd.execute()
 
diff --git a/watcher/db/sqlalchemy/alembic/env.py b/watcher/db/sqlalchemy/alembic/env.py
index def4d67dd..e994acd02 100644
--- a/watcher/db/sqlalchemy/alembic/env.py
+++ b/watcher/db/sqlalchemy/alembic/env.py
@@ -40,8 +40,9 @@ def run_migrations_online():
     """
     engine = enginefacade.writer.get_engine()
     with engine.connect() as connection:
-        context.configure(connection=connection,
-                          target_metadata=target_metadata)
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
         with context.begin_transaction():
             context.run_migrations()
 
diff --git a/watcher/db/sqlalchemy/alembic/versions/001_ocata.py b/watcher/db/sqlalchemy/alembic/versions/001_ocata.py
index f3d0042f9..3158ad866 100644
--- a/watcher/db/sqlalchemy/alembic/versions/001_ocata.py
+++ b/watcher/db/sqlalchemy/alembic/versions/001_ocata.py
@@ -5,6 +5,7 @@ Revises: None
 Create Date: 2017-02-01 09:40:05.065981
 
 """
+
 import oslo_db
 import sqlalchemy as sa
 
@@ -24,17 +25,21 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=True),
         sa.Column('name', sa.String(length=63), nullable=False),
         sa.Column('display_name', sa.String(length=63), nullable=False),
-        sa.Column('efficacy_specification', models.JSONEncodedList(),
-                  nullable=False),
+        sa.Column(
+            'efficacy_specification', models.JSONEncodedList(), nullable=False
+        ),
         sa.PrimaryKeyConstraint('id'),
         sa.UniqueConstraint('name', 'deleted', name='uniq_goals0name'),
-        sa.UniqueConstraint('uuid', name='uniq_goals0uuid')
+        sa.UniqueConstraint('uuid', name='uniq_goals0uuid'),
     )
 
     op.create_table(
@@ -42,17 +47,21 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=False),
         sa.Column('name', sa.String(length=63), nullable=False),
         sa.Column('description', sa.String(length=255), nullable=True),
         sa.Column('metainfo', sa.Text(), nullable=True),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('name', 'deleted',
-                            name='uniq_scoring_engines0name'),
-        sa.UniqueConstraint('uuid', name='uniq_scoring_engines0uuid')
+        sa.UniqueConstraint(
+            'name', 'deleted', name='uniq_scoring_engines0name'
+        ),
+        sa.UniqueConstraint('uuid', name='uniq_scoring_engines0uuid'),
     )
 
     op.create_table(
@@ -60,15 +69,19 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('name', sa.String(length=255), nullable=False),
         sa.Column('host', sa.String(length=255), nullable=False),
         sa.Column('last_seen_up', sa.DateTime(), nullable=True),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('host', 'name', 'deleted',
-                            name='uniq_services0host0name0deleted')
+        sa.UniqueConstraint(
+            'host', 'name', 'deleted', name='uniq_services0host0name0deleted'
+        ),
     )
 
     op.create_table(
@@ -76,19 +89,21 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=True),
         sa.Column('name', sa.String(length=63), nullable=False),
         sa.Column('display_name', sa.String(length=63), nullable=False),
         sa.Column('goal_id', sa.Integer(), nullable=False),
-        sa.Column('parameters_spec', models.JSONEncodedDict(),
-                  nullable=True),
-        sa.ForeignKeyConstraint(['goal_id'], ['goals.id'], ),
+        sa.Column('parameters_spec', models.JSONEncodedDict(), nullable=True),
+        sa.ForeignKeyConstraint(['goal_id'], ['goals.id']),
         sa.PrimaryKeyConstraint('id'),
         sa.UniqueConstraint('name', 'deleted', name='uniq_strategies0name'),
-        sa.UniqueConstraint('uuid', name='uniq_strategies0uuid')
+        sa.UniqueConstraint('uuid', name='uniq_strategies0uuid'),
     )
 
     op.create_table(
@@ -96,30 +111,36 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=True),
         sa.Column('name', sa.String(length=63), nullable=True),
         sa.Column('description', sa.String(length=255), nullable=True),
         sa.Column('goal_id', sa.Integer(), nullable=False),
         sa.Column('strategy_id', sa.Integer(), nullable=True),
-        sa.Column('scope', models.JSONEncodedList(),
-                  nullable=True),
-        sa.ForeignKeyConstraint(['goal_id'], ['goals.id'], ),
-        sa.ForeignKeyConstraint(['strategy_id'], ['strategies.id'], ),
+        sa.Column('scope', models.JSONEncodedList(), nullable=True),
+        sa.ForeignKeyConstraint(['goal_id'], ['goals.id']),
+        sa.ForeignKeyConstraint(['strategy_id'], ['strategies.id']),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('name', 'deleted',
-                            name='uniq_audit_templates0name'),
-        sa.UniqueConstraint('uuid', name='uniq_audit_templates0uuid')
+        sa.UniqueConstraint(
+            'name', 'deleted', name='uniq_audit_templates0name'
+        ),
+        sa.UniqueConstraint('uuid', name='uniq_audit_templates0uuid'),
     )
     op.create_table(
         'audits',
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=True),
         sa.Column('audit_type', sa.String(length=20), nullable=True),
@@ -130,28 +151,31 @@ def upgrade():
         sa.Column('strategy_id', sa.Integer(), nullable=True),
         sa.Column('scope', models.JSONEncodedList(), nullable=True),
         sa.Column('auto_trigger', sa.Boolean(), nullable=False),
-        sa.ForeignKeyConstraint(['goal_id'], ['goals.id'], ),
-        sa.ForeignKeyConstraint(['strategy_id'], ['strategies.id'], ),
+        sa.ForeignKeyConstraint(['goal_id'], ['goals.id']),
+        sa.ForeignKeyConstraint(['strategy_id'], ['strategies.id']),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('uuid', name='uniq_audits0uuid')
+        sa.UniqueConstraint('uuid', name='uniq_audits0uuid'),
     )
     op.create_table(
         'action_plans',
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=True),
         sa.Column('audit_id', sa.Integer(), nullable=False),
         sa.Column('strategy_id', sa.Integer(), nullable=False),
         sa.Column('state', sa.String(length=20), nullable=True),
         sa.Column('global_efficacy', models.JSONEncodedDict(), nullable=True),
-        sa.ForeignKeyConstraint(['audit_id'], ['audits.id'], ),
-        sa.ForeignKeyConstraint(['strategy_id'], ['strategies.id'], ),
+        sa.ForeignKeyConstraint(['audit_id'], ['audits.id']),
+        sa.ForeignKeyConstraint(['strategy_id'], ['strategies.id']),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('uuid', name='uniq_action_plans0uuid')
+        sa.UniqueConstraint('uuid', name='uniq_action_plans0uuid'),
     )
 
     op.create_table(
@@ -159,8 +183,11 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=False),
         sa.Column('action_plan_id', sa.Integer(), nullable=False),
@@ -168,9 +195,9 @@ def upgrade():
         sa.Column('input_parameters', models.JSONEncodedDict(), nullable=True),
         sa.Column('state', sa.String(length=20), nullable=True),
         sa.Column('parents', models.JSONEncodedList(), nullable=True),
-        sa.ForeignKeyConstraint(['action_plan_id'], ['action_plans.id'], ),
+        sa.ForeignKeyConstraint(['action_plan_id'], ['action_plans.id']),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('uuid', name='uniq_actions0uuid')
+        sa.UniqueConstraint('uuid', name='uniq_actions0uuid'),
     )
 
     op.create_table(
@@ -178,8 +205,11 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('uuid', sa.String(length=36), nullable=True),
         sa.Column('name', sa.String(length=63), nullable=True),
@@ -187,9 +217,9 @@ def upgrade():
         sa.Column('unit', sa.String(length=63), nullable=True),
         sa.Column('value', sa.Numeric(), nullable=True),
         sa.Column('action_plan_id', sa.Integer(), nullable=False),
-        sa.ForeignKeyConstraint(['action_plan_id'], ['action_plans.id'], ),
+        sa.ForeignKeyConstraint(['action_plan_id'], ['action_plans.id']),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('uuid', name='uniq_efficacy_indicators0uuid')
+        sa.UniqueConstraint('uuid', name='uniq_efficacy_indicators0uuid'),
     )
 
 
diff --git a/watcher/db/sqlalchemy/alembic/versions/0f6042416884_add_apscheduler_jobs.py b/watcher/db/sqlalchemy/alembic/versions/0f6042416884_add_apscheduler_jobs.py
index b37cd748c..43fb799b1 100644
--- a/watcher/db/sqlalchemy/alembic/versions/0f6042416884_add_apscheduler_jobs.py
+++ b/watcher/db/sqlalchemy/alembic/versions/0f6042416884_add_apscheduler_jobs.py
@@ -5,6 +5,7 @@ Revises: 001
 Create Date: 2017-03-24 11:21:29.036532
 
 """
+
 import sqlalchemy as sa
 
 from alembic import op
@@ -17,6 +18,7 @@ from watcher.db.sqlalchemy import models
 revision = '0f6042416884'
 down_revision = '001'
 
+
 def _table_exists(table_name):
     bind = op.get_context().bind
     insp = inspect(bind)
@@ -30,14 +32,13 @@ def upgrade():
 
     op.create_table(
         'apscheduler_jobs',
-        sa.Column('id', sa.Unicode(191),
-                  nullable=False),
+        sa.Column('id', sa.Unicode(191), nullable=False),
         sa.Column('next_run_time', sa.Float(25), index=True),
         sa.Column('job_state', sa.LargeBinary, nullable=False),
         sa.Column('service_id', sa.Integer(), nullable=False),
         sa.Column('tag', models.JSONEncodedDict(), nullable=True),
         sa.PrimaryKeyConstraint('id'),
-        sa.ForeignKeyConstraint(['service_id'], ['services.id'])
+        sa.ForeignKeyConstraint(['service_id'], ['services.id']),
     )
 
 
diff --git a/watcher/db/sqlalchemy/alembic/versions/15f7375ca737_change_efficiacy_indicator_decimals.py b/watcher/db/sqlalchemy/alembic/versions/15f7375ca737_change_efficiacy_indicator_decimals.py
index 180cd703d..53d6bf272 100644
--- a/watcher/db/sqlalchemy/alembic/versions/15f7375ca737_change_efficiacy_indicator_decimals.py
+++ b/watcher/db/sqlalchemy/alembic/versions/15f7375ca737_change_efficiacy_indicator_decimals.py
@@ -1,10 +1,13 @@
-"""change_efficiacy_indicator_decimals
+(
+    """change_efficiacy_indicator_decimals
 
 Revision ID: 15f7375ca737
 Revises: 609bec748f2a
 Create Date: 2025-03-24 10:15:19.269061
 
-"""""
+"""
+    ""
+)
 
 import sqlalchemy as sa
 
@@ -15,8 +18,6 @@ from alembic import op
 revision = '15f7375ca737'
 down_revision = '609bec748f2a'
 
-def upgrade():
-    op.add_column('efficacy_indicators',
-                  sa.Column('data', sa.Float())
-                 )
 
+def upgrade():
+    op.add_column('efficacy_indicators', sa.Column('data', sa.Float()))
diff --git a/watcher/db/sqlalchemy/alembic/versions/3cfc94cecf4e_add_name_for_audit.py b/watcher/db/sqlalchemy/alembic/versions/3cfc94cecf4e_add_name_for_audit.py
index 339b4f36c..73bf44b31 100644
--- a/watcher/db/sqlalchemy/alembic/versions/3cfc94cecf4e_add_name_for_audit.py
+++ b/watcher/db/sqlalchemy/alembic/versions/3cfc94cecf4e_add_name_for_audit.py
@@ -17,7 +17,9 @@ down_revision = 'd09a5945e4a0'
 
 
 def upgrade():
-    op.add_column('audits', sa.Column('name', sa.String(length=63), nullable=True))
+    op.add_column(
+        'audits', sa.Column('name', sa.String(length=63), nullable=True)
+    )
 
 
 def downgrade():
diff --git a/watcher/db/sqlalchemy/alembic/versions/4b16194c56bc_add_start_end_time.py b/watcher/db/sqlalchemy/alembic/versions/4b16194c56bc_add_start_end_time.py
index e68e205c5..9022aa9e0 100644
--- a/watcher/db/sqlalchemy/alembic/versions/4b16194c56bc_add_start_end_time.py
+++ b/watcher/db/sqlalchemy/alembic/versions/4b16194c56bc_add_start_end_time.py
@@ -17,8 +17,12 @@ down_revision = '52804f2498c4'
 
 
 def upgrade():
-    op.add_column('audits', sa.Column('start_time', sa.DateTime(), nullable=True))
-    op.add_column('audits', sa.Column('end_time', sa.DateTime(), nullable=True))
+    op.add_column(
+        'audits', sa.Column('start_time', sa.DateTime(), nullable=True)
+    )
+    op.add_column(
+        'audits', sa.Column('end_time', sa.DateTime(), nullable=True)
+    )
 
 
 def downgrade():
diff --git a/watcher/db/sqlalchemy/alembic/versions/52804f2498c4_add_hostname.py b/watcher/db/sqlalchemy/alembic/versions/52804f2498c4_add_hostname.py
index 649d33427..62d1f24b8 100644
--- a/watcher/db/sqlalchemy/alembic/versions/52804f2498c4_add_hostname.py
+++ b/watcher/db/sqlalchemy/alembic/versions/52804f2498c4_add_hostname.py
@@ -19,8 +19,8 @@ down_revision = 'a86240e89a29'
 def upgrade():
     for table in ('audits', 'action_plans'):
         op.add_column(
-            table,
-            sa.Column('hostname', sa.String(length=255), nullable=True))
+            table, sa.Column('hostname', sa.String(length=255), nullable=True)
+        )
 
 
 def downgrade():
diff --git a/watcher/db/sqlalchemy/alembic/versions/7150a7d8f228_add_status_message_to_actionplan.py b/watcher/db/sqlalchemy/alembic/versions/7150a7d8f228_add_status_message_to_actionplan.py
index 6ad73d606..8bddfa7e9 100644
--- a/watcher/db/sqlalchemy/alembic/versions/7150a7d8f228_add_status_message_to_actionplan.py
+++ b/watcher/db/sqlalchemy/alembic/versions/7150a7d8f228_add_status_message_to_actionplan.py
@@ -12,13 +12,18 @@ from alembic import op
 # revision identifiers, used by Alembic.
 revision = '7150a7d8f228'
 down_revision = '15f7375ca737'
+
+
 def upgrade():
-    op.add_column('action_plans',
-        sa.Column('status_message', sa.String(length=255), nullable=True)
-        )
-    op.add_column('actions',
-        sa.Column('status_message', sa.String(length=255), nullable=True)
-        )
-    op.add_column('audits',
-        sa.Column('status_message', sa.String(length=255), nullable=True)
-        )
+    op.add_column(
+        'action_plans',
+        sa.Column('status_message', sa.String(length=255), nullable=True),
+    )
+    op.add_column(
+        'actions',
+        sa.Column('status_message', sa.String(length=255), nullable=True),
+    )
+    op.add_column(
+        'audits',
+        sa.Column('status_message', sa.String(length=255), nullable=True),
+    )
diff --git a/watcher/db/sqlalchemy/alembic/versions/a86240e89a29_.py b/watcher/db/sqlalchemy/alembic/versions/a86240e89a29_.py
index 47a10db40..822b87459 100644
--- a/watcher/db/sqlalchemy/alembic/versions/a86240e89a29_.py
+++ b/watcher/db/sqlalchemy/alembic/versions/a86240e89a29_.py
@@ -21,15 +21,21 @@ def upgrade():
     connection = op.get_bind()
     session = sessionmaker()
     s = session(bind=connection)
-    audits = s.query(
-        models.Audit.strategy_id.label('strategy_id'),
-        models.Audit.created_at.label('created_at')).filter(
-        models.Audit.name is None).all()
+    audits = (
+        s.query(
+            models.Audit.strategy_id.label('strategy_id'),
+            models.Audit.created_at.label('created_at'),
+        )
+        .filter(models.Audit.name is None)
+        .all()
+    )
     for audit in audits:
-        strategy_name = s.query(models.Strategy).filter_by(
-            id=audit.strategy_id).one().name
+        strategy_name = (
+            s.query(models.Strategy).filter_by(id=audit.strategy_id).one().name
+        )
         s.query().filter(models.Audit.name is None).update(
-            {'name': strategy_name + '-' + str(audit.created_at)})
+            {'name': strategy_name + '-' + str(audit.created_at)}
+        )
     s.commit()
 
 
@@ -37,11 +43,14 @@ def downgrade():
     connection = op.get_bind()
     session = sessionmaker()
     s = session(bind=connection)
-    audits = s.query(
-        models.Audit.strategy_id.label('strategy_id'),
-        models.Audit.created_at.label('created_at')).filter(
-        models.Audit.name is not None).all()
+    audits = (
+        s.query(
+            models.Audit.strategy_id.label('strategy_id'),
+            models.Audit.created_at.label('created_at'),
+        )
+        .filter(models.Audit.name is not None)
+        .all()
+    )
     for audit in audits:
-        s.query().filter(models.Audit.name is not None).update(
-            {'name': None})
+        s.query().filter(models.Audit.name is not None).update({'name': None})
     s.commit()
diff --git a/watcher/db/sqlalchemy/alembic/versions/d098df6021e2_cron_support_for_audit.py b/watcher/db/sqlalchemy/alembic/versions/d098df6021e2_cron_support_for_audit.py
index df904bde2..64c5150e4 100644
--- a/watcher/db/sqlalchemy/alembic/versions/d098df6021e2_cron_support_for_audit.py
+++ b/watcher/db/sqlalchemy/alembic/versions/d098df6021e2_cron_support_for_audit.py
@@ -5,6 +5,7 @@ Revises: 0f6042416884
 Create Date: 2017-06-08 16:21:35.746752
 
 """
+
 import sqlalchemy as sa
 
 from alembic import op
@@ -16,13 +17,16 @@ down_revision = '0f6042416884'
 
 
 def upgrade():
-    op.alter_column('audits', 'interval', existing_type=sa.String(36),
-                    nullable=True)
-    op.add_column('audits',
-                  sa.Column('next_run_time', sa.DateTime(), nullable=True))
+    op.alter_column(
+        'audits', 'interval', existing_type=sa.String(36), nullable=True
+    )
+    op.add_column(
+        'audits', sa.Column('next_run_time', sa.DateTime(), nullable=True)
+    )
 
 
 def downgrade():
-    op.alter_column('audits', 'interval', existing_type=sa.Integer(),
-                    nullable=True)
+    op.alter_column(
+        'audits', 'interval', existing_type=sa.Integer(), nullable=True
+    )
     op.drop_column('audits', 'next_run_time')
diff --git a/watcher/db/sqlalchemy/alembic/versions/d09a5945e4a0_add_action_description_table.py b/watcher/db/sqlalchemy/alembic/versions/d09a5945e4a0_add_action_description_table.py
index 9d92f3c2f..be96188a5 100644
--- a/watcher/db/sqlalchemy/alembic/versions/d09a5945e4a0_add_action_description_table.py
+++ b/watcher/db/sqlalchemy/alembic/versions/d09a5945e4a0_add_action_description_table.py
@@ -23,14 +23,18 @@ def upgrade():
         sa.Column('created_at', sa.DateTime(), nullable=True),
         sa.Column('updated_at', sa.DateTime(), nullable=True),
         sa.Column('deleted_at', sa.DateTime(), nullable=True),
-        sa.Column('deleted', oslo_db.sqlalchemy.types.SoftDeleteInteger(),
-                  nullable=True),
+        sa.Column(
+            'deleted',
+            oslo_db.sqlalchemy.types.SoftDeleteInteger(),
+            nullable=True,
+        ),
         sa.Column('id', sa.Integer(), nullable=False),
         sa.Column('action_type', sa.String(length=255), nullable=False),
         sa.Column('description', sa.String(length=255), nullable=False),
         sa.PrimaryKeyConstraint('id'),
-        sa.UniqueConstraint('action_type',
-                            name='uniq_action_description0action_type')
+        sa.UniqueConstraint(
+            'action_type', name='uniq_action_description0action_type'
+        ),
     )
 
 
diff --git a/watcher/db/sqlalchemy/api.py b/watcher/db/sqlalchemy/api.py
index 2f26d9ab2..a4f1ff2f5 100644
--- a/watcher/db/sqlalchemy/api.py
+++ b/watcher/db/sqlalchemy/api.py
@@ -77,13 +77,15 @@ def add_identity_filter(query, value):
         raise exception.InvalidIdentity(identity=value)
 
 
-def _paginate_query(model, limit=None, marker=None, sort_key=None,
-                    sort_dir=None, query=None):
+def _paginate_query(
+    model, limit=None, marker=None, sort_key=None, sort_dir=None, query=None
+):
     sort_keys = ['id']
     if sort_key and sort_key not in sort_keys:
         sort_keys.insert(0, sort_key)
-    query = db_utils.paginate_query(query, model, limit, sort_keys,
-                                    marker=marker, sort_dir=sort_dir)
+    query = db_utils.paginate_query(
+        query, model, limit, sort_keys, marker=marker, sort_dir=sort_dir
+    )
     return query.all()
 
 
@@ -92,7 +94,8 @@ class JoinMap(utils.Struct):
 
 
 NaturalJoinFilter = collections.namedtuple(
-    'NaturalJoinFilter', ['join_fieldname', 'join_model'])
+    'NaturalJoinFilter', ['join_fieldname', 'join_model']
+)
 
 
 class Connection(api.BaseConnection):
@@ -116,8 +119,11 @@ class Connection(api.BaseConnection):
     def __add_simple_filter(self, query, model, fieldname, value, operator_):
         field = getattr(model, fieldname)
 
-        if (fieldname != 'deleted' and value and
-                field.type.python_type is datetime.datetime):
+        if (
+            fieldname != 'deleted'
+            and value
+            and field.type.python_type is datetime.datetime
+        ):
             if not isinstance(value, datetime.datetime):
                 value = timeutils.parse_isotime(value)
 
@@ -125,8 +131,9 @@ class Connection(api.BaseConnection):
 
     def __add_join_filter(self, query, model, fieldname, value, operator_):
         query = query.join(model)
-        return self.__add_simple_filter(query, model, fieldname,
-                                        value, operator_)
+        return self.__add_simple_filter(
+            query, model, fieldname, value, operator_
+        )
 
     def __decompose_filter(self, raw_fieldname):
         """Decompose a filter name into its 2 subparts
@@ -153,12 +160,14 @@ class Connection(api.BaseConnection):
 
         if operator_ and operator_ not in self.valid_operators:
             raise exception.InvalidOperator(
-                operator=operator_, valid_operators=self.valid_operators)
+                operator=operator_, valid_operators=self.valid_operators
+            )
 
         return fieldname, operator_
 
-    def _add_filters(self, query, model, filters=None,
-                     plain_fields=None, join_fieldmap=None):
+    def _add_filters(
+        self, query, model, filters=None, plain_fields=None, join_fieldmap=None
+    ):
         """Generic way to add filters to a Watcher model
 
         Each filter key provided by the `filters` parameter will be decomposed
@@ -201,20 +210,23 @@ class Connection(api.BaseConnection):
             filters[f'deleted__{op}'] = 0
 
         plain_fields = tuple(
-            (list(plain_fields) or []) +
-            soft_delete_mixin_fields +
-            timestamp_mixin_fields)
+            (list(plain_fields) or [])
+            + soft_delete_mixin_fields
+            + timestamp_mixin_fields
+        )
         join_fieldmap = join_fieldmap or {}
 
         for raw_fieldname, value in filters.items():
             fieldname, operator_ = self.__decompose_filter(raw_fieldname)
             if fieldname in plain_fields:
                 query = self.__add_simple_filter(
-                    query, model, fieldname, value, operator_)
+                    query, model, fieldname, value, operator_
+                )
             elif fieldname in join_fieldmap:
                 join_field, join_model = join_fieldmap[fieldname]
                 query = self.__add_join_filter(
-                    query, join_model, join_field, value, operator_)
+                    query, join_model, join_field, value, operator_
+                )
 
         return query
 
@@ -228,16 +240,20 @@ class Connection(api.BaseConnection):
         for relationship in relationships:
             if not relationship.uselist:
                 # We have a One-to-X relationship
-                query = query.options(joinedload(
-                    getattr(model, relationship.key)))
+                query = query.options(
+                    joinedload(getattr(model, relationship.key))
+                )
         return query
 
     @oslo_db_api.retry_on_deadlock
     def _create(self, model, values):
         with _session_for_write() as session:
             obj = model()
-            cleaned_values = {k: v for k, v in values.items()
-                              if k not in self._get_relationships(model)}
+            cleaned_values = {
+                k: v
+                for k, v in values.items()
+                if k not in self._get_relationships(model)
+            }
             obj.update(cleaned_values)
             session.add(obj)
             session.flush()
@@ -304,9 +320,18 @@ class Connection(api.BaseConnection):
 
             query.delete()
 
-    def _get_model_list(self, model, add_filters_func, context, filters=None,
-                        limit=None, marker=None, sort_key=None, sort_dir=None,
-                        eager=False):
+    def _get_model_list(
+        self,
+        model,
+        add_filters_func,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         with _session_for_read() as session:
             query = session.query(model)
             if eager:
@@ -314,8 +339,9 @@ class Connection(api.BaseConnection):
             query = add_filters_func(query, filters)
             if not context.show_deleted:
                 query = query.filter(model.deleted_at.is_(None))
-            return _paginate_query(model, limit, marker,
-                                   sort_key, sort_dir, query)
+            return _paginate_query(
+                model, limit, marker, sort_key, sort_dir, query
+            )
 
     # NOTE(erakli): _add_..._filters methods should be refactored to have same
     # content. join_fieldmap should be filled with JoinMap instead of dict
@@ -327,19 +353,29 @@ class Connection(api.BaseConnection):
         plain_fields = ['uuid', 'name', 'display_name']
 
         return self._add_filters(
-            query=query, model=models.Goal, filters=filters,
-            plain_fields=plain_fields)
+            query=query,
+            model=models.Goal,
+            filters=filters,
+            plain_fields=plain_fields,
+        )
 
     def _add_strategies_filters(self, query, filters):
         plain_fields = ['uuid', 'name', 'display_name', 'goal_id']
         join_fieldmap = JoinMap(
             goal_uuid=NaturalJoinFilter(
-                join_fieldname="uuid", join_model=models.Goal),
+                join_fieldname="uuid", join_model=models.Goal
+            ),
             goal_name=NaturalJoinFilter(
-                join_fieldname="name", join_model=models.Goal))
+                join_fieldname="name", join_model=models.Goal
+            ),
+        )
         return self._add_filters(
-            query=query, model=models.Strategy, filters=filters,
-            plain_fields=plain_fields, join_fieldmap=join_fieldmap)
+            query=query,
+            model=models.Strategy,
+            filters=filters,
+            plain_fields=plain_fields,
+            join_fieldmap=join_fieldmap,
+        )
 
     def _add_audit_templates_filters(self, query, filters):
         if filters is None:
@@ -348,25 +384,39 @@ class Connection(api.BaseConnection):
         plain_fields = ['uuid', 'name', 'goal_id', 'strategy_id']
         join_fieldmap = JoinMap(
             goal_uuid=NaturalJoinFilter(
-                join_fieldname="uuid", join_model=models.Goal),
+                join_fieldname="uuid", join_model=models.Goal
+            ),
             goal_name=NaturalJoinFilter(
-                join_fieldname="name", join_model=models.Goal),
+                join_fieldname="name", join_model=models.Goal
+            ),
             strategy_uuid=NaturalJoinFilter(
-                join_fieldname="uuid", join_model=models.Strategy),
+                join_fieldname="uuid", join_model=models.Strategy
+            ),
             strategy_name=NaturalJoinFilter(
-                join_fieldname="name", join_model=models.Strategy),
+                join_fieldname="name", join_model=models.Strategy
+            ),
         )
 
         return self._add_filters(
-            query=query, model=models.AuditTemplate, filters=filters,
-            plain_fields=plain_fields, join_fieldmap=join_fieldmap)
+            query=query,
+            model=models.AuditTemplate,
+            filters=filters,
+            plain_fields=plain_fields,
+            join_fieldmap=join_fieldmap,
+        )
 
     def _add_audits_filters(self, query, filters):
         if filters is None:
             filters = {}
 
-        plain_fields = ['uuid', 'audit_type', 'state', 'goal_id',
-                        'strategy_id', 'hostname']
+        plain_fields = [
+            'uuid',
+            'audit_type',
+            'state',
+            'goal_id',
+            'strategy_id',
+            'hostname',
+        ]
         join_fieldmap = {
             'goal_uuid': ("uuid", models.Goal),
             'goal_name': ("name", models.Goal),
@@ -375,47 +425,64 @@ class Connection(api.BaseConnection):
         }
 
         return self._add_filters(
-            query=query, model=models.Audit, filters=filters,
-            plain_fields=plain_fields, join_fieldmap=join_fieldmap)
+            query=query,
+            model=models.Audit,
+            filters=filters,
+            plain_fields=plain_fields,
+            join_fieldmap=join_fieldmap,
+        )
 
     def _add_action_plans_filters(self, query, filters):
         if filters is None:
             filters = {}
 
-        plain_fields = ['uuid', 'state', 'audit_id', 'strategy_id',
-                        'hostname']
+        plain_fields = ['uuid', 'state', 'audit_id', 'strategy_id', 'hostname']
         join_fieldmap = JoinMap(
             audit_uuid=NaturalJoinFilter(
-                join_fieldname="uuid", join_model=models.Audit),
+                join_fieldname="uuid", join_model=models.Audit
+            ),
             strategy_uuid=NaturalJoinFilter(
-                join_fieldname="uuid", join_model=models.Strategy),
+                join_fieldname="uuid", join_model=models.Strategy
+            ),
             strategy_name=NaturalJoinFilter(
-                join_fieldname="name", join_model=models.Strategy),
+                join_fieldname="name", join_model=models.Strategy
+            ),
         )
 
         return self._add_filters(
-            query=query, model=models.ActionPlan, filters=filters,
-            plain_fields=plain_fields, join_fieldmap=join_fieldmap)
+            query=query,
+            model=models.ActionPlan,
+            filters=filters,
+            plain_fields=plain_fields,
+            join_fieldmap=join_fieldmap,
+        )
 
     def _add_actions_filters(self, query, filters):
         if filters is None:
             filters = {}
 
         plain_fields = ['uuid', 'state', 'action_plan_id']
-        join_fieldmap = {
-            'action_plan_uuid': ("uuid", models.ActionPlan),
-        }
+        join_fieldmap = {'action_plan_uuid': ("uuid", models.ActionPlan)}
 
         query = self._add_filters(
-            query=query, model=models.Action, filters=filters,
-            plain_fields=plain_fields, join_fieldmap=join_fieldmap)
+            query=query,
+            model=models.Action,
+            filters=filters,
+            plain_fields=plain_fields,
+            join_fieldmap=join_fieldmap,
+        )
 
         if 'audit_uuid' in filters:
             with _session_for_read() as session:
-                stmt = session.query(models.ActionPlan).join(
-                    models.Audit,
-                    models.Audit.id == models.ActionPlan.audit_id)\
-                    .filter_by(uuid=filters['audit_uuid']).subquery()
+                stmt = (
+                    session.query(models.ActionPlan)
+                    .join(
+                        models.Audit,
+                        models.Audit.id == models.ActionPlan.audit_id,
+                    )
+                    .filter_by(uuid=filters['audit_uuid'])
+                    .subquery()
+                )
                 query = query.filter_by(action_plan_id=stmt.c.id)
 
         return query
@@ -427,12 +494,17 @@ class Connection(api.BaseConnection):
         plain_fields = ['uuid', 'name', 'unit', 'schema', 'action_plan_id']
         join_fieldmap = JoinMap(
             action_plan_uuid=NaturalJoinFilter(
-                join_fieldname="uuid", join_model=models.ActionPlan),
+                join_fieldname="uuid", join_model=models.ActionPlan
+            )
         )
 
         return self._add_filters(
-            query=query, model=models.EfficacyIndicator, filters=filters,
-            plain_fields=plain_fields, join_fieldmap=join_fieldmap)
+            query=query,
+            model=models.EfficacyIndicator,
+            filters=filters,
+            plain_fields=plain_fields,
+            join_fieldmap=join_fieldmap,
+        )
 
     def _add_scoring_engine_filters(self, query, filters):
         if filters is None:
@@ -441,8 +513,11 @@ class Connection(api.BaseConnection):
         plain_fields = ['id', 'description']
 
         return self._add_filters(
-            query=query, model=models.ScoringEngine, filters=filters,
-            plain_fields=plain_fields)
+            query=query,
+            model=models.ScoringEngine,
+            filters=filters,
+            plain_fields=plain_fields,
+        )
 
     def _add_action_descriptions_filters(self, query, filters):
         if not filters:
@@ -451,8 +526,11 @@ class Connection(api.BaseConnection):
         plain_fields = ['id', 'action_type']
 
         return self._add_filters(
-            query=query, model=models.ActionDescription, filters=filters,
-            plain_fields=plain_fields)
+            query=query,
+            model=models.ActionDescription,
+            filters=filters,
+            plain_fields=plain_fields,
+        )
 
     def _add_services_filters(self, query, filters):
         if not filters:
@@ -461,15 +539,18 @@ class Connection(api.BaseConnection):
         plain_fields = ['id', 'name', 'host']
 
         return self._add_filters(
-            query=query, model=models.Service, filters=filters,
-            plain_fields=plain_fields)
+            query=query,
+            model=models.Service,
+            filters=filters,
+            plain_fields=plain_fields,
+        )
 
     # ### GOALS ### #
 
     def get_goal_list(self, *args, **kwargs):
-        return self._get_model_list(models.Goal,
-                                    self._add_goals_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.Goal, self._add_goals_filters, *args, **kwargs
+        )
 
     def create_goal(self, values):
         # ensure defaults are present for new goals
@@ -484,22 +565,30 @@ class Connection(api.BaseConnection):
 
     def _get_goal(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.Goal,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.Goal,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.GoalNotFound(goal=value)
 
     def get_goal_by_id(self, context, goal_id, eager=False):
         return self._get_goal(
-            context, fieldname="id", value=goal_id, eager=eager)
+            context, fieldname="id", value=goal_id, eager=eager
+        )
 
     def get_goal_by_uuid(self, context, goal_uuid, eager=False):
         return self._get_goal(
-            context, fieldname="uuid", value=goal_uuid, eager=eager)
+            context, fieldname="uuid", value=goal_uuid, eager=eager
+        )
 
     def get_goal_by_name(self, context, goal_name, eager=False):
         return self._get_goal(
-            context, fieldname="name", value=goal_name, eager=eager)
+            context, fieldname="name", value=goal_name, eager=eager
+        )
 
     def destroy_goal(self, goal_id):
         try:
@@ -510,7 +599,8 @@ class Connection(api.BaseConnection):
     def update_goal(self, goal_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing Goal."))
+                message=_("Cannot overwrite UUID for an existing Goal.")
+            )
 
         try:
             return self._update(models.Goal, goal_id, values)
@@ -526,9 +616,9 @@ class Connection(api.BaseConnection):
     # ### STRATEGIES ### #
 
     def get_strategy_list(self, *args, **kwargs):
-        return self._get_model_list(models.Strategy,
-                                    self._add_strategies_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.Strategy, self._add_strategies_filters, *args, **kwargs
+        )
 
     def create_strategy(self, values):
         # ensure defaults are present for new strategies
@@ -543,22 +633,30 @@ class Connection(api.BaseConnection):
 
     def _get_strategy(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.Strategy,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.Strategy,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.StrategyNotFound(strategy=value)
 
     def get_strategy_by_id(self, context, strategy_id, eager=False):
         return self._get_strategy(
-            context, fieldname="id", value=strategy_id, eager=eager)
+            context, fieldname="id", value=strategy_id, eager=eager
+        )
 
     def get_strategy_by_uuid(self, context, strategy_uuid, eager=False):
         return self._get_strategy(
-            context, fieldname="uuid", value=strategy_uuid, eager=eager)
+            context, fieldname="uuid", value=strategy_uuid, eager=eager
+        )
 
     def get_strategy_by_name(self, context, strategy_name, eager=False):
         return self._get_strategy(
-            context, fieldname="name", value=strategy_name, eager=eager)
+            context, fieldname="name", value=strategy_name, eager=eager
+        )
 
     def destroy_strategy(self, strategy_id):
         try:
@@ -569,7 +667,8 @@ class Connection(api.BaseConnection):
     def update_strategy(self, strategy_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing Strategy."))
+                message=_("Cannot overwrite UUID for an existing Strategy.")
+            )
 
         try:
             return self._update(models.Strategy, strategy_id, values)
@@ -585,9 +684,12 @@ class Connection(api.BaseConnection):
     # ### AUDIT TEMPLATES ### #
 
     def get_audit_template_list(self, *args, **kwargs):
-        return self._get_model_list(models.AuditTemplate,
-                                    self._add_audit_templates_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.AuditTemplate,
+            self._add_audit_templates_filters,
+            *args,
+            **kwargs,
+        )
 
     @oslo_db_api.retry_on_deadlock
     def create_audit_template(self, values):
@@ -597,74 +699,92 @@ class Connection(api.BaseConnection):
 
         with _session_for_write() as session:
             query = session.query(models.AuditTemplate)
-            query = query.filter_by(name=values.get('name'),
-                                    deleted_at=None)
+            query = query.filter_by(name=values.get('name'), deleted_at=None)
 
             if len(query.all()) > 0:
                 raise exception.AuditTemplateAlreadyExists(
-                    audit_template=values['name'])
+                    audit_template=values['name']
+                )
 
             try:
                 audit_template = self._create(models.AuditTemplate, values)
             except db_exc.DBDuplicateEntry:
                 raise exception.AuditTemplateAlreadyExists(
-                    audit_template=values['name'])
+                    audit_template=values['name']
+                )
             return audit_template
 
     def _get_audit_template(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.AuditTemplate,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.AuditTemplate,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.AuditTemplateNotFound(audit_template=value)
 
-    def get_audit_template_by_id(self, context, audit_template_id,
-                                 eager=False):
+    def get_audit_template_by_id(
+        self, context, audit_template_id, eager=False
+    ):
         return self._get_audit_template(
-            context, fieldname="id", value=audit_template_id, eager=eager)
+            context, fieldname="id", value=audit_template_id, eager=eager
+        )
 
-    def get_audit_template_by_uuid(self, context, audit_template_uuid,
-                                   eager=False):
+    def get_audit_template_by_uuid(
+        self, context, audit_template_uuid, eager=False
+    ):
         return self._get_audit_template(
-            context, fieldname="uuid", value=audit_template_uuid, eager=eager)
+            context, fieldname="uuid", value=audit_template_uuid, eager=eager
+        )
 
-    def get_audit_template_by_name(self, context, audit_template_name,
-                                   eager=False):
+    def get_audit_template_by_name(
+        self, context, audit_template_name, eager=False
+    ):
         return self._get_audit_template(
-            context, fieldname="name", value=audit_template_name, eager=eager)
+            context, fieldname="name", value=audit_template_name, eager=eager
+        )
 
     def destroy_audit_template(self, audit_template_id):
         try:
             return self._destroy(models.AuditTemplate, audit_template_id)
         except exception.ResourceNotFound:
             raise exception.AuditTemplateNotFound(
-                audit_template=audit_template_id)
+                audit_template=audit_template_id
+            )
 
     def update_audit_template(self, audit_template_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing "
-                          "Audit Template."))
+                message=_(
+                    "Cannot overwrite UUID for an existing Audit Template."
+                )
+            )
         try:
             return self._update(
-                models.AuditTemplate, audit_template_id, values)
+                models.AuditTemplate, audit_template_id, values
+            )
         except exception.ResourceNotFound:
             raise exception.AuditTemplateNotFound(
-                audit_template=audit_template_id)
+                audit_template=audit_template_id
+            )
 
     def soft_delete_audit_template(self, audit_template_id):
         try:
             return self._soft_delete(models.AuditTemplate, audit_template_id)
         except exception.ResourceNotFound:
             raise exception.AuditTemplateNotFound(
-                audit_template=audit_template_id)
+                audit_template=audit_template_id
+            )
 
     # ### AUDITS ### #
 
     def get_audit_list(self, *args, **kwargs):
-        return self._get_model_list(models.Audit,
-                                    self._add_audits_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.Audit, self._add_audits_filters, *args, **kwargs
+        )
 
     @oslo_db_api.retry_on_deadlock
     def create_audit(self, values):
@@ -674,12 +794,10 @@ class Connection(api.BaseConnection):
 
         with _session_for_write() as session:
             query = session.query(models.Audit)
-            query = query.filter_by(name=values.get('name'),
-                                    deleted_at=None)
+            query = query.filter_by(name=values.get('name'), deleted_at=None)
 
             if len(query.all()) > 0:
-                raise exception.AuditAlreadyExists(
-                    audit=values['name'])
+                raise exception.AuditAlreadyExists(audit=values['name'])
 
             if values.get('state') is None:
                 values['state'] = objects.audit.State.PENDING
@@ -695,22 +813,30 @@ class Connection(api.BaseConnection):
 
     def _get_audit(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.Audit,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.Audit,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.AuditNotFound(audit=value)
 
     def get_audit_by_id(self, context, audit_id, eager=False):
         return self._get_audit(
-            context, fieldname="id", value=audit_id, eager=eager)
+            context, fieldname="id", value=audit_id, eager=eager
+        )
 
     def get_audit_by_uuid(self, context, audit_uuid, eager=False):
         return self._get_audit(
-            context, fieldname="uuid", value=audit_uuid, eager=eager)
+            context, fieldname="uuid", value=audit_uuid, eager=eager
+        )
 
     def get_audit_by_name(self, context, audit_name, eager=False):
         return self._get_audit(
-            context, fieldname="name", value=audit_name, eager=eager)
+            context, fieldname="name", value=audit_name, eager=eager
+        )
 
     @oslo_db_api.retry_on_deadlock
     def destroy_audit(self, audit_id):
@@ -718,7 +844,8 @@ class Connection(api.BaseConnection):
             """Checks whether the audit is referenced by action_plan(s)."""
             query = session.query(models.ActionPlan)
             query = self._add_action_plans_filters(
-                query, {'audit_id': audit_id})
+                query, {'audit_id': audit_id}
+            )
             return query.count() != 0
 
         with _session_for_write() as session:
@@ -738,8 +865,8 @@ class Connection(api.BaseConnection):
     def update_audit(self, audit_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing "
-                          "Audit."))
+                message=_("Cannot overwrite UUID for an existing Audit.")
+            )
 
         try:
             return self._update(models.Audit, audit_id, values)
@@ -755,9 +882,9 @@ class Connection(api.BaseConnection):
     # ### ACTIONS ### #
 
     def get_action_list(self, *args, **kwargs):
-        return self._get_model_list(models.Action,
-                                    self._add_actions_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.Action, self._add_actions_filters, *args, **kwargs
+        )
 
     def create_action(self, values):
         # ensure defaults are present for new actions
@@ -775,18 +902,25 @@ class Connection(api.BaseConnection):
 
     def _get_action(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.Action,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.Action,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.ActionNotFound(action=value)
 
     def get_action_by_id(self, context, action_id, eager=False):
         return self._get_action(
-            context, fieldname="id", value=action_id, eager=eager)
+            context, fieldname="id", value=action_id, eager=eager
+        )
 
     def get_action_by_uuid(self, context, action_uuid, eager=False):
         return self._get_action(
-            context, fieldname="uuid", value=action_uuid, eager=eager)
+            context, fieldname="uuid", value=action_uuid, eager=eager
+        )
 
     @oslo_db_api.retry_on_deadlock
     def destroy_action(self, action_id):
@@ -802,7 +936,8 @@ class Connection(api.BaseConnection):
         # NOTE(dtantsur): this can lead to very strange errors
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing Action."))
+                message=_("Cannot overwrite UUID for an existing Action.")
+            )
 
         return self._do_update_action(action_id, values)
 
@@ -828,9 +963,9 @@ class Connection(api.BaseConnection):
     # ### ACTION PLANS ### #
 
     def get_action_plan_list(self, *args, **kwargs):
-        return self._get_model_list(models.ActionPlan,
-                                    self._add_action_plans_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.ActionPlan, self._add_action_plans_filters, *args, **kwargs
+        )
 
     def create_action_plan(self, values):
         # ensure defaults are present for new audits
@@ -845,18 +980,25 @@ class Connection(api.BaseConnection):
 
     def _get_action_plan(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.ActionPlan,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.ActionPlan,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.ActionPlanNotFound(action_plan=value)
 
     def get_action_plan_by_id(self, context, action_plan_id, eager=False):
         return self._get_action_plan(
-            context, fieldname="id", value=action_plan_id, eager=eager)
+            context, fieldname="id", value=action_plan_id, eager=eager
+        )
 
     def get_action_plan_by_uuid(self, context, action_plan_uuid, eager=False):
         return self._get_action_plan(
-            context, fieldname="uuid", value=action_plan_uuid, eager=eager)
+            context, fieldname="uuid", value=action_plan_uuid, eager=eager
+        )
 
     @oslo_db_api.retry_on_deadlock
     def destroy_action_plan(self, action_plan_id):
@@ -864,7 +1006,8 @@ class Connection(api.BaseConnection):
             """Checks whether the action_plan is referenced by action(s)."""
             query = session.query(models.Action)
             query = self._add_actions_filters(
-                query, {'action_plan_id': action_plan_id})
+                query, {'action_plan_id': action_plan_id}
+            )
             return query.count() != 0
 
         with _session_for_write() as session:
@@ -878,7 +1021,8 @@ class Connection(api.BaseConnection):
 
             if is_action_plan_referenced(session, action_plan_ref['id']):
                 raise exception.ActionPlanReferenced(
-                    action_plan=action_plan_id)
+                    action_plan=action_plan_id
+                )
 
             query.delete()
 
@@ -886,8 +1030,8 @@ class Connection(api.BaseConnection):
     def update_action_plan(self, action_plan_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing "
-                          "Action Plan."))
+                message=_("Cannot overwrite UUID for an existing Action Plan.")
+            )
 
         return self._do_update_action_plan(action_plan_id, values)
 
@@ -916,8 +1060,9 @@ class Connection(api.BaseConnection):
         eff_ind_models = self._get_model_list(
             models.EfficacyIndicator,
             self._add_efficacy_indicators_filters,
-            *args, **kwargs
-            )
+            *args,
+            **kwargs,
+        )
         for indicator in eff_ind_models:
             if indicator.data is not None:
                 # jgilaber: use the data value since it stores the value
@@ -930,8 +1075,7 @@ class Connection(api.BaseConnection):
                 # value column
                 indicator.data = indicator.value
                 # store the new column in the database
-                self._update(models.EfficacyIndicator,
-                             indicator.id, indicator)
+                self._update(models.EfficacyIndicator, indicator.id, indicator)
 
         return eff_ind_models
 
@@ -952,10 +1096,13 @@ class Connection(api.BaseConnection):
 
     def _get_efficacy_indicator(self, context, fieldname, value, eager):
         try:
-            efficacy_indicator = self._get(context,
-                                           model=models.EfficacyIndicator,
-                                           fieldname=fieldname,
-                                           value=value, eager=eager)
+            efficacy_indicator = self._get(
+                context,
+                model=models.EfficacyIndicator,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
 
             if efficacy_indicator.data is not None:
                 # jgilaber: use the data value since it stores the value
@@ -968,65 +1115,88 @@ class Connection(api.BaseConnection):
                 # value column
                 efficacy_indicator.data = efficacy_indicator.value
                 # store the new column in the database
-                self._update(models.EfficacyIndicator, efficacy_indicator.id,
-                             efficacy_indicator)
+                self._update(
+                    models.EfficacyIndicator,
+                    efficacy_indicator.id,
+                    efficacy_indicator,
+                )
             return efficacy_indicator
         except exception.ResourceNotFound:
             raise exception.EfficacyIndicatorNotFound(efficacy_indicator=value)
 
-    def get_efficacy_indicator_by_id(self, context, efficacy_indicator_id,
-                                     eager=False):
+    def get_efficacy_indicator_by_id(
+        self, context, efficacy_indicator_id, eager=False
+    ):
         return self._get_efficacy_indicator(
-            context, fieldname="id",
-            value=efficacy_indicator_id, eager=eager)
+            context, fieldname="id", value=efficacy_indicator_id, eager=eager
+        )
 
-    def get_efficacy_indicator_by_uuid(self, context, efficacy_indicator_uuid,
-                                       eager=False):
+    def get_efficacy_indicator_by_uuid(
+        self, context, efficacy_indicator_uuid, eager=False
+    ):
         return self._get_efficacy_indicator(
-            context, fieldname="uuid",
-            value=efficacy_indicator_uuid, eager=eager)
+            context,
+            fieldname="uuid",
+            value=efficacy_indicator_uuid,
+            eager=eager,
+        )
 
-    def get_efficacy_indicator_by_name(self, context, efficacy_indicator_name,
-                                       eager=False):
+    def get_efficacy_indicator_by_name(
+        self, context, efficacy_indicator_name, eager=False
+    ):
         return self._get_efficacy_indicator(
-            context, fieldname="name",
-            value=efficacy_indicator_name, eager=eager)
+            context,
+            fieldname="name",
+            value=efficacy_indicator_name,
+            eager=eager,
+        )
 
     def update_efficacy_indicator(self, efficacy_indicator_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing "
-                          "efficacy indicator."))
+                message=_(
+                    "Cannot overwrite UUID for an existing efficacy indicator."
+                )
+            )
 
         try:
             return self._update(
-                models.EfficacyIndicator, efficacy_indicator_id, values)
+                models.EfficacyIndicator, efficacy_indicator_id, values
+            )
         except exception.ResourceNotFound:
             raise exception.EfficacyIndicatorNotFound(
-                efficacy_indicator=efficacy_indicator_id)
+                efficacy_indicator=efficacy_indicator_id
+            )
 
     def soft_delete_efficacy_indicator(self, efficacy_indicator_id):
         try:
             return self._soft_delete(
-                models.EfficacyIndicator, efficacy_indicator_id)
+                models.EfficacyIndicator, efficacy_indicator_id
+            )
         except exception.ResourceNotFound:
             raise exception.EfficacyIndicatorNotFound(
-                efficacy_indicator=efficacy_indicator_id)
+                efficacy_indicator=efficacy_indicator_id
+            )
 
     def destroy_efficacy_indicator(self, efficacy_indicator_id):
         try:
             return self._destroy(
-                models.EfficacyIndicator, efficacy_indicator_id)
+                models.EfficacyIndicator, efficacy_indicator_id
+            )
         except exception.ResourceNotFound:
             raise exception.EfficacyIndicatorNotFound(
-                efficacy_indicator=efficacy_indicator_id)
+                efficacy_indicator=efficacy_indicator_id
+            )
 
     # ### SCORING ENGINES ### #
 
     def get_scoring_engine_list(self, *args, **kwargs):
-        return self._get_model_list(models.ScoringEngine,
-                                    self._add_scoring_engine_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.ScoringEngine,
+            self._add_scoring_engine_filters,
+            *args,
+            **kwargs,
+        )
 
     def create_scoring_engine(self, values):
         # ensure defaults are present for new scoring engines
@@ -1041,83 +1211,107 @@ class Connection(api.BaseConnection):
 
     def _get_scoring_engine(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.ScoringEngine,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.ScoringEngine,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.ScoringEngineNotFound(scoring_engine=value)
 
-    def get_scoring_engine_by_id(self, context, scoring_engine_id,
-                                 eager=False):
+    def get_scoring_engine_by_id(
+        self, context, scoring_engine_id, eager=False
+    ):
         return self._get_scoring_engine(
-            context, fieldname="id", value=scoring_engine_id, eager=eager)
+            context, fieldname="id", value=scoring_engine_id, eager=eager
+        )
 
-    def get_scoring_engine_by_uuid(self, context, scoring_engine_uuid,
-                                   eager=False):
+    def get_scoring_engine_by_uuid(
+        self, context, scoring_engine_uuid, eager=False
+    ):
         return self._get_scoring_engine(
-            context, fieldname="uuid", value=scoring_engine_uuid, eager=eager)
+            context, fieldname="uuid", value=scoring_engine_uuid, eager=eager
+        )
 
-    def get_scoring_engine_by_name(self, context, scoring_engine_name,
-                                   eager=False):
+    def get_scoring_engine_by_name(
+        self, context, scoring_engine_name, eager=False
+    ):
         return self._get_scoring_engine(
-            context, fieldname="name", value=scoring_engine_name, eager=eager)
+            context, fieldname="name", value=scoring_engine_name, eager=eager
+        )
 
     def destroy_scoring_engine(self, scoring_engine_id):
         try:
             return self._destroy(models.ScoringEngine, scoring_engine_id)
         except exception.ResourceNotFound:
             raise exception.ScoringEngineNotFound(
-                scoring_engine=scoring_engine_id)
+                scoring_engine=scoring_engine_id
+            )
 
     def update_scoring_engine(self, scoring_engine_id, values):
         if 'uuid' in values:
             raise exception.Invalid(
-                message=_("Cannot overwrite UUID for an existing "
-                          "Scoring Engine."))
+                message=_(
+                    "Cannot overwrite UUID for an existing Scoring Engine."
+                )
+            )
 
         try:
             return self._update(
-                models.ScoringEngine, scoring_engine_id, values)
+                models.ScoringEngine, scoring_engine_id, values
+            )
         except exception.ResourceNotFound:
             raise exception.ScoringEngineNotFound(
-                scoring_engine=scoring_engine_id)
+                scoring_engine=scoring_engine_id
+            )
 
     def soft_delete_scoring_engine(self, scoring_engine_id):
         try:
-            return self._soft_delete(
-                models.ScoringEngine, scoring_engine_id)
+            return self._soft_delete(models.ScoringEngine, scoring_engine_id)
         except exception.ResourceNotFound:
             raise exception.ScoringEngineNotFound(
-                scoring_engine=scoring_engine_id)
+                scoring_engine=scoring_engine_id
+            )
 
     # ### SERVICES ### #
 
     def get_service_list(self, *args, **kwargs):
-        return self._get_model_list(models.Service,
-                                    self._add_services_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.Service, self._add_services_filters, *args, **kwargs
+        )
 
     def create_service(self, values):
         try:
             service = self._create(models.Service, values)
         except db_exc.DBDuplicateEntry:
-            raise exception.ServiceAlreadyExists(name=values['name'],
-                                                 host=values['host'])
+            raise exception.ServiceAlreadyExists(
+                name=values['name'], host=values['host']
+            )
         return service
 
     def _get_service(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.Service,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.Service,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.ServiceNotFound(service=value)
 
     def get_service_by_id(self, context, service_id, eager=False):
         return self._get_service(
-            context, fieldname="id", value=service_id, eager=eager)
+            context, fieldname="id", value=service_id, eager=eager
+        )
 
     def get_service_by_name(self, context, service_name, eager=False):
         return self._get_service(
-            context, fieldname="name", value=service_name, eager=eager)
+            context, fieldname="name", value=service_name, eager=eager
+        )
 
     def destroy_service(self, service_id):
         try:
@@ -1140,53 +1334,60 @@ class Connection(api.BaseConnection):
     # ### ACTION_DESCRIPTIONS ### #
 
     def get_action_description_list(self, *args, **kwargs):
-        return self._get_model_list(models.ActionDescription,
-                                    self._add_action_descriptions_filters,
-                                    *args, **kwargs)
+        return self._get_model_list(
+            models.ActionDescription,
+            self._add_action_descriptions_filters,
+            *args,
+            **kwargs,
+        )
 
     def create_action_description(self, values):
         try:
             action_description = self._create(models.ActionDescription, values)
         except db_exc.DBDuplicateEntry:
             raise exception.ActionDescriptionAlreadyExists(
-                action_type=values['action_type'])
+                action_type=values['action_type']
+            )
         return action_description
 
     def _get_action_description(self, context, fieldname, value, eager):
         try:
-            return self._get(context, model=models.ActionDescription,
-                             fieldname=fieldname, value=value, eager=eager)
+            return self._get(
+                context,
+                model=models.ActionDescription,
+                fieldname=fieldname,
+                value=value,
+                eager=eager,
+            )
         except exception.ResourceNotFound:
             raise exception.ActionDescriptionNotFound(action_id=value)
 
-    def get_action_description_by_id(self, context,
-                                     action_id, eager=False):
+    def get_action_description_by_id(self, context, action_id, eager=False):
         return self._get_action_description(
-            context, fieldname="id", value=action_id, eager=eager)
+            context, fieldname="id", value=action_id, eager=eager
+        )
 
-    def get_action_description_by_type(self, context,
-                                       action_type, eager=False):
+    def get_action_description_by_type(
+        self, context, action_type, eager=False
+    ):
         return self._get_action_description(
-            context, fieldname="action_type", value=action_type, eager=eager)
+            context, fieldname="action_type", value=action_type, eager=eager
+        )
 
     def destroy_action_description(self, action_id):
         try:
             return self._destroy(models.ActionDescription, action_id)
         except exception.ResourceNotFound:
-            raise exception.ActionDescriptionNotFound(
-                action_id=action_id)
+            raise exception.ActionDescriptionNotFound(action_id=action_id)
 
     def update_action_description(self, action_id, values):
         try:
-            return self._update(models.ActionDescription,
-                                action_id, values)
+            return self._update(models.ActionDescription, action_id, values)
         except exception.ResourceNotFound:
-            raise exception.ActionDescriptionNotFound(
-                action_id=action_id)
+            raise exception.ActionDescriptionNotFound(action_id=action_id)
 
     def soft_delete_action_description(self, action_id):
         try:
             return self._soft_delete(models.ActionDescription, action_id)
         except exception.ResourceNotFound:
-            raise exception.ActionDescriptionNotFound(
-                action_id=action_id)
+            raise exception.ActionDescriptionNotFound(action_id=action_id)
diff --git a/watcher/db/sqlalchemy/job_store.py b/watcher/db/sqlalchemy/job_store.py
index 8993d3c49..84b157601 100644
--- a/watcher/db/sqlalchemy/job_store.py
+++ b/watcher/db/sqlalchemy/job_store.py
@@ -51,31 +51,40 @@ class WatcherJobStore(sqlalchemy.SQLAlchemyJobStore):
     :param dict tag: tag description
     """
 
-    def __init__(self, url=None, engine=None, tablename='apscheduler_jobs',
-                 metadata=None, pickle_protocol=pickle.HIGHEST_PROTOCOL,
-                 tag=None):
-        super().__init__(url, engine, tablename,
-                         metadata, pickle_protocol)
+    def __init__(
+        self,
+        url=None,
+        engine=None,
+        tablename='apscheduler_jobs',
+        metadata=None,
+        pickle_protocol=pickle.HIGHEST_PROTOCOL,
+        tag=None,
+    ):
+        super().__init__(url, engine, tablename, metadata, pickle_protocol)
         metadata = maybe_ref(metadata) or MetaData()
         self.jobs_t = Table(tablename, metadata, autoload_with=engine)
         service_ident = service.ServiceHeartbeat.get_service_name()
         self.tag = tag or {'host': service_ident[0], 'name': service_ident[1]}
-        self.service_id = objects.Service.list(context=context.make_context(),
-                                               filters=self.tag)[0].id
+        self.service_id = objects.Service.list(
+            context=context.make_context(), filters=self.tag
+        )[0].id
 
     def start(self, scheduler, alias):
         # There should be called 'start' method of parent of SQLAlchemyJobStore
         super(self.__class__.__bases__[0], self).start(scheduler, alias)
 
     def add_job(self, job):
-        insert = self.jobs_t.insert().values(**{
-            'id': job.id,
-            'next_run_time': datetime_to_utc_timestamp(job.next_run_time),
-            'job_state': pickle.dumps(job.__getstate__(),
-                                      self.pickle_protocol),
-            'service_id': self.service_id,
-            'tag': jsonutils.dumps(self.tag)
-        })
+        insert = self.jobs_t.insert().values(
+            **{
+                'id': job.id,
+                'next_run_time': datetime_to_utc_timestamp(job.next_run_time),
+                'job_state': pickle.dumps(
+                    job.__getstate__(), self.pickle_protocol
+                ),
+                'service_id': self.service_id,
+                'tag': jsonutils.dumps(self.tag),
+            }
+        )
         try:
             with self.engine.begin() as conn:
                 conn.execute(insert)
@@ -88,9 +97,12 @@ class WatcherJobStore(sqlalchemy.SQLAlchemyJobStore):
         return jobs
 
     def get_next_run_time(self):
-        selectable = select(self.jobs_t.c.next_run_time).\
-            where(self.jobs_t.c.next_run_time != null()).\
-            order_by(self.jobs_t.c.next_run_time).limit(1)
+        selectable = (
+            select(self.jobs_t.c.next_run_time)
+            .where(self.jobs_t.c.next_run_time != null())
+            .order_by(self.jobs_t.c.next_run_time)
+            .limit(1)
+        )
         with self.engine.begin() as connection:
             # NOTE(danms): The apscheduler implementation of this gets a
             # decimal.Decimal back from scalar() which causes
@@ -98,16 +110,20 @@ class WatcherJobStore(sqlalchemy.SQLAlchemyJobStore):
             # python float. Assume this is SQLAlchemy 2.0 stuff, so just
             # coerce to a float here.
             next_run_time = connection.execute(selectable).scalar()
-            return utc_timestamp_to_datetime(float(next_run_time)
-                                             if next_run_time is not None
-                                             else None)
+            return utc_timestamp_to_datetime(
+                float(next_run_time) if next_run_time is not None else None
+            )
 
     def _get_jobs(self, *conditions):
         jobs = []
         conditions += (self.jobs_t.c.service_id == self.service_id,)
-        selectable = select(
-            self.jobs_t.c.id, self.jobs_t.c.job_state, self.jobs_t.c.tag
-        ).order_by(self.jobs_t.c.next_run_time).where(and_(*conditions))
+        selectable = (
+            select(
+                self.jobs_t.c.id, self.jobs_t.c.job_state, self.jobs_t.c.tag
+            )
+            .order_by(self.jobs_t.c.next_run_time)
+            .where(and_(*conditions))
+        )
         failed_job_ids = set()
         with self.engine.begin() as conn:
             for row in conn.execute(selectable):
@@ -115,13 +131,15 @@ class WatcherJobStore(sqlalchemy.SQLAlchemyJobStore):
                     jobs.append(self._reconstitute_job(row.job_state))
                 except Exception:
                     self._logger.exception(
-                        'Unable to restore job "%s" -- removing it', row.id)
+                        'Unable to restore job "%s" -- removing it', row.id
+                    )
                     failed_job_ids.add(row.id)
 
         # Remove all the jobs we failed to restore
         if failed_job_ids:
             delete = self.jobs_t.delete().where(
-                self.jobs_t.c.id.in_(failed_job_ids))
+                self.jobs_t.c.id.in_(failed_job_ids)
+            )
             self.engine.execute(delete)
 
         return jobs
diff --git a/watcher/db/sqlalchemy/migration.py b/watcher/db/sqlalchemy/migration.py
index cb9164773..4ed3f50c6 100644
--- a/watcher/db/sqlalchemy/migration.py
+++ b/watcher/db/sqlalchemy/migration.py
@@ -71,8 +71,11 @@ def create_schema(config=None, engine=None):
     #                existing as is. So we should avoid of this situation.
     if version(engine=engine) is not None:
         raise db_exc.DBMigrationError(
-            _("Watcher database schema is already under version control; "
-              "use upgrade() instead"))
+            _(
+                "Watcher database schema is already under version control; "
+                "use upgrade() instead"
+            )
+        )
 
     models.Base.metadata.create_all(engine)
     stamp('head', config=config)
@@ -112,5 +115,6 @@ def revision(message=None, autogenerate=False, config=None):
     :type autogenerate: bool
     """
     config = config or _alembic_config()
-    return alembic.command.revision(config, message=message,
-                                    autogenerate=autogenerate)
+    return alembic.command.revision(
+        config, message=message, autogenerate=autogenerate
+    )
diff --git a/watcher/db/sqlalchemy/models.py b/watcher/db/sqlalchemy/models.py
index fe21241cd..77b1b5c52 100644
--- a/watcher/db/sqlalchemy/models.py
+++ b/watcher/db/sqlalchemy/models.py
@@ -44,8 +44,10 @@ CONF = conf.CONF
 def table_args():
     engine_name = urlparse.urlparse(CONF.database.connection).scheme
     if engine_name == 'mysql':
-        return {'mysql_engine': CONF.database.mysql_engine,
-                'mysql_charset': "utf8"}
+        return {
+            'mysql_engine': CONF.database.mysql_engine,
+            'mysql_charset': "utf8",
+        }
     return None
 
 
@@ -64,7 +66,8 @@ class JsonEncodedType(TypeDecorator):
             raise TypeError(
                 f"{self.__class__.__name__} supposes to store "
                 f"{self.type.__name__} objects, but "
-                f"{type(value).__name__} given")
+                f"{type(value).__name__} given"
+            )
         serialized_value = jsonutils.dumps(value)
         return serialized_value
 
@@ -86,8 +89,9 @@ class JSONEncodedList(JsonEncodedType):
     type = list
 
 
-class WatcherBase(models.SoftDeleteMixin,
-                  models.TimestampMixin, models.ModelBase):
+class WatcherBase(
+    models.SoftDeleteMixin, models.TimestampMixin, models.ModelBase
+):
     metadata = None
 
     def as_dict(self):
@@ -123,7 +127,7 @@ class Strategy(Base):
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_strategies0uuid'),
         UniqueConstraint('name', 'deleted', name='uniq_strategies0name'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True, autoincrement=True)
     uuid = Column(String(36))
@@ -142,7 +146,7 @@ class AuditTemplate(Base):
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_audit_templates0uuid'),
         UniqueConstraint('name', 'deleted', name='uniq_audit_templates0name'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True)
     uuid = Column(String(36))
@@ -163,7 +167,7 @@ class Audit(Base):
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_audits0uuid'),
         UniqueConstraint('name', 'deleted', name='uniq_audits0name'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True, autoincrement=True)
     uuid = Column(String(36))
@@ -193,7 +197,7 @@ class ActionPlan(Base):
     __tablename__ = 'action_plans'
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_action_plans0uuid'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True, autoincrement=True)
     uuid = Column(String(36))
@@ -214,12 +218,13 @@ class Action(Base):
     __tablename__ = 'actions'
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_actions0uuid'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True, autoincrement=True)
     uuid = Column(String(36), nullable=False)
-    action_plan_id = Column(Integer, ForeignKey('action_plans.id'),
-                            nullable=False)
+    action_plan_id = Column(
+        Integer, ForeignKey('action_plans.id'), nullable=False
+    )
     # only for the first version
     action_type = Column(String(255), nullable=False)
     input_parameters = Column(JSONEncodedDict, nullable=True)
@@ -228,7 +233,8 @@ class Action(Base):
     status_message = Column(String(255), nullable=True)
 
     action_plan = orm.relationship(
-        ActionPlan, foreign_keys=action_plan_id, lazy=None)
+        ActionPlan, foreign_keys=action_plan_id, lazy=None
+    )
 
 
 class EfficacyIndicator(Base):
@@ -237,7 +243,7 @@ class EfficacyIndicator(Base):
     __tablename__ = 'efficacy_indicators'
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_efficacy_indicators0uuid'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True, autoincrement=True)
     uuid = Column(String(36))
@@ -248,11 +254,13 @@ class EfficacyIndicator(Base):
     # https://bugs.launchpad.net/watcher/+bug/2103458
     value = Column(Numeric())
     data = Column(Float())
-    action_plan_id = Column(Integer, ForeignKey('action_plans.id'),
-                            nullable=False)
+    action_plan_id = Column(
+        Integer, ForeignKey('action_plans.id'), nullable=False
+    )
 
     action_plan = orm.relationship(
-        ActionPlan, foreign_keys=action_plan_id, lazy=None)
+        ActionPlan, foreign_keys=action_plan_id, lazy=None
+    )
 
 
 class ScoringEngine(Base):
@@ -262,7 +270,7 @@ class ScoringEngine(Base):
     __table_args__ = (
         UniqueConstraint('uuid', name='uniq_scoring_engines0uuid'),
         UniqueConstraint('name', 'deleted', name='uniq_scoring_engines0name'),
-        table_args()
+        table_args(),
     )
     id = Column(Integer, primary_key=True, autoincrement=True)
     uuid = Column(String(36), nullable=False)
@@ -279,9 +287,10 @@ class Service(Base):
 
     __tablename__ = 'services'
     __table_args__ = (
-        UniqueConstraint('host', 'name', 'deleted',
-                         name="uniq_services0host0name0deleted"),
-        table_args()
+        UniqueConstraint(
+            'host', 'name', 'deleted', name="uniq_services0host0name0deleted"
+        ),
+        table_args(),
     )
     id = Column(Integer, primary_key=True)
     name = Column(String(255), nullable=False)
@@ -294,9 +303,10 @@ class ActionDescription(Base):
 
     __tablename__ = 'action_descriptions'
     __table_args__ = (
-        UniqueConstraint('action_type',
-                         name="uniq_action_description0action_type"),
-        table_args()
+        UniqueConstraint(
+            'action_type', name="uniq_action_description0action_type"
+        ),
+        table_args(),
     )
     id = Column(Integer, primary_key=True)
     action_type = Column(String(255), nullable=False)
@@ -308,16 +318,13 @@ class APScheulerJob(Base):
 
     __tablename__ = 'apscheduler_jobs'
     __table_args__ = (
-        UniqueConstraint('id',
-                         name="uniq_apscheduler_jobs0id"),
-        table_args()
+        UniqueConstraint('id', name="uniq_apscheduler_jobs0id"),
+        table_args(),
     )
     id = Column(String(191), nullable=False, primary_key=True)
     next_run_time = Column(Float(25), index=True)
     job_state = Column(LargeBinary, nullable=False)
     tag = Column(JSONEncodedDict(), nullable=True)
-    service_id = Column(Integer, ForeignKey('services.id'),
-                        nullable=False)
+    service_id = Column(Integer, ForeignKey('services.id'), nullable=False)
 
-    service = orm.relationship(
-        Service, foreign_keys=service_id, lazy=None)
+    service = orm.relationship(Service, foreign_keys=service_id, lazy=None)
diff --git a/watcher/decision_engine/audit/base.py b/watcher/decision_engine/audit/base.py
index 53029c790..a41387b74 100644
--- a/watcher/decision_engine/audit/base.py
+++ b/watcher/decision_engine/audit/base.py
@@ -40,7 +40,6 @@ class BaseMetaClass(service.Singleton, abc.ABCMeta):
 
 
 class BaseAuditHandler(metaclass=BaseMetaClass):
-
     @abc.abstractmethod
     def execute(self, audit, request_context):
         raise NotImplementedError()
@@ -59,7 +58,6 @@ class BaseAuditHandler(metaclass=BaseMetaClass):
 
 
 class AuditHandler(BaseAuditHandler, metaclass=abc.ABCMeta):
-
     def __init__(self):
         super().__init__()
         self._strategy_context = default_context.DefaultStrategyContext()
@@ -81,29 +79,36 @@ class AuditHandler(BaseAuditHandler, metaclass=abc.ABCMeta):
     def do_execute(self, audit, request_context):
         # execute the strategy
         solution = self.strategy_context.execute_strategy(
-            audit, request_context)
+            audit, request_context
+        )
 
         return solution
 
     def do_schedule(self, request_context, audit, solution):
         try:
             notifications.audit.send_action_notification(
-                request_context, audit,
+                request_context,
+                audit,
                 action=fields.NotificationAction.PLANNER,
-                phase=fields.NotificationPhase.START)
+                phase=fields.NotificationPhase.START,
+            )
             planner = self.get_planner(solution)
             action_plan = planner.schedule(request_context, audit.id, solution)
             notifications.audit.send_action_notification(
-                request_context, audit,
+                request_context,
+                audit,
                 action=fields.NotificationAction.PLANNER,
-                phase=fields.NotificationPhase.END)
+                phase=fields.NotificationPhase.END,
+            )
             return action_plan
         except Exception:
             notifications.audit.send_action_notification(
-                request_context, audit,
+                request_context,
+                audit,
                 action=fields.NotificationAction.PLANNER,
                 priority=fields.NotificationPriority.ERROR,
-                phase=fields.NotificationPhase.ERROR)
+                phase=fields.NotificationPhase.ERROR,
+            )
             raise
 
     @staticmethod
@@ -117,10 +122,12 @@ class AuditHandler(BaseAuditHandler, metaclass=abc.ABCMeta):
     def check_ongoing_action_plans(request_context):
         a_plan_filters = {'state': objects.action_plan.State.ONGOING}
         ongoing_action_plans = objects.ActionPlan.list(
-            request_context, filters=a_plan_filters)
+            request_context, filters=a_plan_filters
+        )
         if ongoing_action_plans:
             raise exception.ActionPlanIsOngoing(
-                action_plan=ongoing_action_plans[0].uuid)
+                action_plan=ongoing_action_plans[0].uuid
+            )
 
     def pre_execute(self, audit, request_context):
         LOG.debug("Trigger audit %s", audit.uuid)
@@ -131,7 +138,8 @@ class AuditHandler(BaseAuditHandler, metaclass=abc.ABCMeta):
         # check current state of the audit right before moving to ONGOING
         # to avoid race conditions
         audit = objects.Audit.get_by_uuid(
-            request_context, audit.uuid, eager=True)
+            request_context, audit.uuid, eager=True
+        )
         if audit.state == objects.audit.State.CANCELLED:
             raise exception.AuditCancelled(uuid=audit.uuid)
         # Write hostname that will execute this audit.
@@ -142,8 +150,9 @@ class AuditHandler(BaseAuditHandler, metaclass=abc.ABCMeta):
     def post_execute(self, audit, solution, request_context):
         action_plan = self.do_schedule(request_context, audit, solution)
         if audit.auto_trigger:
-            self.applier_client.launch_action_plan(request_context,
-                                                   action_plan.uuid)
+            self.applier_client.launch_action_plan(
+                request_context, action_plan.uuid
+            )
 
     def execute(self, audit, request_context):
         try:
diff --git a/watcher/decision_engine/audit/continuous.py b/watcher/decision_engine/audit/continuous.py
index c2eb88b57..846ae298d 100644
--- a/watcher/decision_engine/audit/continuous.py
+++ b/watcher/decision_engine/audit/continuous.py
@@ -44,8 +44,9 @@ class ContinuousAuditHandler(base.AuditHandler):
         self._audit_scheduler = None
         # scheduler for a periodic task to launch audit
         self._period_scheduler = None
-        self.context_show_deleted = context.RequestContext(is_admin=True,
-                                                           show_deleted=True)
+        self.context_show_deleted = context.RequestContext(
+            is_admin=True, show_deleted=True
+        )
 
     @property
     def scheduler(self):
@@ -53,7 +54,8 @@ class ContinuousAuditHandler(base.AuditHandler):
             self._audit_scheduler = scheduling.BackgroundSchedulerService(
                 jobstores={
                     'default': job_store.WatcherJobStore(
-                        engine=sq_api.enginefacade.writer.get_engine()),
+                        engine=sq_api.enginefacade.writer.get_engine()
+                    )
                 }
             )
         return self._audit_scheduler
@@ -66,15 +68,21 @@ class ContinuousAuditHandler(base.AuditHandler):
 
     def _is_audit_inactive(self, audit):
         audit = objects.Audit.get_by_uuid(
-            self.context_show_deleted, audit.uuid, eager=True)
-        if (objects.audit.AuditStateTransitionManager().is_inactive(audit) or
-                (audit.hostname != CONF.host) or
-                (self.check_audit_expired(audit))):
+            self.context_show_deleted, audit.uuid, eager=True
+        )
+        if (
+            objects.audit.AuditStateTransitionManager().is_inactive(audit)
+            or (audit.hostname != CONF.host)
+            or (self.check_audit_expired(audit))
+        ):
             # if audit isn't in active states, audit's job must be removed to
             # prevent using of inactive audit in future.
-            jobs = [job for job in self.scheduler.get_jobs()
-                    if job.name == 'execute_audit' and
-                    job.args[0].uuid == audit.uuid]
+            jobs = [
+                job
+                for job in self.scheduler.get_jobs()
+                if job.name == 'execute_audit'
+                and job.args[0].uuid == audit.uuid
+            ]
             if jobs:
                 jobs[0].remove()
             return True
@@ -82,14 +90,16 @@ class ContinuousAuditHandler(base.AuditHandler):
         return False
 
     def do_execute(self, audit, request_context):
-        solution = super()\
-            .do_execute(audit, request_context)
+        solution = super().do_execute(audit, request_context)
 
         if audit.audit_type == objects.audit.AuditType.CONTINUOUS.value:
-            a_plan_filters = {'audit_uuid': audit.uuid,
-                              'state': objects.action_plan.State.RECOMMENDED}
+            a_plan_filters = {
+                'audit_uuid': audit.uuid,
+                'state': objects.action_plan.State.RECOMMENDED,
+            }
             action_plans = objects.ActionPlan.list(
-                request_context, filters=a_plan_filters, eager=True)
+                request_context, filters=a_plan_filters, eager=True
+            )
             for plan in action_plans:
                 plan.state = objects.action_plan.State.CANCELLED
                 plan.save()
@@ -98,8 +108,9 @@ class ContinuousAuditHandler(base.AuditHandler):
     @staticmethod
     def _next_cron_time(audit):
         if utils.is_cron_like(audit.interval):
-            return croniter(audit.interval, timeutils.utcnow()
-                            ).get_next(datetime.datetime)
+            return croniter(audit.interval, timeutils.utcnow()).get_next(
+                datetime.datetime
+            )
 
     @classmethod
     def execute_audit(cls, audit, request_context):
@@ -112,22 +123,33 @@ class ContinuousAuditHandler(base.AuditHandler):
             finally:
                 if utils.is_int_like(audit.interval):
                     audit.next_run_time = (
-                        timeutils.utcnow() +
-                        datetime.timedelta(seconds=int(audit.interval)))
+                        timeutils.utcnow()
+                        + datetime.timedelta(seconds=int(audit.interval))
+                    )
                 else:
                     audit.next_run_time = self._next_cron_time(audit)
                 audit.save()
 
     def _add_job(self, trigger, audit, audit_context, **trigger_args):
-        time_var = 'next_run_time' if trigger_args.get(
-            'next_run_time') else 'run_date'
+        time_var = (
+            'next_run_time'
+            if trigger_args.get('next_run_time')
+            else 'run_date'
+        )
         # We should convert UTC time to local time without tzinfo
-        trigger_args[time_var] = trigger_args[time_var].replace(
-            tzinfo=timezone.utc).astimezone().replace(tzinfo=None)
-        self.scheduler.add_job(self.execute_audit, trigger,
-                               args=[audit, audit_context],
-                               name='execute_audit',
-                               **trigger_args)
+        trigger_args[time_var] = (
+            trigger_args[time_var]
+            .replace(tzinfo=timezone.utc)
+            .astimezone()
+            .replace(tzinfo=None)
+        )
+        self.scheduler.add_job(
+            self.execute_audit,
+            trigger,
+            args=[audit, audit_context],
+            name='execute_audit',
+            **trigger_args,
+        )
 
     def check_audit_expired(self, audit):
         current = timeutils.utcnow()
@@ -151,12 +173,15 @@ class ContinuousAuditHandler(base.AuditHandler):
         audit_context = context.RequestContext(is_admin=True)
         audit_filters = {
             'audit_type': objects.audit.AuditType.CONTINUOUS.value,
-            'state__in': (objects.audit.State.PENDING,
-                          objects.audit.State.ONGOING),
+            'state__in': (
+                objects.audit.State.PENDING,
+                objects.audit.State.ONGOING,
+            ),
         }
         audit_filters['hostname'] = None
         unscheduled_audits = objects.Audit.list(
-            audit_context, filters=audit_filters, eager=True)
+            audit_context, filters=audit_filters, eager=True
+        )
         for audit in unscheduled_audits:
             # If continuous audit doesn't have a hostname yet,
             # Watcher will set current CONF.host value.
@@ -164,9 +189,10 @@ class ContinuousAuditHandler(base.AuditHandler):
             audit.hostname = CONF.host
             audit.save()
         scheduler_job_args = [
-            (job.args[0].uuid, job) for job
-            in self.scheduler.get_jobs()
-            if job.name == 'execute_audit']
+            (job.args[0].uuid, job)
+            for job in self.scheduler.get_jobs()
+            if job.name == 'execute_audit'
+        ]
         scheduler_jobs = dict(scheduler_job_args)
         # if audit isn't in active states, audit's job should be removed
         jobs_to_remove = []
@@ -177,7 +203,8 @@ class ContinuousAuditHandler(base.AuditHandler):
             scheduler_jobs.pop(audit_uuid)
         audit_filters['hostname'] = CONF.host
         audits = objects.Audit.list(
-            audit_context, filters=audit_filters, eager=True)
+            audit_context, filters=audit_filters, eager=True
+        )
         for audit in audits:
             if self.check_audit_expired(audit):
                 continue
@@ -187,8 +214,9 @@ class ContinuousAuditHandler(base.AuditHandler):
             # if audit is already in the job queue, and interval has changed,
             # we need to remove the old job and add a new one.
             if (existing_job is None) or (
-                existing_job and
-                    audit.interval != existing_job.args[0].interval):
+                existing_job
+                and audit.interval != existing_job.args[0].interval
+            ):
                 if existing_job:
                     self.scheduler.remove_job(existing_job.id)
                 # if interval is provided with seconds
@@ -200,22 +228,33 @@ class ContinuousAuditHandler(base.AuditHandler):
                         current = timeutils.utcnow()
                         if old_run_time < current:
                             delta = datetime.timedelta(
-                                seconds=(int(audit.interval) - (
-                                    current - old_run_time).seconds %
-                                    int(audit.interval)))
+                                seconds=(
+                                    int(audit.interval)
+                                    - (current - old_run_time).seconds
+                                    % int(audit.interval)
+                                )
+                            )
                             audit.next_run_time = current + delta
                         next_run_time = audit.next_run_time
                     # if audit is new one
                     else:
                         next_run_time = timeutils.utcnow()
-                    self._add_job('interval', audit, audit_context,
-                                  seconds=int(audit.interval),
-                                  next_run_time=next_run_time)
+                    self._add_job(
+                        'interval',
+                        audit,
+                        audit_context,
+                        seconds=int(audit.interval),
+                        next_run_time=next_run_time,
+                    )
 
                 else:
                     audit.next_run_time = self._next_cron_time(audit)
-                    self._add_job('date', audit, audit_context,
-                                  run_date=audit.next_run_time)
+                    self._add_job(
+                        'date',
+                        audit,
+                        audit_context,
+                        run_date=audit.next_run_time,
+                    )
                 audit.hostname = CONF.host
                 audit.save()
 
@@ -224,7 +263,8 @@ class ContinuousAuditHandler(base.AuditHandler):
             self.launch_audits_periodically,
             'interval',
             seconds=CONF.watcher_decision_engine.continuous_audit_interval,
-            next_run_time=datetime.datetime.now())
+            next_run_time=datetime.datetime.now(),
+        )
         self.period_scheduler.start()
         # audit scheduler start
         self.scheduler.start()
diff --git a/watcher/decision_engine/audit/event.py b/watcher/decision_engine/audit/event.py
index 9fccb461d..cda642c04 100644
--- a/watcher/decision_engine/audit/event.py
+++ b/watcher/decision_engine/audit/event.py
@@ -18,9 +18,7 @@ from watcher.decision_engine.audit import base
 
 
 class EventAuditHandler(base.AuditHandler):
-
     def post_execute(self, audit, solution, request_context):
-        super().post_execute(audit, solution,
-                             request_context)
+        super().post_execute(audit, solution, request_context)
         # change state of the audit to SUCCEEDED
         self.update_audit_state(audit, objects.audit.State.SUCCEEDED)
diff --git a/watcher/decision_engine/audit/oneshot.py b/watcher/decision_engine/audit/oneshot.py
index 35fc75b48..34338bf51 100644
--- a/watcher/decision_engine/audit/oneshot.py
+++ b/watcher/decision_engine/audit/oneshot.py
@@ -18,9 +18,7 @@ from watcher.decision_engine.audit import base
 
 
 class OneShotAuditHandler(base.AuditHandler):
-
     def post_execute(self, audit, solution, request_context):
-        super().post_execute(audit, solution,
-                             request_context)
+        super().post_execute(audit, solution, request_context)
         # change state of the audit to SUCCEEDED
         self.update_audit_state(audit, objects.audit.State.SUCCEEDED)
diff --git a/watcher/decision_engine/datasources/aetos.py b/watcher/decision_engine/datasources/aetos.py
index a20e98428..4322a66d7 100644
--- a/watcher/decision_engine/datasources/aetos.py
+++ b/watcher/decision_engine/datasources/aetos.py
@@ -57,9 +57,11 @@ class AetosHelper(prometheus_base.PrometheusBase):
         # Get Keystone session from OpenStackClients
         session = self.osc.session
 
-        opts = {'interface': CONF.aetos_client.interface,
-                'region_name': CONF.aetos_client.region_name,
-                'service_type': 'metric-storage'}
+        opts = {
+            'interface': CONF.aetos_client.interface,
+            'region_name': CONF.aetos_client.region_name,
+            'service_type': 'metric-storage',
+        }
 
         the_client = obs_client_utils.get_prom_client_from_keystone(
             session, adapter_options=opts
diff --git a/watcher/decision_engine/datasources/base.py b/watcher/decision_engine/datasources/base.py
index 9a47c84b6..026543642 100644
--- a/watcher/decision_engine/datasources/base.py
+++ b/watcher/decision_engine/datasources/base.py
@@ -43,18 +43,19 @@ class DataSourceBase:
     NAME = ''
 
     """Possible metrics a datasource can support and their internal name"""
-    METRIC_MAP = dict(host_cpu_usage=None,
-                      host_ram_usage=None,
-                      host_outlet_temp=None,
-                      host_inlet_temp=None,
-                      host_airflow=None,
-                      host_power=None,
-                      instance_cpu_usage=None,
-                      instance_ram_usage=None,
-                      instance_ram_allocated=None,
-                      instance_l3_cache_usage=None,
-                      instance_root_disk_size=None,
-                      )
+    METRIC_MAP = dict(
+        host_cpu_usage=None,
+        host_ram_usage=None,
+        host_outlet_temp=None,
+        host_inlet_temp=None,
+        host_airflow=None,
+        host_power=None,
+        instance_cpu_usage=None,
+        instance_ram_usage=None,
+        instance_ram_allocated=None,
+        instance_l3_cache_usage=None,
+        instance_root_disk_size=None,
+    )
 
     def _get_meter(self, meter_name):
         """Retrieve the meter from the metric map or raise error"""
@@ -85,14 +86,20 @@ class DataSourceBase:
             try:
                 return f(*args, **kwargs)
             except ignored_exc as e:
-                LOG.debug("Got an ignored exception (%s) while calling: %s ",
-                          e, f)
+                LOG.debug(
+                    "Got an ignored exception (%s) while calling: %s ", e, f
+                )
                 return
             except Exception as e:
                 LOG.exception(e)
                 self.query_retry_reset(e)
-                LOG.warning("Retry %d of %d while retrieving metrics retry "
-                            "in %d seconds", i+1, num_retries, interval)
+                LOG.warning(
+                    "Retry %d of %d while retrieving metrics retry "
+                    "in %d seconds",
+                    i + 1,
+                    num_retries,
+                    interval,
+                )
                 time.sleep(interval)
 
     @abc.abstractmethod
@@ -117,9 +124,15 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def statistic_aggregation(self, resource=None, resource_type=None,
-                              meter_name=None, period=300, aggregate='mean',
-                              granularity=300):
+    def statistic_aggregation(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=300,
+        aggregate='mean',
+        granularity=300,
+    ):
         """Retrieves and converts metrics based on the specified parameters
 
         :param resource: Resource object as defined in watcher models such as
@@ -140,9 +153,15 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def statistic_series(self, resource=None, resource_type=None,
-                         meter_name=None, start_time=None, end_time=None,
-                         granularity=300):
+    def statistic_series(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        start_time=None,
+        end_time=None,
+        granularity=300,
+    ):
         """Retrieves metrics based on the specified parameters over a period
 
         :param resource: Resource object as defined in watcher models such as
@@ -164,8 +183,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_host_cpu_usage(self, resource, period, aggregate,
-                           granularity=None):
+    def get_host_cpu_usage(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the cpu usage for a host such as a compute_node
 
         :return: cpu usage as float ranging between 0 and 100 representing the
@@ -174,8 +194,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_host_ram_usage(self, resource, period, aggregate,
-                           granularity=None):
+    def get_host_ram_usage(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the ram usage for a host such as a compute_node
 
         :return: ram usage as float in kibibytes
@@ -183,8 +204,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_host_outlet_temp(self, resource, period, aggregate,
-                             granularity=None):
+    def get_host_outlet_temp(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the outlet temperature for a host such as compute_node
 
         :return: outlet temperature as float in degrees celsius
@@ -192,8 +214,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_host_inlet_temp(self, resource, period, aggregate,
-                            granularity=None):
+    def get_host_inlet_temp(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the inlet temperature for a host such as compute_node
 
         :return: inlet temperature as float in degrees celsius
@@ -201,8 +224,7 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_host_airflow(self, resource, period, aggregate,
-                         granularity=None):
+    def get_host_airflow(self, resource, period, aggregate, granularity=None):
         """Get the airflow for a host such as compute_node
 
         :return: airflow as float in cfm
@@ -210,8 +232,7 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_host_power(self, resource, period, aggregate,
-                       granularity=None):
+    def get_host_power(self, resource, period, aggregate, granularity=None):
         """Get the power for a host such as compute_node
 
         :return: power as float in watts
@@ -219,8 +240,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_instance_cpu_usage(self, resource, period,
-                               aggregate, granularity=None):
+    def get_instance_cpu_usage(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the cpu usage for an instance
 
         :return: cpu usage as float ranging between 0 and 100 representing the
@@ -229,8 +251,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_instance_ram_usage(self, resource, period,
-                               aggregate, granularity=None):
+    def get_instance_ram_usage(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the ram usage for an instance
 
         :return: ram usage as float in megabytes
@@ -238,8 +261,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_instance_ram_allocated(self, resource, period,
-                                   aggregate, granularity=None):
+    def get_instance_ram_allocated(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the ram allocated for an instance
 
         :return: total ram allocated as float in megabytes
@@ -247,8 +271,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_instance_l3_cache_usage(self, resource, period,
-                                    aggregate, granularity=None):
+    def get_instance_l3_cache_usage(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the l3 cache usage for an instance
 
         :return: l3 cache usage as integer in bytes
@@ -256,8 +281,9 @@ class DataSourceBase:
         pass
 
     @abc.abstractmethod
-    def get_instance_root_disk_size(self, resource, period,
-                                    aggregate, granularity=None):
+    def get_instance_root_disk_size(
+        self, resource, period, aggregate, granularity=None
+    ):
         """Get the size of the root disk for an instance
 
         :return: root disk size as float in gigabytes
diff --git a/watcher/decision_engine/datasources/gnocchi.py b/watcher/decision_engine/datasources/gnocchi.py
index 9145d084b..4fa384c05 100644
--- a/watcher/decision_engine/datasources/gnocchi.py
+++ b/watcher/decision_engine/datasources/gnocchi.py
@@ -31,20 +31,20 @@ LOG = log.getLogger(__name__)
 
 
 class GnocchiHelper(base.DataSourceBase):
-
     NAME = 'gnocchi'
-    METRIC_MAP = dict(host_cpu_usage='compute.node.cpu.percent',
-                      host_ram_usage='hardware.memory.used',
-                      host_outlet_temp='hardware.ipmi.node.outlet_temperature',
-                      host_inlet_temp='hardware.ipmi.node.temperature',
-                      host_airflow='hardware.ipmi.node.airflow',
-                      host_power='hardware.ipmi.node.power',
-                      instance_cpu_usage='cpu',
-                      instance_ram_usage='memory.resident',
-                      instance_ram_allocated='memory',
-                      instance_l3_cache_usage='cpu_l3_cache',
-                      instance_root_disk_size='disk.root.size',
-                      )
+    METRIC_MAP = dict(
+        host_cpu_usage='compute.node.cpu.percent',
+        host_ram_usage='hardware.memory.used',
+        host_outlet_temp='hardware.ipmi.node.outlet_temperature',
+        host_inlet_temp='hardware.ipmi.node.temperature',
+        host_airflow='hardware.ipmi.node.airflow',
+        host_power='hardware.ipmi.node.power',
+        instance_cpu_usage='cpu',
+        instance_ram_usage='memory.resident',
+        instance_ram_allocated='memory',
+        instance_l3_cache_usage='cpu_l3_cache',
+        instance_root_disk_size='disk.root.size',
+    )
 
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
@@ -66,9 +66,15 @@ class GnocchiHelper(base.DataSourceBase):
         else:
             return {metric['name'] for metric in response}
 
-    def statistic_aggregation(self, resource=None, resource_type=None,
-                              meter_name=None, period=300, aggregate='mean',
-                              granularity=300):
+    def statistic_aggregation(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=300,
+        aggregate='mean',
+        granularity=300,
+    ):
         stop_time = timeutils.utcnow()
         start_time = stop_time - timedelta(seconds=(int(period)))
 
@@ -76,40 +82,52 @@ class GnocchiHelper(base.DataSourceBase):
 
         if aggregate == 'count':
             aggregate = 'mean'
-            LOG.warning('aggregate type count not supported by gnocchi,'
-                        ' replaced with mean.')
+            LOG.warning(
+                'aggregate type count not supported by gnocchi,'
+                ' replaced with mean.'
+            )
 
         resource_id = resource.uuid
         if resource_type == 'compute_node':
             resource_id = resource.hostname + "_" + resource.hostname
-            kwargs = dict(query={"=": {"original_resource_id": resource_id}},
-                          limit=1)
+            kwargs = dict(
+                query={"=": {"original_resource_id": resource_id}}, limit=1
+            )
             resources = self.query_retry(
                 f=self.gnocchi.resource.search,
                 ignored_exc=gnc_exc.NotFound,
-                **kwargs)
+                **kwargs,
+            )
 
             if not resources:
-                LOG.warning("The %s resource %s could not be found",
-                            self.NAME, resource_id)
+                LOG.warning(
+                    "The %s resource %s could not be found",
+                    self.NAME,
+                    resource_id,
+                )
                 return
 
             resource_id = resources[0]['id']
 
         if meter_name == "instance_cpu_usage":
             if resource_type != "instance":
-                LOG.warning("Unsupported resource type for metric "
-                            "'instance_cpu_usage': %s", resource_type)
+                LOG.warning(
+                    "Unsupported resource type for metric "
+                    "'instance_cpu_usage': %s",
+                    resource_type,
+                )
                 return
 
             # The "cpu_util" gauge (percentage) metric has been removed.
             # We're going to obtain the same result by using the rate of change
             # aggregate operation.
             if aggregate not in ("mean", "rate:mean"):
-                LOG.warning("Unsupported aggregate for instance_cpu_usage "
-                            "metric: %s. "
-                            "Supported aggregates: mean, rate:mean ",
-                            aggregate)
+                LOG.warning(
+                    "Unsupported aggregate for instance_cpu_usage "
+                    "metric: %s. "
+                    "Supported aggregates: mean, rate:mean ",
+                    aggregate,
+                )
                 return
 
             # TODO(lpetrut): consider supporting other aggregates.
@@ -129,7 +147,8 @@ class GnocchiHelper(base.DataSourceBase):
         statistics = self.query_retry(
             f=self.gnocchi.metric.get_measures,
             ignored_exc=gnc_exc.NotFound,
-            **kwargs)
+            **kwargs,
+        )
 
         return_value = None
         if statistics:
@@ -151,29 +170,39 @@ class GnocchiHelper(base.DataSourceBase):
                 if not vcpus:
                     LOG.warning("instance vcpu count not set, assuming 1")
                     vcpus = 1
-                return_value *= 100 / (granularity * 10e+8) / vcpus
+                return_value *= 100 / (granularity * 10e8) / vcpus
 
         return return_value
 
-    def statistic_series(self, resource=None, resource_type=None,
-                         meter_name=None, start_time=None, end_time=None,
-                         granularity=300):
-
+    def statistic_series(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        start_time=None,
+        end_time=None,
+        granularity=300,
+    ):
         meter = self._get_meter(meter_name)
 
         resource_id = resource.uuid
         if resource_type == 'compute_node':
             resource_id = resource.hostname + "_" + resource.hostname
-            kwargs = dict(query={"=": {"original_resource_id": resource_id}},
-                          limit=1)
+            kwargs = dict(
+                query={"=": {"original_resource_id": resource_id}}, limit=1
+            )
             resources = self.query_retry(
                 f=self.gnocchi.resource.search,
                 ignored_exc=gnc_exc.NotFound,
-                **kwargs)
+                **kwargs,
+            )
 
             if not resources:
-                LOG.warning("The %s resource %s could not be found",
-                            self.NAME, resource_id)
+                LOG.warning(
+                    "The %s resource %s could not be found",
+                    self.NAME,
+                    resource_id,
+                )
                 return
 
             resource_id = resources[0]['id']
@@ -191,7 +220,8 @@ class GnocchiHelper(base.DataSourceBase):
         statistics = self.query_retry(
             f=self.gnocchi.metric.get_measures,
             ignored_exc=gnc_exc.NotFound,
-            **kwargs)
+            **kwargs,
+        )
 
         return_value = None
         if statistics:
@@ -199,85 +229,132 @@ class GnocchiHelper(base.DataSourceBase):
             if meter_name == 'host_airflow':
                 # Airflow from hardware.ipmi.node.airflow is reported as
                 # 1/10 th of actual CFM
-                return_value = {s[0]: s[2]*10 for s in statistics}
+                return_value = {s[0]: s[2] * 10 for s in statistics}
             else:
                 return_value = {s[0]: s[2] for s in statistics}
 
         return return_value
 
-    def get_host_cpu_usage(self, resource, period, aggregate,
-                           granularity=300):
-
+    def get_host_cpu_usage(self, resource, period, aggregate, granularity=300):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_cpu_usage', period,
-            aggregate, granularity)
-
-    def get_host_ram_usage(self, resource, period, aggregate,
-                           granularity=300):
+            resource,
+            'compute_node',
+            'host_cpu_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_host_ram_usage(self, resource, period, aggregate, granularity=300):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_ram_usage', period,
-            aggregate, granularity)
-
-    def get_host_outlet_temp(self, resource, period, aggregate,
-                             granularity=300):
+            resource,
+            'compute_node',
+            'host_ram_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_host_outlet_temp(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_outlet_temp', period,
-            aggregate, granularity)
-
-    def get_host_inlet_temp(self, resource, period, aggregate,
-                            granularity=300):
+            resource,
+            'compute_node',
+            'host_outlet_temp',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_host_inlet_temp(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_inlet_temp', period,
-            aggregate, granularity)
-
-    def get_host_airflow(self, resource, period, aggregate,
-                         granularity=300):
+            resource,
+            'compute_node',
+            'host_inlet_temp',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_host_airflow(self, resource, period, aggregate, granularity=300):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_airflow', period,
-            aggregate, granularity)
-
-    def get_host_power(self, resource, period, aggregate,
-                       granularity=300):
+            resource,
+            'compute_node',
+            'host_airflow',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_host_power(self, resource, period, aggregate, granularity=300):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_power', period,
-            aggregate, granularity)
-
-    def get_instance_cpu_usage(self, resource, period, aggregate,
-                               granularity=300):
+            resource,
+            'compute_node',
+            'host_power',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_instance_cpu_usage(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_cpu_usage', period,
-            aggregate, granularity)
-
-    def get_instance_ram_usage(self, resource, period, aggregate,
-                               granularity=300):
+            resource,
+            'instance',
+            'instance_cpu_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_instance_ram_usage(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_ram_usage', period,
-            aggregate, granularity)
-
-    def get_instance_ram_allocated(self, resource, period, aggregate,
-                                   granularity=300):
+            resource,
+            'instance',
+            'instance_ram_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_instance_ram_allocated(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_ram_allocated', period,
-            aggregate, granularity)
-
-    def get_instance_l3_cache_usage(self, resource, period, aggregate,
-                                    granularity=300):
+            resource,
+            'instance',
+            'instance_ram_allocated',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_instance_l3_cache_usage(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_l3_cache_usage', period,
-            aggregate, granularity)
-
-    def get_instance_root_disk_size(self, resource, period, aggregate,
-                                    granularity=300):
+            resource,
+            'instance',
+            'instance_l3_cache_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
+    def get_instance_root_disk_size(
+        self, resource, period, aggregate, granularity=300
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_root_disk_size', period,
-            aggregate, granularity)
+            resource,
+            'instance',
+            'instance_root_disk_size',
+            period,
+            aggregate,
+            granularity,
+        )
diff --git a/watcher/decision_engine/datasources/grafana.py b/watcher/decision_engine/datasources/grafana.py
index 495abb36a..93ba4d9a7 100644
--- a/watcher/decision_engine/datasources/grafana.py
+++ b/watcher/decision_engine/datasources/grafana.py
@@ -35,16 +35,13 @@ LOG = log.getLogger(__name__)
 
 
 class GrafanaHelper(base.DataSourceBase):
-
     NAME = 'grafana'
 
     """METRIC_MAP is only available at runtime _build_metric_map"""
     METRIC_MAP = dict()
 
     """All available translators"""
-    TRANSLATOR_LIST = [
-        influxdb.InfluxDBGrafanaTranslator.NAME
-    ]
+    TRANSLATOR_LIST = [influxdb.InfluxDBGrafanaTranslator.NAME]
 
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
@@ -63,20 +60,25 @@ class GrafanaHelper(base.DataSourceBase):
         if not token:
             LOG.critical("GrafanaHelper authentication token not configured")
             return
-        self._headers = {"Authorization": "Bearer " + token,
-                         "Content-Type": "Application/json"}
+        self._headers = {
+            "Authorization": "Bearer " + token,
+            "Content-Type": "Application/json",
+        }
 
         if not base_url:
-            LOG.critical("GrafanaHelper url not properly configured, "
-                         "check base_url")
+            LOG.critical(
+                "GrafanaHelper url not properly configured, check base_url"
+            )
             return
         self._base_url = base_url
 
         # Very basic url parsing
         parse = urlparse.urlparse(self._base_url)
         if parse.scheme == '' or parse.netloc == '' or parse.path == '':
-            LOG.critical("GrafanaHelper url not properly configured, "
-                         "check base_url and project_id")
+            LOG.critical(
+                "GrafanaHelper url not properly configured, "
+                "check base_url and project_id"
+            )
             return
 
         self._build_metric_map()
@@ -95,29 +97,47 @@ class GrafanaHelper(base.DataSourceBase):
                 attribute = CONF.grafana_client.attribute_map[key]
                 translator = CONF.grafana_client.translator_map[key]
                 query = CONF.grafana_client.query_map[key]
-                if project is not None and \
-                   value is not None and\
-                   translator in self.TRANSLATOR_LIST and\
-                   query is not None:
+                if (
+                    project is not None
+                    and value is not None
+                    and translator in self.TRANSLATOR_LIST
+                    and query is not None
+                ):
                     self.METRIC_MAP[key] = {
                         'db': value,
                         'project': project,
                         'attribute': attribute,
                         'translator': translator,
-                        'query': query
+                        'query': query,
                     }
             except KeyError as e:
                 LOG.error(e)
 
-    def _build_translator_schema(self, metric, db, attribute, query, resource,
-                                 resource_type, period, aggregate,
-                                 granularity):
+    def _build_translator_schema(
+        self,
+        metric,
+        db,
+        attribute,
+        query,
+        resource,
+        resource_type,
+        period,
+        aggregate,
+        granularity,
+    ):
         """Create dictionary to pass to grafana proxy translators"""
 
-        return {'metric': metric, 'db': db, 'attribute': attribute,
-                'query': query, 'resource': resource,
-                'resource_type': resource_type, 'period': period,
-                'aggregate': aggregate, 'granularity': granularity}
+        return {
+            'metric': metric,
+            'db': db,
+            'attribute': attribute,
+            'query': query,
+            'resource': resource,
+            'resource_type': resource_type,
+            'period': period,
+            'aggregate': aggregate,
+            'granularity': granularity,
+        }
 
     def _get_translator(self, name, data):
         """Use the names of translators to get the translator for the metric"""
@@ -125,7 +145,8 @@ class GrafanaHelper(base.DataSourceBase):
             return influxdb.InfluxDBGrafanaTranslator(data)
         else:
             raise exception.InvalidParameter(
-                parameter='name', parameter_type='grafana translator')
+                parameter='name', parameter_type='grafana translator'
+            )
 
     def _request(self, params, project_id):
         """Make the request to the endpoint to retrieve data
@@ -136,9 +157,12 @@ class GrafanaHelper(base.DataSourceBase):
         if self.configured is False:
             raise exception.DataSourceNotAvailable(self.NAME)
 
-        resp = requests.get(self._base_url + str(project_id) + '/query',
-                            params=params, headers=self._headers,
-                            timeout=CONF.grafana_client.http_timeout)
+        resp = requests.get(
+            self._base_url + str(project_id) + '/query',
+            params=params,
+            headers=self._headers,
+            timeout=CONF.grafana_client.http_timeout,
+        )
         if resp.status_code == HTTPStatus.OK:
             return resp
         elif resp.status_code == HTTPStatus.BAD_REQUEST:
@@ -147,19 +171,24 @@ class GrafanaHelper(base.DataSourceBase):
             LOG.error("Authorization token is invalid")
         raise exception.DataSourceNotAvailable(self.NAME)
 
-    def statistic_aggregation(self, resource=None, resource_type=None,
-                              meter_name=None, period=300, aggregate='mean',
-                              granularity=300):
-        """Get the value for the specific metric based on specified parameters
-
-        """
+    def statistic_aggregation(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=300,
+        aggregate='mean',
+        granularity=300,
+    ):
+        """Get the metric value based on specified parameters."""
 
         try:
             self.METRIC_MAP[meter_name]
         except KeyError:
             LOG.error(
                 "Metric: %s does not appear in the current Grafana metric map",
-                meter_name)
+                meter_name,
+            )
             raise exception.MetricNotAvailable(metric=meter_name)
 
         db = self.METRIC_MAP[meter_name]['db']
@@ -169,17 +198,22 @@ class GrafanaHelper(base.DataSourceBase):
         query = self.METRIC_MAP[meter_name]['query']
 
         data = self._build_translator_schema(
-            meter_name, db, attribute, query, resource, resource_type, period,
-            aggregate, granularity)
+            meter_name,
+            db,
+            attribute,
+            query,
+            resource,
+            resource_type,
+            period,
+            aggregate,
+            granularity,
+        )
 
         translator = self._get_translator(translator_name, data)
 
         params = translator.build_params()
 
-        raw_kwargs = dict(
-            params=params,
-            project_id=project,
-        )
+        raw_kwargs = dict(params=params, project_id=project)
         kwargs = {k: v for k, v in raw_kwargs.items() if k and v}
 
         resp = self.query_retry(self._request, **kwargs)
@@ -191,74 +225,147 @@ class GrafanaHelper(base.DataSourceBase):
 
         return result
 
-    def statistic_series(self, resource=None, resource_type=None,
-                         meter_name=None, start_time=None, end_time=None,
-                         granularity=300):
+    def statistic_series(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        start_time=None,
+        end_time=None,
+        granularity=300,
+    ):
         raise NotImplementedError(
-            _('Grafana helper does not support statistic series method'))
+            _('Grafana helper does not support statistic series method')
+        )
 
-    def get_host_cpu_usage(self, resource, period=300,
-                           aggregate="mean", granularity=None):
+    def get_host_cpu_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_cpu_usage', period, aggregate,
-            granularity)
+            resource,
+            'compute_node',
+            'host_cpu_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_host_ram_usage(self, resource, period=300,
-                           aggregate="mean", granularity=None):
+    def get_host_ram_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_ram_usage', period, aggregate,
-            granularity)
+            resource,
+            'compute_node',
+            'host_ram_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_host_outlet_temp(self, resource, period=300,
-                             aggregate="mean", granularity=None):
+    def get_host_outlet_temp(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_outlet_temp', period, aggregate,
-            granularity)
+            resource,
+            'compute_node',
+            'host_outlet_temp',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_host_inlet_temp(self, resource, period=300,
-                            aggregate="mean", granularity=None):
+    def get_host_inlet_temp(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_inlet_temp', period, aggregate,
-            granularity)
+            resource,
+            'compute_node',
+            'host_inlet_temp',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_host_airflow(self, resource, period=300,
-                         aggregate="mean", granularity=None):
+    def get_host_airflow(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_airflow', period, aggregate,
-            granularity)
+            resource,
+            'compute_node',
+            'host_airflow',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_host_power(self, resource, period=300,
-                       aggregate="mean", granularity=None):
+    def get_host_power(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'compute_node', 'host_power', period, aggregate,
-            granularity)
+            resource,
+            'compute_node',
+            'host_power',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_instance_cpu_usage(self, resource, period=300,
-                               aggregate="mean", granularity=None):
+    def get_instance_cpu_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_cpu_usage', period, aggregate,
-            granularity)
+            resource,
+            'instance',
+            'instance_cpu_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_instance_ram_usage(self, resource, period=300,
-                               aggregate="mean", granularity=None):
+    def get_instance_ram_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_ram_usage', period, aggregate,
-            granularity)
+            resource,
+            'instance',
+            'instance_ram_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_instance_ram_allocated(self, resource, period=300,
-                                   aggregate="mean", granularity=None):
+    def get_instance_ram_allocated(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_ram_allocated', period, aggregate,
-            granularity)
+            resource,
+            'instance',
+            'instance_ram_allocated',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_instance_l3_cache_usage(self, resource, period=300,
-                                    aggregate="mean", granularity=None):
+    def get_instance_l3_cache_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_l3_cache_usage', period, aggregate,
-            granularity)
+            resource,
+            'instance',
+            'instance_l3_cache_usage',
+            period,
+            aggregate,
+            granularity,
+        )
 
-    def get_instance_root_disk_size(self, resource, period=300,
-                                    aggregate="mean", granularity=None):
+    def get_instance_root_disk_size(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         return self.statistic_aggregation(
-            resource, 'instance', 'instance_root_disk_size', period, aggregate,
-            granularity)
+            resource,
+            'instance',
+            'instance_root_disk_size',
+            period,
+            aggregate,
+            granularity,
+        )
diff --git a/watcher/decision_engine/datasources/grafana_translator/base.py b/watcher/decision_engine/datasources/grafana_translator/base.py
index c9f548ac8..53acbdb8f 100644
--- a/watcher/decision_engine/datasources/grafana_translator/base.py
+++ b/watcher/decision_engine/datasources/grafana_translator/base.py
@@ -72,26 +72,31 @@ class BaseGrafanaTranslator:
             'resource_type': None,
             'period': None,
             'aggregate': None,
-            'granularity': None
+            'granularity': None,
         }
         reference_data.update(self._data)
 
         for key, value in reference_data.items():
             if value is None and key not in optionals:
                 raise exception.InvalidParameter(
-                    message=(_("The value %(value)s for parameter "
-                               "%(parameter)s is invalid") % {'value': None,
-                                                              'parameter': key}
-                             )
+                    message=(
+                        _(
+                            "The value %(value)s for parameter "
+                            "%(parameter)s is invalid"
+                        )
+                        % {'value': None, 'parameter': key}
+                    )
                 )
 
         if reference_data['resource_type'] not in self.RESOURCE_TYPES:
-            raise exception.InvalidParameter(parameter='resource_type',
-                                             parameter_type='RESOURCE_TYPES')
+            raise exception.InvalidParameter(
+                parameter='resource_type', parameter_type='RESOURCE_TYPES'
+            )
 
         if reference_data['aggregate'] not in self.AGGREGATES:
-            raise exception.InvalidParameter(parameter='aggregate',
-                                             parameter_type='AGGREGATES')
+            raise exception.InvalidParameter(
+                parameter='aggregate', parameter_type='AGGREGATES'
+            )
 
     @staticmethod
     def _extract_attribute(resource, attribute):
@@ -108,10 +113,12 @@ class BaseGrafanaTranslator:
             raise
 
     @staticmethod
-    def _query_format(query, aggregate, resource, period,
-                      granularity, translator_specific):
-        return query.format(aggregate, resource, period, granularity,
-                            translator_specific)
+    def _query_format(
+        query, aggregate, resource, period, granularity, translator_specific
+    ):
+        return query.format(
+            aggregate, resource, period, granularity, translator_specific
+        )
 
     @abc.abstractmethod
     def build_params(self):
diff --git a/watcher/decision_engine/datasources/grafana_translator/influxdb.py b/watcher/decision_engine/datasources/grafana_translator/influxdb.py
index 397fa909c..2ed39b974 100644
--- a/watcher/decision_engine/datasources/grafana_translator/influxdb.py
+++ b/watcher/decision_engine/datasources/grafana_translator/influxdb.py
@@ -51,27 +51,40 @@ class InfluxDBGrafanaTranslator(BaseGrafanaTranslator):
 
         if retention_period is None:
             retention_period = max(available_periods)[0]
-            LOG.warning("Longest retention period is to short for desired"
-                        " period")
+            LOG.warning(
+                "Longest retention period is to short for desired period"
+            )
 
         try:
             resource = self._extract_attribute(
-                data['resource'], data['attribute'])
+                data['resource'], data['attribute']
+            )
         except AttributeError:
-            LOG.error("Resource: %s does not contain attribute %s",
-                      data['resource'], data['attribute'])
+            LOG.error(
+                "Resource: %s does not contain attribute %s",
+                data['resource'],
+                data['attribute'],
+            )
             raise
 
         # Granularity is optional if it is None the minimal value for InfluxDB
         # will be 1
-        granularity = \
+        granularity = (
             data['granularity'] if data['granularity'] is not None else 1
+        )
 
-        return {'db': data['db'],
-                'epoch': 'ms',
-                'q': self._query_format(
-                    data['query'], data['aggregate'], resource, data['period'],
-                    granularity, retention_period)}
+        return {
+            'db': data['db'],
+            'epoch': 'ms',
+            'q': self._query_format(
+                data['query'],
+                data['aggregate'],
+                resource,
+                data['period'],
+                granularity,
+                retention_period,
+            ),
+        }
 
     def extract_result(self, raw_results):
         """"""
@@ -83,7 +96,11 @@ class InfluxDBGrafanaTranslator(BaseGrafanaTranslator):
             index_aggregate = result['columns'].index(self._data['aggregate'])
             return result['values'][0][index_aggregate]
         except KeyError:
-            LOG.error("Could not extract %s for the resource: %s",
-                      self._data['metric'], self._data['resource'])
+            LOG.error(
+                "Could not extract %s for the resource: %s",
+                self._data['metric'],
+                self._data['resource'],
+            )
             raise exception.NoSuchMetricForHost(
-                metric=self._data['metric'], host=self._data['resource'])
+                metric=self._data['metric'], host=self._data['resource']
+            )
diff --git a/watcher/decision_engine/datasources/manager.py b/watcher/decision_engine/datasources/manager.py
index c01519005..2b2cbef8d 100644
--- a/watcher/decision_engine/datasources/manager.py
+++ b/watcher/decision_engine/datasources/manager.py
@@ -32,13 +32,14 @@ LOG = log.getLogger(__name__)
 
 
 class DataSourceManager:
-
-    metric_map = OrderedDict([
-        (gnoc.GnocchiHelper.NAME, gnoc.GnocchiHelper.METRIC_MAP),
-        (graf.GrafanaHelper.NAME, graf.GrafanaHelper.METRIC_MAP),
-        (prom.PrometheusHelper.NAME, prom.PrometheusHelper.METRIC_MAP),
-        (aetos.AetosHelper.NAME, aetos.AetosHelper.METRIC_MAP),
-    ])
+    metric_map = OrderedDict(
+        [
+            (gnoc.GnocchiHelper.NAME, gnoc.GnocchiHelper.METRIC_MAP),
+            (graf.GrafanaHelper.NAME, graf.GrafanaHelper.METRIC_MAP),
+            (prom.PrometheusHelper.NAME, prom.PrometheusHelper.METRIC_MAP),
+            (aetos.AetosHelper.NAME, aetos.AetosHelper.METRIC_MAP),
+        ]
+    )
     """Dictionary with all possible datasources, dictionary order is
     the default order for attempting to use datasources
     """
@@ -66,8 +67,10 @@ class DataSourceManager:
 
         self.datasources = self.config.datasources
         if self.datasources and 'prometheus' in self.datasources:
-            LOG.warning('The prometheus datasource is deprecated and will '
-                        'be removed in a future release.')
+            LOG.warning(
+                'The prometheus datasource is deprecated and will '
+                'be removed in a future release.'
+            )
 
         self._validate_datasource_config()
 
@@ -77,14 +80,18 @@ class DataSourceManager:
         Checks for configuration conflicts, such as having both prometheus
         and aetos datasources configured simultaneously.
         """
-        if (self.datasources and
-                prom.PrometheusHelper.NAME in self.datasources and
-                aetos.AetosHelper.NAME in self.datasources):
-            LOG.error("Configuration error: Cannot use both prometheus "
-                      "and aetos datasources simultaneously.")
+        if (
+            self.datasources
+            and prom.PrometheusHelper.NAME in self.datasources
+            and aetos.AetosHelper.NAME in self.datasources
+        ):
+            LOG.error(
+                "Configuration error: Cannot use both prometheus "
+                "and aetos datasources simultaneously."
+            )
             raise exception.DataSourceConfigConflict(
                 datasource_one=prom.PrometheusHelper.NAME,
-                datasource_two=aetos.AetosHelper.NAME
+                datasource_two=aetos.AetosHelper.NAME,
             )
 
     @property
@@ -139,23 +146,27 @@ class DataSourceManager:
             raise exception.NoDatasourceAvailable
 
         if not metrics or len(metrics) == 0:
-            LOG.critical("Can not retrieve datasource without specifying "
-                         "list of required metrics.")
-            raise exception.InvalidParameter(parameter='metrics',
-                                             parameter_type='none empty list')
+            LOG.critical(
+                "Can not retrieve datasource without specifying "
+                "list of required metrics."
+            )
+            raise exception.InvalidParameter(
+                parameter='metrics', parameter_type='none empty list'
+            )
 
         for datasource in self.datasources:
             # Skip configured datasources that are not available at runtime
             if datasource not in self.metric_map:
                 LOG.warning(
-                    "Datasource: %s is not available; skipping.",
-                    datasource,
+                    "Datasource: %s is not available; skipping.", datasource
                 )
                 continue
             no_metric = False
             for metric in metrics:
-                if (metric not in self.metric_map[datasource] or
-                        self.metric_map[datasource].get(metric) is None):
+                if (
+                    metric not in self.metric_map[datasource]
+                    or self.metric_map[datasource].get(metric) is None
+                ):
                     no_metric = True
                     LOG.warning(
                         "Datasource: %s could not be used due to metric: %s",
diff --git a/watcher/decision_engine/datasources/prometheus.py b/watcher/decision_engine/datasources/prometheus.py
index 8635605c6..6ea5d8f06 100644
--- a/watcher/decision_engine/datasources/prometheus.py
+++ b/watcher/decision_engine/datasources/prometheus.py
@@ -31,8 +31,9 @@ LOG = log.getLogger(__name__)
 warnings.simplefilter("once")
 
 
-@removals.removed_class("PrometheusHelper", version="2026.1",
-                        removal_version="2027.1")
+@removals.removed_class(
+    "PrometheusHelper", version="2026.1", removal_version="2027.1"
+)
 class PrometheusHelper(prometheus_base.PrometheusBase):
     """PrometheusHelper class for retrieving metrics from Prometheus server
 
@@ -70,13 +71,16 @@ class PrometheusHelper(prometheus_base.PrometheusBase):
         _port = CONF.prometheus_client.port
         if not _host:
             raise exception.MissingParameter(
-                message=(_(
-                    "prometheus host must be set in watcher.conf "
-                    "under the [prometheus_client] section. Can't initialise "
-                    "the datasource without valid host."))
+                message=(
+                    _(
+                        "prometheus host must be set in watcher.conf "
+                        "under the [prometheus_client] section. "
+                        "Can't initialise "
+                        "the datasource without valid host."
+                    )
+                )
             )
-        the_client = prometheus_client.PrometheusAPIClient(
-            f"{_host}:{_port}")
+        the_client = prometheus_client.PrometheusAPIClient(f"{_host}:{_port}")
 
         # check if tls options or basic_auth options are set and use them
         prometheus_user = CONF.prometheus_client.username
@@ -84,12 +88,13 @@ class PrometheusHelper(prometheus_base.PrometheusBase):
         prometheus_ca_cert = CONF.prometheus_client.cafile
         prometheus_client_cert = CONF.prometheus_client.certfile
         prometheus_client_key = CONF.prometheus_client.keyfile
-        if (prometheus_ca_cert):
+        if prometheus_ca_cert:
             the_client.set_ca_cert(prometheus_ca_cert)
-            if (prometheus_client_cert and prometheus_client_key):
+            if prometheus_client_cert and prometheus_client_key:
                 the_client.set_client_cert(
-                    prometheus_client_cert, prometheus_client_key)
-        if (prometheus_user and prometheus_pass):
+                    prometheus_client_cert, prometheus_client_key
+                )
+        if prometheus_user and prometheus_pass:
             the_client.set_basic_auth(prometheus_user, prometheus_pass)
 
         return the_client
diff --git a/watcher/decision_engine/datasources/prometheus_base.py b/watcher/decision_engine/datasources/prometheus_base.py
index a261a751f..1794cda6e 100644
--- a/watcher/decision_engine/datasources/prometheus_base.py
+++ b/watcher/decision_engine/datasources/prometheus_base.py
@@ -35,18 +35,19 @@ class PrometheusBase(base.DataSourceBase):
     to provide the appropriate client configuration.
     """
 
-    METRIC_MAP = dict(host_cpu_usage='node_cpu_seconds_total',
-                      host_ram_usage='node_memory_MemAvailable_bytes',
-                      host_outlet_temp=None,
-                      host_inlet_temp=None,
-                      host_airflow=None,
-                      host_power=None,
-                      instance_cpu_usage='ceilometer_cpu',
-                      instance_ram_usage='ceilometer_memory_usage',
-                      instance_ram_allocated='instance.memory',
-                      instance_l3_cache_usage=None,
-                      instance_root_disk_size='instance.disk',
-                      )
+    METRIC_MAP = dict(
+        host_cpu_usage='node_cpu_seconds_total',
+        host_ram_usage='node_memory_MemAvailable_bytes',
+        host_outlet_temp=None,
+        host_inlet_temp=None,
+        host_airflow=None,
+        host_power=None,
+        instance_cpu_usage='ceilometer_cpu',
+        instance_ram_usage='ceilometer_memory_usage',
+        instance_ram_allocated='instance.memory',
+        instance_l3_cache_usage=None,
+        instance_root_disk_size='instance.disk',
+    )
     AGGREGATES_MAP = dict(mean='avg', max='max', min='min', count='avg')
 
     def __init__(self):
@@ -64,9 +65,7 @@ class PrometheusBase(base.DataSourceBase):
         """
         self.prometheus = self._setup_prometheus_client()
         self.prometheus_fqdn_label = self._get_fqdn_label()
-        self.prometheus_fqdn_labels = (
-            self._build_prometheus_fqdn_labels()
-        )
+        self.prometheus_fqdn_labels = self._build_prometheus_fqdn_labels()
         self.prometheus_host_instance_map = (
             self._build_prometheus_host_instance_map()
         )
@@ -115,8 +114,9 @@ class PrometheusBase(base.DataSourceBase):
                 {'foo.example.com', 'bar.example.com'}
                 {'foo', 'bar'}
         """
-        prometheus_targets = self.prometheus._get(
-            "targets?state=active")['data']['activeTargets']
+        prometheus_targets = self.prometheus._get("targets?state=active")[
+            'data'
+        ]['activeTargets']
         # >>> prometheus_targets[0]['labels']
         # {'fqdn': 'marios-env-again.controlplane.domain',
         #  'instance': 'localhost:9100', 'job': 'node'}
@@ -124,13 +124,14 @@ class PrometheusBase(base.DataSourceBase):
         for target in prometheus_targets:
             if target.get('labels', {}).get(self.prometheus_fqdn_label):
                 fqdn_instance_labels.add(
-                    target['labels'].get(self.prometheus_fqdn_label))
+                    target['labels'].get(self.prometheus_fqdn_label)
+                )
 
         if not fqdn_instance_labels:
             LOG.error(
                 "Could not create fqdn labels list from Prometheus "
                 "targets config. Prometheus returned the following: %s",
-                prometheus_targets
+                prometheus_targets,
             )
             return set()
         return fqdn_instance_labels
@@ -150,19 +151,23 @@ class PrometheusBase(base.DataSourceBase):
                 {'foo': 'foo.example.com', 'bar': 'bar.example.com'}
         """
         if not self.prometheus_fqdn_labels:
-            LOG.error("Cannot build host_instance_map without "
-                      "fqdn_instance_labels")
+            LOG.error(
+                "Cannot build host_instance_map without fqdn_instance_labels"
+            )
             return {}
         host_instance_map = {
-            host: fqdn for (host, fqdn) in (
+            host: fqdn
+            for (host, fqdn) in (
                 (fqdn.split('.')[0], fqdn)
                 for fqdn in self.prometheus_fqdn_labels
                 if '.' in fqdn
             )
         }
         if not host_instance_map:
-            LOG.warning("Creating empty host instance map. Are the keys "
-                        "in prometheus_fqdn_labels valid fqdn?")
+            LOG.warning(
+                "Creating empty host instance map. Are the keys "
+                "in prometheus_fqdn_labels valid fqdn?"
+            )
             return {}
         return host_instance_map
 
@@ -178,6 +183,7 @@ class PrometheusBase(base.DataSourceBase):
         :param node_name: the watcher node.hostname
         :return String for the prometheus instance label and None if not found
         """
+
         def _query_maps(node):
             if node in self.prometheus_fqdn_labels:
                 return node
@@ -187,17 +193,18 @@ class PrometheusBase(base.DataSourceBase):
         instance_label = _query_maps(node_name)
         # refresh the fqdn and host instance maps and retry
         if not instance_label:
-            self.prometheus_fqdn_labels = (
-                self._build_prometheus_fqdn_labels()
-            )
+            self.prometheus_fqdn_labels = self._build_prometheus_fqdn_labels()
             self.prometheus_host_instance_map = (
                 self._build_prometheus_host_instance_map()
             )
             instance_label = _query_maps(node_name)
 
         if not instance_label:
-            LOG.error("Cannot query prometheus without instance label. "
-                      "Could not resolve %s", node_name)
+            LOG.error(
+                "Cannot query prometheus without instance label. "
+                "Could not resolve %s",
+                node_name,
+            )
             return None
         return instance_label
 
@@ -208,19 +215,26 @@ class PrometheusBase(base.DataSourceBase):
         aggregate to use in queries, from the given watcher aggregate
         """
         if watcher_aggregate == 'count':
-            LOG.warning('Prometheus data source does not currently support '
-                        ' the count aggregate. Proceeding with mean (avg).')
+            LOG.warning(
+                'Prometheus data source does not currently support '
+                ' the count aggregate. Proceeding with mean (avg).'
+            )
         promql_aggregate = self.AGGREGATES_MAP.get(watcher_aggregate)
         if not promql_aggregate:
             raise exception.InvalidParameter(
-                message=(_("Unknown Watcher aggregate %s. This does not "
-                           "resolve to any valid prometheus query aggregate.")
-                         % watcher_aggregate)
+                message=(
+                    _(
+                        "Unknown Watcher aggregate %s. This does not "
+                        "resolve to any valid prometheus query aggregate."
+                    )
+                    % watcher_aggregate
+                )
             )
         return promql_aggregate
 
-    def _build_prometheus_query(self, aggregate, meter, instance_label,
-                                period, resource=None):
+    def _build_prometheus_query(
+        self, aggregate, meter, instance_label, period, resource=None
+    ):
         """Build and return the prometheus query string with the given args
 
         This function builds and returns the string query that will be sent
@@ -256,15 +270,26 @@ class PrometheusBase(base.DataSourceBase):
         """
         query_args = None
         uuid_label_key = self._get_instance_uuid_label()
-        if (meter is None or aggregate is None or instance_label is None or
-                period is None):
+        if (
+            meter is None
+            or aggregate is None
+            or instance_label is None
+            or period is None
+        ):
             raise exception.InvalidParameter(
-                message=(_(
-                    "Cannot build prometheus query without args. "
-                    "You provided: meter %(mtr)s, aggregate %(agg)s, "
-                    "instance_label %(inst)s, period %(prd)s")
-                    % {'mtr': meter, 'agg': aggregate,
-                       'inst': instance_label, 'prd': period})
+                message=(
+                    _(
+                        "Cannot build prometheus query without args. "
+                        "You provided: meter %(mtr)s, aggregate %(agg)s, "
+                        "instance_label %(inst)s, period %(prd)s"
+                    )
+                    % {
+                        'mtr': meter,
+                        'agg': aggregate,
+                        'inst': instance_label,
+                        'prd': period,
+                    }
+                )
             )
 
         if meter == 'node_cpu_seconds_total':
@@ -299,7 +324,7 @@ class PrometheusBase(base.DataSourceBase):
             if not vcpus:
                 LOG.warning(
                     "instance vcpu count not set for instance %s, assuming 1",
-                    instance_label
+                    instance_label,
                 )
                 vcpus = 1
             query_args = (
@@ -317,9 +342,9 @@ class PrometheusBase(base.DataSourceBase):
     def check_availability(self):
         """check if Prometheus server is available for queries
 
-         Performs HTTP get on the prometheus API /status/runtimeinfo endpoint.
-         The prometheus_client will raise a PrometheuAPIClientError if the
-         call is unsuccessful, which is caught here and a warning logged.
+        Performs HTTP get on the prometheus API /status/runtimeinfo endpoint.
+        The prometheus_client will raise a PrometheuAPIClientError if the
+        call is unsuccessful, which is caught here and a warning logged.
         """
         try:
             self.prometheus._get("status/runtimeinfo")
@@ -347,10 +372,15 @@ class PrometheusBase(base.DataSourceBase):
             return set()
         return set(response['data'])
 
-    def statistic_aggregation(self, resource=None, resource_type=None,
-                              meter_name=None, period=300, aggregate='mean',
-                              granularity=300):
-
+    def statistic_aggregation(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=300,
+        aggregate='mean',
+        granularity=300,
+    ):
         meter = self._get_meter(meter_name)
         query_args = ''
         instance_label = ''
@@ -360,7 +390,8 @@ class PrometheusBase(base.DataSourceBase):
         # specific key value.
         if resource_type == 'compute_node':
             instance_label = self._resolve_prometheus_instance_label(
-                resource.hostname)
+                resource.hostname
+            )
         elif resource_type == 'instance':
             instance_label = resource.uuid
             # For ram_allocated and root_disk size metrics there are no valid
@@ -373,7 +404,8 @@ class PrometheusBase(base.DataSourceBase):
         else:
             LOG.warning(
                 "Prometheus data source does not currently support "
-                "resource_type %s", resource_type
+                "resource_type %s",
+                resource_type,
             )
             return None
 
@@ -386,29 +418,40 @@ class PrometheusBase(base.DataSourceBase):
             return None
 
         result = self.query_retry(
-            self.prometheus.query, query_args,
+            self.prometheus.query,
+            query_args,
             ignored_exc=prometheus_client.PrometheusAPIClientError,
         )
 
         return float(result[0].value) if result else None
 
-    def statistic_series(self, resource=None, resource_type=None,
-                         meter_name=None, start_time=None, end_time=None,
-                         granularity=300):
+    def statistic_series(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        start_time=None,
+        end_time=None,
+        granularity=300,
+    ):
         raise NotImplementedError(
-            _('Prometheus helper currently does not support statistic_series. '
-              'This can be considered for future enhancement.'))
+            _(
+                'Prometheus helper currently does not support '
+                'statistic_series. '
+                'This can be considered for future enhancement.'
+            )
+        )
 
     def _invert_max_min_aggregate(self, agg):
         """Invert max and min for node/host metric queries from node-exporter
 
-            because we query for 'idle'/'unused' cpu and memory.
-            For Watcher 'max cpu used' we query for prometheus 'min idle time'.
-            For Watcher 'max memory used' we retrieve min 'unused'/'available'
-            memory from Prometheus. This internal function is used exclusively
-            by get_host_cpu_usage and get_host_ram_usage.
-            :param agg: the metric collection aggregate
-            :return: a String aggregate
+        because we query for 'idle'/'unused' cpu and memory.
+        For Watcher 'max cpu used' we query for prometheus 'min idle time'.
+        For Watcher 'max memory used' we retrieve min 'unused'/'available'
+        memory from Prometheus. This internal function is used exclusively
+        by get_host_cpu_usage and get_host_ram_usage.
+        :param agg: the metric collection aggregate
+        :return: a String aggregate
 
         """
         if agg == 'max':
@@ -417,8 +460,9 @@ class PrometheusBase(base.DataSourceBase):
             return 'max'
         return agg
 
-    def get_host_cpu_usage(self, resource, period=300,
-                           aggregate="mean", granularity=None):
+    def get_host_cpu_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         """Query prometheus for node_cpu_seconds_total
 
         This calculates the host cpu usage and returns it as a percentage
@@ -429,48 +473,77 @@ class PrometheusBase(base.DataSourceBase):
         """
         aggregate = self._invert_max_min_aggregate(aggregate)
         cpu_usage = self.statistic_aggregation(
-            resource, 'compute_node',
-            'host_cpu_usage', period=period,
-            granularity=granularity, aggregate=aggregate)
+            resource,
+            'compute_node',
+            'host_cpu_usage',
+            period=period,
+            granularity=granularity,
+            aggregate=aggregate,
+        )
         return float(cpu_usage) if cpu_usage else None
 
-    def get_host_ram_usage(self, resource, period=300,
-                           aggregate="mean", granularity=None):
+    def get_host_ram_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         aggregate = self._invert_max_min_aggregate(aggregate)
         ram_usage = self.statistic_aggregation(
-            resource, 'compute_node',
-            'host_ram_usage', period=period,
-            granularity=granularity, aggregate=aggregate)
+            resource,
+            'compute_node',
+            'host_ram_usage',
+            period=period,
+            granularity=granularity,
+            aggregate=aggregate,
+        )
         return float(ram_usage) if ram_usage else None
 
-    def get_instance_ram_usage(self, resource, period=300,
-                               aggregate="mean", granularity=None):
+    def get_instance_ram_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         ram_usage = self.statistic_aggregation(
-            resource, 'instance',
-            'instance_ram_usage', period=period,
-            granularity=granularity, aggregate=aggregate)
+            resource,
+            'instance',
+            'instance_ram_usage',
+            period=period,
+            granularity=granularity,
+            aggregate=aggregate,
+        )
         return ram_usage
 
-    def get_instance_cpu_usage(self, resource, period=300,
-                               aggregate="mean", granularity=None):
+    def get_instance_cpu_usage(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         cpu_usage = self.statistic_aggregation(
-            resource, 'instance',
-            'instance_cpu_usage', period=period,
-            granularity=granularity, aggregate=aggregate)
+            resource,
+            'instance',
+            'instance_cpu_usage',
+            period=period,
+            granularity=granularity,
+            aggregate=aggregate,
+        )
         return cpu_usage
 
-    def get_instance_ram_allocated(self, resource, period=300,
-                                   aggregate="mean", granularity=None):
+    def get_instance_ram_allocated(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         ram_allocated = self.statistic_aggregation(
-            resource, 'instance',
-            'instance_ram_allocated', period=period,
-            granularity=granularity, aggregate=aggregate)
+            resource,
+            'instance',
+            'instance_ram_allocated',
+            period=period,
+            granularity=granularity,
+            aggregate=aggregate,
+        )
         return ram_allocated
 
-    def get_instance_root_disk_size(self, resource, period=300,
-                                    aggregate="mean", granularity=None):
+    def get_instance_root_disk_size(
+        self, resource, period=300, aggregate="mean", granularity=None
+    ):
         root_disk_size = self.statistic_aggregation(
-            resource, 'instance',
-            'instance_root_disk_size', period=period,
-            granularity=granularity, aggregate=aggregate)
+            resource,
+            'instance',
+            'instance_root_disk_size',
+            period=period,
+            granularity=granularity,
+            aggregate=aggregate,
+        )
         return root_disk_size
diff --git a/watcher/decision_engine/goal/__init__.py b/watcher/decision_engine/goal/__init__.py
index c101c329e..53376aaf0 100644
--- a/watcher/decision_engine/goal/__init__.py
+++ b/watcher/decision_engine/goal/__init__.py
@@ -26,7 +26,13 @@ SavingEnergy = goals.SavingEnergy
 HardwareMaintenance = goals.HardwareMaintenance
 
 
-__all__ = ("Dummy", "ServerConsolidation", "ThermalOptimization",
-           "Unclassified", "WorkloadBalancing",
-           "NoisyNeighborOptimization", "SavingEnergy",
-           "HardwareMaintenance")
+__all__ = (
+    "Dummy",
+    "ServerConsolidation",
+    "ThermalOptimization",
+    "Unclassified",
+    "WorkloadBalancing",
+    "NoisyNeighborOptimization",
+    "SavingEnergy",
+    "HardwareMaintenance",
+)
diff --git a/watcher/decision_engine/goal/base.py b/watcher/decision_engine/goal/base.py
index e797b2574..7a864b442 100644
--- a/watcher/decision_engine/goal/base.py
+++ b/watcher/decision_engine/goal/base.py
@@ -19,7 +19,6 @@ from watcher.common.loader import loadable
 
 
 class Goal(loadable.Loadable, metaclass=abc.ABCMeta):
-
     def __init__(self, config):
         super().__init__(config)
         self.name = self.get_name()
diff --git a/watcher/decision_engine/goal/efficacy/base.py b/watcher/decision_engine/goal/efficacy/base.py
index cc7ad3178..03120abbf 100644
--- a/watcher/decision_engine/goal/efficacy/base.py
+++ b/watcher/decision_engine/goal/efficacy/base.py
@@ -30,7 +30,6 @@ from oslo_serialization import jsonutils
 
 
 class EfficacySpecification(metaclass=abc.ABCMeta):
-
     def __init__(self):
         self._indicators_specs = self.get_indicators_specifications()
 
@@ -63,11 +62,7 @@ class EfficacySpecification(metaclass=abc.ABCMeta):
     @property
     def schema(self):
         """Combined schema from the schema of the indicators"""
-        schema = {
-            "type": "object",
-            "properties": {},
-            "required": []
-        }
+        schema = {"type": "object", "properties": {}, "required": []}
         for indicator in self.indicators_specs:
             schema["properties"][indicator.name] = indicator.schema
             if indicator.required:
@@ -81,8 +76,7 @@ class EfficacySpecification(metaclass=abc.ABCMeta):
             True
 
     def get_indicators_specs_dicts(self):
-        return [indicator.to_dict()
-                for indicator in self.indicators_specs]
+        return [indicator.to_dict() for indicator in self.indicators_specs]
 
     def serialize_indicators_specs(self):
         return jsonutils.dumps(self.get_indicators_specs_dicts())
diff --git a/watcher/decision_engine/goal/efficacy/indicators.py b/watcher/decision_engine/goal/efficacy/indicators.py
index 823177561..50f2003cf 100644
--- a/watcher/decision_engine/goal/efficacy/indicators.py
+++ b/watcher/decision_engine/goal/efficacy/indicators.py
@@ -30,7 +30,6 @@ LOG = log.getLogger(__name__)
 
 
 class IndicatorSpecification(metaclass=abc.ABCMeta):
-
     def __init__(self, name=None, description=None, unit=None, required=True):
         self.name = name
         self.description = description
@@ -63,7 +62,8 @@ class IndicatorSpecification(metaclass=abc.ABCMeta):
         except Exception as exc:
             LOG.exception(exc)
             raise exception.InvalidIndicatorValue(
-                name=indicator.name, value=value, spec_type=type(indicator))
+                name=indicator.name, value=value, spec_type=type(indicator)
+            )
 
     def to_dict(self):
         return {
@@ -87,10 +87,7 @@ class ComputeNodesCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class ReleasedComputeNodesCount(IndicatorSpecification):
@@ -103,28 +100,23 @@ class ReleasedComputeNodesCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class InstancesCount(IndicatorSpecification):
     def __init__(self):
         super().__init__(
             name="instances_count",
-            description=_("The total number of audited instances in "
-                          "strategy."),
+            description=_(
+                "The total number of audited instances in strategy."
+            ),
             unit=None,
             required=False,
         )
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class InstanceMigrationsCount(IndicatorSpecification):
@@ -137,10 +129,7 @@ class InstanceMigrationsCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class LiveInstanceMigrateCount(IndicatorSpecification):
@@ -153,10 +142,7 @@ class LiveInstanceMigrateCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class PlannedLiveInstanceMigrateCount(IndicatorSpecification):
@@ -169,10 +155,7 @@ class PlannedLiveInstanceMigrateCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class ColdInstanceMigrateCount(IndicatorSpecification):
@@ -185,10 +168,7 @@ class ColdInstanceMigrateCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class PlannedColdInstanceMigrateCount(IndicatorSpecification):
@@ -201,10 +181,7 @@ class PlannedColdInstanceMigrateCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class VolumeMigrateCount(IndicatorSpecification):
@@ -217,61 +194,50 @@ class VolumeMigrateCount(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class PlannedVolumeMigrateCount(IndicatorSpecification):
     def __init__(self):
         super().__init__(
             name="planned_volume_migrate_count",
-            description=_("The number of detached volumes planned"
-                          " to migrate."),
+            description=_(
+                "The number of detached volumes planned to migrate."
+            ),
             unit=None,
         )
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class VolumeUpdateCount(IndicatorSpecification):
     def __init__(self):
         super().__init__(
             name="volume_update_count",
-            description=_("The number of attached volumes actually"
-                          " migrated."),
+            description=_("The number of attached volumes actually migrated."),
             unit=None,
         )
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class PlannedVolumeUpdateCount(IndicatorSpecification):
     def __init__(self):
         super().__init__(
             name="planned_volume_update_count",
-            description=_("The number of attached volumes planned to"
-                          " migrate."),
+            description=_(
+                "The number of attached volumes planned to migrate."
+            ),
             unit=None,
         )
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-        }
+        return {"type": "integer", "minimum": 0}
 
 
 class StandardDeviationValue(IndicatorSpecification):
@@ -285,10 +251,7 @@ class StandardDeviationValue(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "number",
-            "minimum": 0
-        }
+        return {"type": "number", "minimum": 0}
 
 
 class OriginalStandardDeviationValue(IndicatorSpecification):
@@ -302,7 +265,4 @@ class OriginalStandardDeviationValue(IndicatorSpecification):
 
     @property
     def schema(self):
-        return {
-            "type": "number",
-            "minimum": 0
-        }
+        return {"type": "number", "minimum": 0}
diff --git a/watcher/decision_engine/goal/efficacy/specs.py b/watcher/decision_engine/goal/efficacy/specs.py
index 9ef2ffc35..387798f30 100644
--- a/watcher/decision_engine/goal/efficacy/specs.py
+++ b/watcher/decision_engine/goal/efficacy/specs.py
@@ -20,7 +20,6 @@ from watcher.decision_engine.solution import efficacy
 
 
 class Unclassified(base.EfficacySpecification):
-
     def get_indicators_specifications(self):
         return ()
 
@@ -29,7 +28,6 @@ class Unclassified(base.EfficacySpecification):
 
 
 class ServerConsolidation(base.EfficacySpecification):
-
     def get_indicators_specifications(self):
         return [
             indicators.ComputeNodesCount(),
@@ -41,27 +39,32 @@ class ServerConsolidation(base.EfficacySpecification):
         value = 0
         global_efficacy = []
         if indicators_map and indicators_map.compute_nodes_count > 0:
-            value = (float(indicators_map.released_compute_nodes_count) /
-                     float(indicators_map.compute_nodes_count)) * 100
-        global_efficacy.append(efficacy.Indicator(
-            name="released_nodes_ratio",
-            description=_("Ratio of released compute nodes divided by the "
-                          "total number of enabled compute nodes."),
-            unit='%',
-            value=value,
-        ))
+            value = (
+                float(indicators_map.released_compute_nodes_count)
+                / float(indicators_map.compute_nodes_count)
+            ) * 100
+        global_efficacy.append(
+            efficacy.Indicator(
+                name="released_nodes_ratio",
+                description=_(
+                    "Ratio of released compute nodes divided by the "
+                    "total number of enabled compute nodes."
+                ),
+                unit='%',
+                value=value,
+            )
+        )
 
         return global_efficacy
 
 
 class WorkloadBalancing(base.EfficacySpecification):
-
     def get_indicators_specifications(self):
         return [
             indicators.InstanceMigrationsCount(),
             indicators.InstancesCount(),
             indicators.StandardDeviationValue(),
-            indicators.OriginalStandardDeviationValue()
+            indicators.OriginalStandardDeviationValue(),
         ]
 
     def get_global_efficacy_indicator(self, indicators_map=None):
@@ -69,19 +72,25 @@ class WorkloadBalancing(base.EfficacySpecification):
         mig_value = 0
         if indicators_map and indicators_map.instance_migrations_count > 0:
             mig_value = (
-                indicators_map.instance_migrations_count /
-                float(indicators_map.instances_count) * 100)
-        gl_indicators.append(efficacy.Indicator(
-            name="live_migrations_count",
-            description=_("Ratio of migrated virtual machines to audited "
-                          "virtual machines"),
-            unit='%',
-            value=mig_value))
+                indicators_map.instance_migrations_count
+                / float(indicators_map.instances_count)
+                * 100
+            )
+        gl_indicators.append(
+            efficacy.Indicator(
+                name="live_migrations_count",
+                description=_(
+                    "Ratio of migrated virtual machines to audited "
+                    "virtual machines"
+                ),
+                unit='%',
+                value=mig_value,
+            )
+        )
         return gl_indicators
 
 
 class HardwareMaintenance(base.EfficacySpecification):
-
     def get_indicators_specifications(self):
         return [
             indicators.LiveInstanceMigrateCount(),
@@ -91,73 +100,86 @@ class HardwareMaintenance(base.EfficacySpecification):
             indicators.VolumeMigrateCount(),
             indicators.PlannedVolumeMigrateCount(),
             indicators.VolumeUpdateCount(),
-            indicators.PlannedVolumeUpdateCount()
+            indicators.PlannedVolumeUpdateCount(),
         ]
 
     def get_global_efficacy_indicator(self, indicators_map=None):
         li_value = 0
-        if (indicators_map and
-                indicators_map.planned_live_migrate_instance_count > 0):
+        if (
+            indicators_map
+            and indicators_map.planned_live_migrate_instance_count > 0
+        ):
             li_value = (
-                float(indicators_map.planned_live_migrate_instance_count) /
-                float(indicators_map.live_migrate_instance_count) *
-                100
-                )
+                float(indicators_map.planned_live_migrate_instance_count)
+                / float(indicators_map.live_migrate_instance_count)
+                * 100
+            )
 
         li_indicator = efficacy.Indicator(
             name="live_instance_migrate_ratio",
-            description=_("Ratio of actual live migrated instances "
-                          "to planned live migrate instances."),
+            description=_(
+                "Ratio of actual live migrated instances "
+                "to planned live migrate instances."
+            ),
             unit='%',
-            value=li_value)
+            value=li_value,
+        )
 
         ci_value = 0
-        if (indicators_map and
-                indicators_map.planned_cold_migrate_instance_count > 0):
+        if (
+            indicators_map
+            and indicators_map.planned_cold_migrate_instance_count > 0
+        ):
             ci_value = (
-                float(indicators_map.planned_cold_migrate_instance_count) /
-                float(indicators_map.cold_migrate_instance_count) *
-                100
-                )
+                float(indicators_map.planned_cold_migrate_instance_count)
+                / float(indicators_map.cold_migrate_instance_count)
+                * 100
+            )
 
         ci_indicator = efficacy.Indicator(
             name="cold_instance_migrate_ratio",
-            description=_("Ratio of actual cold migrated instances "
-                          "to planned cold migrate instances."),
+            description=_(
+                "Ratio of actual cold migrated instances "
+                "to planned cold migrate instances."
+            ),
             unit='%',
-            value=ci_value)
+            value=ci_value,
+        )
 
         dv_value = 0
-        if (indicators_map and
-                indicators_map.planned_volume_migrate_count > 0):
-            dv_value = (float(indicators_map.planned_volume_migrate_count) /
-                        float(indicators_map.
-                              volume_migrate_count) *
-                        100)
+        if indicators_map and indicators_map.planned_volume_migrate_count > 0:
+            dv_value = (
+                float(indicators_map.planned_volume_migrate_count)
+                / float(indicators_map.volume_migrate_count)
+                * 100
+            )
 
         dv_indicator = efficacy.Indicator(
             name="volume_migrate_ratio",
-            description=_("Ratio of actual detached volumes migrated to"
-                          " planned detached volumes migrate."),
+            description=_(
+                "Ratio of actual detached volumes migrated to"
+                " planned detached volumes migrate."
+            ),
             unit='%',
-            value=dv_value)
+            value=dv_value,
+        )
 
         av_value = 0
-        if (indicators_map and
-                indicators_map.planned_volume_update_count > 0):
-            av_value = (float(indicators_map.planned_volume_update_count) /
-                        float(indicators_map.
-                              volume_update_count) *
-                        100)
+        if indicators_map and indicators_map.planned_volume_update_count > 0:
+            av_value = (
+                float(indicators_map.planned_volume_update_count)
+                / float(indicators_map.volume_update_count)
+                * 100
+            )
 
         av_indicator = efficacy.Indicator(
             name="volume_update_ratio",
-            description=_("Ratio of actual attached volumes migrated to"
-                          " planned attached volumes migrate."),
+            description=_(
+                "Ratio of actual attached volumes migrated to"
+                " planned attached volumes migrate."
+            ),
             unit='%',
-            value=av_value)
+            value=av_value,
+        )
 
-        return [li_indicator,
-                ci_indicator,
-                dv_indicator,
-                av_indicator]
+        return [li_indicator, ci_indicator, dv_indicator, av_indicator]
diff --git a/watcher/decision_engine/loading/default.py b/watcher/decision_engine/loading/default.py
index 24efbc911..a51e66b59 100644
--- a/watcher/decision_engine/loading/default.py
+++ b/watcher/decision_engine/loading/default.py
@@ -23,35 +23,29 @@ from watcher.common.loader import default
 
 class DefaultStrategyLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_strategies')
+        super().__init__(namespace='watcher_strategies')
 
 
 class DefaultGoalLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_goals')
+        super().__init__(namespace='watcher_goals')
 
 
 class DefaultPlannerLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_planners')
+        super().__init__(namespace='watcher_planners')
 
 
 class ClusterDataModelCollectorLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_cluster_data_model_collectors')
+        super().__init__(namespace='watcher_cluster_data_model_collectors')
 
 
 class DefaultScoringLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_scoring_engines')
+        super().__init__(namespace='watcher_scoring_engines')
 
 
 class DefaultScoringContainerLoader(default.DefaultLoader):
     def __init__(self):
-        super().__init__(
-            namespace='watcher_scoring_engine_containers')
+        super().__init__(namespace='watcher_scoring_engine_containers')
diff --git a/watcher/decision_engine/manager.py b/watcher/decision_engine/manager.py
index 4f1070601..32c213463 100644
--- a/watcher/decision_engine/manager.py
+++ b/watcher/decision_engine/manager.py
@@ -50,7 +50,6 @@ CONF = conf.CONF
 
 
 class DecisionEngineManager(service_manager.ServiceManager):
-
     @property
     def service_name(self):
         return 'watcher-decision-engine'
@@ -73,9 +72,11 @@ class DecisionEngineManager(service_manager.ServiceManager):
 
     @property
     def conductor_endpoints(self):
-        return [audit_endpoint.AuditEndpoint,
-                strategy_endpoint.StrategyEndpoint,
-                data_model_endpoint.DataModelEndpoint]
+        return [
+            audit_endpoint.AuditEndpoint,
+            strategy_endpoint.StrategyEndpoint,
+            data_model_endpoint.DataModelEndpoint,
+        ]
 
     @property
     def notification_endpoints(self):
diff --git a/watcher/decision_engine/messaging/audit_endpoint.py b/watcher/decision_engine/messaging/audit_endpoint.py
index ccf4834ae..f9dbaad69 100644
--- a/watcher/decision_engine/messaging/audit_endpoint.py
+++ b/watcher/decision_engine/messaging/audit_endpoint.py
@@ -29,12 +29,12 @@ LOG = log.getLogger(__name__)
 
 
 class AuditEndpoint:
-
     def __init__(self, messaging):
         self._messaging = messaging
         self.amount_workers = CONF.watcher_decision_engine.max_audit_workers
-        self._executor = (
-            executor.get_futurist_pool_executor(self.amount_workers))
+        self._executor = executor.get_futurist_pool_executor(
+            self.amount_workers
+        )
         self._oneshot_handler = o_handler.OneShotAuditHandler()
         self._event_handler = e_handler.EventAuditHandler()
 
@@ -52,7 +52,5 @@ class AuditEndpoint:
     def trigger_audit(self, context, audit_uuid):
         LOG.debug("Trigger audit %s", audit_uuid)
         executor.log_executor_stats(self.executor, name="audit-endpoint-pool")
-        self.executor.submit(self.do_trigger_audit,
-                             context,
-                             audit_uuid)
+        self.executor.submit(self.do_trigger_audit, context, audit_uuid)
         return audit_uuid
diff --git a/watcher/decision_engine/messaging/data_model_endpoint.py b/watcher/decision_engine/messaging/data_model_endpoint.py
index d52b6543c..c1586ba73 100644
--- a/watcher/decision_engine/messaging/data_model_endpoint.py
+++ b/watcher/decision_engine/messaging/data_model_endpoint.py
@@ -28,11 +28,9 @@ class DataModelEndpoint:
         scope = None
         try:
             if utils.is_uuid_like(audit) or utils.is_int_like(audit):
-                audit = objects.Audit.get(
-                    context, audit)
+                audit = objects.Audit.get(context, audit)
             else:
-                audit = objects.Audit.get_by_name(
-                    context, audit)
+                audit = objects.Audit.get_by_name(context, audit)
         except exception.AuditNotFound:
             raise exception.InvalidIdentity(identity=audit)
         if audit:
@@ -41,19 +39,23 @@ class DataModelEndpoint:
             scope = []
         return scope
 
-    def get_data_model_info(self, context, data_model_type='compute',
-                            audit=None):
+    def get_data_model_info(
+        self, context, data_model_type='compute', audit=None
+    ):
         if audit is not None:
             scope = self.get_audit_scope(context, audit)
         else:
             scope = []
         collector_manager = manager.CollectorManager()
         collector = collector_manager.get_cluster_model_collector(
-            data_model_type)
+            data_model_type
+        )
         audit_scope_handler = collector.get_audit_scope_handler(
-            audit_scope=scope)
+            audit_scope=scope
+        )
         available_data_model = audit_scope_handler.get_scoped_model(
-            collector.get_latest_cluster_data_model())
+            collector.get_latest_cluster_data_model()
+        )
         if not available_data_model:
             return {"context": []}
         return {"context": available_data_model.to_list()}
diff --git a/watcher/decision_engine/model/base.py b/watcher/decision_engine/model/base.py
index 085332960..6ff5d4924 100644
--- a/watcher/decision_engine/model/base.py
+++ b/watcher/decision_engine/model/base.py
@@ -27,7 +27,6 @@ import abc
 
 
 class Model(metaclass=abc.ABCMeta):
-
     @abc.abstractmethod
     def to_string(self):
         raise NotImplementedError()
diff --git a/watcher/decision_engine/model/collector/base.py b/watcher/decision_engine/model/collector/base.py
index 8744fbc31..1efebcca0 100644
--- a/watcher/decision_engine/model/collector/base.py
+++ b/watcher/decision_engine/model/collector/base.py
@@ -119,9 +119,9 @@ LOG = log.getLogger(__name__)
 CONF = cfg.CONF
 
 
-class BaseClusterDataModelCollector(loadable.LoadableSingleton,
-                                    metaclass=abc.ABCMeta):
-
+class BaseClusterDataModelCollector(
+    loadable.LoadableSingleton, metaclass=abc.ABCMeta
+):
     STALE_MODEL = model_root.ModelRoot(stale=True)
 
     def __init__(self, config, osc=None):
@@ -177,7 +177,8 @@ class BaseClusterDataModelCollector(loadable.LoadableSingleton,
                 'period',
                 default=3600,
                 help='The time interval (in seconds) between each '
-                     'synchronization of the model'),
+                'synchronization of the model',
+            )
         ]
 
     def get_latest_cluster_data_model(self):
@@ -199,7 +200,6 @@ class BaseClusterDataModelCollector(loadable.LoadableSingleton,
 
 
 class BaseModelBuilder:
-
     def call_retry(self, f, *args, **kwargs):
         """Attempts to call external service
 
@@ -221,9 +221,13 @@ class BaseModelBuilder:
             except Exception as e:
                 LOG.exception(e)
                 self.call_retry_reset(e)
-                LOG.warning("Retry %d of %d, error while calling service "
-                            "retry in %s seconds",
-                            i+1, num_retries, interval)
+                LOG.warning(
+                    "Retry %d of %d, error while calling service "
+                    "retry in %s seconds",
+                    i + 1,
+                    num_retries,
+                    interval,
+                )
                 time.sleep(interval)
         raise
 
diff --git a/watcher/decision_engine/model/collector/cinder.py b/watcher/decision_engine/model/collector/cinder.py
index c206e3589..3f4f979cf 100644
--- a/watcher/decision_engine/model/collector/cinder.py
+++ b/watcher/decision_engine/model/collector/cinder.py
@@ -32,6 +32,7 @@ class CinderClusterDataModelCollector(base.BaseClusterDataModelCollector):
     The Cinder cluster data model collector creates an in-memory
     representation of the resources exposed by the storage service.
     """
+
     SCHEMA = {
         "$schema": "http://json-schema.org/draft-04/schema#",
         "type": "array",
@@ -42,25 +43,17 @@ class CinderClusterDataModelCollector(base.BaseClusterDataModelCollector):
                     "type": "array",
                     "items": {
                         "type": "object",
-                        "properties": {
-                            "name": {
-                                "type": "string"
-                            }
-                        },
-                        "additionalProperties": False
-                    }
+                        "properties": {"name": {"type": "string"}},
+                        "additionalProperties": False,
+                    },
                 },
                 "volume_types": {
                     "type": "array",
                     "items": {
                         "type": "object",
-                        "properties": {
-                            "name": {
-                                "type": "string"
-                            }
-                        },
-                        "additionalProperties": False
-                    }
+                        "properties": {"name": {"type": "string"}},
+                        "additionalProperties": False,
+                    },
                 },
                 "exclude": {
                     "type": "array",
@@ -71,45 +64,33 @@ class CinderClusterDataModelCollector(base.BaseClusterDataModelCollector):
                                 "type": "array",
                                 "items": {
                                     "type": "object",
-                                    "properties": {
-                                        "name": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "additionalProperties": False
-                                }
+                                    "properties": {"name": {"type": "string"}},
+                                    "additionalProperties": False,
+                                },
                             },
                             "volumes": {
                                 "type": "array",
                                 "items": {
                                     "type": "object",
-                                    "properties": {
-                                        "uuid": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "additionalProperties": False
-                                }
+                                    "properties": {"uuid": {"type": "string"}},
+                                    "additionalProperties": False,
+                                },
                             },
                             "projects": {
                                 "type": "array",
                                 "items": {
                                     "type": "object",
-                                    "properties": {
-                                        "uuid": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "additionalProperties": False
-                                }
+                                    "properties": {"uuid": {"type": "string"}},
+                                    "additionalProperties": False,
+                                },
                             },
-                            "additionalProperties": False
-                        }
-                    }
-                }
+                            "additionalProperties": False,
+                        },
+                    },
+                },
             },
-            "additionalProperties": False
-        }
+            "additionalProperties": False,
+        },
     }
 
     def __init__(self, config, osc=None):
@@ -129,15 +110,17 @@ class CinderClusterDataModelCollector(base.BaseClusterDataModelCollector):
             cinder.VolumeUpdateEnd(self),
             cinder.VolumeAttachEnd(self),
             cinder.VolumeDetachEnd(self),
-            cinder.VolumeResizeEnd(self)
+            cinder.VolumeResizeEnd(self),
         ]
 
     def get_audit_scope_handler(self, audit_scope):
         self._audit_scope_handler = storage_scope.StorageScope(
-            audit_scope, self.config)
+            audit_scope, self.config
+        )
         if self._data_model_scope is None or (
-            len(self._data_model_scope) > 0 and (
-                self._data_model_scope != audit_scope)):
+            len(self._data_model_scope) > 0
+            and (self._data_model_scope != audit_scope)
+        ):
             self._data_model_scope = audit_scope
             self._cluster_data_model = None
         LOG.debug("audit scope %s", audit_scope)
@@ -160,7 +143,8 @@ class CinderClusterDataModelCollector(base.BaseClusterDataModelCollector):
         except Exception as e:
             LOG.exception(e)
             raise exception.ClusterDataModelCollectionError(
-                cdm="storage") from e
+                cdm="storage"
+            ) from e
 
 
 class CinderModelBuilder(base.BaseModelBuilder):
@@ -183,16 +167,14 @@ class CinderModelBuilder(base.BaseModelBuilder):
         This includes components which represent actual infrastructure
         hardware.
         """
-        for snode in self.call_retry(
-                self.cinder_helper.get_storage_node_list):
+        for snode in self.call_retry(self.cinder_helper.get_storage_node_list):
             self.add_storage_node(snode)
         for pool in self.call_retry(self.cinder_helper.get_storage_pool_list):
             pool = self._build_storage_pool(pool)
             self.model.add_pool(pool)
             storage_name = getattr(pool, 'name')
             try:
-                storage_node = self.model.get_node_by_name(
-                    storage_name)
+                storage_node = self.model.get_node_by_name(storage_name)
                 # Connect the instance to its compute node
                 self.model.map_pool(pool, storage_node)
             except exception.StorageNodeNotFound:
@@ -222,7 +204,8 @@ class CinderModelBuilder(base.BaseModelBuilder):
             pass
 
         volume_type = self.call_retry(
-            self.cinder_helper.get_volume_type_by_backendname, backend)
+            self.cinder_helper.get_volume_type_by_backendname, backend
+        )
 
         # build up the storage node.
         node_attributes = {
@@ -230,7 +213,8 @@ class CinderModelBuilder(base.BaseModelBuilder):
             "zone": node.zone,
             "state": node.state,
             "status": node.status,
-            "volume_type": volume_type}
+            "volume_type": volume_type,
+        }
 
         storage_node = element.StorageNode(**node_attributes)
         return storage_node
@@ -244,20 +228,26 @@ class CinderModelBuilder(base.BaseModelBuilder):
         """
         # build up the storage pool.
 
-        attrs = ["total_volumes", "total_capacity_gb",
-                 "free_capacity_gb", "provisioned_capacity_gb",
-                 "allocated_capacity_gb"]
+        attrs = [
+            "total_volumes",
+            "total_capacity_gb",
+            "free_capacity_gb",
+            "provisioned_capacity_gb",
+            "allocated_capacity_gb",
+        ]
 
         node_attributes = {"name": pool.name}
         for attr in attrs:
             try:
                 node_attributes[attr] = int(getattr(pool, attr))
             except AttributeError:
-                LOG.debug("Attribute %s for pool %s is not provided",
-                          attr, pool.name)
+                LOG.debug(
+                    "Attribute %s for pool %s is not provided", attr, pool.name
+                )
             except ValueError:
                 raise exception.InvalidPoolAttributeValue(
-                    name=pool.name, attribute=attr)
+                    name=pool.name, attribute=attr
+                )
 
         storage_pool = element.Pool(**node_attributes)
         return storage_pool
@@ -279,8 +269,7 @@ class CinderModelBuilder(base.BaseModelBuilder):
                 # The volume is not attached to any pool
                 continue
             try:
-                pool = self.model.get_pool_by_pool_name(
-                    pool_name)
+                pool = self.model.get_pool_by_pool_name(pool_name)
                 self.model.map_volume(volume, pool)
             except exception.PoolNotFound:
                 continue
@@ -293,8 +282,14 @@ class CinderModelBuilder(base.BaseModelBuilder):
         :param instance: Cinder Volume object.
         :return: A volume node for the graph.
         """
-        attachments = [{k: v for k, v in iter(d.items()) if k in (
-            'server_id', 'attachment_id')} for d in volume.attachments]
+        attachments = [
+            {
+                k: v
+                for k, v in iter(d.items())
+                if k in ('server_id', 'attachment_id')
+            }
+            for d in volume.attachments
+        ]
 
         volume_attributes = {
             "uuid": volume.id,
@@ -306,7 +301,8 @@ class CinderModelBuilder(base.BaseModelBuilder):
             "snapshot_id": volume.snapshot_id or "",
             "project_id": getattr(volume, 'os-vol-tenant-attr:tenant_id'),
             "metadata": volume.metadata,
-            "bootable": volume.bootable}
+            "bootable": volume.bootable,
+        }
 
         return element.Volume(**volume_attributes)
 
diff --git a/watcher/decision_engine/model/collector/ironic.py b/watcher/decision_engine/model/collector/ironic.py
index 1b7068888..4df50a4e6 100644
--- a/watcher/decision_engine/model/collector/ironic.py
+++ b/watcher/decision_engine/model/collector/ironic.py
@@ -48,10 +48,12 @@ class BaremetalClusterDataModelCollector(base.BaseClusterDataModelCollector):
 
     def get_audit_scope_handler(self, audit_scope):
         self._audit_scope_handler = baremetal_scope.BaremetalScope(
-            audit_scope, self.config)
+            audit_scope, self.config
+        )
         if self._data_model_scope is None or (
-            len(self._data_model_scope) > 0 and (
-                self._data_model_scope != audit_scope)):
+            len(self._data_model_scope) > 0
+            and (self._data_model_scope != audit_scope)
+        ):
             self._data_model_scope = audit_scope
             self._cluster_data_model = None
         LOG.debug("audit scope %s", audit_scope)
@@ -74,7 +76,8 @@ class BaremetalClusterDataModelCollector(base.BaseClusterDataModelCollector):
         except Exception as e:
             LOG.exception(e)
             raise exception.ClusterDataModelCollectionError(
-                cdm="baremetal") from e
+                cdm="baremetal"
+            ) from e
 
 
 class BareMetalModelBuilder(base.BaseModelBuilder):
@@ -108,8 +111,8 @@ class BareMetalModelBuilder(base.BaseModelBuilder):
             "power_state": node.power_state,
             "maintenance": node.maintenance,
             "maintenance_reason": node.maintenance_reason,
-            "extra": {"compute_node_id": node.extra.compute_node_id}
-            }
+            "extra": {"compute_node_id": node.extra.compute_node_id},
+        }
 
         ironic_node = element.IronicNode(**node_attributes)
         return ironic_node
diff --git a/watcher/decision_engine/model/collector/manager.py b/watcher/decision_engine/model/collector/manager.py
index 8619f0f7a..2e99b29fa 100644
--- a/watcher/decision_engine/model/collector/manager.py
+++ b/watcher/decision_engine/model/collector/manager.py
@@ -29,7 +29,6 @@ LOG = log.getLogger(__name__)
 
 
 class CollectorManager:
-
     def __init__(self, osc=None):
         self.collector_loader = default.ClusterDataModelCollectorLoader()
         self._collectors = None
@@ -83,5 +82,4 @@ class CollectorManager:
         :returns: cluster data model collector plugin
         :rtype: :py:class:`~.BaseClusterDataModelCollector`
         """
-        return self.collector_loader.load(
-            name, osc=osc)
+        return self.collector_loader.load(name, osc=osc)
diff --git a/watcher/decision_engine/model/collector/nova.py b/watcher/decision_engine/model/collector/nova.py
index ef9820b1d..10ea1564e 100644
--- a/watcher/decision_engine/model/collector/nova.py
+++ b/watcher/decision_engine/model/collector/nova.py
@@ -54,19 +54,15 @@ class NovaClusterDataModelCollector(base.BaseClusterDataModelCollector):
                             {"$ref": HOST_AGGREGATES + "host_aggr_id"},
                             {"$ref": HOST_AGGREGATES + "name"},
                         ]
-                    }
+                    },
                 },
                 "availability_zones": {
                     "type": "array",
                     "items": {
                         "type": "object",
-                        "properties": {
-                            "name": {
-                                "type": "string"
-                            }
-                        },
-                        "additionalProperties": False
-                    }
+                        "properties": {"name": {"type": "string"}},
+                        "additionalProperties": False,
+                    },
                 },
                 "exclude": {
                     "type": "array",
@@ -77,83 +73,62 @@ class NovaClusterDataModelCollector(base.BaseClusterDataModelCollector):
                                 "type": "array",
                                 "items": {
                                     "type": "object",
-                                    "properties": {
-                                        "uuid": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "additionalProperties": False
-                                }
+                                    "properties": {"uuid": {"type": "string"}},
+                                    "additionalProperties": False,
+                                },
                             },
                             "compute_nodes": {
                                 "type": "array",
                                 "items": {
                                     "type": "object",
-                                    "properties": {
-                                        "name": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "additionalProperties": False
-                                }
+                                    "properties": {"name": {"type": "string"}},
+                                    "additionalProperties": False,
+                                },
                             },
                             "host_aggregates": {
                                 "type": "array",
                                 "items": {
                                     "anyOf": [
-                                        {"$ref":
-                                            HOST_AGGREGATES + "host_aggr_id"},
+                                        {
+                                            "$ref": HOST_AGGREGATES
+                                            + "host_aggr_id"
+                                        },
                                         {"$ref": HOST_AGGREGATES + "name"},
                                     ]
-                                }
+                                },
                             },
                             "instance_metadata": {
                                 "type": "array",
-                                "items": {
-                                    "type": "object"
-                                }
+                                "items": {"type": "object"},
                             },
                             "projects": {
                                 "type": "array",
                                 "items": {
                                     "type": "object",
-                                    "properties": {
-                                        "uuid": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "additionalProperties": False
-                                }
-                            }
+                                    "properties": {"uuid": {"type": "string"}},
+                                    "additionalProperties": False,
+                                },
+                            },
                         },
-                        "additionalProperties": False
-                    }
-                }
+                        "additionalProperties": False,
+                    },
+                },
             },
-            "additionalProperties": False
+            "additionalProperties": False,
         },
         "host_aggregates": {
             "host_aggr_id": {
                 "properties": {
-                    "id": {
-                        "oneOf": [
-                            {"type": "integer"},
-                            {"enum": ["*"]}
-                        ]
-                    }
+                    "id": {"oneOf": [{"type": "integer"}, {"enum": ["*"]}]}
                 },
-                "additionalProperties": False
+                "additionalProperties": False,
             },
             "name": {
-                "properties": {
-                    "name": {
-                        "type": "string"
-                    }
-                },
-                "additionalProperties": False
-            }
+                "properties": {"name": {"type": "string"}},
+                "additionalProperties": False,
+            },
         },
-        "additionalProperties": False
+        "additionalProperties": False,
     }
 
     def __init__(self, config, osc=None):
@@ -166,16 +141,16 @@ class NovaClusterDataModelCollector(base.BaseClusterDataModelCollector):
         :return: Associated notification endpoints
         :rtype: List of :py:class:`~.EventsNotificationEndpoint` instances
         """
-        return [
-            nova.VersionedNotification(self),
-        ]
+        return [nova.VersionedNotification(self)]
 
     def get_audit_scope_handler(self, audit_scope):
         self._audit_scope_handler = compute_scope.ComputeScope(
-            audit_scope, self.config)
+            audit_scope, self.config
+        )
         if self._data_model_scope is None or (
-            len(self._data_model_scope) > 0 and (
-                self._data_model_scope != audit_scope)):
+            len(self._data_model_scope) > 0
+            and (self._data_model_scope != audit_scope)
+        ):
             self._data_model_scope = audit_scope
             self._cluster_data_model = None
         LOG.debug("audit scope %s", audit_scope)
@@ -198,7 +173,8 @@ class NovaClusterDataModelCollector(base.BaseClusterDataModelCollector):
         except Exception as e:
             LOG.exception(e)
             raise exception.ClusterDataModelCollectionError(
-                cdm="compute") from e
+                cdm="compute"
+            ) from e
 
 
 class NovaModelBuilder(base.BaseModelBuilder):
@@ -228,24 +204,34 @@ class NovaModelBuilder(base.BaseModelBuilder):
         self.placement_helper = placement_helper.PlacementHelper(osc=self.osc)
         self.executor = threading.DecisionEngineThreadPool()
         self.collector_timeout = (
-            CONF.collector.compute_resources_collector_timeout)
+            CONF.collector.compute_resources_collector_timeout
+        )
 
     def _collect_aggregates(self, host_aggregates, _nodes):
         if not host_aggregates:
             return
 
         aggregate_list = self.call_retry(f=self.nova_helper.get_aggregate_list)
-        aggregate_ids = [aggregate['id'] for aggregate
-                         in host_aggregates if 'id' in aggregate]
-        aggregate_names = [aggregate['name'] for aggregate
-                           in host_aggregates if 'name' in aggregate]
-        include_all_nodes = any('*' in field
-                                for field in (aggregate_ids, aggregate_names))
+        aggregate_ids = [
+            aggregate['id']
+            for aggregate in host_aggregates
+            if 'id' in aggregate
+        ]
+        aggregate_names = [
+            aggregate['name']
+            for aggregate in host_aggregates
+            if 'name' in aggregate
+        ]
+        include_all_nodes = any(
+            '*' in field for field in (aggregate_ids, aggregate_names)
+        )
 
         for aggregate in aggregate_list:
-            if (aggregate.id in aggregate_ids or
-                aggregate.name in aggregate_names or
-                    include_all_nodes):
+            if (
+                aggregate.id in aggregate_ids
+                or aggregate.name in aggregate_names
+                or include_all_nodes
+            ):
                 _nodes.update(aggregate.hosts)
 
     def _collect_zones(self, availability_zones, _nodes):
@@ -253,8 +239,7 @@ class NovaModelBuilder(base.BaseModelBuilder):
             return
 
         service_list = self.call_retry(f=self.nova_helper.get_service_list)
-        zone_names = [zone['name'] for zone
-                      in availability_zones]
+        zone_names = [zone['name'] for zone in availability_zones]
         include_all_nodes = False
         if '*' in zone_names:
             include_all_nodes = True
@@ -284,11 +269,14 @@ class NovaModelBuilder(base.BaseModelBuilder):
                 return
             future_instances.append(
                 self.executor.submit(
-                    self.add_instance_node, node_info, instances)
+                    self.add_instance_node, node_info, instances
+                )
             )
         except Exception:
-            LOG.error("compute node from aggregate / "
-                      "availability_zone could not be found")
+            LOG.error(
+                "compute node from aggregate / "
+                "availability_zone could not be found"
+            )
 
     def _add_physical_layer(self):
         """Collects all information on compute nodes and instances
@@ -317,18 +305,22 @@ class NovaModelBuilder(base.BaseModelBuilder):
         enabled."""
         zone_aggregate_futures = {
             self.executor.submit(
-                self._collect_aggregates, host_aggregates, compute_nodes),
+                self._collect_aggregates, host_aggregates, compute_nodes
+            ),
             self.executor.submit(
-                self._collect_zones, availability_zones, compute_nodes)
+                self._collect_zones, availability_zones, compute_nodes
+            ),
         }
         _done, zone_aggregate_not_done = waiters.wait_for_all(
-            zone_aggregate_futures,
-            timeout=self.collector_timeout)
+            zone_aggregate_futures, timeout=self.collector_timeout
+        )
 
         if len(zone_aggregate_not_done) > 0:
-            LOG.warning("Timed out waiting to collect compute nodes "
-                        "from availability zones and host aggregates. "
-                        "Aborting collection of compute nodes information")
+            LOG.warning(
+                "Timed out waiting to collect compute nodes "
+                "from availability zones and host aggregates. "
+                "Aborting collection of compute nodes information"
+            )
             for future in zone_aggregate_not_done:
                 future.cancel()
             # Return and don't continue with the collection
@@ -338,32 +330,41 @@ class NovaModelBuilder(base.BaseModelBuilder):
         if not compute_nodes:
             self.no_model_scope_flag = True
             all_nodes = self.call_retry(
-                f=self.nova_helper.get_compute_node_list)
-            compute_nodes = {
-                node.hypervisor_hostname for node in all_nodes}
+                f=self.nova_helper.get_compute_node_list
+            )
+            compute_nodes = {node.hypervisor_hostname for node in all_nodes}
         LOG.debug("compute nodes: %s", compute_nodes)
 
-        node_futures = [self.executor.submit(
-            self.nova_helper.get_compute_node_by_name,
-            node, servers=True, detailed=True)
-            for node in compute_nodes]
+        node_futures = [
+            self.executor.submit(
+                self.nova_helper.get_compute_node_by_name,
+                node,
+                servers=True,
+                detailed=True,
+            )
+            for node in compute_nodes
+        ]
         LOG.debug("submitted %d jobs", len(compute_nodes))
 
         # Futures will concurrently be added, only safe with CPython GIL
         future_instances = []
         self.executor.do_while_futures_modify(
             node_futures,
-            self._compute_node_future, future_instances,
-            futures_timeout=self.collector_timeout)
+            self._compute_node_future,
+            future_instances,
+            futures_timeout=self.collector_timeout,
+        )
 
         # Wait for all instance jobs to finish
         _done, instances_not_done = waiters.wait_for_all(
-            future_instances,
-            timeout=self.collector_timeout)
+            future_instances, timeout=self.collector_timeout
+        )
         if len(instances_not_done) > 0:
-            LOG.warning("Timed out waiting to collect instances "
-                        "information for compute nodes. "
-                        "Aborting collection of instances information.")
+            LOG.warning(
+                "Timed out waiting to collect instances "
+                "information for compute nodes. "
+                "Aborting collection of instances information."
+            )
             for future in instances_not_done:
                 future.cancel()
             # Return and don't continue with the collection
@@ -447,7 +448,8 @@ class NovaModelBuilder(base.BaseModelBuilder):
             "vcpu_ratio": vcpu_ratio,
             "state": node.state,
             "status": node.status,
-            "disabled_reason": node.service_disabled_reason}
+            "disabled_reason": node.service_disabled_reason,
+        }
 
         compute_node = element.ComputeNode(**node_attributes)
         # compute_node = self._build_node("physical", "compute", "hypervisor",
@@ -469,12 +471,12 @@ class NovaModelBuilder(base.BaseModelBuilder):
         # compute API. If we need to request more than 1000 servers,
         # we can set limit=-1. For details, please see:
         # https://bugs.launchpad.net/watcher/+bug/1834679
-        instances = self.call_retry(f=self.nova_helper.get_instance_list,
-                                    filters=filters, limit=limit)
+        instances = self.call_retry(
+            f=self.nova_helper.get_instance_list, filters=filters, limit=limit
+        )
         for inst in instances:
             # skip deleted instance
-            if inst.vm_state == (
-                    element.InstanceState.DELETED.value):
+            if inst.vm_state == (element.InstanceState.DELETED.value):
                 continue
             # Add Node
             instance = self._build_instance_node(inst)
@@ -508,9 +510,9 @@ class NovaModelBuilder(base.BaseModelBuilder):
         }
 
         if self.model.extended_attributes_enabled:
-            instance_attributes.update({
-                "flavor_extra_specs": flavor["extra_specs"],
-            })
+            instance_attributes.update(
+                {"flavor_extra_specs": flavor["extra_specs"]}
+            )
             if self.nova_helper.is_pinned_az_available():
                 instance_attributes["pinned_az"] = (
                     instance.pinned_availability_zone
diff --git a/watcher/decision_engine/model/element/__init__.py b/watcher/decision_engine/model/element/__init__.py
index 06ac764ed..30416c656 100644
--- a/watcher/decision_engine/model/element/__init__.py
+++ b/watcher/decision_engine/model/element/__init__.py
@@ -31,12 +31,14 @@ Instance = instance.Instance
 VolumeState = volume.VolumeState
 Volume = volume.Volume
 
-__all__ = ['ServiceState',
-           'ComputeNode',
-           'InstanceState',
-           'Instance',
-           'StorageNode',
-           'Pool',
-           'VolumeState',
-           'Volume',
-           'IronicNode']
+__all__ = [
+    'ServiceState',
+    'ComputeNode',
+    'InstanceState',
+    'Instance',
+    'StorageNode',
+    'Pool',
+    'VolumeState',
+    'Volume',
+    'IronicNode',
+]
diff --git a/watcher/decision_engine/model/element/baremetal_resource.py b/watcher/decision_engine/model/element/baremetal_resource.py
index e2028df8f..a8651d936 100644
--- a/watcher/decision_engine/model/element/baremetal_resource.py
+++ b/watcher/decision_engine/model/element/baremetal_resource.py
@@ -20,7 +20,6 @@ from watcher.objects import fields as wfields
 
 
 class BaremetalResource(base.Element, metaclass=abc.ABCMeta):
-
     VERSION = '1.0'
 
     fields = {
diff --git a/watcher/decision_engine/model/element/base.py b/watcher/decision_engine/model/element/base.py
index ee263943b..505896e55 100644
--- a/watcher/decision_engine/model/element/base.py
+++ b/watcher/decision_engine/model/element/base.py
@@ -28,9 +28,12 @@ from watcher.objects import fields as wfields
 LOG = log.getLogger(__name__)
 
 
-class Element(base.WatcherObject, base.WatcherObjectDictCompat,
-              base.WatcherComparableObject, metaclass=abc.ABCMeta):
-
+class Element(
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+    base.WatcherComparableObject,
+    metaclass=abc.ABCMeta,
+):
     # Initial version
     VERSION = '1.0'
 
@@ -40,8 +43,11 @@ class Element(base.WatcherObject, base.WatcherObjectDictCompat,
         for name, field in self.fields.items():
             # The idea here is to force the initialization of unspecified
             # fields that have a default value
-            if (name not in kwargs and not field.nullable and
-                    field.default != wfields.UnspecifiedDefault):
+            if (
+                name not in kwargs
+                and not field.nullable
+                and field.default != wfields.UnspecifiedDefault
+            ):
                 kwargs[name] = field.default
         super().__init__(context, **kwargs)
 
@@ -57,8 +63,12 @@ class Element(base.WatcherObject, base.WatcherObjectDictCompat,
                 value = str(self[field])
                 sorted_fieldmap.append((field, value))
             except NotImplementedError:
-                LOG.debug("Attribute %s for object %s: %s is not provided",
-                          field, element_name, self)
+                LOG.debug(
+                    "Attribute %s for object %s: %s is not provided",
+                    field,
+                    element_name,
+                    self,
+                )
             except Exception as exc:
                 LOG.exception(exc)
 
diff --git a/watcher/decision_engine/model/element/compute_resource.py b/watcher/decision_engine/model/element/compute_resource.py
index 448845913..450b138e3 100644
--- a/watcher/decision_engine/model/element/compute_resource.py
+++ b/watcher/decision_engine/model/element/compute_resource.py
@@ -20,9 +20,6 @@ from watcher.objects import fields as wfields
 
 
 class ComputeResource(base.Element, metaclass=abc.ABCMeta):
-
     VERSION = '1.0'
 
-    fields = {
-        "uuid": wfields.StringField(),
-    }
+    fields = {"uuid": wfields.StringField()}
diff --git a/watcher/decision_engine/model/element/instance.py b/watcher/decision_engine/model/element/instance.py
index 45d3f5e2e..464fb9e95 100644
--- a/watcher/decision_engine/model/element/instance.py
+++ b/watcher/decision_engine/model/element/instance.py
@@ -40,7 +40,6 @@ class InstanceState(enum.Enum):
 
 @base.WatcherObjectRegistry.register_if(False)
 class Instance(compute_resource.ComputeResource):
-
     fields = {
         # If the resource is excluded by the scope,
         # 'watcher_exclude' property will be set True.
diff --git a/watcher/decision_engine/model/element/node.py b/watcher/decision_engine/model/element/node.py
index 1b07a77b4..ba0b8c8f2 100644
--- a/watcher/decision_engine/model/element/node.py
+++ b/watcher/decision_engine/model/element/node.py
@@ -31,7 +31,6 @@ class ServiceState(enum.Enum):
 
 @base.WatcherObjectRegistry.register_if(False)
 class ComputeNode(compute_resource.ComputeResource):
-
     fields = {
         "hostname": wfields.StringField(),
         "status": wfields.StringField(default=ServiceState.ENABLED.value),
@@ -53,26 +52,25 @@ class ComputeNode(compute_resource.ComputeResource):
 
     @property
     def memory_mb_capacity(self):
-        return (self.memory-self.memory_mb_reserved)*self.memory_ratio
+        return (self.memory - self.memory_mb_reserved) * self.memory_ratio
 
     @property
     def disk_gb_capacity(self):
-        return (self.disk-self.disk_gb_reserved)*self.disk_ratio
+        return (self.disk - self.disk_gb_reserved) * self.disk_ratio
 
     @property
     def vcpu_capacity(self):
-        return (self.vcpus-self.vcpu_reserved)*self.vcpu_ratio
+        return (self.vcpus - self.vcpu_reserved) * self.vcpu_ratio
 
 
 @base.WatcherObjectRegistry.register_if(False)
 class StorageNode(storage_resource.StorageResource):
-
     fields = {
         "host": wfields.StringField(),
         "zone": wfields.StringField(),
         "status": wfields.StringField(default=ServiceState.ENABLED.value),
         "state": wfields.StringField(default=ServiceState.ONLINE.value),
-        "volume_type": wfields.ListOfStringsField()
+        "volume_type": wfields.ListOfStringsField(),
     }
 
     def accept(self, visitor):
@@ -81,7 +79,6 @@ class StorageNode(storage_resource.StorageResource):
 
 @base.WatcherObjectRegistry.register_if(False)
 class Pool(storage_resource.StorageResource):
-
     fields = {
         "name": wfields.StringField(),
         "total_volumes": wfields.NonNegativeIntegerField(),
@@ -98,12 +95,11 @@ class Pool(storage_resource.StorageResource):
 
 @base.WatcherObjectRegistry.register_if(False)
 class IronicNode(baremetal_resource.BaremetalResource):
-
     fields = {
         "power_state": wfields.StringField(),
         "maintenance": wfields.BooleanField(),
         "maintenance_reason": wfields.StringField(),
-        "extra": wfields.DictField()
+        "extra": wfields.DictField(),
     }
 
     def accept(self, visitor):
diff --git a/watcher/decision_engine/model/element/storage_resource.py b/watcher/decision_engine/model/element/storage_resource.py
index c2195955a..7a19676b6 100644
--- a/watcher/decision_engine/model/element/storage_resource.py
+++ b/watcher/decision_engine/model/element/storage_resource.py
@@ -20,7 +20,6 @@ from watcher.objects import fields as wfields
 
 
 class StorageResource(base.Element, metaclass=abc.ABCMeta):
-
     VERSION = '1.0'
 
     fields = {
diff --git a/watcher/decision_engine/model/element/volume.py b/watcher/decision_engine/model/element/volume.py
index 00f6ecc66..f4a0d66da 100644
--- a/watcher/decision_engine/model/element/volume.py
+++ b/watcher/decision_engine/model/element/volume.py
@@ -38,7 +38,6 @@ class VolumeState(enum.Enum):
 
 @base.WatcherObjectRegistry.register_if(False)
 class Volume(storage_resource.StorageResource):
-
     fields = {
         "size": wfields.NonNegativeIntegerField(),
         "status": wfields.StringField(default=VolumeState.AVAILABLE.value),
@@ -48,7 +47,7 @@ class Volume(storage_resource.StorageResource):
         "snapshot_id": wfields.UUIDField(nullable=True),
         "project_id": wfields.UUIDField(),
         "metadata": wfields.JsonField(),
-        "bootable": wfields.BooleanField()
+        "bootable": wfields.BooleanField(),
     }
 
     def accept(self, visitor):
diff --git a/watcher/decision_engine/model/model_root.py b/watcher/decision_engine/model/model_root.py
index 4af345c9a..d4d8fbbce 100644
--- a/watcher/decision_engine/model/model_root.py
+++ b/watcher/decision_engine/model/model_root.py
@@ -51,7 +51,8 @@ class ModelRoot(nx.DiGraph, base.Model):
     def extended_attributes_enabled(self):
         if self._extended_attributes_enabled is None:
             self._extended_attributes_enabled = (
-                CONF.compute_model.enable_extended_attributes)
+                CONF.compute_model.enable_extended_attributes
+            )
         return self._extended_attributes_enabled
 
     @extended_attributes_enabled.setter
@@ -62,13 +63,15 @@ class ModelRoot(nx.DiGraph, base.Model):
     def assert_node(obj):
         if not isinstance(obj, element.ComputeNode):
             raise exception.IllegalArgumentException(
-                message=_("'obj' argument type is not valid: %s") % type(obj))
+                message=_("'obj' argument type is not valid: %s") % type(obj)
+            )
 
     @staticmethod
     def assert_instance(obj):
         if not isinstance(obj, element.Instance):
             raise exception.IllegalArgumentException(
-                message=_("'obj' argument type is not valid"))
+                message=_("'obj' argument type is not valid")
+            )
 
     @lockutils.synchronized("model_root")
     def add_node(self, node):
@@ -154,8 +157,11 @@ class ModelRoot(nx.DiGraph, base.Model):
 
     @lockutils.synchronized("model_root")
     def get_all_compute_nodes(self):
-        return {uuid: cn['attr'] for uuid, cn in self.nodes(data=True)
-                if isinstance(cn['attr'], element.ComputeNode)}
+        return {
+            uuid: cn['attr']
+            for uuid, cn in self.nodes(data=True)
+            if isinstance(cn['attr'], element.ComputeNode)
+        }
 
     @lockutils.synchronized("model_root")
     def get_node_by_uuid(self, uuid):
@@ -167,9 +173,14 @@ class ModelRoot(nx.DiGraph, base.Model):
     @lockutils.synchronized("model_root")
     def get_node_by_name(self, name):
         try:
-            node_list = [cn['attr'] for uuid, cn in self.nodes(data=True)
-                         if (isinstance(cn['attr'], element.ComputeNode) and
-                         cn['attr']['hostname'] == name)]
+            node_list = [
+                cn['attr']
+                for uuid, cn in self.nodes(data=True)
+                if (
+                    isinstance(cn['attr'], element.ComputeNode)
+                    and cn['attr']['hostname'] == name
+                )
+            ]
             if node_list:
                 return node_list[0]
             else:
@@ -202,8 +213,11 @@ class ModelRoot(nx.DiGraph, base.Model):
 
     @lockutils.synchronized("model_root")
     def get_all_instances(self):
-        return {uuid: inst['attr'] for uuid, inst in self.nodes(data=True)
-                if isinstance(inst['attr'], element.Instance)}
+        return {
+            uuid: inst['attr']
+            for uuid, inst in self.nodes(data=True)
+            if isinstance(inst['attr'], element.Instance)
+        }
 
     @lockutils.synchronized("model_root")
     def get_node_instances(self, node):
@@ -229,9 +243,9 @@ class ModelRoot(nx.DiGraph, base.Model):
 
     def get_node_free_resources(self, node):
         resources_used = self.get_node_used_resources(node)
-        vcpu_free = node.vcpu_capacity-resources_used.get('vcpu')
-        memory_free = node.memory_mb_capacity-resources_used.get('memory')
-        disk_free = node.disk_gb_capacity-resources_used.get('disk')
+        vcpu_free = node.vcpu_capacity - resources_used.get('vcpu')
+        memory_free = node.memory_mb_capacity - resources_used.get('memory')
+        disk_free = node.disk_gb_capacity - resources_used.get('disk')
 
         return dict(vcpu=vcpu_free, memory=memory_free, disk=disk_free)
 
@@ -241,8 +255,9 @@ class ModelRoot(nx.DiGraph, base.Model):
     def to_xml(self):
         root = etree.Element("ModelRoot")
         # Build compute node tree
-        for cn in sorted(self.get_all_compute_nodes().values(),
-                         key=lambda cn: cn.uuid):
+        for cn in sorted(
+            self.get_all_compute_nodes().values(), key=lambda cn: cn.uuid
+        ):
             compute_node_el = cn.as_xml_element()
 
             # Build mapped instance tree
@@ -254,8 +269,9 @@ class ModelRoot(nx.DiGraph, base.Model):
             root.append(compute_node_el)
 
         # Build unmapped instance tree (i.e. not assigned to any compute node)
-        for instance in sorted(self.get_all_instances().values(),
-                               key=lambda inst: inst.uuid):
+        for instance in sorted(
+            self.get_all_instances().values(), key=lambda inst: inst.uuid
+        ):
             try:
                 self.get_node_by_instance_uuid(instance.uuid)
             except exception.ComputeResourceNotFound:
@@ -265,19 +281,23 @@ class ModelRoot(nx.DiGraph, base.Model):
 
     def to_list(self):
         ret_list = []
-        for cn in sorted(self.get_all_compute_nodes().values(),
-                         key=lambda cn: cn.uuid):
+        for cn in sorted(
+            self.get_all_compute_nodes().values(), key=lambda cn: cn.uuid
+        ):
             in_dict = {}
             for field in cn.fields:
-                new_name = "node_"+str(field)
+                new_name = "node_" + str(field)
                 try:
                     in_dict[new_name] = cn[field]
                 # NotImplementedError means field not assigned
                 # which is really not an issue as it can be an
                 # optional field
                 except NotImplementedError:
-                    LOG.debug("Attribute %s for Compute: %s is not provided",
-                              field, cn.hostname)
+                    LOG.debug(
+                        "Attribute %s for Compute: %s is not provided",
+                        field,
+                        cn.hostname,
+                    )
             node_instances = self.get_node_instances(cn)
             if not node_instances:
                 deep_in_dict = in_dict.copy()
@@ -285,12 +305,15 @@ class ModelRoot(nx.DiGraph, base.Model):
                 continue
             for instance in sorted(node_instances, key=lambda x: x.uuid):
                 for field in instance.fields:
-                    new_name = "server_"+str(field)
+                    new_name = "server_" + str(field)
                     try:
                         in_dict[new_name] = instance[field]
                     except NotImplementedError:
-                        LOG.debug("Attribute %s for Instance: %s is not "
-                                  "provided", field, instance.uuid)
+                        LOG.debug(
+                            "Attribute %s for Instance: %s is not provided",
+                            field,
+                            instance.uuid,
+                        )
                 if in_dict != {}:
                     deep_in_dict = in_dict.copy()
                     ret_list.append(deep_in_dict)
@@ -308,7 +331,8 @@ class ModelRoot(nx.DiGraph, base.Model):
         for inst in root.findall('.//Instance'):
             instance = element.Instance(**inst.attrib)
             instance.watcher_exclude = ast.literal_eval(
-                inst.attrib["watcher_exclude"])
+                inst.attrib["watcher_exclude"]
+            )
             model.add_instance(instance)
 
             parent = inst.getparent()
@@ -324,8 +348,10 @@ class ModelRoot(nx.DiGraph, base.Model):
     def is_isomorphic(cls, G1, G2):
         def node_match(node1, node2):
             return node1['attr'].as_dict() == node2['attr'].as_dict()
+
         return nx.algorithms.isomorphism.isomorph.is_isomorphic(
-            G1, G2, node_match=node_match)
+            G1, G2, node_match=node_match
+        )
 
 
 class StorageModelRoot(nx.DiGraph, base.Model):
@@ -344,19 +370,22 @@ class StorageModelRoot(nx.DiGraph, base.Model):
     def assert_node(obj):
         if not isinstance(obj, element.StorageNode):
             raise exception.IllegalArgumentException(
-                message=_("'obj' argument type is not valid: %s") % type(obj))
+                message=_("'obj' argument type is not valid: %s") % type(obj)
+            )
 
     @staticmethod
     def assert_pool(obj):
         if not isinstance(obj, element.Pool):
             raise exception.IllegalArgumentException(
-                message=_("'obj' argument type is not valid: %s") % type(obj))
+                message=_("'obj' argument type is not valid: %s") % type(obj)
+            )
 
     @staticmethod
     def assert_volume(obj):
         if not isinstance(obj, element.Volume):
             raise exception.IllegalArgumentException(
-                message=_("'obj' argument type is not valid: %s") % type(obj))
+                message=_("'obj' argument type is not valid: %s") % type(obj)
+            )
 
     @lockutils.synchronized("storage_model")
     def add_node(self, node):
@@ -466,8 +495,11 @@ class StorageModelRoot(nx.DiGraph, base.Model):
 
     @lockutils.synchronized("storage_model")
     def get_all_storage_nodes(self):
-        return {host: cn['attr'] for host, cn in self.nodes(data=True)
-                if isinstance(cn['attr'], element.StorageNode)}
+        return {
+            host: cn['attr']
+            for host, cn in self.nodes(data=True)
+            if isinstance(cn['attr'], element.StorageNode)
+        }
 
     @lockutils.synchronized("storage_model")
     def get_node_by_name(self, name):
@@ -488,8 +520,9 @@ class StorageModelRoot(nx.DiGraph, base.Model):
         try:
             return self._get_by_uuid(uuid)
         except exception.StorageResourceNotFound:
-            LOG.debug("Volume %(volume)s not found in the model",
-                      dict(volume=uuid))
+            LOG.debug(
+                "Volume %(volume)s not found in the model", dict(volume=uuid)
+            )
             raise exception.VolumeNotFound(name=uuid)
 
     def _get_by_uuid(self, uuid):
@@ -539,8 +572,11 @@ class StorageModelRoot(nx.DiGraph, base.Model):
 
     @lockutils.synchronized("storage_model")
     def get_all_volumes(self):
-        return {name: vol['attr'] for name, vol in self.nodes(data=True)
-                if isinstance(vol['attr'], element.Volume)}
+        return {
+            name: vol['attr']
+            for name, vol in self.nodes(data=True)
+            if isinstance(vol['attr'], element.Volume)
+        }
 
     @lockutils.synchronized("storage_model")
     def get_pool_volumes(self, pool):
@@ -559,8 +595,9 @@ class StorageModelRoot(nx.DiGraph, base.Model):
     def to_xml(self):
         root = etree.Element("ModelRoot")
         # Build storage node tree
-        for cn in sorted(self.get_all_storage_nodes().values(),
-                         key=lambda cn: cn.host):
+        for cn in sorted(
+            self.get_all_storage_nodes().values(), key=lambda cn: cn.host
+        ):
             storage_node_el = cn.as_xml_element()
             # Build mapped pool tree
             node_pools = self.get_node_pools(cn)
@@ -576,8 +613,9 @@ class StorageModelRoot(nx.DiGraph, base.Model):
             root.append(storage_node_el)
 
         # Build unmapped volume tree (i.e. not assigned to any pool)
-        for volume in sorted(self.get_all_volumes().values(),
-                             key=lambda vol: vol.uuid):
+        for volume in sorted(
+            self.get_all_volumes().values(), key=lambda vol: vol.uuid
+        ):
             try:
                 self.get_pool_by_volume(volume)
             except (exception.VolumeNotFound, exception.PoolNotFound):
@@ -626,12 +664,10 @@ class StorageModelRoot(nx.DiGraph, base.Model):
 
     @classmethod
     def is_isomorphic(cls, G1, G2):
-        return nx.algorithms.isomorphism.isomorph.is_isomorphic(
-            G1, G2)
+        return nx.algorithms.isomorphism.isomorph.is_isomorphic(G1, G2)
 
 
 class BaremetalModelRoot(nx.DiGraph, base.Model):
-
     """Cluster graph for an Openstack cluster: Baremetal Cluster."""
 
     def __init__(self, stale=False):
@@ -647,7 +683,8 @@ class BaremetalModelRoot(nx.DiGraph, base.Model):
     def assert_node(obj):
         if not isinstance(obj, element.IronicNode):
             raise exception.IllegalArgumentException(
-                message=_("'obj' argument type is not valid: %s") % type(obj))
+                message=_("'obj' argument type is not valid: %s") % type(obj)
+            )
 
     @lockutils.synchronized("baremetal_model")
     def add_node(self, node):
@@ -665,8 +702,11 @@ class BaremetalModelRoot(nx.DiGraph, base.Model):
 
     @lockutils.synchronized("baremetal_model")
     def get_all_ironic_nodes(self):
-        return {uuid: cn['attr'] for uuid, cn in self.nodes(data=True)
-                if isinstance(cn['attr'], element.IronicNode)}
+        return {
+            uuid: cn['attr']
+            for uuid, cn in self.nodes(data=True)
+            if isinstance(cn['attr'], element.IronicNode)
+        }
 
     @lockutils.synchronized("baremetal_model")
     def get_node_by_uuid(self, uuid):
@@ -688,8 +728,9 @@ class BaremetalModelRoot(nx.DiGraph, base.Model):
     def to_xml(self):
         root = etree.Element("ModelRoot")
         # Build Ironic node tree
-        for cn in sorted(self.get_all_ironic_nodes().values(),
-                         key=lambda cn: cn.uuid):
+        for cn in sorted(
+            self.get_all_ironic_nodes().values(), key=lambda cn: cn.uuid
+        ):
             ironic_node_el = cn.as_xml_element()
             root.append(ironic_node_el)
 
@@ -708,5 +749,4 @@ class BaremetalModelRoot(nx.DiGraph, base.Model):
 
     @classmethod
     def is_isomorphic(cls, G1, G2):
-        return nx.algorithms.isomorphism.isomorph.is_isomorphic(
-            G1, G2)
+        return nx.algorithms.isomorphism.isomorph.is_isomorphic(G1, G2)
diff --git a/watcher/decision_engine/model/notification/base.py b/watcher/decision_engine/model/notification/base.py
index 321d9ad39..fe0b2f317 100644
--- a/watcher/decision_engine/model/notification/base.py
+++ b/watcher/decision_engine/model/notification/base.py
@@ -19,7 +19,6 @@ import abc
 
 
 class NotificationEndpoint(metaclass=abc.ABCMeta):
-
     def __init__(self, collector):
         super().__init__()
         self.collector = collector
diff --git a/watcher/decision_engine/model/notification/cinder.py b/watcher/decision_engine/model/notification/cinder.py
index f18c07156..7f21a44a8 100644
--- a/watcher/decision_engine/model/notification/cinder.py
+++ b/watcher/decision_engine/model/notification/cinder.py
@@ -26,7 +26,6 @@ LOG = log.getLogger(__name__)
 
 
 class CinderNotification(base.NotificationEndpoint):
-
     def __init__(self, collector):
         super().__init__(collector)
         self._cinder = None
@@ -39,13 +38,15 @@ class CinderNotification(base.NotificationEndpoint):
 
     def update_pool(self, pool, data):
         """Update the storage pool using the notification data."""
-        pool.update({
-            "total_capacity_gb": data['total'],
-            "free_capacity_gb": data['free'],
-            "provisioned_capacity_gb": data['provisioned'],
-            "allocated_capacity_gb": data['allocated'],
-            "virtual_free": data['virtual_free']
-        })
+        pool.update(
+            {
+                "total_capacity_gb": data['total'],
+                "free_capacity_gb": data['free'],
+                "provisioned_capacity_gb": data['provisioned'],
+                "allocated_capacity_gb": data['allocated'],
+                "virtual_free": data['virtual_free'],
+            }
+        )
 
         node_name = pool.name.split("#")[0]
         node = self.get_or_create_node(node_name)
@@ -57,13 +58,15 @@ class CinderNotification(base.NotificationEndpoint):
         if not pool:
             return
         _pool = self.cinder.get_storage_pool_by_name(pool.name)
-        pool.update({
-            "total_volumes": _pool.total_volumes,
-            "total_capacity_gb": _pool.total_capacity_gb,
-            "free_capacity_gb": _pool.free_capacity_gb,
-            "provisioned_capacity_gb": _pool.provisioned_capacity_gb,
-            "allocated_capacity_gb": _pool.allocated_capacity_gb
-        })
+        pool.update(
+            {
+                "total_volumes": _pool.total_volumes,
+                "total_capacity_gb": _pool.total_capacity_gb,
+                "free_capacity_gb": _pool.free_capacity_gb,
+                "provisioned_capacity_gb": _pool.provisioned_capacity_gb,
+                "allocated_capacity_gb": _pool.allocated_capacity_gb,
+            }
+        )
         node_name = pool.name.split("#")[0]
         node = self.get_or_create_node(node_name)
         self.cluster_data_model.map_pool(pool, node)
@@ -75,13 +78,15 @@ class CinderNotification(base.NotificationEndpoint):
             _node = self.cinder.get_storage_node_by_name(name)
             _volume_type = self.cinder.get_volume_type_by_backendname(
                 # name is formatted as host@backendname
-                name.split('@')[1])
+                name.split('@')[1]
+            )
             storage_node = element.StorageNode(
                 host=_node.host,
                 zone=_node.zone,
                 state=_node.state,
                 status=_node.status,
-                volume_type=_volume_type)
+                volume_type=_volume_type,
+            )
             return storage_node
         except Exception as exc:
             LOG.exception(exc)
@@ -113,7 +118,8 @@ class CinderNotification(base.NotificationEndpoint):
                 total_capacity_gb=_pool.total_capacity_gb,
                 free_capacity_gb=_pool.free_capacity_gb,
                 provisioned_capacity_gb=_pool.provisioned_capacity_gb,
-                allocated_capacity_gb=_pool.allocated_capacity_gb)
+                allocated_capacity_gb=_pool.allocated_capacity_gb,
+            )
             return pool
         except Exception as exc:
             LOG.exception(exc)
@@ -139,14 +145,17 @@ class CinderNotification(base.NotificationEndpoint):
             if pool_name:
                 self.get_or_create_pool(pool_name)
         except exception.PoolNotFound:
-            LOG.warning("Could not find storage pool %(pool)s for "
-                        "volume %(volume)s",
-                        dict(pool=pool_name, volume=volume_id))
+            LOG.warning(
+                "Could not find storage pool %(pool)s for volume %(volume)s",
+                dict(pool=pool_name, volume=volume_id),
+            )
         try:
             return self.cluster_data_model.get_volume_by_uuid(volume_id)
         except exception.VolumeNotFound:
-            LOG.debug("Volume %(volume)s not found in the model, creating it",
-                      dict(volume=volume_id))
+            LOG.debug(
+                "Volume %(volume)s not found in the model, creating it",
+                dict(volume=volume_id),
+            )
             # The volume didn't exist yet so we create a new volume object
             volume = element.Volume(uuid=volume_id)
             self.cluster_data_model.add_volume(volume)
@@ -162,8 +171,11 @@ class CinderNotification(base.NotificationEndpoint):
                 return 'attachment_id'
 
         attachments = [
-            {_keyReplace(k): v for k, v in iter(d.items())
-                if k in ('instance_uuid', 'id')}
+            {
+                _keyReplace(k): v
+                for k, v in iter(d.items())
+                if k in ('instance_uuid', 'id')
+            }
             for d in data['volume_attachment']
         ]
 
@@ -172,16 +184,18 @@ class CinderNotification(base.NotificationEndpoint):
         if 'glance_metadata' in data:
             bootable = True
 
-        volume.update({
-            "name": data['display_name'] or "",
-            "size": data['size'],
-            "status": data['status'],
-            "attachments": attachments,
-            "snapshot_id": data['snapshot_id'] or "",
-            "project_id": data['tenant_id'],
-            "metadata": data['metadata'],
-            "bootable": bootable
-            })
+        volume.update(
+            {
+                "name": data['display_name'] or "",
+                "size": data['size'],
+                "status": data['status'],
+                "attachments": attachments,
+                "snapshot_id": data['snapshot_id'] or "",
+                "project_id": data['tenant_id'],
+                "metadata": data['metadata'],
+                "bootable": bootable,
+            }
+        )
 
         try:
             # if volume is under pool, let's update pool element.
@@ -198,14 +212,15 @@ class CinderNotification(base.NotificationEndpoint):
     def update_volume_mapping(self, volume, pool):
         if pool is None:
             self.cluster_data_model.add_volume(volume)
-            LOG.debug("Volume %s not yet attached to any pool: skipping",
-                      volume.uuid)
+            LOG.debug(
+                "Volume %s not yet attached to any pool: skipping", volume.uuid
+            )
             return
         try:
             try:
-                current_pool = (
-                    self.cluster_data_model.get_pool_by_volume(
-                        volume) or self.get_or_create_pool(pool.name))
+                current_pool = self.cluster_data_model.get_pool_by_volume(
+                    volume
+                ) or self.get_or_create_pool(pool.name)
             except exception.PoolNotFound as exc:
                 LOG.exception(exc)
                 # If we can't create the pool,
@@ -214,8 +229,9 @@ class CinderNotification(base.NotificationEndpoint):
 
             LOG.debug("Mapped pool %s found", pool.name)
             if current_pool and pool != current_pool:
-                LOG.debug("Unmapping volume %s from %s",
-                          volume.uuid, pool.name)
+                LOG.debug(
+                    "Unmapping volume %s from %s", volume.uuid, pool.name
+                )
                 self.cluster_data_model.unmap_volume(volume, current_pool)
         except exception.VolumeNotFound:
             # The instance didn't exist yet so we map it for the first time
@@ -243,27 +259,27 @@ class CinderNotification(base.NotificationEndpoint):
 
 
 class CapacityNotificationEndpoint(CinderNotification):
-
     @property
     def filter_rule(self):
         """Cinder capacity notification filter"""
         return filtering.NotificationFilter(
-            publisher_id=r'capacity.*',
-            event_type='capacity.pool',
+            publisher_id=r'capacity.*', event_type='capacity.pool'
         )
 
     def info(self, ctxt, publisher_id, event_type, payload, metadata):
         ctxt.request_id = metadata['message_id']
         ctxt.project_domain = event_type
-        LOG.info("Event '%(event)s' received from %(publisher)s "
-                 "with metadata %(metadata)s",
-                 dict(event=event_type,
-                      publisher=publisher_id,
-                      metadata=metadata))
+        LOG.info(
+            "Event '%(event)s' received from %(publisher)s "
+            "with metadata %(metadata)s",
+            dict(event=event_type, publisher=publisher_id, metadata=metadata),
+        )
         LOG.debug(payload)
         if not self.cluster_data_model:
-            LOG.debug('Storage CDM has not yet been built; ignoring '
-                      'notifications until an audit is performed.')
+            LOG.debug(
+                'Storage CDM has not yet been built; ignoring '
+                'notifications until an audit is performed.'
+            )
             return
         name = payload['name_to_id']
         try:
@@ -278,7 +294,6 @@ class VolumeNotificationEndpoint(CinderNotification):
 
 
 class VolumeCreateEnd(VolumeNotificationEndpoint):
-
     @property
     def filter_rule(self):
         """Cinder volume notification filter"""
@@ -290,15 +305,17 @@ class VolumeCreateEnd(VolumeNotificationEndpoint):
     def info(self, ctxt, publisher_id, event_type, payload, metadata):
         ctxt.request_id = metadata['message_id']
         ctxt.project_domain = event_type
-        LOG.info("Event '%(event)s' received from %(publisher)s "
-                 "with metadata %(metadata)s",
-                 dict(event=event_type,
-                      publisher=publisher_id,
-                      metadata=metadata))
+        LOG.info(
+            "Event '%(event)s' received from %(publisher)s "
+            "with metadata %(metadata)s",
+            dict(event=event_type, publisher=publisher_id, metadata=metadata),
+        )
         LOG.debug(payload)
         if not self.cluster_data_model:
-            LOG.debug('Storage CDM has not yet been built; ignoring '
-                      'notifications until an audit is performed.')
+            LOG.debug(
+                'Storage CDM has not yet been built; ignoring '
+                'notifications until an audit is performed.'
+            )
             return
         volume_id = payload['volume_id']
         poolname = payload['host']
@@ -307,7 +324,6 @@ class VolumeCreateEnd(VolumeNotificationEndpoint):
 
 
 class VolumeUpdateEnd(VolumeNotificationEndpoint):
-
     @property
     def filter_rule(self):
         """Cinder volume notification filter"""
@@ -319,15 +335,17 @@ class VolumeUpdateEnd(VolumeNotificationEndpoint):
     def info(self, ctxt, publisher_id, event_type, payload, metadata):
         ctxt.request_id = metadata['message_id']
         ctxt.project_domain = event_type
-        LOG.info("Event '%(event)s' received from %(publisher)s "
-                 "with metadata %(metadata)s",
-                 dict(event=event_type,
-                      publisher=publisher_id,
-                      metadata=metadata))
+        LOG.info(
+            "Event '%(event)s' received from %(publisher)s "
+            "with metadata %(metadata)s",
+            dict(event=event_type, publisher=publisher_id, metadata=metadata),
+        )
         LOG.debug(payload)
         if not self.cluster_data_model:
-            LOG.debug('Storage CDM has not yet been built; ignoring '
-                      'notifications until an audit is performed.')
+            LOG.debug(
+                'Storage CDM has not yet been built; ignoring '
+                'notifications until an audit is performed.'
+            )
             return
         volume_id = payload['volume_id']
         poolname = payload['host']
@@ -336,7 +354,6 @@ class VolumeUpdateEnd(VolumeNotificationEndpoint):
 
 
 class VolumeAttachEnd(VolumeUpdateEnd):
-
     @property
     def filter_rule(self):
         """Cinder volume notification filter"""
@@ -347,7 +364,6 @@ class VolumeAttachEnd(VolumeUpdateEnd):
 
 
 class VolumeDetachEnd(VolumeUpdateEnd):
-
     @property
     def filter_rule(self):
         """Cinder volume notification filter"""
@@ -358,7 +374,6 @@ class VolumeDetachEnd(VolumeUpdateEnd):
 
 
 class VolumeResizeEnd(VolumeUpdateEnd):
-
     @property
     def filter_rule(self):
         """Cinder volume notification filter"""
@@ -369,7 +384,6 @@ class VolumeResizeEnd(VolumeUpdateEnd):
 
 
 class VolumeDeleteEnd(VolumeNotificationEndpoint):
-
     @property
     def filter_rule(self):
         """Cinder volume notification filter"""
@@ -381,15 +395,17 @@ class VolumeDeleteEnd(VolumeNotificationEndpoint):
     def info(self, ctxt, publisher_id, event_type, payload, metadata):
         ctxt.request_id = metadata['message_id']
         ctxt.project_domain = event_type
-        LOG.info("Event '%(event)s' received from %(publisher)s "
-                 "with metadata %(metadata)s",
-                 dict(event=event_type,
-                      publisher=publisher_id,
-                      metadata=metadata))
+        LOG.info(
+            "Event '%(event)s' received from %(publisher)s "
+            "with metadata %(metadata)s",
+            dict(event=event_type, publisher=publisher_id, metadata=metadata),
+        )
         LOG.debug(payload)
         if not self.cluster_data_model:
-            LOG.debug('Storage CDM has not yet been built; ignoring '
-                      'notifications until an audit is performed.')
+            LOG.debug(
+                'Storage CDM has not yet been built; ignoring '
+                'notifications until an audit is performed.'
+            )
             return
         volume_id = payload['volume_id']
         poolname = payload['host']
diff --git a/watcher/decision_engine/model/notification/filtering.py b/watcher/decision_engine/model/notification/filtering.py
index 41f11b7c9..b434c81f2 100644
--- a/watcher/decision_engine/model/notification/filtering.py
+++ b/watcher/decision_engine/model/notification/filtering.py
@@ -78,9 +78,11 @@ class NotificationFilter(om.NotificationFilter):
             return regex(data)
         elif regex is not None and data is None:
             return True
-        elif (regex is not None and
-              isinstance(data, str) and
-              not regex.match(data)):
+        elif (
+            regex is not None
+            and isinstance(data, str)
+            and not regex.match(data)
+        ):
             return True
 
         return False
diff --git a/watcher/decision_engine/model/notification/nova.py b/watcher/decision_engine/model/notification/nova.py
index 6d54a049a..95710d7a5 100644
--- a/watcher/decision_engine/model/notification/nova.py
+++ b/watcher/decision_engine/model/notification/nova.py
@@ -33,7 +33,6 @@ LOG = log.getLogger(__name__)
 
 
 class NovaNotification(base.NotificationEndpoint):
-
     def __init__(self, collector):
         super().__init__(collector)
         self._nova = None
@@ -57,12 +56,15 @@ class NovaNotification(base.NotificationEndpoint):
             if node_name:
                 node = self.get_or_create_node(node_name)
         except exception.ComputeNodeNotFound:
-            LOG.warning("Could not find compute node %(node)s for "
-                        "instance %(instance)s",
-                        dict(node=node_name, instance=instance_uuid))
+            LOG.warning(
+                "Could not find compute node %(node)s for "
+                "instance %(instance)s",
+                dict(node=node_name, instance=instance_uuid),
+            )
         try:
             instance = self.cluster_data_model.get_instance_by_uuid(
-                instance_uuid)
+                instance_uuid
+            )
         except exception.InstanceNotFound:
             # The instance didn't exist yet so we create a new instance object
             LOG.debug("New instance created: %s", instance_uuid)
@@ -86,18 +88,20 @@ class NovaNotification(base.NotificationEndpoint):
         disk_gb = instance_flavor_data['root_gb']
         instance_metadata = data['nova_object.data']['metadata']
 
-        instance.update({
-            'state': instance_data['state'],
-            'hostname': instance_data['host_name'],
-            # this is the user-provided display name of the server which is not
-            # guaranteed to be unique nor is it immutable.
-            'name': instance_data['display_name'],
-            'memory': memory_mb,
-            'vcpus': num_cores,
-            'disk': disk_gb,
-            'metadata': instance_metadata,
-            'project_id': instance_data['tenant_id'],
-        })
+        instance.update(
+            {
+                'state': instance_data['state'],
+                'hostname': instance_data['host_name'],
+                # this is the user-provided display name of the server
+                # which is not guaranteed to be unique nor is it immutable.
+                'name': instance_data['display_name'],
+                'memory': memory_mb,
+                'vcpus': num_cores,
+                'disk': disk_gb,
+                'metadata': instance_metadata,
+                'project_id': instance_data['tenant_id'],
+            }
+        )
 
         # locked was added in nova notification payload version 1.1
         if n_version > microversion_parse.parse_version_string('1.0'):
@@ -105,8 +109,10 @@ class NovaNotification(base.NotificationEndpoint):
 
         # NOTE(dviroel): extra_specs can change due to a resize operation.
         # 'extra_specs' was added in nova notification payload version 1.2
-        if (n_version > microversion_parse.parse_version_string('1.1') and
-                self.cluster_data_model.extended_attributes_enabled):
+        if (
+            n_version > microversion_parse.parse_version_string('1.1')
+            and self.cluster_data_model.extended_attributes_enabled
+        ):
             extra_specs = instance_flavor_data.get("extra_specs", {})
             instance.update({'flavor_extra_specs': extra_specs})
 
@@ -124,20 +130,26 @@ class NovaNotification(base.NotificationEndpoint):
         node_data = data['nova_object.data']
         node_state = (
             element.ServiceState.OFFLINE.value
-            if node_data['forced_down'] else element.ServiceState.ONLINE.value)
+            if node_data['forced_down']
+            else element.ServiceState.ONLINE.value
+        )
         node_status = (
             element.ServiceState.DISABLED.value
-            if node_data['disabled'] else element.ServiceState.ENABLED.value)
+            if node_data['disabled']
+            else element.ServiceState.ENABLED.value
+        )
         disabled_reason = (
-            node_data['disabled_reason']
-            if node_data['disabled'] else None)
+            node_data['disabled_reason'] if node_data['disabled'] else None
+        )
 
-        node.update({
-            'hostname': node_data['host'],
-            'state': node_state,
-            'status': node_status,
-            'disabled_reason': disabled_reason,
-        })
+        node.update(
+            {
+                'hostname': node_data['host'],
+                'state': node_state,
+                'status': node_status,
+                'disabled_reason': disabled_reason,
+            }
+        )
 
     def create_compute_node(self, uuid_or_name):
         """Create the computeNode node."""
@@ -193,7 +205,8 @@ class NovaNotification(base.NotificationEndpoint):
                 "vcpu_ratio": vcpu_ratio,
                 "state": _node.state,
                 "status": _node.status,
-                "disabled_reason": _node.service_disabled_reason}
+                "disabled_reason": _node.service_disabled_reason,
+            }
 
             node = element.ComputeNode(**node_attributes)
             self.cluster_data_model.add_node(node)
@@ -222,14 +235,18 @@ class NovaNotification(base.NotificationEndpoint):
     def update_instance_mapping(self, instance, node):
         if node is None:
             self.cluster_data_model.add_instance(instance)
-            LOG.debug("Instance %s not yet attached to any node: skipping",
-                      instance.uuid)
+            LOG.debug(
+                "Instance %s not yet attached to any node: skipping",
+                instance.uuid,
+            )
             return
         try:
             try:
                 current_node = (
                     self.cluster_data_model.get_node_by_instance_uuid(
-                        instance.uuid))
+                        instance.uuid
+                    )
+                )
             except exception.ComputeResourceNotFound as exc:
                 LOG.exception(exc)
                 # If we can't create the node,
@@ -238,8 +255,9 @@ class NovaNotification(base.NotificationEndpoint):
 
             LOG.debug("Mapped node %s found", node.uuid)
             if current_node and node != current_node:
-                LOG.debug("Unmapping instance %s from %s",
-                          instance.uuid, node.uuid)
+                LOG.debug(
+                    "Unmapping instance %s from %s", instance.uuid, node.uuid
+                )
                 self.cluster_data_model.unmap_instance(instance, current_node)
         except exception.InstanceNotFound:
             # The instance didn't exist yet so we map it for the first time
@@ -350,21 +368,21 @@ class VersionedNotification(NovaNotification):
         'service.create': service_updated,
         'service.delete': service_deleted,
         'service.update': service_updated,
-        }
+    }
 
     @property
     def filter_rule(self):
         """Nova notification filter"""
         return filtering.NotificationFilter(
-            publisher_id=self.publisher_id_regex,
+            publisher_id=self.publisher_id_regex
         )
 
     def info(self, ctxt, publisher_id, event_type, payload, metadata):
-        LOG.info("Event '%(event)s' received from %(publisher)s "
-                 "with metadata %(metadata)s",
-                 dict(event=event_type,
-                      publisher=publisher_id,
-                      metadata=metadata))
+        LOG.info(
+            "Event '%(event)s' received from %(publisher)s "
+            "with metadata %(metadata)s",
+            dict(event=event_type, publisher=publisher_id, metadata=metadata),
+        )
         func = self.notification_mapping.get(event_type)
         if func:
             # The nova CDM is not built until an audit is performed.
@@ -372,5 +390,7 @@ class VersionedNotification(NovaNotification):
                 LOG.debug(payload)
                 func(self, payload)
             else:
-                LOG.debug('Nova CDM has not yet been built; ignoring '
-                          'notifications until an audit is performed.')
+                LOG.debug(
+                    'Nova CDM has not yet been built; ignoring '
+                    'notifications until an audit is performed.'
+                )
diff --git a/watcher/decision_engine/planner/base.py b/watcher/decision_engine/planner/base.py
index bd85e34f2..95e8ac70f 100644
--- a/watcher/decision_engine/planner/base.py
+++ b/watcher/decision_engine/planner/base.py
@@ -49,7 +49,6 @@ from watcher.common.loader import loadable
 
 
 class BasePlanner(loadable.Loadable, metaclass=abc.ABCMeta):
-
     @classmethod
     def get_config_opts(cls):
         """Defines the configuration options to be associated to this loadable
diff --git a/watcher/decision_engine/planner/node_resource_consolidation.py b/watcher/decision_engine/planner/node_resource_consolidation.py
index 662e19d1f..6ba97c16f 100644
--- a/watcher/decision_engine/planner/node_resource_consolidation.py
+++ b/watcher/decision_engine/planner/node_resource_consolidation.py
@@ -36,10 +36,9 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
     - This is a proof of concept that is not meant to be used in production
     """
 
-    def create_action(self,
-                      action_plan_id,
-                      action_type,
-                      input_parameters=None):
+    def create_action(
+        self, action_plan_id, action_type, input_parameters=None
+    ):
         uuid = utils.generate_uuid()
         action = {
             'uuid': uuid,
@@ -47,7 +46,7 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
             'action_type': action_type,
             'input_parameters': input_parameters,
             'state': objects.action.State.PENDING,
-            'parents': None
+            'parents': None,
         }
 
         return action
@@ -72,11 +71,13 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
             json_action = self.create_action(
                 action_plan_id=action_plan.id,
                 action_type=action_type,
-                input_parameters=parameters)
+                input_parameters=parameters,
+            )
             # classing actions
             if action_type == 'change_nova_service_state':
                 if parameters.get('state') == (
-                        element.ServiceState.DISABLED.value):
+                    element.ServiceState.DISABLED.value
+                ):
                     node_disabled_actions.append(json_action)
                 else:
                     node_enabled_actions.append(json_action)
@@ -88,7 +89,8 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
                     node_migrate_actions[source_node] = [json_action]
             else:
                 raise exception.UnsupportedActionType(
-                    action_type=action.get("action_type"))
+                    action_type=action.get("action_type")
+                )
 
         # creating actions
         mig_parents = []
@@ -110,13 +112,15 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
             self._create_action(context, action)
 
         self._create_efficacy_indicators(
-            context, action_plan.id, solution.efficacy_indicators)
+            context, action_plan.id, solution.efficacy_indicators
+        )
 
         return action_plan
 
     def _create_action_plan(self, context, audit_id, solution):
         strategy = objects.Strategy.get_by_name(
-            context, solution.strategy.name)
+            context, solution.strategy.name
+        )
 
         action_plan_dict = {
             'uuid': utils.generate_uuid(),
@@ -143,7 +147,8 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
                 'action_plan_id': action_plan_id,
             }
             new_efficacy_indicator = objects.EfficacyIndicator(
-                context, **efficacy_indicator_dict)
+                context, **efficacy_indicator_dict
+            )
             new_efficacy_indicator.create()
 
             efficacy_indicators.append(new_efficacy_indicator)
@@ -151,8 +156,10 @@ class NodeResourceConsolidationPlanner(base.BasePlanner):
 
     def _create_action(self, context, _action):
         try:
-            LOG.debug("Creating the %s in the Watcher database",
-                      _action.get("action_type"))
+            LOG.debug(
+                "Creating the %s in the Watcher database",
+                _action.get("action_type"),
+            )
 
             new_action = objects.Action(context, **_action)
             new_action.create()
diff --git a/watcher/decision_engine/planner/weight.py b/watcher/decision_engine/planner/weight.py
index e39c2a926..5edd42dd4 100644
--- a/watcher/decision_engine/planner/weight.py
+++ b/watcher/decision_engine/planner/weight.py
@@ -67,7 +67,7 @@ class WeightPlanner(base.BasePlanner):
         'change_nova_service_state': 1,
         'nop': 1,
         'change_node_power_state': 2,
-        'volume_migrate': 2
+        'volume_migrate': 2,
     }
 
     @classmethod
@@ -76,15 +76,17 @@ class WeightPlanner(base.BasePlanner):
             cfg.DictOpt(
                 'weights',
                 help="These weights are used to schedule the actions. "
-                     "Action Plan will be build in accordance with sets of "
-                     "actions ordered by descending weights."
-                     "Two action types cannot have the same weight. ",
-                default=cls.action_weights),
+                "Action Plan will be build in accordance with sets of "
+                "actions ordered by descending weights."
+                "Two action types cannot have the same weight. ",
+                default=cls.action_weights,
+            ),
             cfg.DictOpt(
                 'parallelization',
                 help="Number of actions to be run in parallel on a per "
-                     "action type basis.",
-                default=cls.parallelization),
+                "action type basis.",
+                default=cls.parallelization,
+            ),
         ]
 
     @staticmethod
@@ -98,7 +100,7 @@ class WeightPlanner(base.BasePlanner):
         # Split a flat list in a list of chunks of size n.
         # e.g. chunkify([0, 1, 2, 3, 4], 2) -> [[0, 1], [2, 3], [4]]
         for i in range(0, len(lst), n):
-            yield lst[i:i + n]
+            yield lst[i : i + n]
 
     def compute_action_graph(self, sorted_weighted_actions):
         reverse_weights = {v: k for k, v in self.config.weights.items()}
@@ -119,7 +121,8 @@ class WeightPlanner(base.BasePlanner):
         # insert them in a Directed Acyclic Graph
         for idx, (weight, actions) in enumerate(sorted_weighted_actions):
             action_chunks = self.chunkify(
-                actions, self.config.parallelization[reverse_weights[weight]])
+                actions, self.config.parallelization[reverse_weights[weight]]
+            )
 
             # We split the actions into chunks/layers that will have to be
             # spread across all the available branches of the graph
@@ -149,11 +152,13 @@ class WeightPlanner(base.BasePlanner):
         action_plan = self.create_action_plan(context, audit_id, solution)
 
         sorted_weighted_actions = self.get_sorted_actions_by_weight(
-            context, action_plan, solution)
+            context, action_plan, solution
+        )
         action_graph = self.compute_action_graph(sorted_weighted_actions)
 
         self._create_efficacy_indicators(
-            context, action_plan.id, solution.efficacy_indicators)
+            context, action_plan.id, solution.efficacy_indicators
+        )
 
         if len(action_graph.nodes()) == 0:
             LOG.warning("The action plan is empty")
@@ -165,11 +170,18 @@ class WeightPlanner(base.BasePlanner):
 
     def get_sorted_actions_by_weight(self, context, action_plan, solution):
         # We need to make them immutable to add them to the graph
-        action_objects = list([
-            objects.Action(
-                context, uuid=utils.generate_uuid(), parents=[],
-                action_plan_id=action_plan.id, **a)
-            for a in solution.actions])
+        action_objects = list(
+            [
+                objects.Action(
+                    context,
+                    uuid=utils.generate_uuid(),
+                    parents=[],
+                    action_plan_id=action_plan.id,
+                    **a,
+                )
+                for a in solution.actions
+            ]
+        )
         # This is a dict of list with each being a weight and the list being
         # all the actions associated to this weight
         weighted_actions = collections.defaultdict(list)
@@ -181,8 +193,9 @@ class WeightPlanner(base.BasePlanner):
 
     def create_scheduled_actions(self, graph):
         for action in graph.nodes():
-            LOG.debug("Creating the %s in the Watcher database",
-                      action.action_type)
+            LOG.debug(
+                "Creating the %s in the Watcher database", action.action_type
+            )
             try:
                 action.create()
             except Exception as exc:
@@ -191,7 +204,8 @@ class WeightPlanner(base.BasePlanner):
 
     def create_action_plan(self, context, audit_id, solution):
         strategy = objects.Strategy.get_by_name(
-            context, solution.strategy.name)
+            context, solution.strategy.name
+        )
 
         action_plan_dict = {
             'uuid': utils.generate_uuid(),
@@ -218,7 +232,8 @@ class WeightPlanner(base.BasePlanner):
                 'action_plan_id': action_plan_id,
             }
             new_efficacy_indicator = objects.EfficacyIndicator(
-                context, **efficacy_indicator_dict)
+                context, **efficacy_indicator_dict
+            )
             new_efficacy_indicator.create()
 
             efficacy_indicators.append(new_efficacy_indicator)
diff --git a/watcher/decision_engine/planner/workload_stabilization.py b/watcher/decision_engine/planner/workload_stabilization.py
index fa5209749..dd9b75caa 100644
--- a/watcher/decision_engine/planner/workload_stabilization.py
+++ b/watcher/decision_engine/planner/workload_stabilization.py
@@ -67,13 +67,13 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
             cfg.DictOpt(
                 'weights',
                 help="These weights are used to schedule the actions",
-                default=cls.weights_dict),
+                default=cls.weights_dict,
+            )
         ]
 
-    def create_action(self,
-                      action_plan_id,
-                      action_type,
-                      input_parameters=None):
+    def create_action(
+        self, action_plan_id, action_type, input_parameters=None
+    ):
         uuid = utils.generate_uuid()
         action = {
             'uuid': uuid,
@@ -81,7 +81,7 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
             'action_type': action_type,
             'input_parameters': input_parameters,
             'state': objects.action.State.PENDING,
-            'parents': None
+            'parents': None,
         }
 
         return action
@@ -103,16 +103,20 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
             json_action = self.create_action(
                 action_plan_id=action_plan.id,
                 action_type=action.get('action_type'),
-                input_parameters=action.get('input_parameters'))
-            to_schedule.append((weights[action.get('action_type')],
-                                json_action))
+                input_parameters=action.get('input_parameters'),
+            )
+            to_schedule.append(
+                (weights[action.get('action_type')], json_action)
+            )
 
         self._create_efficacy_indicators(
-            context, action_plan.id, solution.efficacy_indicators)
+            context, action_plan.id, solution.efficacy_indicators
+        )
 
         # scheduling
-        scheduled = sorted(to_schedule, key=lambda weight: (weight[0]),
-                           reverse=True)
+        scheduled = sorted(
+            to_schedule, key=lambda weight: (weight[0]), reverse=True
+        )
         if len(scheduled) == 0:
             LOG.warning("The action plan is empty")
             action_plan.state = objects.action_plan.State.SUCCEEDED
@@ -124,13 +128,16 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
                 a_type = action['action_type']
                 if a_type != 'turn_host_to_acpi_s3_state':
                     plugin_action = self.load_child_class(
-                        action.get("action_type"))
+                        action.get("action_type")
+                    )
                     if not plugin_action:
                         raise exception.UnsupportedActionType(
-                            action_type=action.get("action_type"))
+                            action_type=action.get("action_type")
+                        )
                     db_action = self._create_action(context, action)
                     parents = plugin_action.validate_parents(
-                        resource_action_map, action)
+                        resource_action_map, action
+                    )
                     if parents:
                         db_action.parents = parents
                         db_action.save()
@@ -146,23 +153,37 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
                     host_actions = resource_action_map.get(host_to_acpi_s3)
                     action_parents = []
                     if host_actions:
-                        resize_actions = [x[0] for x in host_actions
-                                          if x[1] == 'resize']
-                        migrate_actions = [x[0] for x in host_actions
-                                           if x[1] == 'migrate']
+                        resize_actions = [
+                            x[0] for x in host_actions if x[1] == 'resize'
+                        ]
+                        migrate_actions = [
+                            x[0] for x in host_actions if x[1] == 'migrate'
+                        ]
                         resize_migration_parents = [
-                            x.parents for x in
-                            [objects.Action.get_by_uuid(context, resize_action)
-                             for resize_action in resize_actions]]
+                            x.parents
+                            for x in [
+                                objects.Action.get_by_uuid(
+                                    context, resize_action
+                                )
+                                for resize_action in resize_actions
+                            ]
+                        ]
                         # resize_migration_parents should be one level list
                         resize_migration_parents = [
-                            parent for sublist in resize_migration_parents
-                            for parent in sublist]
-                        action_parents.extend([uuid for uuid in
-                                               resize_actions])
-                        action_parents.extend([uuid for uuid in
-                                              migrate_actions if uuid not in
-                                              resize_migration_parents])
+                            parent
+                            for sublist in resize_migration_parents
+                            for parent in sublist
+                        ]
+                        action_parents.extend(
+                            [uuid for uuid in resize_actions]
+                        )
+                        action_parents.extend(
+                            [
+                                uuid
+                                for uuid in migrate_actions
+                                if uuid not in resize_migration_parents
+                            ]
+                        )
                     db_action = self._create_action(context, action)
                     db_action.parents = action_parents
                     db_action.save()
@@ -171,7 +192,8 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
 
     def _create_action_plan(self, context, audit_id, solution):
         strategy = objects.Strategy.get_by_name(
-            context, solution.strategy.name)
+            context, solution.strategy.name
+        )
 
         action_plan_dict = {
             'uuid': utils.generate_uuid(),
@@ -198,7 +220,8 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
                 'action_plan_id': action_plan_id,
             }
             new_efficacy_indicator = objects.EfficacyIndicator(
-                context, **efficacy_indicator_dict)
+                context, **efficacy_indicator_dict
+            )
             new_efficacy_indicator.create()
 
             efficacy_indicators.append(new_efficacy_indicator)
@@ -206,8 +229,10 @@ class WorkloadStabilizationPlanner(base.BasePlanner):
 
     def _create_action(self, context, _action):
         try:
-            LOG.debug("Creating the %s in the Watcher database",
-                      _action.get("action_type"))
+            LOG.debug(
+                "Creating the %s in the Watcher database",
+                _action.get("action_type"),
+            )
 
             new_action = objects.Action(context, **_action)
             new_action.create()
@@ -235,14 +260,13 @@ class BaseActionValidator:
     def validate_parents(self, resource_action_map, action):
         raise NotImplementedError()
 
-    def _mapping(self, resource_action_map, resource_id, action_uuid,
-                 action_type):
+    def _mapping(
+        self, resource_action_map, resource_id, action_uuid, action_type
+    ):
         if resource_id not in resource_action_map:
-            resource_action_map[resource_id] = [(action_uuid,
-                                                 action_type,)]
+            resource_action_map[resource_id] = [(action_uuid, action_type)]
         else:
-            resource_action_map[resource_id].append((action_uuid,
-                                                     action_type,))
+            resource_action_map[resource_id].append((action_uuid, action_type))
 
 
 class MigrationActionValidator(BaseActionValidator):
@@ -251,10 +275,12 @@ class MigrationActionValidator(BaseActionValidator):
     def validate_parents(self, resource_action_map, action):
         instance_uuid = action['input_parameters']['resource_id']
         host_name = action['input_parameters']['source_node']
-        self._mapping(resource_action_map, instance_uuid, action['uuid'],
-                      'migrate')
-        self._mapping(resource_action_map, host_name, action['uuid'],
-                      'migrate')
+        self._mapping(
+            resource_action_map, instance_uuid, action['uuid'], 'migrate'
+        )
+        self._mapping(
+            resource_action_map, host_name, action['uuid'], 'migrate'
+        )
 
 
 class ResizeActionValidator(BaseActionValidator):
@@ -265,9 +291,11 @@ class ResizeActionValidator(BaseActionValidator):
         instance_uuid = action['input_parameters']['resource_id']
         parent_actions = resource_action_map.get(instance_uuid)
         host_of_instance = nova.get_hostname(
-            nova.get_instance_by_uuid(instance_uuid))
-        self._mapping(resource_action_map, host_of_instance, action['uuid'],
-                      'resize')
+            nova.get_instance_by_uuid(instance_uuid)
+        )
+        self._mapping(
+            resource_action_map, host_of_instance, action['uuid'], 'resize'
+        )
         if parent_actions:
             return [x[0] for x in parent_actions]
         else:
@@ -279,8 +307,12 @@ class ChangeNovaServiceStateActionValidator(BaseActionValidator):
 
     def validate_parents(self, resource_action_map, action):
         host_name = action['input_parameters']['resource_id']
-        self._mapping(resource_action_map, host_name, action['uuid'],
-                      'change_nova_service_state')
+        self._mapping(
+            resource_action_map,
+            host_name,
+            action['uuid'],
+            'change_nova_service_state',
+        )
         return []
 
 
diff --git a/watcher/decision_engine/rpcapi.py b/watcher/decision_engine/rpcapi.py
index 255a6f37c..d796a1371 100644
--- a/watcher/decision_engine/rpcapi.py
+++ b/watcher/decision_engine/rpcapi.py
@@ -28,7 +28,6 @@ CONF = conf.CONF
 
 
 class DecisionEngineAPI(service.Service):
-
     def __init__(self):
         super().__init__(DecisionEngineAPIManager)
 
@@ -37,20 +36,24 @@ class DecisionEngineAPI(service.Service):
             raise exception.InvalidUuidOrName(name=audit_uuid)
 
         self.conductor_client.cast(
-            context, 'trigger_audit', audit_uuid=audit_uuid)
+            context, 'trigger_audit', audit_uuid=audit_uuid
+        )
 
     def get_strategy_info(self, context, strategy_name):
         return self.conductor_client.call(
-            context, 'get_strategy_info', strategy_name=strategy_name)
+            context, 'get_strategy_info', strategy_name=strategy_name
+        )
 
     def get_data_model_info(self, context, data_model_type, audit):
         return self.conductor_client.call(
-            context, 'get_data_model_info',
-            data_model_type=data_model_type, audit=audit)
+            context,
+            'get_data_model_info',
+            data_model_type=data_model_type,
+            audit=audit,
+        )
 
 
 class DecisionEngineAPIManager(service_manager.ServiceManager):
-
     @property
     def service_name(self):
         return None
diff --git a/watcher/decision_engine/scheduling.py b/watcher/decision_engine/scheduling.py
index cec4c7324..f24be3fc1 100644
--- a/watcher/decision_engine/scheduling.py
+++ b/watcher/decision_engine/scheduling.py
@@ -29,11 +29,9 @@ CONF = conf.CONF
 
 
 class DecisionEngineSchedulingService(scheduling.BackgroundSchedulerService):
-
     def __init__(self, gconfig=None, **options):
         gconfig = None or {}
-        super().__init__(
-            gconfig, **options)
+        super().__init__(gconfig, **options)
         self.collector_manager = manager.CollectorManager()
 
     @property
@@ -42,40 +40,49 @@ class DecisionEngineSchedulingService(scheduling.BackgroundSchedulerService):
 
     def add_sync_jobs(self):
         for collector in self.collectors.values():
-            self.add_job(collector.synchronize,
-                         trigger='interval',
-                         seconds=collector.config.period,
-                         next_run_time=datetime.datetime.now())
+            self.add_job(
+                collector.synchronize,
+                trigger='interval',
+                seconds=collector.config.period,
+                next_run_time=datetime.datetime.now(),
+            )
 
     def add_checkstate_job(self):
         # 30 minutes interval
         interval = CONF.watcher_decision_engine.check_periodic_interval
         ap_manager = objects.action_plan.StateManager()
         if CONF.watcher_decision_engine.action_plan_expiry != 0:
-            self.add_job(ap_manager.check_expired, 'interval',
-                         args=[context.make_context()],
-                         seconds=interval,
-                         next_run_time=datetime.datetime.now())
+            self.add_job(
+                ap_manager.check_expired,
+                'interval',
+                args=[context.make_context()],
+                seconds=interval,
+                next_run_time=datetime.datetime.now(),
+            )
 
     def cancel_ongoing_audits(self):
         audit_filters = {
             'audit_type': objects.audit.AuditType.ONESHOT.value,
             'state': objects.audit.State.ONGOING,
-            'hostname': CONF.host
+            'hostname': CONF.host,
         }
         local_context = context.make_context()
         ongoing_audits = objects.Audit.list(
-            local_context,
-            filters=audit_filters)
+            local_context, filters=audit_filters
+        )
         for audit in ongoing_audits:
             audit.state = objects.audit.State.CANCELLED
             audit.save()
-            LOG.info("Audit %(uuid)s has been cancelled because it was in "
-                     "%(state)s state when Decision Engine had been stopped "
-                     "on %(hostname)s host.",
-                     {'uuid': audit.uuid,
-                      'state': objects.audit.State.ONGOING,
-                      'hostname': audit.hostname})
+            LOG.info(
+                "Audit %(uuid)s has been cancelled because it was in "
+                "%(state)s state when Decision Engine had been stopped "
+                "on %(hostname)s host.",
+                {
+                    'uuid': audit.uuid,
+                    'state': objects.audit.State.ONGOING,
+                    'hostname': audit.hostname,
+                },
+            )
 
     def start(self):
         """Start service."""
diff --git a/watcher/decision_engine/scope/baremetal.py b/watcher/decision_engine/scope/baremetal.py
index d0584e8ef..421d9aeaf 100644
--- a/watcher/decision_engine/scope/baremetal.py
+++ b/watcher/decision_engine/scope/baremetal.py
@@ -28,8 +28,8 @@ class BaremetalScope(base.BaseScope):
         for resource in resources:
             if 'ironic_nodes' in resource:
                 nodes_to_exclude.extend(
-                    [node['uuid'] for node
-                     in resource['ironic_nodes']])
+                    [node['uuid'] for node in resource['ironic_nodes']]
+                )
 
     def remove_nodes_from_model(self, nodes_to_exclude, cluster_model):
         for node_uuid in nodes_to_exclude:
@@ -57,8 +57,7 @@ class BaremetalScope(base.BaseScope):
 
         for rule in baremetal_scope:
             if 'exclude' in rule:
-                self.exclude_resources(
-                    rule['exclude'], nodes=nodes_to_exclude)
+                self.exclude_resources(rule['exclude'], nodes=nodes_to_exclude)
 
         self.remove_nodes_from_model(nodes_to_exclude, cluster_model)
 
diff --git a/watcher/decision_engine/scope/compute.py b/watcher/decision_engine/scope/compute.py
index ae6785717..f54198b18 100644
--- a/watcher/decision_engine/scope/compute.py
+++ b/watcher/decision_engine/scope/compute.py
@@ -47,35 +47,46 @@ class ComputeScope(base.BaseScope):
                 return True
             else:
                 raise exception.WildcardCharacterIsUsed(
-                    resource="host aggregates")
+                    resource="host aggregates"
+                )
         return False
 
     def _collect_aggregates(self, host_aggregates, compute_nodes):
         aggregate_list = self.wrapper.get_aggregate_list()
-        aggregate_ids = [aggregate['id'] for aggregate
-                         in host_aggregates if 'id' in aggregate]
-        aggregate_names = [aggregate['name'] for aggregate
-                           in host_aggregates if 'name' in aggregate]
-        include_all_nodes = any(self._check_wildcard(field)
-                                for field in (aggregate_ids, aggregate_names))
+        aggregate_ids = [
+            aggregate['id']
+            for aggregate in host_aggregates
+            if 'id' in aggregate
+        ]
+        aggregate_names = [
+            aggregate['name']
+            for aggregate in host_aggregates
+            if 'name' in aggregate
+        ]
+        include_all_nodes = any(
+            self._check_wildcard(field)
+            for field in (aggregate_ids, aggregate_names)
+        )
 
         for aggregate in aggregate_list:
-            if (aggregate.id in aggregate_ids or
-                aggregate.name in aggregate_names or
-                    include_all_nodes):
+            if (
+                aggregate.id in aggregate_ids
+                or aggregate.name in aggregate_names
+                or include_all_nodes
+            ):
                 compute_nodes.extend(aggregate.hosts)
 
     def _collect_zones(self, availability_zones, allowed_nodes):
         service_list = self.wrapper.get_service_list()
-        zone_names = [zone['name'] for zone
-                      in availability_zones]
+        zone_names = [zone['name'] for zone in availability_zones]
         include_all_nodes = False
         if '*' in zone_names:
             if len(zone_names) == 1:
                 include_all_nodes = True
             else:
                 raise exception.WildcardCharacterIsUsed(
-                    resource="availability zones")
+                    resource="availability zones"
+                )
         for service in service_list:
             if service.zone in zone_names or include_all_nodes:
                 allowed_nodes.extend(service.host)
@@ -89,23 +100,26 @@ class ComputeScope(base.BaseScope):
         for resource in resources:
             if 'instances' in resource:
                 instances_to_exclude.extend(
-                    [instance['uuid'] for instance
-                     in resource['instances']])
+                    [instance['uuid'] for instance in resource['instances']]
+                )
             elif 'compute_nodes' in resource:
                 nodes_to_exclude.extend(
-                    [host['name'] for host
-                     in resource['compute_nodes']])
+                    [host['name'] for host in resource['compute_nodes']]
+                )
             elif 'host_aggregates' in resource:
                 prohibited_nodes = []
-                self._collect_aggregates(resource['host_aggregates'],
-                                         prohibited_nodes)
+                self._collect_aggregates(
+                    resource['host_aggregates'], prohibited_nodes
+                )
                 nodes_to_exclude.extend(prohibited_nodes)
             elif 'instance_metadata' in resource:
                 instance_metadata.extend(
-                    [metadata for metadata in resource['instance_metadata']])
+                    [metadata for metadata in resource['instance_metadata']]
+                )
             elif 'projects' in resource:
                 projects_to_exclude.extend(
-                    [project['uuid'] for project in resource['projects']])
+                    [project['uuid'] for project in resource['projects']]
+                )
 
     def remove_nodes_from_model(self, nodes_to_remove, cluster_model):
         for node_name in nodes_to_remove:
@@ -116,26 +130,33 @@ class ComputeScope(base.BaseScope):
             cluster_model.remove_node(node)
 
     def update_exclude_instance_in_model(
-            self, instances_to_exclude, cluster_model):
+        self, instances_to_exclude, cluster_model
+    ):
         for instance_uuid in instances_to_exclude:
             try:
                 node_uuid = cluster_model.get_node_by_instance_uuid(
-                    instance_uuid).uuid
+                    instance_uuid
+                ).uuid
             except exception.ComputeResourceNotFound:
-                LOG.warning("The following instance %s cannot be found. "
-                            "It might be deleted from CDM along with node"
-                            " instance was hosted on.",
-                            instance_uuid)
+                LOG.warning(
+                    "The following instance %s cannot be found. "
+                    "It might be deleted from CDM along with node"
+                    " instance was hosted on.",
+                    instance_uuid,
+                )
                 continue
             self.update_exclude_instance(
                 cluster_model,
                 cluster_model.get_instance_by_uuid(instance_uuid),
-                node_uuid)
+                node_uuid,
+            )
 
     def exclude_instances_with_given_metadata(
-            self, instance_metadata, cluster_model, instances_to_remove):
+        self, instance_metadata, cluster_model, instances_to_remove
+    ):
         metadata_dict = {
-            key: val for d in instance_metadata for key, val in d.items()}
+            key: val for d in instance_metadata for key, val in d.items()
+        }
         instances = cluster_model.get_all_instances()
         for uuid, instance in instances.items():
             metadata = instance.metadata
@@ -146,7 +167,8 @@ class ComputeScope(base.BaseScope):
                         instances_to_remove.add(uuid)
 
     def exclude_instances_with_given_project(
-            self, projects_to_exclude, cluster_model, instances_to_exclude):
+        self, projects_to_exclude, cluster_model, instances_to_exclude
+    ):
         all_instances = cluster_model.get_all_instances()
         for uuid, instance in all_instances.items():
             if instance.project_id in projects_to_exclude:
@@ -165,8 +187,9 @@ class ComputeScope(base.BaseScope):
         projects_to_exclude = []
         compute_scope = []
         found_nothing_flag = False
-        model_hosts = [n.hostname for n in
-                       cluster_model.get_all_compute_nodes().values()]
+        model_hosts = [
+            n.hostname for n in cluster_model.get_all_compute_nodes().values()
+        ]
 
         if not self.scope:
             return cluster_model
@@ -181,21 +204,23 @@ class ComputeScope(base.BaseScope):
 
         for rule in compute_scope:
             if 'host_aggregates' in rule:
-                self._collect_aggregates(rule['host_aggregates'],
-                                         allowed_nodes)
+                self._collect_aggregates(
+                    rule['host_aggregates'], allowed_nodes
+                )
                 if not allowed_nodes:
                     found_nothing_flag = True
             elif 'availability_zones' in rule:
-                self._collect_zones(rule['availability_zones'],
-                                    allowed_nodes)
+                self._collect_zones(rule['availability_zones'], allowed_nodes)
                 if not allowed_nodes:
                     found_nothing_flag = True
             elif 'exclude' in rule:
                 self.exclude_resources(
-                    rule['exclude'], instances=instances_to_exclude,
+                    rule['exclude'],
+                    instances=instances_to_exclude,
                     nodes=nodes_to_exclude,
                     instance_metadata=instance_metadata,
-                    projects=projects_to_exclude)
+                    projects=projects_to_exclude,
+                )
 
         instances_to_exclude = set(instances_to_exclude)
         if allowed_nodes:
@@ -210,13 +235,16 @@ class ComputeScope(base.BaseScope):
 
         if instance_metadata and self.config.check_optimize_metadata:
             self.exclude_instances_with_given_metadata(
-                instance_metadata, cluster_model, instances_to_exclude)
+                instance_metadata, cluster_model, instances_to_exclude
+            )
 
         if projects_to_exclude:
             self.exclude_instances_with_given_project(
-                projects_to_exclude, cluster_model, instances_to_exclude)
+                projects_to_exclude, cluster_model, instances_to_exclude
+            )
 
-        self.update_exclude_instance_in_model(instances_to_exclude,
-                                              cluster_model)
+        self.update_exclude_instance_in_model(
+            instances_to_exclude, cluster_model
+        )
 
         return cluster_model
diff --git a/watcher/decision_engine/scope/storage.py b/watcher/decision_engine/scope/storage.py
index 6f27dbcd8..0d16443a6 100644
--- a/watcher/decision_engine/scope/storage.py
+++ b/watcher/decision_engine/scope/storage.py
@@ -34,14 +34,14 @@ class StorageScope(base.BaseScope):
                 include_all_nodes = True
             else:
                 raise exception.WildcardCharacterIsUsed(
-                    resource="volume_types")
+                    resource="volume_types"
+                )
         for service in service_list:
             if include_all_nodes:
                 allowed_nodes.append(service.host)
                 continue
             backend = service.host.split('@')[1]
-            v_types = self.wrapper.get_volume_type_by_backendname(
-                backend)
+            v_types = self.wrapper.get_volume_type_by_backendname(backend)
             for volume_type in v_types:
                 if volume_type in vt_names:
                     # Note(adisky): It can generate duplicate values
@@ -50,15 +50,15 @@ class StorageScope(base.BaseScope):
 
     def _collect_zones(self, availability_zones, allowed_nodes):
         service_list = self.wrapper.get_storage_node_list()
-        zone_names = [zone['name'] for zone
-                      in availability_zones]
+        zone_names = [zone['name'] for zone in availability_zones]
         include_all_nodes = False
         if '*' in zone_names:
             if len(zone_names) == 1:
                 include_all_nodes = True
             else:
                 raise exception.WildcardCharacterIsUsed(
-                    resource="availability zones")
+                    resource="availability zones"
+                )
         for service in service_list:
             if service.zone in zone_names or include_all_nodes:
                 allowed_nodes.append(service.host)
@@ -71,18 +71,21 @@ class StorageScope(base.BaseScope):
         for resource in resources:
             if 'storage_pools' in resource:
                 pools_to_exclude.extend(
-                    [storage_pool['name'] for storage_pool
-                     in resource['storage_pools']])
+                    [
+                        storage_pool['name']
+                        for storage_pool in resource['storage_pools']
+                    ]
+                )
 
             elif 'volumes' in resource:
                 volumes_to_exclude.extend(
-                    [volume['uuid'] for volume in
-                     resource['volumes']])
+                    [volume['uuid'] for volume in resource['volumes']]
+                )
 
             elif 'projects' in resource:
                 projects_to_exclude.extend(
-                    [project['uuid'] for project in
-                     resource['projects']])
+                    [project['uuid'] for project in resource['projects']]
+                )
 
     def exclude_pools(self, pools_to_exclude, cluster_model):
         for pool_name in pools_to_exclude:
@@ -140,16 +143,18 @@ class StorageScope(base.BaseScope):
 
         for rule in storage_scope:
             if 'volume_types' in rule:
-                self._collect_vtype(rule['volume_types'],
-                                    allowed_nodes, cluster_model)
+                self._collect_vtype(
+                    rule['volume_types'], allowed_nodes, cluster_model
+                )
             elif 'availability_zones' in rule:
-                self._collect_zones(rule['availability_zones'],
-                                    allowed_nodes)
+                self._collect_zones(rule['availability_zones'], allowed_nodes)
             elif 'exclude' in rule:
                 self.exclude_resources(
-                    rule['exclude'], pools=pools_to_exclude,
+                    rule['exclude'],
+                    pools=pools_to_exclude,
                     volumes=volumes_to_exclude,
-                    projects=projects_to_exclude)
+                    projects=projects_to_exclude,
+                )
 
         if allowed_nodes:
             nodes_to_remove = set(model_hosts) - set(allowed_nodes)
diff --git a/watcher/decision_engine/scoring/dummy_scorer.py b/watcher/decision_engine/scoring/dummy_scorer.py
index 6f3962015..52b380649 100644
--- a/watcher/decision_engine/scoring/dummy_scorer.py
+++ b/watcher/decision_engine/scoring/dummy_scorer.py
@@ -149,21 +149,28 @@ class DummyScorer(base.ScoringEngine):
         if flist[self.PROCESSOR_TIME_PERC] >= 80:
             workload = self.WORKLOAD_CPU
             cpu_prob = 100.0
-        elif flist[self.MEM_PAGE_READS_PER_SEC] >= 1000 \
-                and flist[self.MEM_PAGE_WRITES_PER_SEC] >= 1000:
+        elif (
+            flist[self.MEM_PAGE_READS_PER_SEC] >= 1000
+            and flist[self.MEM_PAGE_WRITES_PER_SEC] >= 1000
+        ):
             workload = self.WORKLOAD_MEM
             mem_prob = 100.0
-        elif flist[self.DISK_READ_BYTES_PER_SEC] >= 50*units.Mi \
-                and flist[self.DISK_WRITE_BYTES_PER_SEC] >= 50*units.Mi:
+        elif (
+            flist[self.DISK_READ_BYTES_PER_SEC] >= 50 * units.Mi
+            and flist[self.DISK_WRITE_BYTES_PER_SEC] >= 50 * units.Mi
+        ):
             workload = self.WORKLOAD_DISK
             disk_prob = 100.0
         else:
             idle_prob = 100.0
             if flist[self.PROCESSOR_TIME_PERC] >= 40:
                 cpu_prob = 50.0
-            if flist[self.MEM_PAGE_READS_PER_SEC] >= 500 \
-                    or flist[self.MEM_PAGE_WRITES_PER_SEC] >= 500:
+            if (
+                flist[self.MEM_PAGE_READS_PER_SEC] >= 500
+                or flist[self.MEM_PAGE_WRITES_PER_SEC] >= 500
+            ):
                 mem_prob = 50.0
 
         return jsonutils.dumps(
-            [workload, idle_prob, cpu_prob, mem_prob, disk_prob])
+            [workload, idle_prob, cpu_prob, mem_prob, disk_prob]
+        )
diff --git a/watcher/decision_engine/scoring/dummy_scoring_container.py b/watcher/decision_engine/scoring/dummy_scoring_container.py
index 291d5e7d4..562f07dbc 100644
--- a/watcher/decision_engine/scoring/dummy_scoring_container.py
+++ b/watcher/decision_engine/scoring/dummy_scoring_container.py
@@ -42,15 +42,18 @@ class DummyScoringContainer(base.ScoringEngineContainer):
             SimpleFunctionScorer(
                 'dummy_min_scorer',
                 'Dummy Scorer calculating the minimum value',
-                min),
+                min,
+            ),
             SimpleFunctionScorer(
                 'dummy_max_scorer',
                 'Dummy Scorer calculating the maximum value',
-                max),
+                max,
+            ),
             SimpleFunctionScorer(
                 'dummy_avg_scorer',
                 'Dummy Scorer calculating the average value',
-                lambda x: float(sum(x)) / len(x)),
+                lambda x: float(sum(x)) / len(x),
+            ),
         ]
 
 
diff --git a/watcher/decision_engine/scoring/scoring_factory.py b/watcher/decision_engine/scoring/scoring_factory.py
index 5011e0a30..ec7d3b2e2 100644
--- a/watcher/decision_engine/scoring/scoring_factory.py
+++ b/watcher/decision_engine/scoring/scoring_factory.py
@@ -48,8 +48,9 @@ def get_scoring_engine(scoring_engine_name):
     _reload_scoring_engines()
     scoring_engine = _scoring_engine_map.get(scoring_engine_name)
     if scoring_engine is None:
-        raise KeyError(_('Scoring Engine with name=%s not found')
-                       % scoring_engine_name)
+        raise KeyError(
+            _('Scoring Engine with name=%s not found') % scoring_engine_name
+        )
 
     return scoring_engine
 
@@ -93,13 +94,14 @@ def _reload_scoring_engines(refresh=False):
             LOG.debug("Found Scoring Engine plugin: %s", se_impl.get_name())
             _scoring_engine_map[se_impl.get_name()] = se_impl
 
-        engine_containers = \
+        engine_containers = (
             default.DefaultScoringContainerLoader().list_available()
+        )
 
         for container_id, container_cls in engine_containers.items():
-            LOG.debug("Found Scoring Engine container plugin: %s",
-                      container_id)
+            LOG.debug(
+                "Found Scoring Engine container plugin: %s", container_id
+            )
             for se in container_cls.get_scoring_engine_list():
-                LOG.debug("Found Scoring Engine plugin: %s",
-                          se.get_name())
+                LOG.debug("Found Scoring Engine plugin: %s", se.get_name())
                 _scoring_engine_map[se.get_name()] = se
diff --git a/watcher/decision_engine/service_monitor.py b/watcher/decision_engine/service_monitor.py
index 32f5d145b..8db2b4edc 100644
--- a/watcher/decision_engine/service_monitor.py
+++ b/watcher/decision_engine/service_monitor.py
@@ -44,20 +44,23 @@ class DecisionEngineMonitor(service.ServiceMonitoringBase):
             failed_host = audit.hostname
             audit.hostname = round_robin.__next__()
             audit.save()
-            LOG.info('Audit %(audit)s has been migrated to '
-                     '%(host)s since %(failed_host)s is in'
-                     ' %(state)s',
-                     {'audit': audit.uuid,
-                      'host': audit.hostname,
-                      'failed_host': failed_host,
-                      'state': objects.service.ServiceStatus.FAILED})
+            LOG.info(
+                'Audit %(audit)s has been migrated to '
+                '%(host)s since %(failed_host)s is in'
+                ' %(state)s',
+                {
+                    'audit': audit.uuid,
+                    'host': audit.hostname,
+                    'failed_host': failed_host,
+                    'state': objects.service.ServiceStatus.FAILED,
+                },
+            )
 
     def monitor_services_status(self, context):
         active_s = objects.service.ServiceStatus.ACTIVE
         failed_s = objects.service.ServiceStatus.FAILED
         services = self.get_services_status(context)
-        alive_services = [
-            s.host for s in services if s.state == active_s]
+        alive_services = [s.host for s in services if s.state == active_s]
         leader = self._am_i_leader(services)
         for watcher_service in services:
             result = watcher_service.state
@@ -76,7 +79,8 @@ class DecisionEngineMonitor(service.ServiceMonitoringBase):
                     continue
                 if changed:
                     notifications.service.send_service_update(
-                        context, watcher_service, state=result)
+                        context, watcher_service, state=result
+                    )
                 # Only execute the migration logic if there are alive
                 # services
                 if len(alive_services) == 0:
@@ -86,11 +90,11 @@ class DecisionEngineMonitor(service.ServiceMonitoringBase):
                     audit_filters = {
                         'audit_type': objects.audit.AuditType.CONTINUOUS.value,
                         'state': objects.audit.State.ONGOING,
-                        'hostname': watcher_service.host
+                        'hostname': watcher_service.host,
                     }
                     ongoing_audits = objects.Audit.list(
-                        context,
-                        filters=audit_filters,
-                        eager=True)
+                        context, filters=audit_filters, eager=True
+                    )
                     self._migrate_audits_to_new_host(
-                        ongoing_audits, alive_services)
+                        ongoing_audits, alive_services
+                    )
diff --git a/watcher/decision_engine/solution/default.py b/watcher/decision_engine/solution/default.py
index 1a6cc5179..c843e58a8 100644
--- a/watcher/decision_engine/solution/default.py
+++ b/watcher/decision_engine/solution/default.py
@@ -43,8 +43,9 @@ class DefaultSolution(base.BaseSolution):
     def add_action(self, action_type, input_parameters=None, resource_id=None):
         if input_parameters is not None:
             if baction.BaseAction.RESOURCE_ID in input_parameters.keys():
-                raise exception.ReservedWord(name=baction.BaseAction.
-                                             RESOURCE_ID)
+                raise exception.ReservedWord(
+                    name=baction.BaseAction.RESOURCE_ID
+                )
         else:
             input_parameters = {}
 
@@ -52,13 +53,16 @@ class DefaultSolution(base.BaseSolution):
             input_parameters[baction.BaseAction.RESOURCE_ID] = resource_id
         action = {
             'action_type': action_type,
-            'input_parameters': input_parameters
+            'input_parameters': input_parameters,
         }
         if action not in self._actions:
             self._actions.append(action)
         else:
-            LOG.warning('Action %s has been added into the solution, '
-                        'duplicate action will be dropped.', str(action))
+            LOG.warning(
+                'Action %s has been added into the solution, '
+                'duplicate action will be dropped.',
+                str(action),
+            )
 
     def __str__(self):
         return "\n".join(self._actions)
diff --git a/watcher/decision_engine/solution/efficacy.py b/watcher/decision_engine/solution/efficacy.py
index 3671b3613..63d90ef82 100644
--- a/watcher/decision_engine/solution/efficacy.py
+++ b/watcher/decision_engine/solution/efficacy.py
@@ -30,7 +30,6 @@ class IndicatorsMap(utils.Struct):
 
 
 class Indicator(utils.Struct):
-
     def __init__(self, name, description, unit, value):
         super().__init__()
         self.name = name
@@ -38,7 +37,8 @@ class Indicator(utils.Struct):
         self.unit = unit
         if not isinstance(value, numbers.Number):
             raise exception.InvalidIndicatorValue(
-                _("An indicator value should be a number"))
+                _("An indicator value should be a number")
+            )
         self.value = value
 
 
@@ -77,15 +77,19 @@ class Efficacy:
 
     def compute_global_efficacy(self):
         self._efficacy_spec.validate_efficacy_indicators(
-            self._indicators_mapping)
+            self._indicators_mapping
+        )
         try:
             self.global_efficacy = (
                 self._efficacy_spec.get_global_efficacy_indicator(
-                    self._indicators_mapping))
+                    self._indicators_mapping
+                )
+            )
 
             indicators_specs_map = {
                 indicator_spec.name: indicator_spec
-                for indicator_spec in self._efficacy_spec.indicators_specs}
+                for indicator_spec in self._efficacy_spec.indicators_specs
+            }
 
             indicators = []
             for indicator_name, value in self._indicators_mapping.items():
@@ -95,11 +99,13 @@ class Efficacy:
                         name=related_indicator_spec.name,
                         description=related_indicator_spec.description,
                         unit=related_indicator_spec.unit,
-                        value=value))
+                        value=value,
+                    )
+                )
 
             self.indicators = indicators
         except Exception as exc:
             LOG.exception(exc)
             raise exception.GlobalEfficacyComputationError(
-                goal=self.goal.name,
-                strategy=self.strategy.name)
+                goal=self.goal.name, strategy=self.strategy.name
+            )
diff --git a/watcher/decision_engine/strategy/context/base.py b/watcher/decision_engine/strategy/context/base.py
index ff02ee972..971d801c0 100644
--- a/watcher/decision_engine/strategy/context/base.py
+++ b/watcher/decision_engine/strategy/context/base.py
@@ -23,7 +23,6 @@ from watcher.objects import fields
 
 
 class StrategyContext(metaclass=abc.ABCMeta):
-
     def execute_strategy(self, audit, request_context):
         """Execute the strategy for the given an audit
 
@@ -36,21 +35,27 @@ class StrategyContext(metaclass=abc.ABCMeta):
         """
         try:
             notifications.audit.send_action_notification(
-                request_context, audit,
+                request_context,
+                audit,
                 action=fields.NotificationAction.STRATEGY,
-                phase=fields.NotificationPhase.START)
+                phase=fields.NotificationPhase.START,
+            )
             solution = self.do_execute_strategy(audit, request_context)
             notifications.audit.send_action_notification(
-                request_context, audit,
+                request_context,
+                audit,
                 action=fields.NotificationAction.STRATEGY,
-                phase=fields.NotificationPhase.END)
+                phase=fields.NotificationPhase.END,
+            )
             return solution
         except Exception:
             notifications.audit.send_action_notification(
-                request_context, audit,
+                request_context,
+                audit,
                 action=fields.NotificationAction.STRATEGY,
                 priority=fields.NotificationPriority.ERROR,
-                phase=fields.NotificationPhase.ERROR)
+                phase=fields.NotificationPhase.ERROR,
+            )
             raise
 
     @abc.abstractmethod
diff --git a/watcher/decision_engine/strategy/context/default.py b/watcher/decision_engine/strategy/context/default.py
index 243c31d15..83e30f21d 100644
--- a/watcher/decision_engine/strategy/context/default.py
+++ b/watcher/decision_engine/strategy/context/default.py
@@ -43,13 +43,13 @@ class DefaultStrategyContext(base.StrategyContext):
         strategy_name = None
         if audit.strategy_id:
             strategy = objects.Strategy.get_by_id(
-                request_context, audit.strategy_id)
+                request_context, audit.strategy_id
+            )
             strategy_name = strategy.name
 
         strategy_selector = default.DefaultStrategySelector(
-            goal_name=goal.name,
-            strategy_name=strategy_name,
-            osc=osc)
+            goal_name=goal.name, strategy_name=strategy_name, osc=osc
+        )
         return strategy_selector.select()
 
     def do_execute_strategy(self, audit, request_context):
@@ -60,10 +60,11 @@ class DefaultStrategyContext(base.StrategyContext):
         if not audit.parameters and schema:
             # Default value feedback if no predefined strategy
             utils.StrictDefaultValidatingDraft4Validator(schema).validate(
-                audit.parameters)
+                audit.parameters
+            )
 
-        selected_strategy.input_parameters.update({
-            name: value for name, value in audit.parameters.items()
-        })
+        selected_strategy.input_parameters.update(
+            {name: value for name, value in audit.parameters.items()}
+        )
 
         return selected_strategy.execute(audit=audit)
diff --git a/watcher/decision_engine/strategy/selection/base.py b/watcher/decision_engine/strategy/selection/base.py
index 4263f677d..6ca0460b7 100644
--- a/watcher/decision_engine/strategy/selection/base.py
+++ b/watcher/decision_engine/strategy/selection/base.py
@@ -19,7 +19,6 @@ import abc
 
 
 class BaseSelector(metaclass=abc.ABCMeta):
-
     @abc.abstractmethod
     def select(self):
         raise NotImplementedError()
diff --git a/watcher/decision_engine/strategy/selection/default.py b/watcher/decision_engine/strategy/selection/default.py
index 4ce000058..a9cd8c685 100644
--- a/watcher/decision_engine/strategy/selection/default.py
+++ b/watcher/decision_engine/strategy/selection/default.py
@@ -25,7 +25,6 @@ LOG = log.getLogger(__name__)
 
 
 class DefaultStrategySelector(base.BaseSelector):
-
     def __init__(self, goal_name, strategy_name=None, osc=None):
         """Default strategy selector
 
@@ -52,12 +51,15 @@ class DefaultStrategySelector(base.BaseSelector):
             else:
                 available_strategies = self.strategy_loader.list_available()
                 available_strategies_for_goal = list(
-                    key for key, strategy in available_strategies.items()
-                    if strategy.get_goal_name() == self.goal_name)
+                    key
+                    for key, strategy in available_strategies.items()
+                    if strategy.get_goal_name() == self.goal_name
+                )
 
                 if not available_strategies_for_goal:
                     raise exception.NoAvailableStrategyForGoal(
-                        goal=self.goal_name)
+                        goal=self.goal_name
+                    )
 
                 # TODO(v-francoise): We should do some more work here to select
                 # a strategy out of a given goal instead of just choosing the
@@ -70,4 +72,5 @@ class DefaultStrategySelector(base.BaseSelector):
             LOG.exception(exc)
             raise exception.LoadingError(
                 _("Could not load any strategy for goal %(goal)s"),
-                goal=self.goal_name)
+                goal=self.goal_name,
+            )
diff --git a/watcher/decision_engine/strategy/strategies/__init__.py b/watcher/decision_engine/strategy/strategies/__init__.py
index 7da72dab1..918e85f86 100644
--- a/watcher/decision_engine/strategy/strategies/__init__.py
+++ b/watcher/decision_engine/strategy/strategies/__init__.py
@@ -50,14 +50,27 @@ WorkloadBalance = workload_balance.WorkloadBalance
 WorkloadStabilization = workload_stabilization.WorkloadStabilization
 UniformAirflow = uniform_airflow.UniformAirflow
 NodeResourceConsolidation = (
-    node_resource_consolidation.NodeResourceConsolidation)
+    node_resource_consolidation.NodeResourceConsolidation
+)
 NoisyNeighbor = noisy_neighbor.NoisyNeighbor
 ZoneMigration = zone_migration.ZoneMigration
 HostMaintenance = host_maintenance.HostMaintenance
 
-__all__ = ("Actuator", "BaseStrategy", "BasicConsolidation",
-           "OutletTempControl", "DummyStrategy", "DummyWithScorer",
-           "VMWorkloadConsolidation", "WorkloadBalance",
-           "WorkloadStabilization", "UniformAirflow", "NoisyNeighbor",
-           "SavingEnergy", "StorageCapacityBalance", "ZoneMigration",
-           "HostMaintenance", "NodeResourceConsolidation")
+__all__ = (
+    "Actuator",
+    "BaseStrategy",
+    "BasicConsolidation",
+    "OutletTempControl",
+    "DummyStrategy",
+    "DummyWithScorer",
+    "VMWorkloadConsolidation",
+    "WorkloadBalance",
+    "WorkloadStabilization",
+    "UniformAirflow",
+    "NoisyNeighbor",
+    "SavingEnergy",
+    "StorageCapacityBalance",
+    "ZoneMigration",
+    "HostMaintenance",
+    "NodeResourceConsolidation",
+)
diff --git a/watcher/decision_engine/strategy/strategies/actuation.py b/watcher/decision_engine/strategy/strategies/actuation.py
index 0e441384b..c2c60b235 100644
--- a/watcher/decision_engine/strategy/strategies/actuation.py
+++ b/watcher/decision_engine/strategy/strategies/actuation.py
@@ -55,33 +55,25 @@ class Actuator(base.UnclassifiedStrategy):
                     "items": {
                         "type": "object",
                         "properties": {
-                            "action_type": {
-                                "type": "string"
-                            },
-                            "resource_id": {
-                                "type": "string"
-                            },
+                            "action_type": {"type": "string"},
+                            "resource_id": {"type": "string"},
                             "input_parameters": {
                                 "type": "object",
                                 "properties": {},
-                                "additionalProperties": True
-                            }
+                                "additionalProperties": True,
+                            },
                         },
-                        "required": [
-                            "action_type", "input_parameters"
-                        ],
+                        "required": ["action_type", "input_parameters"],
                         "additionalProperties": True,
-                    }
+                    },
                 }
             },
-            "required": [
-                "actions"
-            ]
+            "required": ["actions"],
         }
 
     @classmethod
     def get_config_opts(cls):
-        """Override base class config options as do not use datasource """
+        """Override base class config options as do not use datasource"""
 
         return []
 
diff --git a/watcher/decision_engine/strategy/strategies/base.py b/watcher/decision_engine/strategy/strategies/base.py
index aaa5282df..436d7755b 100644
--- a/watcher/decision_engine/strategy/strategies/base.py
+++ b/watcher/decision_engine/strategy/strategies/base.py
@@ -64,13 +64,18 @@ class StrategyEndpoint:
     def _collect_metrics(self, strategy, datasource):
         metrics = []
         if not datasource:
-            return {'type': 'Metrics', 'state': metrics,
-                    'mandatory': False, 'comment': ''}
+            return {
+                'type': 'Metrics',
+                'state': metrics,
+                'mandatory': False,
+                'comment': '',
+            }
         else:
             ds_metrics = datasource.list_metrics()
             if ds_metrics is None:
                 raise exception.DataSourceNotAvailable(
-                    datasource=datasource.NAME)
+                    datasource=datasource.NAME
+                )
             else:
                 for metric in strategy.DATASOURCE_METRICS:
                     original_metric_name = datasource.METRIC_MAP.get(metric)
@@ -78,17 +83,24 @@ class StrategyEndpoint:
                         metrics.append({original_metric_name: 'available'})
                     else:
                         metrics.append({original_metric_name: 'not available'})
-        return {'type': 'Metrics', 'state': metrics,
-                'mandatory': False, 'comment': ''}
+        return {
+            'type': 'Metrics',
+            'state': metrics,
+            'mandatory': False,
+            'comment': '',
+        }
 
     def _get_datasource_status(self, strategy, datasource):
         if not datasource:
             state = "Datasource is not presented for this strategy"
         else:
             state = f"{datasource.NAME}: {datasource.check_availability()}"
-        return {'type': 'Datasource',
-                'state': state,
-                'mandatory': True, 'comment': ''}
+        return {
+            'type': 'Datasource',
+            'state': state,
+            'mandatory': True,
+            'comment': '',
+        }
 
     def _get_cdm(self, strategy):
         models = []
@@ -99,8 +111,12 @@ class StrategyEndpoint:
                 models.append({model: 'not available'})
             else:
                 models.append({model: 'available'})
-        return {'type': 'CDM', 'state': models,
-                'mandatory': True, 'comment': ''}
+        return {
+            'type': 'CDM',
+            'state': models,
+            'mandatory': True,
+            'comment': '',
+        }
 
     def get_strategy_info(self, context, strategy_name):
         strategy = loading.DefaultStrategyLoader().load(strategy_name)
@@ -112,8 +128,9 @@ class StrategyEndpoint:
                 datasource = getattr(strategy, strategy.config.datasource)
         except (AttributeError, IndexError):
             datasource = []
-        available_datasource = self._get_datasource_status(strategy,
-                                                           datasource)
+        available_datasource = self._get_datasource_status(
+            strategy, datasource
+        )
         available_metrics = self._collect_metrics(strategy, datasource)
         available_cdm = self._get_cdm(strategy)
         return [available_datasource, available_metrics, available_cdm]
@@ -206,10 +223,11 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
             cfg.ListOpt(
                 "datasources",
                 help="Datasources to use in order to query the needed metrics."
-                     " This option overrides the global preference."
-                     f" options: {datasources_ops}",
+                " This option overrides the global preference."
+                f" options: {datasources_ops}",
                 item_type=cfg.types.String(choices=datasources_ops),
-                default=None)
+                default=None,
+            )
         ]
 
     @abc.abstractmethod
@@ -242,8 +260,8 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
     def _pre_execute(self):
         """Base Pre-execution phase
 
-         This will perform basic pre execution operations most strategies
-         should perform.
+        This will perform basic pre execution operations most strategies
+        should perform.
         """
 
         LOG.info("Initializing %s", self.get_display_name())
@@ -284,11 +302,14 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
         """
         if self._compute_model is None:
             collector = self.collector_manager.get_cluster_model_collector(
-                'compute', osc=self.osc)
+                'compute', osc=self.osc
+            )
             audit_scope_handler = collector.get_audit_scope_handler(
-                audit_scope=self.audit_scope)
+                audit_scope=self.audit_scope
+            )
             self._compute_model = audit_scope_handler.get_scoped_model(
-                collector.get_latest_cluster_data_model())
+                collector.get_latest_cluster_data_model()
+            )
 
         if not self._compute_model:
             raise exception.ClusterStateNotDefined()
@@ -307,11 +328,14 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
         """
         if self._storage_model is None:
             collector = self.collector_manager.get_cluster_model_collector(
-                'storage', osc=self.osc)
+                'storage', osc=self.osc
+            )
             audit_scope_handler = collector.get_audit_scope_handler(
-                audit_scope=self.audit_scope)
+                audit_scope=self.audit_scope
+            )
             self._storage_model = audit_scope_handler.get_scoped_model(
-                collector.get_latest_cluster_data_model())
+                collector.get_latest_cluster_data_model()
+            )
 
         if not self._storage_model:
             raise exception.ClusterStateNotDefined()
@@ -330,11 +354,14 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
         """
         if self._baremetal_model is None:
             collector = self.collector_manager.get_cluster_model_collector(
-                'baremetal', osc=self.osc)
+                'baremetal', osc=self.osc
+            )
             audit_scope_handler = collector.get_audit_scope_handler(
-                audit_scope=self.audit_scope)
+                audit_scope=self.audit_scope
+            )
             self._baremetal_model = audit_scope_handler.get_scoped_model(
-                collector.get_latest_cluster_data_model())
+                collector.get_latest_cluster_data_model()
+            )
 
         if not self._baremetal_model:
             raise exception.ClusterStateNotDefined()
@@ -356,7 +383,6 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
     @property
     def datasource_backend(self):
         if not self._datasource_backend:
-
             # Load the global preferred datasources order but override it
             # if the strategy has a specific datasources config
             datasources = CONF.watcher_datasources
@@ -364,8 +390,7 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
                 datasources = self.config
 
             self._datasource_backend = ds_manager.DataSourceManager(
-                config=datasources,
-                osc=self.osc
+                config=datasources, osc=self.osc
             ).get_backend(self.DATASOURCE_METRICS)
         return self._datasource_backend
 
@@ -444,36 +469,38 @@ class BaseStrategy(loadable.Loadable, metaclass=abc.ABCMeta):
             if instance.metadata:
                 try:
                     optimize = strutils.bool_from_string(
-                        instance.metadata.get('optimize'))
+                        instance.metadata.get('optimize')
+                    )
                 except ValueError:
                     optimize = False
             if optimize:
                 instances_to_migrate.append(instance)
         return instances_to_migrate
 
-    def add_action_migrate(self,
-                           instance,
-                           migration_type,
-                           source_node,
-                           destination_node):
-        parameters = {'migration_type': migration_type,
-                      'source_node': source_node.hostname,
-                      'destination_node': destination_node.hostname,
-                      'resource_name': instance.name}
-        self.solution.add_action(action_type=self.MIGRATION,
-                                 resource_id=instance.uuid,
-                                 input_parameters=parameters)
+    def add_action_migrate(
+        self, instance, migration_type, source_node, destination_node
+    ):
+        parameters = {
+            'migration_type': migration_type,
+            'source_node': source_node.hostname,
+            'destination_node': destination_node.hostname,
+            'resource_name': instance.name,
+        }
+        self.solution.add_action(
+            action_type=self.MIGRATION,
+            resource_id=instance.uuid,
+            input_parameters=parameters,
+        )
 
 
 class DummyBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     @classmethod
     def get_goal_name(cls):
         return "dummy"
 
     @classmethod
     def get_config_opts(cls):
-        """Override base class config options as do not use datasource """
+        """Override base class config options as do not use datasource"""
 
         return []
 
@@ -493,7 +520,6 @@ class UnclassifiedStrategy(BaseStrategy, metaclass=abc.ABCMeta):
 
 
 class ServerConsolidationBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     REASON_FOR_DISABLE = 'watcher_disabled'
 
     @classmethod
@@ -502,14 +528,12 @@ class ServerConsolidationBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
 
 
 class ThermalOptimizationBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     @classmethod
     def get_goal_name(cls):
         return "thermal_optimization"
 
 
 class WorkloadStabilizationBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._planner = 'workload_stabilization'
@@ -520,40 +544,36 @@ class WorkloadStabilizationBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
 
 
 class NoisyNeighborBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     @classmethod
     def get_goal_name(cls):
         return "noisy_neighbor"
 
 
 class SavingEnergyBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     @classmethod
     def get_goal_name(cls):
         return "saving_energy"
 
     @classmethod
     def get_config_opts(cls):
-        """Override base class config options as do not use datasource """
+        """Override base class config options as do not use datasource"""
 
         return []
 
 
 class ZoneMigrationBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     @classmethod
     def get_goal_name(cls):
         return "hardware_maintenance"
 
     @classmethod
     def get_config_opts(cls):
-        """Override base class config options as do not use datasource """
+        """Override base class config options as do not use datasource"""
 
         return []
 
 
 class HostMaintenanceBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
-
     REASON_FOR_MAINTAINING = 'watcher_maintaining'
 
     @classmethod
@@ -562,6 +582,6 @@ class HostMaintenanceBaseStrategy(BaseStrategy, metaclass=abc.ABCMeta):
 
     @classmethod
     def get_config_opts(cls):
-        """Override base class config options as do not use datasource """
+        """Override base class config options as do not use datasource"""
 
         return []
diff --git a/watcher/decision_engine/strategy/strategies/basic_consolidation.py b/watcher/decision_engine/strategy/strategies/basic_consolidation.py
index 6219dafc1..c17f77a6c 100644
--- a/watcher/decision_engine/strategy/strategies/basic_consolidation.py
+++ b/watcher/decision_engine/strategy/strategies/basic_consolidation.py
@@ -95,11 +95,8 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
     @property
     def aggregation_method(self):
         return self.input_parameters.get(
-            'aggregation_method', {
-                "instance": 'mean',
-                "compute_node": 'mean',
-                "node": ''
-            }
+            'aggregation_method',
+            {"instance": 'mean', "compute_node": 'mean', "node": ''},
         )
 
     @classmethod
@@ -117,45 +114,39 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
             "properties": {
                 "migration_attempts": {
                     "description": "Maximum number of combinations to be "
-                                   "tried by the strategy while searching "
-                                   "for potential candidates. To remove the "
-                                   "limit, set it to 0 (by default)",
+                    "tried by the strategy while searching "
+                    "for potential candidates. To remove the "
+                    "limit, set it to 0 (by default)",
                     "type": "number",
-                    "default": 0
+                    "default": 0,
                 },
                 "period": {
                     "description": "The time interval in seconds for "
-                                   "getting statistic aggregation",
+                    "getting statistic aggregation",
                     "type": "number",
-                    "default": 7200
+                    "default": 7200,
                 },
                 "granularity": {
                     "description": "The time between two measures in an "
-                                   "aggregated timeseries of a metric.",
+                    "aggregated timeseries of a metric.",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
                 "aggregation_method": {
                     "description": "Function used to aggregate multiple "
-                                   "measures into an aggregate. For example, "
-                                   "the min aggregation method will aggregate "
-                                   "the values of different measures to the "
-                                   "minimum value of all the measures in the "
-                                   "time range.",
+                    "measures into an aggregate. For example, "
+                    "the min aggregation method will aggregate "
+                    "the values of different measures to the "
+                    "minimum value of all the measures in the "
+                    "time range.",
                     "type": "object",
                     "properties": {
-                        "instance": {
-                            "type": "string",
-                            "default": 'mean'
-                        },
-                        "compute_node": {
-                            "type": "string",
-                            "default": 'mean'
-                        },
+                        "instance": {"type": "string", "default": 'mean'},
+                        "compute_node": {"type": "string", "default": 'mean'},
                         "node": {
                             "type": "string",
                             # node is deprecated
-                            "default": ''
+                            "default": '',
                         },
                     },
                     "default": {
@@ -163,9 +154,9 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
                         "compute_node": 'mean',
                         # node is deprecated
                         "node": '',
-                    }
+                    },
                 },
-            },
+            }
         }
 
     @classmethod
@@ -174,20 +165,26 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
             cfg.BoolOpt(
                 'check_optimize_metadata',
                 help='Check optimize metadata field in instance before'
-                     ' migration',
-                default=False),
+                ' migration',
+                default=False,
+            )
         ]
 
     def get_available_compute_nodes(self):
-        default_node_scope = [element.ServiceState.ENABLED.value,
-                              element.ServiceState.DISABLED.value]
-        return {uuid: cn for uuid, cn in
-                self.compute_model.get_all_compute_nodes().items()
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        default_node_scope = [
+            element.ServiceState.ENABLED.value,
+            element.ServiceState.DISABLED.value,
+        ]
+        return {
+            uuid: cn
+            for uuid, cn in self.compute_model.get_all_compute_nodes().items()
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
-    def check_migration(self, source_node, destination_node,
-                        instance_to_migrate):
+    def check_migration(
+        self, source_node, destination_node, instance_to_migrate
+    ):
         """Check if the migration is possible
 
         :param source_node: the current node of the virtual machine
@@ -198,22 +195,29 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         if source_node == destination_node:
             return False
 
-        LOG.debug('Migrate instance %s from %s to  %s',
-                  instance_to_migrate, source_node, destination_node)
+        LOG.debug(
+            'Migrate instance %s from %s to  %s',
+            instance_to_migrate,
+            source_node,
+            destination_node,
+        )
 
         used_resources = self.compute_model.get_node_used_resources(
-            destination_node)
+            destination_node
+        )
 
         # capacity requested by the compute node
         total_cores = used_resources['vcpu'] + instance_to_migrate.vcpus
         total_disk = used_resources['disk'] + instance_to_migrate.disk
         total_mem = used_resources['memory'] + instance_to_migrate.memory
 
-        return self.check_threshold(destination_node, total_cores, total_disk,
-                                    total_mem)
+        return self.check_threshold(
+            destination_node, total_cores, total_disk, total_mem
+        )
 
-    def check_threshold(self, destination_node, total_cores,
-                        total_disk, total_mem):
+    def check_threshold(
+        self, destination_node, total_cores, total_disk, total_mem
+    ):
         """Check threshold
 
         Check the threshold value defined by the ratio of
@@ -230,12 +234,19 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         disk_capacity = destination_node.disk_gb_capacity
         memory_capacity = destination_node.memory_mb_capacity
 
-        return (cpu_capacity >= total_cores * self.threshold_cores and
-                disk_capacity >= total_disk * self.threshold_disk and
-                memory_capacity >= total_mem * self.threshold_mem)
+        return (
+            cpu_capacity >= total_cores * self.threshold_cores
+            and disk_capacity >= total_disk * self.threshold_disk
+            and memory_capacity >= total_mem * self.threshold_mem
+        )
 
-    def calculate_weight(self, compute_resource, total_cores_used,
-                         total_disk_used, total_memory_used):
+    def calculate_weight(
+        self,
+        compute_resource,
+        total_cores_used,
+        total_disk_used,
+        total_memory_used,
+    ):
         """Calculate weight of every resource
 
         :param compute_resource:
@@ -248,31 +259,39 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         disk_capacity = compute_resource.disk
         memory_capacity = compute_resource.memory
 
-        score_cores = (1 - (float(cpu_capacity) - float(total_cores_used)) /
-                       float(cpu_capacity))
+        score_cores = 1 - (
+            float(cpu_capacity) - float(total_cores_used)
+        ) / float(cpu_capacity)
 
         # It's possible that disk_capacity is 0, e.g., m1.nano.disk = 0
         if disk_capacity == 0:
             score_disk = 0
         else:
-            score_disk = (1 - (float(disk_capacity) - float(total_disk_used)) /
-                          float(disk_capacity))
+            score_disk = 1 - (
+                float(disk_capacity) - float(total_disk_used)
+            ) / float(disk_capacity)
 
-        score_memory = (
-            1 - (float(memory_capacity) - float(total_memory_used)) /
-            float(memory_capacity))
+        score_memory = 1 - (
+            float(memory_capacity) - float(total_memory_used)
+        ) / float(memory_capacity)
         # TODO(jed): take in account weight
         return (score_cores + score_disk + score_memory) / 3
 
     def get_compute_node_cpu_usage(self, compute_node):
         return self.datasource_backend.get_host_cpu_usage(
-            compute_node, self.period, self.aggregation_method['compute_node'],
-            self.granularity)
+            compute_node,
+            self.period,
+            self.aggregation_method['compute_node'],
+            self.granularity,
+        )
 
     def get_instance_cpu_usage(self, instance):
         return self.datasource_backend.get_instance_cpu_usage(
-            instance, self.period, self.aggregation_method['instance'],
-            self.granularity)
+            instance,
+            self.period,
+            self.aggregation_method['instance'],
+            self.granularity,
+        )
 
     def calculate_score_node(self, node):
         """Calculate the score that represent the utilization level
@@ -286,10 +305,9 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         if host_avg_cpu_util is None:
             resource_id = f"{node.uuid}_{node.hostname}"
             LOG.error(
-                "No values returned by %(resource_id)s "
-                "for %(metric_name)s", dict(
-                    resource_id=resource_id,
-                    metric_name='host_cpu_usage'))
+                "No values returned by %(resource_id)s for %(metric_name)s",
+                dict(resource_id=resource_id, metric_name='host_cpu_usage'),
+            )
             host_avg_cpu_util = 100
 
         total_cores_used = node.vcpus * (host_avg_cpu_util / 100.0)
@@ -305,10 +323,11 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         instance_cpu_utilization = self.get_instance_cpu_usage(instance)
         if instance_cpu_utilization is None:
             LOG.error(
-                "No values returned by %(resource_id)s "
-                "for %(metric_name)s", dict(
-                    resource_id=instance.uuid,
-                    metric_name='instance_cpu_usage'))
+                "No values returned by %(resource_id)s for %(metric_name)s",
+                dict(
+                    resource_id=instance.uuid, metric_name='instance_cpu_usage'
+                ),
+            )
             instance_cpu_utilization = 100
 
         total_cores_used = instance.vcpus * (instance_cpu_utilization / 100.0)
@@ -316,12 +335,16 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         return self.calculate_weight(instance, total_cores_used, 0, 0)
 
     def add_action_disable_node(self, node):
-        parameters = {'state': element.ServiceState.DISABLED.value,
-                      'disabled_reason': self.REASON_FOR_DISABLE,
-                      'resource_name': node.hostname}
-        self.solution.add_action(action_type=self.CHANGE_NOVA_SERVICE_STATE,
-                                 resource_id=node.uuid,
-                                 input_parameters=parameters)
+        parameters = {
+            'state': element.ServiceState.DISABLED.value,
+            'disabled_reason': self.REASON_FOR_DISABLE,
+            'resource_name': node.hostname,
+        }
+        self.solution.add_action(
+            action_type=self.CHANGE_NOVA_SERVICE_STATE,
+            resource_id=node.uuid,
+            input_parameters=parameters,
+        )
 
     def compute_score_of_nodes(self):
         """Calculate score of nodes based on load by VMs"""
@@ -341,56 +364,68 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         """Get List of VMs from node"""
         node_to_release = sorted_scores[len(sorted_scores) - 1][0]
         instances = self.compute_model.get_node_instances(
-            self.compute_model.get_node_by_uuid(node_to_release))
+            self.compute_model.get_node_by_uuid(node_to_release)
+        )
 
         instances_to_migrate = self.filter_instances_by_audit_tag(instances)
         instance_score = []
         for instance in instances_to_migrate:
             if instance.state == element.InstanceState.ACTIVE.value:
                 instance_score.append(
-                    (instance, self.calculate_score_instance(instance)))
+                    (instance, self.calculate_score_instance(instance))
+                )
 
         return node_to_release, instance_score
 
-    def create_migration_instance(self, mig_instance, mig_source_node,
-                                  mig_destination_node):
+    def create_migration_instance(
+        self, mig_instance, mig_source_node, mig_destination_node
+    ):
         """Create migration VM"""
         if self.compute_model.migrate_instance(
-                mig_instance, mig_source_node, mig_destination_node):
-            self.add_action_migrate(mig_instance, 'live',
-                                    mig_source_node,
-                                    mig_destination_node)
+            mig_instance, mig_source_node, mig_destination_node
+        ):
+            self.add_action_migrate(
+                mig_instance, 'live', mig_source_node, mig_destination_node
+            )
 
         if len(self.compute_model.get_node_instances(mig_source_node)) == 0:
             self.add_action_disable_node(mig_source_node)
             self.number_of_released_nodes += 1
 
-    def calculate_num_migrations(self, sorted_instances, node_to_release,
-                                 sorted_score):
+    def calculate_num_migrations(
+        self, sorted_instances, node_to_release, sorted_score
+    ):
         number_migrations = 0
         for mig_instance, __ in sorted_instances:
             # skip exclude instance when migrating
             if mig_instance.watcher_exclude:
-                LOG.debug("Instance is excluded by scope, "
-                          "skipped: %s", mig_instance.uuid)
+                LOG.debug(
+                    "Instance is excluded by scope, skipped: %s",
+                    mig_instance.uuid,
+                )
                 continue
             for node_uuid, __ in sorted_score:
                 mig_source_node = self.compute_model.get_node_by_uuid(
-                    node_to_release)
+                    node_to_release
+                )
                 mig_destination_node = self.compute_model.get_node_by_uuid(
-                    node_uuid)
+                    node_uuid
+                )
 
                 result = self.check_migration(
-                    mig_source_node, mig_destination_node, mig_instance)
+                    mig_source_node, mig_destination_node, mig_instance
+                )
                 if result:
                     self.create_migration_instance(
-                        mig_instance, mig_source_node, mig_destination_node)
+                        mig_instance, mig_source_node, mig_destination_node
+                    )
                     number_migrations += 1
                     break
         return number_migrations
 
-    def unsuccessful_migration_actualization(self, number_migrations,
-                                             unsuccessful_migration):
+    def unsuccessful_migration_actualization(
+        self, number_migrations, unsuccessful_migration
+    ):
         if number_migrations > 0:
             self.number_of_migrations += number_migrations
             return 0
@@ -402,10 +437,13 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
 
         # backwards compatibility for node parameter.
         if self.aggregation_method['node'] != '':
-            LOG.warning('Parameter node has been renamed to compute_node and '
-                        'will be removed in next release.')
-            self.aggregation_method['compute_node'] = \
-                self.aggregation_method['node']
+            LOG.warning(
+                'Parameter node has been renamed to compute_node and '
+                'will be removed in next release.'
+            )
+            self.aggregation_method['compute_node'] = self.aggregation_method[
+                'node'
+            ]
 
     def do_execute(self, audit=None):
         unsuccessful_migration = 0
@@ -417,27 +455,32 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         # Get Node to be released
         if len(scores) == 0:
             LOG.warning(
-                "The workloads of the compute nodes"
-                " of the cluster is zero")
+                "The workloads of the compute nodes of the cluster is zero"
+            )
             return
 
         while sorted_scores and (
-                not self.migration_attempts or
-                self.migration_attempts >= unsuccessful_migration):
+            not self.migration_attempts
+            or self.migration_attempts >= unsuccessful_migration
+        ):
             node_to_release, instance_score = self.node_and_instance_score(
-                sorted_scores)
+                sorted_scores
+            )
 
             # Sort instances by Score
             sorted_instances = sorted(
-                instance_score, reverse=True, key=lambda x: (x[1]))
+                instance_score, reverse=True, key=lambda x: (x[1])
+            )
             # BFD: Best Fit Decrease
             LOG.debug("Instance(s) BFD %s", sorted_instances)
 
             migrations = self.calculate_num_migrations(
-                sorted_instances, node_to_release, sorted_scores)
+                sorted_instances, node_to_release, sorted_scores
+            )
 
             unsuccessful_migration = self.unsuccessful_migration_actualization(
-                migrations, unsuccessful_migration)
+                migrations, unsuccessful_migration
+            )
 
             if not migrations:
                 # We don't have any possible migrations to perform on this node
@@ -449,7 +492,7 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
             "compute_nodes_count": self.number_of_enabled_nodes,
             "released_compute_nodes_count": self.number_of_released_nodes,
             "instance_migrations_count": self.number_of_migrations,
-            "efficacy": self.efficacy
+            "efficacy": self.efficacy,
         }
         LOG.debug(infos)
 
diff --git a/watcher/decision_engine/strategy/strategies/dummy_strategy.py b/watcher/decision_engine/strategy/strategies/dummy_strategy.py
index 4acbc6cf5..55cafb74d 100644
--- a/watcher/decision_engine/strategy/strategies/dummy_strategy.py
+++ b/watcher/decision_engine/strategy/strategies/dummy_strategy.py
@@ -54,18 +54,23 @@ class DummyStrategy(base.DummyBaseStrategy):
     def do_execute(self, audit=None):
         para1 = self.input_parameters.para1
         para2 = self.input_parameters.para2
-        LOG.debug("Executing Dummy strategy with para1=%(p1)f, para2=%(p2)s",
-                  {'p1': para1, 'p2': para2})
+        LOG.debug(
+            "Executing Dummy strategy with para1=%(p1)f, para2=%(p2)s",
+            {'p1': para1, 'p2': para2},
+        )
         parameters = {'message': 'hello World'}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
         parameters = {'message': para2}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
-        self.solution.add_action(action_type=self.SLEEP,
-                                 input_parameters={'duration': para1})
+        self.solution.add_action(
+            action_type=self.SLEEP, input_parameters={'duration': para1}
+        )
 
     def post_execute(self):
         pass
@@ -97,7 +102,7 @@ class DummyStrategy(base.DummyBaseStrategy):
                 "para2": {
                     "description": "string parameter example",
                     "type": "string",
-                    "default": "hello"
+                    "default": "hello",
                 },
-            },
+            }
         }
diff --git a/watcher/decision_engine/strategy/strategies/dummy_with_resize.py b/watcher/decision_engine/strategy/strategies/dummy_with_resize.py
index a48bfc3a4..5d15aaf94 100644
--- a/watcher/decision_engine/strategy/strategies/dummy_with_resize.py
+++ b/watcher/decision_engine/strategy/strategies/dummy_with_resize.py
@@ -51,25 +51,32 @@ class DummyWithResize(base.DummyBaseStrategy):
     def do_execute(self, audit=None):
         para1 = self.input_parameters.para1
         para2 = self.input_parameters.para2
-        LOG.debug("Executing Dummy strategy with para1=%(p1)f, para2=%(p2)s",
-                  {'p1': para1, 'p2': para2})
+        LOG.debug(
+            "Executing Dummy strategy with para1=%(p1)f, para2=%(p2)s",
+            {'p1': para1, 'p2': para2},
+        )
         parameters = {'message': 'hello World'}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
         parameters = {'message': 'Welcome'}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
-        self.solution.add_action(action_type=self.SLEEP,
-                                 input_parameters={'duration': 5.0})
+        self.solution.add_action(
+            action_type=self.SLEEP, input_parameters={'duration': 5.0}
+        )
         self.solution.add_action(
             action_type='migrate',
             resource_id='b199db0c-1408-4d52-b5a5-5ca14de0ff36',
             input_parameters={
                 'source_node': 'compute2',
                 'destination_node': 'compute3',
-                'migration_type': 'live'})
+                'migration_type': 'live',
+            },
+        )
 
         self.solution.add_action(
             action_type='migrate',
@@ -77,12 +84,13 @@ class DummyWithResize(base.DummyBaseStrategy):
             input_parameters={
                 'source_node': 'compute2',
                 'destination_node': 'compute3',
-                'migration_type': 'live'}
+                'migration_type': 'live',
+            },
         )
         self.solution.add_action(
             action_type='resize',
             resource_id='8db1b3c1-7938-4c34-8c03-6de14b874f8f',
-            input_parameters={'flavor': 'x2'}
+            input_parameters={'flavor': 'x2'},
         )
 
     def post_execute(self):
@@ -115,7 +123,7 @@ class DummyWithResize(base.DummyBaseStrategy):
                 "para2": {
                     "description": "string parameter example",
                     "type": "string",
-                    "default": "hello"
+                    "default": "hello",
                 },
-            },
+            }
         }
diff --git a/watcher/decision_engine/strategy/strategies/dummy_with_scorer.py b/watcher/decision_engine/strategy/strategies/dummy_with_scorer.py
index 4fc5afed1..09912abb7 100644
--- a/watcher/decision_engine/strategy/strategies/dummy_with_scorer.py
+++ b/watcher/decision_engine/strategy/strategies/dummy_with_scorer.py
@@ -64,16 +64,19 @@ class DummyWithScorer(base.DummyBaseStrategy):
         super().__init__(config, osc)
 
         # Setup Scoring Engines
-        self._workload_scorer = (scoring_factory
-                                 .get_scoring_engine('dummy_scorer'))
-        self._avg_scorer = (scoring_factory
-                            .get_scoring_engine('dummy_avg_scorer'))
+        self._workload_scorer = scoring_factory.get_scoring_engine(
+            'dummy_scorer'
+        )
+        self._avg_scorer = scoring_factory.get_scoring_engine(
+            'dummy_avg_scorer'
+        )
 
         # Get metainfo from Workload Scorer for result interpretation
         metainfo = jsonutils.loads(self._workload_scorer.get_metainfo())
-        self._workloads = {index: workload
-                           for index, workload in enumerate(
-                               metainfo['workloads'])}
+        self._workloads = {
+            index: workload
+            for index, workload in enumerate(metainfo['workloads'])
+        }
 
     def pre_execute(self):
         self._pre_execute()
@@ -82,11 +85,14 @@ class DummyWithScorer(base.DummyBaseStrategy):
         # Simple "hello world" from strategy
         param1 = self.input_parameters.param1
         param2 = self.input_parameters.param2
-        LOG.debug('DummyWithScorer params: param1=%(p1)f, param2=%(p2)s',
-                  {'p1': param1, 'p2': param2})
+        LOG.debug(
+            'DummyWithScorer params: param1=%(p1)f, param2=%(p2)s',
+            {'p1': param1, 'p2': param2},
+        )
         parameters = {'message': 'Hello from Dummy Strategy with Scorer!'}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
         # Demonstrate workload scorer
         features = self._generate_random_telemetry()
@@ -97,8 +103,9 @@ class DummyWithScorer(base.DummyBaseStrategy):
         result = self._workloads[jsonutils.loads(result_str)[0]]
         LOG.debug('Detected Workload: %s', result)
         parameters = {'message': f'Detected Workload: {result}'}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
         # Demonstrate AVG scorer
         features = jsonutils.dumps(random.sample(range(1000), 20))
@@ -107,12 +114,14 @@ class DummyWithScorer(base.DummyBaseStrategy):
         result = jsonutils.loads(result_str)[0]
         LOG.debug('AVG Scorer result (parsed): %d', result)
         parameters = {'message': f'AVG Scorer result: {result}'}
-        self.solution.add_action(action_type=self.NOP,
-                                 input_parameters=parameters)
+        self.solution.add_action(
+            action_type=self.NOP, input_parameters=parameters
+        )
 
         # Sleep action
-        self.solution.add_action(action_type=self.SLEEP,
-                                 input_parameters={'duration': 5.0})
+        self.solution.add_action(
+            action_type=self.SLEEP, input_parameters={'duration': 5.0}
+        )
 
     def post_execute(self):
         pass
@@ -144,23 +153,32 @@ class DummyWithScorer(base.DummyBaseStrategy):
                 'param2': {
                     'description': 'string parameter example',
                     'type': "string",
-                    'default': "hello"
+                    'default': "hello",
                 },
-            },
+            }
         }
 
     def _generate_random_telemetry(self):
         processor_time = random.randint(0, 100)
-        mem_total_bytes = 4*units.Gi
-        mem_avail_bytes = random.randint(1*units.Gi, 4*units.Gi)
+        mem_total_bytes = 4 * units.Gi
+        mem_avail_bytes = random.randint(1 * units.Gi, 4 * units.Gi)
         mem_page_reads = random.randint(0, 2000)
         mem_page_writes = random.randint(0, 2000)
-        disk_read_bytes = random.randint(0*units.Mi, 200*units.Mi)
-        disk_write_bytes = random.randint(0*units.Mi, 200*units.Mi)
-        net_bytes_received = random.randint(0*units.Mi, 20*units.Mi)
-        net_bytes_sent = random.randint(0*units.Mi, 10*units.Mi)
+        disk_read_bytes = random.randint(0 * units.Mi, 200 * units.Mi)
+        disk_write_bytes = random.randint(0 * units.Mi, 200 * units.Mi)
+        net_bytes_received = random.randint(0 * units.Mi, 20 * units.Mi)
+        net_bytes_sent = random.randint(0 * units.Mi, 10 * units.Mi)
 
-        return jsonutils.dumps([
-            processor_time, mem_total_bytes, mem_avail_bytes,
-            mem_page_reads, mem_page_writes, disk_read_bytes,
-            disk_write_bytes, net_bytes_received, net_bytes_sent])
+        return jsonutils.dumps(
+            [
+                processor_time,
+                mem_total_bytes,
+                mem_avail_bytes,
+                mem_page_reads,
+                mem_page_writes,
+                disk_read_bytes,
+                disk_write_bytes,
+                net_bytes_received,
+                net_bytes_sent,
+            ]
+        )
diff --git a/watcher/decision_engine/strategy/strategies/host_maintenance.py b/watcher/decision_engine/strategy/strategies/host_maintenance.py
index 02486c258..d68602973 100644
--- a/watcher/decision_engine/strategy/strategies/host_maintenance.py
+++ b/watcher/decision_engine/strategy/strategies/host_maintenance.py
@@ -82,26 +82,26 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
             "properties": {
                 "maintenance_node": {
                     "description": "The name of the compute node which "
-                                   "need maintenance",
+                    "need maintenance",
                     "type": "string",
                 },
                 "backup_node": {
                     "description": "The name of the compute node which "
-                                   "will backup the maintenance node.",
+                    "will backup the maintenance node.",
                     "type": "string",
                 },
                 "disable_live_migration": {
                     "description": "Disable live migration in maintenance. "
-                                   "If True, active instances will be cold "
-                                   "migrated if `disable_cold_migration` is "
-                                   "not set, otherwise they will be stopped.",
+                    "If True, active instances will be cold "
+                    "migrated if `disable_cold_migration` is "
+                    "not set, otherwise they will be stopped.",
                     "type": "boolean",
                     "default": False,
                 },
                 "disable_cold_migration": {
                     "description": "Disable cold migration in maintenance. "
-                                   "If True, non-active instances will not be "
-                                   "cold migrated.",
+                    "If True, non-active instances will not be "
+                    "cold migrated.",
                     "type": "boolean",
                     "default": False,
                 },
@@ -116,10 +116,11 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         elif isinstance(instance.state, element.InstanceState):
             return instance.state.value
         else:
-            LOG.error('Unexpected instance state type, '
-                      'state=%(state)s, state_type=%(st)s.',
-                      dict(state=instance.state,
-                           st=type(instance.state)))
+            LOG.error(
+                'Unexpected instance state type, '
+                'state=%(state)s, state_type=%(st)s.',
+                dict(state=instance.state, st=type(instance.state)),
+            )
             raise exception.WatcherException
 
     def get_node_status_str(self, node):
@@ -129,10 +130,11 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         elif isinstance(node.status, element.ServiceState):
             return node.status.value
         else:
-            LOG.error('Unexpected node status type, '
-                      'status=%(status)s, status_type=%(st)s.',
-                      dict(status=node.status,
-                           st=type(node.status)))
+            LOG.error(
+                'Unexpected node status type, '
+                'status=%(status)s, status_type=%(st)s.',
+                dict(status=node.status, st=type(node.status)),
+            )
             raise exception.WatcherException
 
     def get_node_capacity(self, node):
@@ -141,9 +143,11 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         :param node: node object
         :return: dict(cpu(cores), ram(MB), disk(B))
         """
-        return dict(cpu=node.vcpu_capacity,
-                    ram=node.memory_mb_capacity,
-                    disk=node.disk_gb_capacity)
+        return dict(
+            cpu=node.vcpu_capacity,
+            ram=node.memory_mb_capacity,
+            disk=node.disk_gb_capacity,
+        )
 
     def host_fits(self, source_node, destination_node):
         """check host fits
@@ -153,9 +157,11 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         """
 
         source_node_used = self.compute_model.get_node_used_resources(
-            source_node)
+            source_node
+        )
         destination_node_free = self.compute_model.get_node_free_resources(
-            destination_node)
+            destination_node
+        )
         metrics = ['vcpu', 'memory']
         for m in metrics:
             if source_node_used[m] > destination_node_free[m]:
@@ -164,22 +170,28 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
 
     def add_action_enable_compute_node(self, node):
         """Add an action for node enabler into the solution."""
-        params = {'state': element.ServiceState.ENABLED.value,
-                  'resource_name': node.hostname}
+        params = {
+            'state': element.ServiceState.ENABLED.value,
+            'resource_name': node.hostname,
+        }
         self.solution.add_action(
             action_type=self.CHANGE_NOVA_SERVICE_STATE,
             resource_id=node.uuid,
-            input_parameters=params)
+            input_parameters=params,
+        )
 
     def add_action_maintain_compute_node(self, node):
         """Add an action for node maintenance into the solution."""
-        params = {'state': element.ServiceState.DISABLED.value,
-                  'disabled_reason': self.REASON_FOR_MAINTAINING,
-                  'resource_name': node.hostname}
+        params = {
+            'state': element.ServiceState.DISABLED.value,
+            'disabled_reason': self.REASON_FOR_MAINTAINING,
+            'resource_name': node.hostname,
+        }
         self.solution.add_action(
             action_type=self.CHANGE_NOVA_SERVICE_STATE,
             resource_id=node.uuid,
-            input_parameters=params)
+            input_parameters=params,
+        )
 
     def enable_compute_node_if_disabled(self, node):
         node_status_str = self.get_node_status_str(node)
@@ -189,8 +201,8 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
     def add_action_stop_instance(self, instance):
         """Add an action for instance stop into the solution."""
         self.solution.add_action(
-            action_type=self.INSTANCE_STOP,
-            resource_id=instance.uuid)
+            action_type=self.INSTANCE_STOP, resource_id=instance.uuid
+        )
 
     def instance_handle(self, instance, src_node, des_node=None):
         """Add an action for instance handling into the solution.
@@ -206,9 +218,11 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         """
         instance_state_str = self.get_instance_state_str(instance)
         disable_live_migration = self.input_parameters.get(
-            'disable_live_migration', False)
+            'disable_live_migration', False
+        )
         disable_cold_migration = self.input_parameters.get(
-            'disable_cold_migration', False)
+            'disable_cold_migration', False
+        )
 
         # Case 1: Both migrations disabled -> only stop active instance
         if disable_live_migration and disable_cold_migration:
@@ -233,14 +247,18 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
             # Cold migrate non-active instance
             migration_type = 'cold'
 
-        params = {'migration_type': migration_type,
-                  'source_node': src_node.hostname,
-                  'resource_name': instance.name}
+        params = {
+            'migration_type': migration_type,
+            'source_node': src_node.hostname,
+            'resource_name': instance.name,
+        }
         if des_node:
             params['destination_node'] = des_node.hostname
-        self.solution.add_action(action_type=self.INSTANCE_MIGRATION,
-                                 resource_id=instance.uuid,
-                                 input_parameters=params)
+        self.solution.add_action(
+            action_type=self.INSTANCE_MIGRATION,
+            resource_id=instance.uuid,
+            input_parameters=params,
+        )
 
     def host_migration(self, source_node, destination_node):
         """host migration
@@ -300,8 +318,7 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         # if no VMs in the maintenance_node, just maintain the compute node
         src_node = self.compute_model.get_node_by_name(maintenance_node)
         if len(self.compute_model.get_node_instances(src_node)) == 0:
-            if (src_node.disabled_reason !=
-                    self.REASON_FOR_MAINTAINING):
+            if src_node.disabled_reason != self.REASON_FOR_MAINTAINING:
                 self.add_action_maintain_compute_node(src_node)
                 return
 
diff --git a/watcher/decision_engine/strategy/strategies/node_resource_consolidation.py b/watcher/decision_engine/strategy/strategies/node_resource_consolidation.py
index 25cdf815a..ba9dd642c 100644
--- a/watcher/decision_engine/strategy/strategies/node_resource_consolidation.py
+++ b/watcher/decision_engine/strategy/strategies/node_resource_consolidation.py
@@ -87,15 +87,15 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
             "properties": {
                 "host_choice": {
                     "description": "The way to select the server migration "
-                                   "destination node. The value 'auto' "
-                                   "means that Nova scheduler selects "
-                                   "the destination node, and 'specify' "
-                                   "means the strategy specifies the "
-                                   "destination.",
+                    "destination node. The value 'auto' "
+                    "means that Nova scheduler selects "
+                    "the destination node, and 'specify' "
+                    "means the strategy specifies the "
+                    "destination.",
                     "type": "string",
-                    "default": 'auto'
-                },
-            },
+                    "default": 'auto',
+                }
+            }
         }
 
     def check_resources(self, servers, destination):
@@ -107,7 +107,8 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
         for server in servers:
             # just vcpu and memory, do not consider disk
             if free_res['vcpu'] >= server.vcpus and (
-                    free_res['memory'] >= server.memory):
+                free_res['memory'] >= server.memory
+            ):
                 free_res['vcpu'] -= server.vcpus
                 free_res['memory'] -= server.memory
                 dest_flag = True
@@ -121,8 +122,10 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
             return dest_node
         sorted_nodes = sorted(
             destinations,
-            key=lambda x: self.compute_model.get_node_free_resources(
-                x)['vcpu'])
+            key=lambda x: self.compute_model.get_node_free_resources(x)[
+                'vcpu'
+            ],
+        )
         for dest in sorted_nodes:
             if self.check_resources([server], dest):
                 if self.compute_model.migrate_instance(server, source, dest):
@@ -137,13 +140,14 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
         for node in sources:
             servers = self.compute_model.get_node_instances(node)
             sorted_servers = sorted(
-                servers,
-                key=lambda x: x.vcpus,
-                reverse=True)
+                servers, key=lambda x: x.vcpus, reverse=True
+            )
             for server in sorted_servers:
-                parameters = {'migration_type': 'live',
-                              'source_node': node.hostname,
-                              'resource_name': server.name}
+                parameters = {
+                    'migration_type': 'live',
+                    'source_node': node.hostname,
+                    'resource_name': server.name,
+                }
                 action_flag = False
                 if self.host_choice != 'auto':
                     # specify destination host
@@ -158,24 +162,28 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
                     self.solution.add_action(
                         action_type=self.MIGRATION,
                         resource_id=server.uuid,
-                        input_parameters=parameters)
+                        input_parameters=parameters,
+                    )
 
     def add_change_node_state_actions(self, nodes, status):
-        if status not in (element.ServiceState.DISABLED.value,
-                          element.ServiceState.ENABLED.value):
+        if status not in (
+            element.ServiceState.DISABLED.value,
+            element.ServiceState.ENABLED.value,
+        ):
             raise exception.IllegalArgumentException(
-                message=_("The node status is not defined"))
+                message=_("The node status is not defined")
+            )
         changed_nodes = []
         for node in nodes:
             if node.status != status:
-                parameters = {'state': status,
-                              'resource_name': node.hostname}
+                parameters = {'state': status, 'resource_name': node.hostname}
                 if status == element.ServiceState.DISABLED.value:
                     parameters['disabled_reason'] = self.REASON_FOR_DISABLE
                 self.solution.add_action(
                     action_type=self.CHANGE_NOVA_SERVICE_STATE,
                     resource_id=node.uuid,
-                    input_parameters=parameters)
+                    input_parameters=parameters,
+                )
                 node.status = status
                 changed_nodes.append(node)
 
@@ -186,19 +194,19 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
         # just for continuous audit
         nodes_failed = []
         if self.audit is None or (
-                self.audit.audit_type ==
-                objects.audit.AuditType.ONESHOT.value):
+            self.audit.audit_type == objects.audit.AuditType.ONESHOT.value
+        ):
             return nodes_failed
         filters = {'audit_uuid': self.audit.uuid}
-        actions = objects.action.Action.list(
-            self.ctx,
-            filters=filters)
+        actions = objects.action.Action.list(self.ctx, filters=filters)
         for action in actions:
             if action.state == objects.action.State.FAILED and (
-                    action.action_type == self.MIGRATION):
+                action.action_type == self.MIGRATION
+            ):
                 server_uuid = action.input_parameters.get('resource_id')
                 node = self.compute_model.get_node_by_instance_uuid(
-                    server_uuid)
+                    server_uuid
+                )
                 if node not in nodes_failed:
                     nodes_failed.append(node)
 
@@ -212,8 +220,10 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
         LOG.info("nodes: %s migration failed", nodes_failed)
         sorted_nodes = sorted(
             nodes,
-            key=lambda x: self.compute_model.get_node_used_resources(
-                x)['vcpu'])
+            key=lambda x: self.compute_model.get_node_used_resources(x)[
+                'vcpu'
+            ],
+        )
         for node in sorted_nodes:
             if node in dest_nodes:
                 break
@@ -273,17 +283,17 @@ class NodeResourceConsolidation(base.ServerConsolidationBaseStrategy):
         if self.host_choice == 'auto':
             # disable compute node to avoid to be select by Nova scheduler
             nodes_disabled = self.add_change_node_state_actions(
-                free_nodes+source_nodes, element.ServiceState.DISABLED.value)
+                free_nodes + source_nodes, element.ServiceState.DISABLED.value
+            )
         self.add_migrate_actions(source_nodes, dest_nodes)
         if nodes_disabled:
             # restore disabled compute node after migration
             self.add_change_node_state_actions(
-                nodes_disabled, element.ServiceState.ENABLED.value)
+                nodes_disabled, element.ServiceState.ENABLED.value
+            )
 
     def post_execute(self):
-        """Post-execution phase
-
-        """
+        """Post-execution phase"""
         self.solution.set_efficacy_indicators(
             compute_nodes_count=self.compute_nodes_count,
             released_compute_nodes_count=self.number_of_released_nodes,
diff --git a/watcher/decision_engine/strategy/strategies/noisy_neighbor.py b/watcher/decision_engine/strategy/strategies/noisy_neighbor.py
index 0ac102956..96479079e 100644
--- a/watcher/decision_engine/strategy/strategies/noisy_neighbor.py
+++ b/watcher/decision_engine/strategy/strategies/noisy_neighbor.py
@@ -31,8 +31,9 @@ CONF = cfg.CONF
 warnings.simplefilter('always')
 
 
-@removals.removed_class("NoisyNeighbor", version="2025.2",
-                        removal_version="2026.2")
+@removals.removed_class(
+    "NoisyNeighbor", version="2025.2", removal_version="2026.2"
+)
 class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
     """Noisy Neighbor strategy using live migration
 
@@ -86,28 +87,37 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
             "properties": {
                 "cache_threshold": {
                     "description": "Performance drop in L3_cache threshold "
-                                   "for migration",
+                    "for migration",
                     "type": "number",
-                    "default": 35.0
+                    "default": 35.0,
                 },
                 "period": {
                     "description": "Aggregate time period of "
-                                   "ceilometer and gnocchi",
+                    "ceilometer and gnocchi",
                     "type": "number",
-                    "default": 100.0
+                    "default": 100.0,
                 },
-            },
+            }
         }
 
     def get_current_and_previous_cache(self, instance):
         try:
             curr_cache = self.datasource_backend.get_instance_l3_cache_usage(
-                instance, self.meter_name, self.period,
-                'mean', granularity=300)
-            previous_cache = 2 * (
-                self.datasource_backend.get_instance_l3_cache_usage(
-                    instance, self.meter_name, 2 * self.period,
-                    'mean', granularity=300)) - curr_cache
+                instance, self.meter_name, self.period, 'mean', granularity=300
+            )
+            previous_cache = (
+                2
+                * (
+                    self.datasource_backend.get_instance_l3_cache_usage(
+                        instance,
+                        self.meter_name,
+                        2 * self.period,
+                        'mean',
+                        granularity=300,
+                    )
+                )
+                - curr_cache
+            )
 
         except Exception as exc:
             LOG.exception(exc)
@@ -116,33 +126,40 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
         return curr_cache, previous_cache
 
     def find_priority_instance(self, instance):
-
-        current_cache, previous_cache = \
-            self.get_current_and_previous_cache(instance)
+        current_cache, previous_cache = self.get_current_and_previous_cache(
+            instance
+        )
 
         if None in (current_cache, previous_cache):
-            LOG.warning("Datasource unable to pick L3 Cache "
-                        "values. Skipping the instance")
+            LOG.warning(
+                "Datasource unable to pick L3 Cache "
+                "values. Skipping the instance"
+            )
             return None
 
-        if (current_cache < (1 - (self.cache_threshold / 100.0)) *
-                previous_cache):
+        if (
+            current_cache
+            < (1 - (self.cache_threshold / 100.0)) * previous_cache
+        ):
             return instance
         else:
             return None
 
     def find_noisy_instance(self, instance):
-
-        noisy_current_cache, noisy_previous_cache = \
+        noisy_current_cache, noisy_previous_cache = (
             self.get_current_and_previous_cache(instance)
+        )
 
         if None in (noisy_current_cache, noisy_previous_cache):
-            LOG.warning("Datasource unable to pick "
-                        "L3 Cache. Skipping the instance")
+            LOG.warning(
+                "Datasource unable to pick L3 Cache. Skipping the instance"
+            )
             return None
 
-        if (noisy_current_cache > (1 + (self.cache_threshold / 100.0)) *
-                noisy_previous_cache):
+        if (
+            noisy_current_cache
+            > (1 + (self.cache_threshold / 100.0)) * noisy_previous_cache
+        ):
             return instance
         else:
             return None
@@ -163,7 +180,6 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
             loop_break_flag = False
 
             if node_instance_count > 1:
-
                 instance_priority_list = []
 
                 for instance in instances_of_node:
@@ -171,38 +187,49 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
 
                 # If there is no metadata regarding watcher-priority, it takes
                 # DEFAULT_WATCHER_PRIORITY as priority.
-                instance_priority_list.sort(key=lambda a: (
-                    a.get('metadata').get('watcher-priority'),
-                    self.DEFAULT_WATCHER_PRIORITY))
+                instance_priority_list.sort(
+                    key=lambda a: (
+                        a.get('metadata').get('watcher-priority'),
+                        self.DEFAULT_WATCHER_PRIORITY,
+                    )
+                )
 
                 instance_priority_list_reverse = list(instance_priority_list)
                 instance_priority_list_reverse.reverse()
 
                 for potential_priority_instance in instance_priority_list:
-
                     priority_instance = self.find_priority_instance(
-                        potential_priority_instance)
+                        potential_priority_instance
+                    )
 
-                    if (priority_instance is not None):
-
-                        for potential_noisy_instance in (
-                                instance_priority_list_reverse):
-                            if (potential_noisy_instance ==
-                                    potential_priority_instance):
+                    if priority_instance is not None:
+                        for (
+                            potential_noisy_instance
+                        ) in instance_priority_list_reverse:
+                            if (
+                                potential_noisy_instance
+                                == potential_priority_instance
+                            ):
                                 loop_break_flag = True
                                 break
 
                             noisy_instance = self.find_noisy_instance(
-                                potential_noisy_instance)
+                                potential_noisy_instance
+                            )
 
                             if noisy_instance is not None:
                                 hosts_need_release[node.uuid] = {
                                     'priority_vm': potential_priority_instance,
-                                    'noisy_vm': potential_noisy_instance}
-                                LOG.debug("Priority VM found: %s",
-                                          potential_priority_instance.uuid)
-                                LOG.debug("Noisy VM found: %s",
-                                          potential_noisy_instance.uuid)
+                                    'noisy_vm': potential_noisy_instance,
+                                }
+                                LOG.debug(
+                                    "Priority VM found: %s",
+                                    potential_priority_instance.uuid,
+                                )
+                                LOG.debug(
+                                    "Noisy VM found: %s",
+                                    potential_noisy_instance.uuid,
+                                )
                                 loop_break_flag = True
                                 break
 
@@ -223,8 +250,11 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
         dest_servers = []
         for host in hosts:
             free_res = self.compute_model.get_node_free_resources(host)
-            if (free_res['vcpu'] >= required_cores and free_res['disk'] >=
-                    required_disk and free_res['memory'] >= required_memory):
+            if (
+                free_res['vcpu'] >= required_cores
+                and free_res['disk'] >= required_disk
+                and free_res['memory'] >= required_memory
+            ):
                 dest_servers.append(host)
 
         return dest_servers
@@ -246,16 +276,20 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
             LOG.debug("No hosts available to migrate")
             return
 
-        mig_source_node_name = max(hosts_need_release.keys(), key=lambda a:
-                                   hosts_need_release[a]['priority_vm'])
+        mig_source_node_name = max(
+            hosts_need_release.keys(),
+            key=lambda a: hosts_need_release[a]['priority_vm'],
+        )
         instance_to_migrate = hosts_need_release[mig_source_node_name][
-            'noisy_vm']
+            'noisy_vm'
+        ]
 
         if instance_to_migrate is None:
             return
 
-        dest_servers = self.filter_dest_servers(hosts_target,
-                                                instance_to_migrate)
+        dest_servers = self.filter_dest_servers(
+            hosts_target, instance_to_migrate
+        )
 
         if len(dest_servers) == 0:
             LOG.info("No proper target host could be found")
@@ -264,18 +298,23 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
         # Destination node will be the first available node in the list.
         mig_destination_node = dest_servers[0]
         mig_source_node = self.compute_model.get_node_by_uuid(
-            mig_source_node_name)
+            mig_source_node_name
+        )
 
-        if self.compute_model.migrate_instance(instance_to_migrate,
-                                               mig_source_node,
-                                               mig_destination_node):
-            parameters = {'migration_type': 'live',
-                          'source_node': mig_source_node.uuid,
-                          'destination_node': mig_destination_node.uuid,
-                          'resource_name': instance_to_migrate.name}
-            self.solution.add_action(action_type=self.MIGRATION,
-                                     resource_id=instance_to_migrate.uuid,
-                                     input_parameters=parameters)
+        if self.compute_model.migrate_instance(
+            instance_to_migrate, mig_source_node, mig_destination_node
+        ):
+            parameters = {
+                'migration_type': 'live',
+                'source_node': mig_source_node.uuid,
+                'destination_node': mig_destination_node.uuid,
+                'resource_name': instance_to_migrate.name,
+            }
+            self.solution.add_action(
+                action_type=self.MIGRATION,
+                resource_id=instance_to_migrate.uuid,
+                input_parameters=parameters,
+            )
 
     def post_execute(self):
         self.solution.model = self.compute_model
diff --git a/watcher/decision_engine/strategy/strategies/outlet_temp_control.py b/watcher/decision_engine/strategy/strategies/outlet_temp_control.py
index e64cfdb16..8d5cef11b 100644
--- a/watcher/decision_engine/strategy/strategies/outlet_temp_control.py
+++ b/watcher/decision_engine/strategy/strategies/outlet_temp_control.py
@@ -111,21 +111,21 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
                 "threshold": {
                     "description": "temperature threshold for migration",
                     "type": "number",
-                    "default": 35.0
+                    "default": 35.0,
                 },
                 "period": {
                     "description": "The time interval in seconds for "
-                                   "getting statistic aggregation",
+                    "getting statistic aggregation",
                     "type": "number",
-                    "default": 30
+                    "default": 30,
                 },
                 "granularity": {
                     "description": "The time between two measures in an "
-                                   "aggregated timeseries of a metric.",
+                    "aggregated timeseries of a metric.",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
-            },
+            }
         }
 
     @property
@@ -134,10 +134,12 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
 
     def get_available_compute_nodes(self):
         default_node_scope = [element.ServiceState.ENABLED.value]
-        return {uuid: cn for uuid, cn in
-                self.compute_model.get_all_compute_nodes().items()
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        return {
+            uuid: cn
+            for uuid, cn in self.compute_model.get_all_compute_nodes().items()
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
     def group_hosts_by_outlet_temp(self):
         """Group hosts based on outlet temp meters"""
@@ -161,8 +163,10 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
                 LOG.warning("%s: no outlet temp data", node.uuid)
                 continue
 
-            LOG.debug("%(resource)s: outlet temperature %(temp)f",
-                      {'resource': node.uuid, 'temp': outlet_temp})
+            LOG.debug(
+                "%(resource)s: outlet temperature %(temp)f",
+                {'resource': node.uuid, 'temp': outlet_temp},
+            )
             instance_data = {'compute_node': node, 'outlet_temp': outlet_temp}
             if outlet_temp >= self.threshold:
                 # mark the node to release resources
@@ -176,19 +180,22 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
         for instance_data in hosts:
             mig_source_node = instance_data['compute_node']
             instances_of_src = self.compute_model.get_node_instances(
-                mig_source_node)
+                mig_source_node
+            )
             for instance in instances_of_src:
                 try:
                     # NOTE: skip exclude instance when migrating
                     if instance.watcher_exclude:
-                        LOG.debug("Instance is excluded by scope, "
-                                  "skipped: %s", instance.uuid)
+                        LOG.debug(
+                            "Instance is excluded by scope, skipped: %s",
+                            instance.uuid,
+                        )
                         continue
                     # select the first active instance to migrate
-                    if (instance.state !=
-                            element.InstanceState.ACTIVE.value):
-                        LOG.info("Instance not active, skipped: %s",
-                                 instance.uuid)
+                    if instance.state != element.InstanceState.ACTIVE.value:
+                        LOG.info(
+                            "Instance not active, skipped: %s", instance.uuid
+                        )
                         continue
                     return mig_source_node, instance
                 except exception.InstanceNotFound as e:
@@ -209,8 +216,11 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
             host = instance_data['compute_node']
             # available
             free_res = self.compute_model.get_node_free_resources(host)
-            if (free_res['vcpu'] >= required_cores and free_res['disk'] >=
-                    required_disk and free_res['memory'] >= required_memory):
+            if (
+                free_res['vcpu'] >= required_cores
+                and free_res['disk'] >= required_disk
+                and free_res['memory'] >= required_memory
+            ):
                 dest_servers.append(instance_data)
 
         return dest_servers
@@ -220,8 +230,7 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
         # the migration plan will be triggered when the outlet temperature
         # reaches threshold
         self.threshold = self.input_parameters.threshold
-        LOG.info("Outlet temperature strategy threshold=%d",
-                 self.threshold)
+        LOG.info("Outlet temperature strategy threshold=%d", self.threshold)
 
     def do_execute(self, audit=None):
         hosts_need_release, hosts_target = self.group_hosts_by_outlet_temp()
@@ -236,12 +245,13 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
             return self.solution
 
         # choose the server with highest outlet t
-        hosts_need_release = sorted(hosts_need_release,
-                                    reverse=True,
-                                    key=lambda x: (x["outlet_temp"]))
+        hosts_need_release = sorted(
+            hosts_need_release, reverse=True, key=lambda x: (x["outlet_temp"])
+        )
 
         instance_to_migrate = self.choose_instance_to_migrate(
-            hosts_need_release)
+            hosts_need_release
+        )
         # calculate the instance's cpu cores,memory,disk needs
         if instance_to_migrate is None:
             return self.solution
@@ -261,14 +271,19 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
         mig_destination_node = dest_servers[0]['compute_node']
         # generate solution to migrate the instance to the dest server,
         if self.compute_model.migrate_instance(
-                instance_src, mig_source_node, mig_destination_node):
-            parameters = {'migration_type': 'live',
-                          'source_node': mig_source_node.uuid,
-                          'destination_node': mig_destination_node.uuid,
-                          'resource_name': instance_src.name}
-            self.solution.add_action(action_type=self.MIGRATION,
-                                     resource_id=instance_src.uuid,
-                                     input_parameters=parameters)
+            instance_src, mig_source_node, mig_destination_node
+        ):
+            parameters = {
+                'migration_type': 'live',
+                'source_node': mig_source_node.uuid,
+                'destination_node': mig_destination_node.uuid,
+                'resource_name': instance_src.name,
+            }
+            self.solution.add_action(
+                action_type=self.MIGRATION,
+                resource_id=instance_src.uuid,
+                input_parameters=parameters,
+            )
 
     def post_execute(self):
         self.solution.model = self.compute_model
diff --git a/watcher/decision_engine/strategy/strategies/saving_energy.py b/watcher/decision_engine/strategy/strategies/saving_energy.py
index 58908d578..9185e92b5 100644
--- a/watcher/decision_engine/strategy/strategies/saving_energy.py
+++ b/watcher/decision_engine/strategy/strategies/saving_energy.py
@@ -81,7 +81,6 @@ class SavingEnergy(base.SavingEnergyBaseStrategy):
     """
 
     def __init__(self, config, osc=None):
-
         super().__init__(config, osc)
         self._metal_helper = None
 
@@ -119,21 +118,25 @@ class SavingEnergy(base.SavingEnergyBaseStrategy):
         return {
             "properties": {
                 "free_used_percent": {
-                    "description": ("a rational number, which describes the"
-                                    " quotient of"
-                                    " min_free_hosts_num/nodes_with_VMs_num"
-                                    " where nodes_with_VMs_num is the number"
-                                    " of nodes with VMs"),
+                    "description": (
+                        "a rational number, which describes the"
+                        " quotient of"
+                        " min_free_hosts_num/nodes_with_VMs_num"
+                        " where nodes_with_VMs_num is the number"
+                        " of nodes with VMs"
+                    ),
                     "type": "number",
-                    "default": 10.0
+                    "default": 10.0,
                 },
                 "min_free_hosts_num": {
-                    "description": ("minimum number of hosts without VMs"
-                                    " but still powered on"),
+                    "description": (
+                        "minimum number of hosts without VMs"
+                        " but still powered on"
+                    ),
                     "type": "number",
-                    "default": 1
+                    "default": 1,
                 },
-            },
+            }
         }
 
     def add_action_poweronoff_node(self, node, state):
@@ -143,12 +146,15 @@ class SavingEnergy(base.SavingEnergyBaseStrategy):
         :param state: node power state, power on or power off
         :return: None
         """
-        params = {'state': state,
-                  'resource_name': node.get_hypervisor_hostname()}
+        params = {
+            'state': state,
+            'resource_name': node.get_hypervisor_hostname(),
+        }
         self.solution.add_action(
             action_type='change_node_power_state',
             resource_id=node.get_id(),
-            input_parameters=params)
+            input_parameters=params,
+        )
 
     def get_hosts_pool(self):
         """Get three pools, with_vms_node_pool, free_poweron_node_pool,
@@ -167,50 +173,68 @@ class SavingEnergy(base.SavingEnergyBaseStrategy):
             try:
                 self.compute_model.get_node_by_name(host_name)
             except exception.ComputeNodeNotFound:
-                LOG.info("The compute model does not contain the host: %s",
-                         host_name)
+                LOG.info(
+                    "The compute model does not contain the host: %s",
+                    host_name,
+                )
                 continue
 
-            if (node.hv_up_when_powered_off and
-                    hypervisor_node.get('state') != 'up'):
+            if (
+                node.hv_up_when_powered_off
+                and hypervisor_node.get('state') != 'up'
+            ):
                 # filter nodes that are not in 'up' state
-                LOG.info("Ignoring node that isn't in 'up' state: %s",
-                         host_name)
+                LOG.info(
+                    "Ignoring node that isn't in 'up' state: %s", host_name
+                )
                 continue
             else:
-                if (hypervisor_node['running_vms'] == 0):
+                if hypervisor_node['running_vms'] == 0:
                     power_state = node.get_power_state()
                     if power_state == metal_constants.PowerState.ON:
                         self.free_poweron_node_pool.append(node)
                     elif power_state == metal_constants.PowerState.OFF:
                         self.free_poweroff_node_pool.append(node)
                     else:
-                        LOG.info("Ignoring node %s, unknown state: %s",
-                                 node, power_state)
+                        LOG.info(
+                            "Ignoring node %s, unknown state: %s",
+                            node,
+                            power_state,
+                        )
                 else:
                     self.with_vms_node_pool.append(node)
 
     def save_energy(self):
-
-        need_poweron = int(max(
-            (len(self.with_vms_node_pool) * self.free_used_percent / 100), (
-                self.min_free_hosts_num)))
+        need_poweron = int(
+            max(
+                (len(self.with_vms_node_pool) * self.free_used_percent / 100),
+                (self.min_free_hosts_num),
+            )
+        )
         len_poweron = len(self.free_poweron_node_pool)
         len_poweroff = len(self.free_poweroff_node_pool)
-        LOG.debug("need_poweron: %s, len_poweron: %s, len_poweroff: %s",
-                  need_poweron, len_poweron, len_poweroff)
+        LOG.debug(
+            "need_poweron: %s, len_poweron: %s, len_poweroff: %s",
+            need_poweron,
+            len_poweron,
+            len_poweroff,
+        )
         if len_poweron > need_poweron:
-            for node in random.sample(self.free_poweron_node_pool,
-                                      (len_poweron - need_poweron)):
-                self.add_action_poweronoff_node(node,
-                                                metal_constants.PowerState.OFF)
+            for node in random.sample(
+                self.free_poweron_node_pool, (len_poweron - need_poweron)
+            ):
+                self.add_action_poweronoff_node(
+                    node, metal_constants.PowerState.OFF
+                )
                 LOG.info("power off %s", node.get_id())
         elif len_poweron < need_poweron:
             diff = need_poweron - len_poweron
-            for node in random.sample(self.free_poweroff_node_pool,
-                                      min(len_poweroff, diff)):
-                self.add_action_poweronoff_node(node,
-                                                metal_constants.PowerState.ON)
+            for node in random.sample(
+                self.free_poweroff_node_pool, min(len_poweroff, diff)
+            ):
+                self.add_action_poweronoff_node(
+                    node, metal_constants.PowerState.ON
+                )
                 LOG.info("power on %s", node.get_id())
 
     def pre_execute(self):
diff --git a/watcher/decision_engine/strategy/strategies/storage_capacity_balance.py b/watcher/decision_engine/strategy/strategies/storage_capacity_balance.py
index 923739088..45e9d4756 100644
--- a/watcher/decision_engine/strategy/strategies/storage_capacity_balance.py
+++ b/watcher/decision_engine/strategy/strategies/storage_capacity_balance.py
@@ -92,18 +92,17 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
                 "volume_threshold": {
                     "description": "volume threshold for capacity balance",
                     "type": "number",
-                    "default": 80.0
-                },
-            },
+                    "default": 80.0,
+                }
+            }
         }
 
     @classmethod
     def get_config_opts(cls):
         return super().get_config_opts() + [
             cfg.ListOpt(
-                "ex_pools",
-                help="exclude pools",
-                default=['local_vstorage']),
+                "ex_pools", help="exclude pools", default=['local_vstorage']
+            )
         ]
 
     def get_pools(self, cinder):
@@ -114,8 +113,7 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         """
         ex_pools = self.config.ex_pools
         pools = cinder.get_storage_pool_list()
-        filtered_pools = [p for p in pools
-                          if p.pool_name not in ex_pools]
+        filtered_pools = [p for p in pools if p.pool_name not in ex_pools]
         return filtered_pools
 
     def get_volumes(self, cinder):
@@ -132,14 +130,19 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         for snapshot in volume_snapshots:
             snapshot_volume_ids.append(snapshot.volume_id)
 
-        nosnap_volumes = list(filter(lambda v: v.id not in snapshot_volume_ids,
-                              all_volumes))
+        nosnap_volumes = list(
+            filter(lambda v: v.id not in snapshot_volume_ids, all_volumes)
+        )
         LOG.info("volumes in snap: %s", snapshot_volume_ids)
         status_volumes = list(
-            filter(lambda v: v.status in valid_status, nosnap_volumes))
-        valid_volumes = [v for v in status_volumes
-                         if getattr(v, 'migration_status') == 'success' or
-                         getattr(v, 'migration_status') is None]
+            filter(lambda v: v.status in valid_status, nosnap_volumes)
+        )
+        valid_volumes = [
+            v
+            for v in status_volumes
+            if getattr(v, 'migration_status') == 'success'
+            or getattr(v, 'migration_status') is None
+        ]
         LOG.info("valid volumes: %s", valid_volumes)
 
         return valid_volumes
@@ -152,14 +155,22 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         :return: under and over threshold pools
         """
         under_pools = list(
-            filter(lambda p: float(p.total_capacity_gb) -
-                   float(p.free_capacity_gb) <
-                   float(p.total_capacity_gb) * threshold, pools))
+            filter(
+                lambda p: float(p.total_capacity_gb)
+                - float(p.free_capacity_gb)
+                < float(p.total_capacity_gb) * threshold,
+                pools,
+            )
+        )
 
         over_pools = list(
-            filter(lambda p: float(p.total_capacity_gb) -
-                   float(p.free_capacity_gb) >=
-                   float(p.total_capacity_gb) * threshold, pools))
+            filter(
+                lambda p: float(p.total_capacity_gb)
+                - float(p.free_capacity_gb)
+                >= float(p.total_capacity_gb) * threshold,
+                pools,
+            )
+        )
 
         return over_pools, under_pools
 
@@ -169,10 +180,15 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
             return self.pool_type_cache.get(backendname)
 
         volume_type_list = cinder.get_volume_type_list()
-        volume_type = list(filter(
-            lambda volume_type:
-                volume_type.extra_specs.get(
-                    'volume_backend_name') == backendname, volume_type_list))
+        volume_type = list(
+            filter(
+                lambda volume_type: volume_type.extra_specs.get(
+                    'volume_backend_name'
+                )
+                == backendname,
+                volume_type_list,
+            )
+        )
         if volume_type:
             self.pool_type_cache[backendname] = volume_type
             return self.pool_type_cache.get(backendname)
@@ -185,8 +201,9 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
             LOG.info("volume %s type %s", volume.id, volume.volume_type)
             return target_pool_name
         self.dest_pools.sort(
-            key=lambda p: float(p.free_capacity_gb) /
-            float(p.total_capacity_gb))
+            key=lambda p: float(p.free_capacity_gb)
+            / float(p.total_capacity_gb)
+        )
         for pool in reversed(self.dest_pools):
             total_cap = float(pool.total_capacity_gb)
             allocated = float(pool.allocated_capacity_gb)
@@ -198,10 +215,14 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
             if free_cap > (1 - threshold) * total_cap:
                 target_pool_name = pool.name
                 index = self.dest_pools.index(pool)
-                setattr(self.dest_pools[index], 'free_capacity_gb',
-                        str(free_cap))
-                LOG.info("volume: get pool %s for vol %s", target_pool_name,
-                         volume.name)
+                setattr(
+                    self.dest_pools[index], 'free_capacity_gb', str(free_cap)
+                )
+                LOG.info(
+                    "volume: get pool %s for vol %s",
+                    target_pool_name,
+                    volume.name,
+                )
                 break
         return target_pool_name
 
@@ -212,9 +233,12 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         if not volume.volume_type:
             return target_type
         volume_type_list = self.cinder.get_volume_type_list()
-        volume_type = list(filter(
-            lambda volume_type:
-                volume_type.name == volume.volume_type, volume_type_list))
+        volume_type = list(
+            filter(
+                lambda volume_type: volume_type.name == volume.volume_type,
+                volume_type_list,
+            )
+        )
         if volume_type:
             src_extra_specs = volume_type[0].extra_specs
             src_extra_specs.pop('volume_backend_name', None)
@@ -223,9 +247,11 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         dst_pool_type = self.get_volume_type_by_name(self.cinder, backendname)
 
         for src_key in src_extra_specs.keys():
-            dst_pool_type = [pt for pt in dst_pool_type
-                             if pt.extra_specs.get(src_key) ==
-                             src_extra_specs.get(src_key)]
+            dst_pool_type = [
+                pt
+                for pt in dst_pool_type
+                if pt.extra_specs.get(src_key) == src_extra_specs.get(src_key)
+            ]
         if dst_pool_type:
             if volume.volume_type:
                 if dst_pool_type[0].name != volume.volume_type:
@@ -237,8 +263,9 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
     def retype_fit(self, volume, threshold):
         target_type = None
         self.dest_pools.sort(
-            key=lambda p: float(p.free_capacity_gb) /
-            float(p.total_capacity_gb))
+            key=lambda p: float(p.free_capacity_gb)
+            / float(p.total_capacity_gb)
+        )
         for pool in reversed(self.dest_pools):
             backendname = getattr(pool, 'volume_backend_name')
             pool_type = self.get_volume_type_by_name(self.cinder, backendname)
@@ -257,10 +284,12 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
                 if target_type is None:
                     continue
                 index = self.dest_pools.index(pool)
-                setattr(self.dest_pools[index], 'free_capacity_gb',
-                        str(free_cap))
-                LOG.info("volume: get type %s for vol %s", target_type,
-                         volume.name)
+                setattr(
+                    self.dest_pools[index], 'free_capacity_gb', str(free_cap)
+                )
+                LOG.info(
+                    "volume: get type %s for vol %s", target_type, volume.name
+                )
                 break
         return target_type
 
@@ -276,13 +305,17 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         seek_flag = True
 
         volumes_in_pool = list(
-            filter(lambda v: getattr(v, 'os-vol-host-attr:host') == pool.name,
-                   volumes))
+            filter(
+                lambda v: getattr(v, 'os-vol-host-attr:host') == pool.name,
+                volumes,
+            )
+        )
         LOG.info("volumes in pool: %s", str(volumes_in_pool))
         if not volumes_in_pool:
             return retype_dicts, migrate_dicts
-        ava_volumes = list(filter(lambda v: v.status == 'available',
-                           volumes_in_pool))
+        ava_volumes = list(
+            filter(lambda v: v.status == 'available', volumes_in_pool)
+        )
         ava_volumes.sort(key=lambda v: float(v.size))
         LOG.info("available volumes in pool: %s ", str(ava_volumes))
         for vol in ava_volumes:
@@ -303,8 +336,12 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
                     break
         if seek_flag:
             noboot_volumes = list(
-                filter(lambda v: v.bootable.lower() == 'false' and
-                       v.status == 'in-use', volumes_in_pool))
+                filter(
+                    lambda v: v.bootable.lower() == 'false'
+                    and v.status == 'in-use',
+                    volumes_in_pool,
+                )
+            )
             noboot_volumes.sort(key=lambda v: float(v.size))
             LOG.info("noboot volumes: %s ", str(noboot_volumes))
             for vol in noboot_volumes:
@@ -326,8 +363,11 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
 
         if seek_flag:
             boot_volumes = list(
-                filter(lambda v: v.bootable.lower() == 'true' and
-                       v.status == 'in-use', volumes_in_pool)
+                filter(
+                    lambda v: v.bootable.lower() == 'true'
+                    and v.status == 'in-use',
+                    volumes_in_pool,
+                )
             )
             boot_volumes.sort(key=lambda v: float(v.size))
             LOG.info("boot volumes: %s ", str(boot_volumes))
@@ -362,9 +402,13 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
         all_volumes = self.get_volumes(self.cinder)
         threshold = float(self.volume_threshold) / 100
         self.source_pools, self.dest_pools = self.group_pools(
-            all_pools, threshold)
-        LOG.info(" source pools: %s dest pools:%s",
-                 self.source_pools, self.dest_pools)
+            all_pools, threshold
+        )
+        LOG.info(
+            " source pools: %s dest pools:%s",
+            self.source_pools,
+            self.dest_pools,
+        )
         if not self.source_pools:
             LOG.info("No pools require optimization")
             return
@@ -374,29 +418,35 @@ class StorageCapacityBalance(base.WorkloadStabilizationBaseStrategy):
             return
         for source_pool in self.source_pools:
             retype_actions, migrate_actions = self.get_actions(
-                source_pool, all_volumes, threshold)
+                source_pool, all_volumes, threshold
+            )
             for vol_id, pool_type in retype_actions.items():
                 vol = [v for v in all_volumes if v.id == vol_id]
-                parameters = {'migration_type': 'retype',
-                              'destination_type': pool_type,
-                              'resource_name': vol[0].name}
-                self.solution.add_action(action_type='volume_migrate',
-                                         resource_id=vol_id,
-                                         input_parameters=parameters)
+                parameters = {
+                    'migration_type': 'retype',
+                    'destination_type': pool_type,
+                    'resource_name': vol[0].name,
+                }
+                self.solution.add_action(
+                    action_type='volume_migrate',
+                    resource_id=vol_id,
+                    input_parameters=parameters,
+                )
             for vol_id, pool_name in migrate_actions.items():
                 vol = [v for v in all_volumes if v.id == vol_id]
-                parameters = {'migration_type': 'migrate',
-                              'destination_node': pool_name,
-                              'resource_name': vol[0].name}
-                self.solution.add_action(action_type='volume_migrate',
-                                         resource_id=vol_id,
-                                         input_parameters=parameters)
+                parameters = {
+                    'migration_type': 'migrate',
+                    'destination_node': pool_name,
+                    'resource_name': vol[0].name,
+                }
+                self.solution.add_action(
+                    action_type='volume_migrate',
+                    resource_id=vol_id,
+                    input_parameters=parameters,
+                )
 
     def post_execute(self):
-        """Post-execution phase
-
-        """
+        """Post-execution phase"""
         self.solution.set_efficacy_indicators(
-            instance_migrations_count=0,
-            instances_count=0,
+            instance_migrations_count=0, instances_count=0
         )
diff --git a/watcher/decision_engine/strategy/strategies/uniform_airflow.py b/watcher/decision_engine/strategy/strategies/uniform_airflow.py
index 8f67804b0..f9733db4a 100644
--- a/watcher/decision_engine/strategy/strategies/uniform_airflow.py
+++ b/watcher/decision_engine/strategy/strategies/uniform_airflow.py
@@ -95,43 +95,48 @@ class UniformAirflow(base.BaseStrategy):
         return {
             "properties": {
                 "threshold_airflow": {
-                    "description": ("airflow threshold for migration, Unit is "
-                                    "0.1CFM"),
+                    "description": (
+                        "airflow threshold for migration, Unit is 0.1CFM"
+                    ),
                     "type": "number",
-                    "default": 400.0
+                    "default": 400.0,
                 },
                 "threshold_inlet_t": {
-                    "description": ("inlet temperature threshold for "
-                                    "migration decision"),
+                    "description": (
+                        "inlet temperature threshold for migration decision"
+                    ),
                     "type": "number",
-                    "default": 28.0
+                    "default": 28.0,
                 },
                 "threshold_power": {
-                    "description": ("system power threshold for migration "
-                                    "decision"),
+                    "description": (
+                        "system power threshold for migration decision"
+                    ),
                     "type": "number",
-                    "default": 350.0
+                    "default": 350.0,
                 },
                 "period": {
                     "description": "aggregate time period of ceilometer",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
                 "granularity": {
                     "description": "The time between two measures in an "
-                                   "aggregated timeseries of a metric.",
+                    "aggregated timeseries of a metric.",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
-            },
+            }
         }
 
     def get_available_compute_nodes(self):
         default_node_scope = [element.ServiceState.ENABLED.value]
-        return {uuid: cn for uuid, cn in
-                self.compute_model.get_all_compute_nodes().items()
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        return {
+            uuid: cn
+            for uuid, cn in self.compute_model.get_all_compute_nodes().items()
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
     def calculate_used_resource(self, node):
         """Compute the used vcpus, memory and disk based on instance flavors"""
@@ -148,22 +153,27 @@ class UniformAirflow(base.BaseStrategy):
         for nodemap in hosts:
             source_node = nodemap['node']
             source_instances = self.compute_model.get_node_instances(
-                source_node)
+                source_node
+            )
             if source_instances:
                 inlet_temp = self.datasource_backend.statistic_aggregation(
                     resource=source_node,
                     resource_type='instance',
                     meter_name='host_inlet_temp',
                     period=self._period,
-                    granularity=self.granularity)
+                    granularity=self.granularity,
+                )
                 power = self.datasource_backend.statistic_aggregation(
                     resource=source_node,
                     resource_type='instance',
                     meter_name='host_power',
                     period=self._period,
-                    granularity=self.granularity)
-                if (power < self.threshold_power and
-                        inlet_temp < self.threshold_inlet_t):
+                    granularity=self.granularity,
+                )
+                if (
+                    power < self.threshold_power
+                    and inlet_temp < self.threshold_inlet_t
+                ):
                     # hardware issue, migrate all instances from this node
                     for instance in source_instances:
                         instances_tobe_migrate.append(instance)
@@ -173,27 +183,31 @@ class UniformAirflow(base.BaseStrategy):
                     for instance in source_instances:
                         # NOTE: skip exclude instance when migrating
                         if instance.watcher_exclude:
-                            LOG.debug("Instance is excluded by scope, "
-                                      "skipped: %s", instance.uuid)
+                            LOG.debug(
+                                "Instance is excluded by scope, skipped: %s",
+                                instance.uuid,
+                            )
                             continue
-                        if (instance.state !=
-                                element.InstanceState.ACTIVE.value):
+                        if (
+                            instance.state
+                            != element.InstanceState.ACTIVE.value
+                        ):
                             LOG.info(
                                 "Instance not active, skipped: %s",
-                                instance.uuid)
+                                instance.uuid,
+                            )
                             continue
                         instances_tobe_migrate.append(instance)
                         return source_node, instances_tobe_migrate
             else:
-                LOG.info("Instance not found on node: %s",
-                         source_node.uuid)
+                LOG.info("Instance not found on node: %s", source_node.uuid)
 
     def filter_destination_hosts(self, hosts, instances_to_migrate):
         """Find instance and host with sufficient available resources"""
         # large instances go first
         instances_to_migrate = sorted(
-            instances_to_migrate, reverse=True,
-            key=lambda x: (x.vcpus))
+            instances_to_migrate, reverse=True, key=lambda x: (x.vcpus)
+        )
         # find hosts for instances
         destination_hosts = []
         for instance_to_migrate in instances_to_migrate:
@@ -205,18 +219,19 @@ class UniformAirflow(base.BaseStrategy):
                 host = nodemap['node']
                 if 'cores_used' not in nodemap:
                     # calculate the available resources
-                    nodemap['cores_used'], nodemap['mem_used'], \
-                        nodemap['disk_used'] = self.calculate_used_resource(
-                            host)
-                cores_available = (host.vcpus -
-                                   nodemap['cores_used'])
-                disk_available = (host.disk -
-                                  nodemap['disk_used'])
-                mem_available = (
-                    host.memory - nodemap['mem_used'])
-                if (cores_available >= required_cores and
-                        disk_available >= required_disk and
-                        mem_available >= required_mem):
+                    (
+                        nodemap['cores_used'],
+                        nodemap['mem_used'],
+                        nodemap['disk_used'],
+                    ) = self.calculate_used_resource(host)
+                cores_available = host.vcpus - nodemap['cores_used']
+                disk_available = host.disk - nodemap['disk_used']
+                mem_available = host.memory - nodemap['mem_used']
+                if (
+                    cores_available >= required_cores
+                    and disk_available >= required_disk
+                    and mem_available >= required_mem
+                ):
                     dest_migrate_info['instance'] = instance_to_migrate
                     dest_migrate_info['node'] = host
                     nodemap['cores_used'] += required_cores
@@ -226,8 +241,10 @@ class UniformAirflow(base.BaseStrategy):
                     break
         # check if all instances have target hosts
         if len(destination_hosts) != len(instances_to_migrate):
-            LOG.warning("Not all target hosts could be found; it might "
-                        "be because there is not enough resource")
+            LOG.warning(
+                "Not all target hosts could be found; it might "
+                "be because there is not enough resource"
+            )
             return None
         return destination_hosts
 
@@ -239,21 +256,23 @@ class UniformAirflow(base.BaseStrategy):
         nonoverload_hosts = []
         for node_id in nodes:
             airflow = None
-            node = self.compute_model.get_node_by_uuid(
-                node_id)
+            node = self.compute_model.get_node_by_uuid(node_id)
             airflow = self.datasource_backend.statistic_aggregation(
                 resource=node,
                 resource_type='compute_node',
                 meter_name='host_airflow',
                 period=self._period,
-                granularity=self.granularity)
+                granularity=self.granularity,
+            )
             # some hosts may not have airflow meter, remove from target
             if airflow is None:
                 LOG.warning("%s: no airflow data", node.uuid)
                 continue
 
-            LOG.debug("%(resource)s: airflow %(airflow)f",
-                      {'resource': node, 'airflow': airflow})
+            LOG.debug(
+                "%(resource)s: airflow %(airflow)f",
+                {'resource': node, 'airflow': airflow},
+            )
             nodemap = {'node': node, 'airflow': airflow}
             if airflow >= self.threshold_airflow:
                 # mark the node to release resources
@@ -281,16 +300,18 @@ class UniformAirflow(base.BaseStrategy):
             return self.solution
 
         if not target_nodes:
-            LOG.warning("No hosts currently have airflow under %s, "
-                        "therefore there are no possible target "
-                        "hosts for any migration",
-                        self.threshold_airflow)
+            LOG.warning(
+                "No hosts currently have airflow under %s, "
+                "therefore there are no possible target "
+                "hosts for any migration",
+                self.threshold_airflow,
+            )
             return self.solution
 
         # migrate the instance from server with largest airflow first
-        source_nodes = sorted(source_nodes,
-                              reverse=True,
-                              key=lambda x: (x["airflow"]))
+        source_nodes = sorted(
+            source_nodes, reverse=True, key=lambda x: (x["airflow"])
+        )
         instances_to_migrate = self.choose_instance_to_migrate(source_nodes)
         if not instances_to_migrate:
             return self.solution
@@ -300,22 +321,24 @@ class UniformAirflow(base.BaseStrategy):
         # find the hosts that have enough resource
         # for the instance to be migrated
         destination_hosts = self.filter_destination_hosts(
-            target_nodes, instances_src)
+            target_nodes, instances_src
+        )
         if not destination_hosts:
-            LOG.warning("No target host could be found; it might "
-                        "be because there is not enough resources")
+            LOG.warning(
+                "No target host could be found; it might "
+                "be because there is not enough resources"
+            )
             return self.solution
         # generate solution to migrate the instance to the dest server,
         for info in destination_hosts:
             instance = info['instance']
             destination_node = info['node']
             if self.compute_model.migrate_instance(
-                    instance, source_node, destination_node):
+                instance, source_node, destination_node
+            ):
                 self.add_action_migrate(
-                    instance,
-                    'live',
-                    source_node,
-                    destination_node)
+                    instance, 'live', source_node, destination_node
+                )
 
     def post_execute(self):
         self.solution.model = self.compute_model
diff --git a/watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py b/watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py
index b6412482d..6bba972a1 100644
--- a/watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py
+++ b/watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py
@@ -70,9 +70,14 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
     """
 
     AGGREGATE = 'mean'
-    DATASOURCE_METRICS = ['instance_ram_allocated', 'instance_cpu_usage',
-                          'instance_ram_usage', 'instance_root_disk_size',
-                          'host_cpu_usage', 'host_ram_usage']
+    DATASOURCE_METRICS = [
+        'instance_ram_allocated',
+        'instance_cpu_usage',
+        'instance_ram_usage',
+        'instance_root_disk_size',
+        'host_cpu_usage',
+        'host_ram_usage',
+    ]
 
     MIGRATION = "migrate"
     CHANGE_NOVA_SERVICE_STATE = "change_nova_service_state"
@@ -86,7 +91,8 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         # Host metric adjustments that take into account planned
         # migrations.
         self.host_metric_delta = collections.defaultdict(
-            lambda: collections.defaultdict(int))
+            lambda: collections.defaultdict(int)
+        )
 
     @classmethod
     def get_name(cls):
@@ -115,27 +121,31 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
             "properties": {
                 "period": {
                     "description": "The time interval in seconds for "
-                                   "getting statistic aggregation",
+                    "getting statistic aggregation",
                     "type": "number",
-                    "default": 3600
+                    "default": 3600,
                 },
                 "granularity": {
                     "description": "The time between two measures in an "
-                                   "aggregated timeseries of a metric.",
+                    "aggregated timeseries of a metric.",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
             }
         }
 
     def get_available_compute_nodes(self):
-        default_node_scope = [element.ServiceState.ENABLED.value,
-                              element.ServiceState.DISABLED.value]
+        default_node_scope = [
+            element.ServiceState.ENABLED.value,
+            element.ServiceState.DISABLED.value,
+        ]
         nodes = self.compute_model.get_all_compute_nodes().items()
-        return {uuid: cn for uuid, cn in
-                nodes
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        return {
+            uuid: cn
+            for uuid, cn in nodes
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
     def get_instance_state_str(self, instance):
         """Get instance state in string format.
@@ -147,10 +157,11 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         elif isinstance(instance.state, element.InstanceState):
             return instance.state.value
         else:
-            LOG.error('Unexpected instance state type, '
-                      'state=%(state)s, state_type=%(st)s.',
-                      dict(state=instance.state,
-                           st=type(instance.state)))
+            LOG.error(
+                'Unexpected instance state type, '
+                'state=%(state)s, state_type=%(st)s.',
+                dict(state=instance.state, st=type(instance.state)),
+            )
             raise exception.WatcherException
 
     def get_node_status_str(self, node):
@@ -163,10 +174,11 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         elif isinstance(node.status, element.ServiceState):
             return node.status.value
         else:
-            LOG.error('Unexpected node status type, '
-                      'status=%(status)s, status_type=%(st)s.',
-                      dict(status=node.status,
-                           st=type(node.status)))
+            LOG.error(
+                'Unexpected node status type, '
+                'status=%(status)s, status_type=%(st)s.',
+                dict(status=node.status, st=type(node.status)),
+            )
             raise exception.WatcherException
 
     def add_action_enable_compute_node(self, node):
@@ -175,12 +187,15 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         :param node: node object
         :return: None
         """
-        params = {'state': element.ServiceState.ENABLED.value,
-                  'resource_name': node.hostname}
+        params = {
+            'state': element.ServiceState.ENABLED.value,
+            'resource_name': node.hostname,
+        }
         self.solution.add_action(
             action_type=self.CHANGE_NOVA_SERVICE_STATE,
             resource_id=node.uuid,
-            input_parameters=params)
+            input_parameters=params,
+        )
         self.number_of_released_nodes -= 1
 
     def add_action_disable_node(self, node):
@@ -189,13 +204,16 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         :param node: node object
         :return: None
         """
-        params = {'state': element.ServiceState.DISABLED.value,
-                  'disabled_reason': self.REASON_FOR_DISABLE,
-                  'resource_name': node.hostname}
+        params = {
+            'state': element.ServiceState.DISABLED.value,
+            'disabled_reason': self.REASON_FOR_DISABLE,
+            'resource_name': node.hostname,
+        }
         self.solution.add_action(
             action_type=self.CHANGE_NOVA_SERVICE_STATE,
             resource_id=node.uuid,
-            input_parameters=params)
+            input_parameters=params,
+        )
         self.number_of_released_nodes += 1
 
     def add_migration(self, instance, source_node, destination_node):
@@ -207,47 +225,56 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         :return: None
         """
         instance_state_str = self.get_instance_state_str(instance)
-        if instance_state_str in (element.InstanceState.ACTIVE.value,
-                                  element.InstanceState.PAUSED.value):
+        if instance_state_str in (
+            element.InstanceState.ACTIVE.value,
+            element.InstanceState.PAUSED.value,
+        ):
             migration_type = migration.Migrate.LIVE_MIGRATION
         elif instance_state_str == element.InstanceState.STOPPED.value:
             migration_type = migration.Migrate.COLD_MIGRATION
         else:
             LOG.error(
                 'Cannot live migrate: instance_uuid=%(instance_uuid)s, '
-                'state=%(instance_state)s.', dict(
+                'state=%(instance_state)s.',
+                dict(
                     instance_uuid=instance.uuid,
-                    instance_state=instance_state_str))
+                    instance_state=instance_state_str,
+                ),
+            )
             return
 
         # Here will makes repeated actions to enable the same compute node,
         # when migrating VMs to the destination node which is disabled.
         # Whether should we remove the same actions in the solution???
         destination_node_status_str = self.get_node_status_str(
-            destination_node)
+            destination_node
+        )
         if destination_node_status_str == element.ServiceState.DISABLED.value:
             self.add_action_enable_compute_node(destination_node)
 
         if self.compute_model.migrate_instance(
-                instance, source_node, destination_node):
+            instance, source_node, destination_node
+        ):
             self.add_action_migrate(
-                instance,
-                migration_type,
-                source_node,
-                destination_node)
+                instance, migration_type, source_node, destination_node
+            )
             self.number_of_migrations += 1
 
             instance_util = self.get_instance_utilization(instance)
             self.host_metric_delta[source_node.hostname]['cpu'] -= (
-                instance_util['cpu'])
+                instance_util['cpu']
+            )
             # We'll deduce the vm allocated memory.
             self.host_metric_delta[source_node.hostname]['ram'] -= (
-                instance.memory)
+                instance.memory
+            )
 
             self.host_metric_delta[destination_node.hostname]['cpu'] += (
-                instance_util['cpu'])
+                instance_util['cpu']
+            )
             self.host_metric_delta[destination_node.hostname]['ram'] += (
-                instance.memory)
+                instance.memory
+            )
 
     def disable_unused_nodes(self):
         """Generate actions for disabling unused nodes.
@@ -255,9 +282,10 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         :return: None
         """
         for node in self.get_available_compute_nodes().values():
-            if (len(self.compute_model.get_node_instances(node)) == 0 and
-                    node.status !=
-                    element.ServiceState.DISABLED.value):
+            if (
+                len(self.compute_model.get_node_instances(node)) == 0
+                and node.status != element.ServiceState.DISABLED.value
+            ):
                 self.add_action_disable_node(node)
 
     def get_instance_utilization(self, instance):
@@ -275,40 +303,63 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
             return self.datasource_instance_data_cache.get(instance.uuid)
 
         instance_cpu_util = self.datasource_backend.get_instance_cpu_usage(
-            resource=instance, period=self.period,
-            aggregate=self.AGGREGATE, granularity=self.granularity)
+            resource=instance,
+            period=self.period,
+            aggregate=self.AGGREGATE,
+            granularity=self.granularity,
+        )
         instance_ram_util = self.datasource_backend.get_instance_ram_usage(
-            resource=instance, period=self.period,
-            aggregate=self.AGGREGATE, granularity=self.granularity)
+            resource=instance,
+            period=self.period,
+            aggregate=self.AGGREGATE,
+            granularity=self.granularity,
+        )
         if not instance_ram_util:
             instance_ram_util = (
                 self.datasource_backend.get_instance_ram_allocated(
-                    resource=instance, period=self.period,
-                    aggregate=self.AGGREGATE, granularity=self.granularity))
+                    resource=instance,
+                    period=self.period,
+                    aggregate=self.AGGREGATE,
+                    granularity=self.granularity,
+                )
+            )
         instance_disk_util = (
             self.datasource_backend.get_instance_root_disk_size(
-                resource=instance, period=self.period,
-                aggregate=self.AGGREGATE, granularity=self.granularity))
+                resource=instance,
+                period=self.period,
+                aggregate=self.AGGREGATE,
+                granularity=self.granularity,
+            )
+        )
 
         if instance_cpu_util:
-            total_cpu_utilization = (
-                instance.vcpus * (instance_cpu_util / 100.0))
+            total_cpu_utilization = instance.vcpus * (
+                instance_cpu_util / 100.0
+            )
         else:
             total_cpu_utilization = instance.vcpus
 
         if not instance_ram_util:
             instance_ram_util = instance.memory
-            LOG.warning('No values returned by %s for memory.resident, '
-                        'use instance flavor ram value', instance.uuid)
+            LOG.warning(
+                'No values returned by %s for memory.resident, '
+                'use instance flavor ram value',
+                instance.uuid,
+            )
 
         if not instance_disk_util:
             instance_disk_util = instance.disk
-            LOG.warning('No values returned by %s for disk.root.size, '
-                        'use instance flavor disk value', instance.uuid)
+            LOG.warning(
+                'No values returned by %s for disk.root.size, '
+                'use instance flavor disk value',
+                instance.uuid,
+            )
 
         self.datasource_instance_data_cache[instance.uuid] = dict(
-            cpu=total_cpu_utilization, ram=instance_ram_util,
-            disk=instance_disk_util)
+            cpu=total_cpu_utilization,
+            ram=instance_ram_util,
+            disk=instance_disk_util,
+        )
         return self.datasource_instance_data_cache.get(instance.uuid)
 
     def _get_node_total_utilization(self, node):
@@ -316,14 +367,13 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
             return self.datasource_node_data_cache[node.hostname]
 
         cpu = self.datasource_backend.get_host_cpu_usage(
-            node, self.period, self.AGGREGATE,
-            self.granularity)
+            node, self.period, self.AGGREGATE, self.granularity
+        )
         ram = self.datasource_backend.get_host_ram_usage(
-            node, self.period, self.AGGREGATE,
-            self.granularity)
+            node, self.period, self.AGGREGATE, self.granularity
+        )
 
-        self.datasource_node_data_cache[node.hostname] = dict(
-            cpu=cpu, ram=ram)
+        self.datasource_node_data_cache[node.hostname] = dict(cpu=cpu, ram=ram)
         return self.datasource_node_data_cache[node.hostname]
 
     def get_node_utilization(self, node):
@@ -338,13 +388,11 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         node_disk_util = 0
         node_cpu_util = 0
         for instance in node_instances:
-            instance_util = self.get_instance_utilization(
-                instance)
+            instance_util = self.get_instance_utilization(instance)
             node_cpu_util += instance_util['cpu']
             node_ram_util += instance_util['ram']
             node_disk_util += instance_util['disk']
-            LOG.debug("instance utilization: %s %s",
-                      instance, instance_util)
+            LOG.debug("instance utilization: %s %s", instance, instance_util)
 
         total_node_util = self._get_node_total_utilization(node)
         total_node_cpu_util = total_node_util['cpu'] or 0
@@ -367,13 +415,19 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
             "total host ram: %s, "
             "node delta usage: %s.",
             node,
-            node_cpu_util, node_ram_util, node_disk_util,
-            total_node_cpu_util, total_node_ram_util,
-            self.host_metric_delta[node.hostname])
+            node_cpu_util,
+            node_ram_util,
+            node_disk_util,
+            total_node_cpu_util,
+            total_node_ram_util,
+            self.host_metric_delta[node.hostname],
+        )
 
-        return dict(cpu=max(node_cpu_util, total_node_cpu_util),
-                    ram=max(node_ram_util, total_node_ram_util),
-                    disk=node_disk_util)
+        return dict(
+            cpu=max(node_cpu_util, total_node_cpu_util),
+            ram=max(node_ram_util, total_node_ram_util),
+            disk=node_disk_util,
+        )
 
     def get_node_capacity(self, node):
         """Collect cpu, ram and disk capacity of a node.
@@ -381,8 +435,11 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         :param node: node object
         :return: dict(cpu(cores), ram(MB), disk(B))
         """
-        return dict(cpu=node.vcpu_capacity, ram=node.memory_mb_capacity,
-                    disk=node.disk_gb_capacity)
+        return dict(
+            cpu=node.vcpu_capacity,
+            ram=node.memory_mb_capacity,
+            disk=node.disk_gb_capacity,
+        )
 
     def get_relative_node_utilization(self, node):
         """Return relative node utilization.
@@ -430,8 +487,7 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         :return: [True, False]
         """
         node_capacity = self.get_node_capacity(node)
-        node_utilization = self.get_node_utilization(
-            node)
+        node_utilization = self.get_node_utilization(node)
         metrics = ['cpu']
         for m in metrics:
             if node_utilization[m] > node_capacity[m] * cc[m]:
@@ -452,14 +508,23 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         instance_utilization = self.get_instance_utilization(instance)
         metrics = ['cpu', 'ram', 'disk']
         for m in metrics:
-            fits = (instance_utilization[m] + node_utilization[m] <=
-                    node_capacity[m] * cc[m])
+            fits = (
+                instance_utilization[m] + node_utilization[m]
+                <= node_capacity[m] * cc[m]
+            )
             LOG.debug(
                 "Instance fits: %s, metric: %s, instance: %s, "
                 "node: %s, instance utilization: %s, "
                 "node utilization: %s, node capacity: %s, cc: %s",
-                fits, m, instance, node, instance_utilization[m],
-                node_utilization[m], node_capacity[m], cc[m])
+                fits,
+                m,
+                instance,
+                node,
+                instance_utilization[m],
+                node_utilization[m],
+                node_capacity[m],
+                cc[m],
+            )
             if not fits:
                 return False
         return True
@@ -479,31 +544,40 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
           in a new VM placement.
         """
         migrate_actions = (
-            a for a in self.solution.actions if a[
-                'action_type'] == self.MIGRATION)
+            a
+            for a in self.solution.actions
+            if a['action_type'] == self.MIGRATION
+        )
         instance_to_be_migrated = (
-            a['input_parameters']['resource_id'] for a in migrate_actions)
+            a['input_parameters']['resource_id'] for a in migrate_actions
+        )
         instance_uuids = list(set(instance_to_be_migrated))
         for instance_uuid in instance_uuids:
             actions = list(
-                a for a in self.solution.actions if a[
-                    'input_parameters'][
-                        'resource_id'] == instance_uuid)
+                a
+                for a in self.solution.actions
+                if a['input_parameters']['resource_id'] == instance_uuid
+            )
             if len(actions) > 1:
                 src_name = actions[0]['input_parameters']['source_node']
                 dst_name = actions[-1]['input_parameters']['destination_node']
                 for a in actions:
                     self.solution.actions.remove(a)
                     self.number_of_migrations -= 1
-                LOG.info("Optimized migrations: %s. "
-                         "Source: %s, destination: %s", actions,
-                         src_name, dst_name)
+                LOG.info(
+                    "Optimized migrations: %s. Source: %s, destination: %s",
+                    actions,
+                    src_name,
+                    dst_name,
+                )
                 src_node = self.compute_model.get_node_by_name(src_name)
                 dst_node = self.compute_model.get_node_by_name(dst_name)
                 instance = self.compute_model.get_instance_by_uuid(
-                    instance_uuid)
+                    instance_uuid
+                )
                 if self.compute_model.migrate_instance(
-                        instance, dst_node, src_node):
+                    instance, dst_node, src_node
+                ):
                     self.add_migration(instance, src_node, dst_node)
 
     def offload_phase(self, cc):
@@ -526,37 +600,46 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         """
         sorted_nodes = sorted(
             self.get_available_compute_nodes().values(),
-            key=lambda x: self.get_node_utilization(x)['cpu'])
+            key=lambda x: self.get_node_utilization(x)['cpu'],
+        )
         for node in reversed(sorted_nodes):
             if self.is_overloaded(node, cc):
                 for instance in sorted(
-                        self.compute_model.get_node_instances(node),
-                        key=lambda x: self.get_instance_utilization(
-                            x)['cpu']
+                    self.compute_model.get_node_instances(node),
+                    key=lambda x: self.get_instance_utilization(x)['cpu'],
                 ):
-                    LOG.info("Node %s overloaded, attempting to reduce load.",
-                             node)
+                    LOG.info(
+                        "Node %s overloaded, attempting to reduce load.", node
+                    )
                     # skip exclude instance when migrating
                     if instance.watcher_exclude:
-                        LOG.debug("Instance is excluded by scope, "
-                                  "skipped: %s", instance.uuid)
+                        LOG.debug(
+                            "Instance is excluded by scope, skipped: %s",
+                            instance.uuid,
+                        )
                         continue
                     for destination_node in reversed(sorted_nodes):
-                        if self.instance_fits(
-                                instance, destination_node, cc):
-                            LOG.info("Offload: found fitting "
-                                     "destination (%s) for instance: %s. "
-                                     "Planning migration.",
-                                     destination_node, instance.uuid)
-                            self.add_migration(instance, node,
-                                               destination_node)
+                        if self.instance_fits(instance, destination_node, cc):
+                            LOG.info(
+                                "Offload: found fitting "
+                                "destination (%s) for instance: %s. "
+                                "Planning migration.",
+                                destination_node,
+                                instance.uuid,
+                            )
+                            self.add_migration(
+                                instance, node, destination_node
+                            )
                             break
                     if not self.is_overloaded(node, cc):
                         LOG.info("Node %s no longer overloaded.", node)
                         break
                     else:
-                        LOG.info("Node still overloaded (%s), "
-                                 "continuing offload phase.", node)
+                        LOG.info(
+                            "Node still overloaded (%s), "
+                            "continuing offload phase.",
+                            node,
+                        )
 
     def consolidation_phase(self, cc):
         """Perform consolidation phase.
@@ -574,30 +657,35 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
         """
         sorted_nodes = sorted(
             self.get_available_compute_nodes().values(),
-            key=lambda x: self.get_node_utilization(x)['cpu'])
+            key=lambda x: self.get_node_utilization(x)['cpu'],
+        )
         asc = 0
         for node in sorted_nodes:
             instances = sorted(
                 self.compute_model.get_node_instances(node),
-                key=lambda x: self.get_instance_utilization(x)['cpu'])
+                key=lambda x: self.get_instance_utilization(x)['cpu'],
+            )
             for instance in reversed(instances):
                 # skip exclude instance when migrating
                 if instance.watcher_exclude:
-                    LOG.debug("Instance is excluded by scope, "
-                              "skipped: %s", instance.uuid)
+                    LOG.debug(
+                        "Instance is excluded by scope, skipped: %s",
+                        instance.uuid,
+                    )
                     continue
                 dsc = len(sorted_nodes) - 1
                 for destination_node in reversed(sorted_nodes):
                     if asc >= dsc:
                         break
-                    if self.instance_fits(
-                            instance, destination_node, cc):
-                        LOG.info("Consolidation: found fitting "
-                                 "destination (%s) for instance: %s. "
-                                 "Planning migration.",
-                                 destination_node, instance.uuid)
-                        self.add_migration(instance, node,
-                                           destination_node)
+                    if self.instance_fits(instance, destination_node, cc):
+                        LOG.info(
+                            "Consolidation: found fitting "
+                            "destination (%s) for instance: %s. "
+                            "Planning migration.",
+                            destination_node,
+                            instance.uuid,
+                        )
+                        self.add_migration(instance, node, destination_node)
                         break
                     dsc -= 1
             asc += 1
@@ -638,21 +726,18 @@ class VMWorkloadConsolidation(base.ServerConsolidationBaseStrategy):
 
         rcu_after = self.get_relative_cluster_utilization()
         info = {
-            "compute_nodes_count": len(
-                self.get_available_compute_nodes()),
+            "compute_nodes_count": len(self.get_available_compute_nodes()),
             'number_of_migrations': self.number_of_migrations,
-            'number_of_released_nodes':
-                self.number_of_released_nodes,
+            'number_of_released_nodes': self.number_of_released_nodes,
             'relative_cluster_utilization_before': str(rcu),
-            'relative_cluster_utilization_after': str(rcu_after)
+            'relative_cluster_utilization_after': str(rcu_after),
         }
 
         LOG.debug(info)
 
     def post_execute(self):
         self.solution.set_efficacy_indicators(
-            compute_nodes_count=len(
-                self.get_available_compute_nodes()),
+            compute_nodes_count=len(self.get_available_compute_nodes()),
             released_compute_nodes_count=self.number_of_released_nodes,
             instance_migrations_count=self.number_of_migrations,
         )
diff --git a/watcher/decision_engine/strategy/strategies/workload_balance.py b/watcher/decision_engine/strategy/strategies/workload_balance.py
index 1cb5995d7..81f9a26e3 100644
--- a/watcher/decision_engine/strategy/strategies/workload_balance.py
+++ b/watcher/decision_engine/strategy/strategies/workload_balance.py
@@ -101,38 +101,40 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
             "properties": {
                 "metrics": {
                     "description": "Workload balance based on metrics: "
-                                   "cpu or ram utilization",
+                    "cpu or ram utilization",
                     "type": "string",
                     "choice": ["instance_cpu_usage", "instance_ram_usage"],
-                    "default": "instance_cpu_usage"
+                    "default": "instance_cpu_usage",
                 },
                 "threshold": {
                     "description": "Workload threshold for migration - "
-                                   "used for source and destination hosts. "
-                                   "It is always a percentage value.",
+                    "used for source and destination hosts. "
+                    "It is always a percentage value.",
                     "type": "number",
-                    "default": 25.0
+                    "default": 25.0,
                 },
                 "period": {
                     "description": "aggregate time period of ceilometer",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
                 "granularity": {
                     "description": "The time between two measures in an "
-                                   "aggregated timeseries of a metric.",
+                    "aggregated timeseries of a metric.",
                     "type": "number",
-                    "default": 300
+                    "default": 300,
                 },
-            },
+            }
         }
 
     def get_available_compute_nodes(self):
         default_node_scope = [element.ServiceState.ENABLED.value]
-        return {uuid: cn for uuid, cn in
-                self.compute_model.get_all_compute_nodes().items()
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        return {
+            uuid: cn
+            for uuid, cn in self.compute_model.get_all_compute_nodes().items()
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
     def choose_instance_to_migrate(self, hosts, avg_workload, workload_cache):
         """Pick up an active instance to migrate from provided hosts
@@ -144,7 +146,8 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
         for instance_data in hosts:
             source_node = instance_data['compute_node']
             source_instances = self.compute_model.get_node_instances(
-                source_node)
+                source_node
+            )
             if source_instances:
                 delta_workload = instance_data['workload'] - avg_workload
                 min_delta = 1000000
@@ -153,33 +156,42 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
                     try:
                         # NOTE: skip exclude instance when migrating
                         if instance.watcher_exclude:
-                            LOG.debug("Instance is excluded by scope, "
-                                      "skipped: %s", instance.uuid)
+                            LOG.debug(
+                                "Instance is excluded by scope, skipped: %s",
+                                instance.uuid,
+                            )
                             continue
                         # select the first active VM to migrate
-                        if (instance.state !=
-                                element.InstanceState.ACTIVE.value):
-                            LOG.debug("Instance not active, skipped: %s",
-                                      instance.uuid)
+                        if (
+                            instance.state
+                            != element.InstanceState.ACTIVE.value
+                        ):
+                            LOG.debug(
+                                "Instance not active, skipped: %s",
+                                instance.uuid,
+                            )
                             continue
                         current_delta = (
-                            delta_workload - workload_cache[instance.uuid])
+                            delta_workload - workload_cache[instance.uuid]
+                        )
                         if 0 <= current_delta < min_delta:
                             min_delta = current_delta
                             instance_id = instance.uuid
                     except exception.InstanceNotFound:
-                        LOG.error("Instance not found; error: %s",
-                                  instance_id)
+                        LOG.error("Instance not found; error: %s", instance_id)
                 if instance_id:
-                    return (source_node,
-                            self.compute_model.get_instance_by_uuid(
-                                instance_id))
+                    return (
+                        source_node,
+                        self.compute_model.get_instance_by_uuid(instance_id),
+                    )
             else:
-                LOG.info("VM not found from compute_node: %s",
-                         source_node.uuid)
+                LOG.info(
+                    "VM not found from compute_node: %s", source_node.uuid
+                )
 
-    def filter_destination_hosts(self, hosts, instance_to_migrate,
-                                 avg_workload, workload_cache):
+    def filter_destination_hosts(
+        self, hosts, instance_to_migrate, avg_workload, workload_cache
+    ):
         """Only return hosts with sufficient available resources"""
         required_cores = instance_to_migrate.vcpus
         required_disk = instance_to_migrate.disk
@@ -193,9 +205,11 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
             workload = instance_data['workload']
             # calculate the available resources
             free_res = self.compute_model.get_node_free_resources(host)
-            if (free_res['vcpu'] >= required_cores and
-                    free_res['memory'] >= required_mem and
-                    free_res['disk'] >= required_disk):
+            if (
+                free_res['vcpu'] >= required_cores
+                and free_res['memory'] >= required_mem
+                and free_res['disk'] >= required_disk
+            ):
                 if self._meter == 'instance_cpu_usage':
                     usage = src_instance_workload + workload
                     usage_percent = usage / host.vcpus * 100
@@ -206,8 +220,12 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
                         "Host %s evaluated as destination for %s. "
                         "Host usage for cpu would be %s."
                         "The threshold is: %s. selected: %s",
-                        host.hostname, instance_to_migrate.uuid,
-                        usage_percent, self.threshold, usage < limit)
+                        host.hostname,
+                        instance_to_migrate.uuid,
+                        usage_percent,
+                        self.threshold,
+                        usage < limit,
+                    )
                 if self._meter == 'instance_ram_usage':
                     usage = src_instance_workload + workload
                     usage_percent = usage / host.memory * 100
@@ -218,8 +236,12 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
                         "Host %s evaluated as destination for %s. "
                         "Host usage for ram would be %s."
                         "The threshold is: %s. selected: %s",
-                        host.hostname, instance_to_migrate.uuid,
-                        usage_percent, self.threshold, usage < limit)
+                        host.hostname,
+                        instance_to_migrate.uuid,
+                        usage_percent,
+                        self.threshold,
+                        usage < limit,
+                    )
         return destination_hosts
 
     def group_hosts_by_cpu_or_ram_util(self):
@@ -247,25 +269,32 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
                 util = None
                 try:
                     util = self.datasource_backend.statistic_aggregation(
-                        instance, 'instance', self._meter, self._period,
-                        'mean', self._granularity)
+                        instance,
+                        'instance',
+                        self._meter,
+                        self._period,
+                        'mean',
+                        self._granularity,
+                    )
                 except Exception as exc:
                     LOG.exception(exc)
-                    LOG.error("Can not get %s from %s", self._meter,
-                              self.datasource_backend.NAME)
+                    LOG.error(
+                        "Can not get %s from %s",
+                        self._meter,
+                        self.datasource_backend.NAME,
+                    )
                     continue
                 if util is None:
-                    LOG.debug("Instance (%s): %s is None",
-                              instance.uuid, self._meter)
+                    LOG.debug(
+                        "Instance (%s): %s is None", instance.uuid, self._meter
+                    )
                     continue
                 if self._meter == 'instance_cpu_usage':
-                    workload_cache[instance.uuid] = (util *
-                                                     instance.vcpus / 100)
+                    workload_cache[instance.uuid] = util * instance.vcpus / 100
                 else:
                     workload_cache[instance.uuid] = util
                 node_workload += workload_cache[instance.uuid]
-                LOG.debug("VM (%s): %s %f", instance.uuid, self._meter,
-                          util)
+                LOG.debug("VM (%s): %s %f", instance.uuid, self._meter, util)
 
             cluster_workload += node_workload
             if self._meter == 'instance_cpu_usage':
@@ -276,18 +305,23 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
                 host_metric = 'host_ram_usage_percent'
 
             instance_data = {
-                'compute_node': node, self._meter: node_util,
-                'workload': node_workload}
+                'compute_node': node,
+                self._meter: node_util,
+                'workload': node_workload,
+            }
             if node_util >= self.threshold:
                 # mark the node to release resources
                 overload_hosts.append(instance_data)
             else:
                 nonoverload_hosts.append(instance_data)
             LOG.debug(
-                "Host usage for %s: %s is %s. "
-                "Higher than threshold %s: %s",
-                node_id, host_metric, node_util,
-                self.threshold, node_util >= self.threshold)
+                "Host usage for %s: %s is %s. Higher than threshold %s: %s",
+                node_id,
+                host_metric,
+                node_util,
+                self.threshold,
+                node_util >= self.threshold,
+            )
 
         avg_workload = 0
         if cluster_size != 0:
@@ -308,51 +342,58 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
         This phase is where you should put the main logic of your strategy.
         """
         source_nodes, target_nodes, avg_workload, workload_cache = (
-            self.group_hosts_by_cpu_or_ram_util())
+            self.group_hosts_by_cpu_or_ram_util()
+        )
 
         if not source_nodes:
             LOG.debug("No hosts require optimization")
             return self.solution
 
         if not target_nodes:
-            LOG.warning("No hosts current have CPU utilization under %s "
-                        "percent, therefore there are no possible target "
-                        "hosts for any migration",
-                        self.threshold)
+            LOG.warning(
+                "No hosts current have CPU utilization under %s "
+                "percent, therefore there are no possible target "
+                "hosts for any migration",
+                self.threshold,
+            )
             return self.solution
 
         # choose the server with largest cpu usage
-        source_nodes = sorted(source_nodes,
-                              reverse=True,
-                              key=lambda x: (x[self._meter]))
+        source_nodes = sorted(
+            source_nodes, reverse=True, key=lambda x: (x[self._meter])
+        )
 
         instance_to_migrate = self.choose_instance_to_migrate(
-            source_nodes, avg_workload, workload_cache)
+            source_nodes, avg_workload, workload_cache
+        )
         if not instance_to_migrate:
             return self.solution
         source_node, instance_src = instance_to_migrate
         # find the hosts that have enough resource for the VM to be migrated
         destination_hosts = self.filter_destination_hosts(
-            target_nodes, instance_src, avg_workload, workload_cache)
+            target_nodes, instance_src, avg_workload, workload_cache
+        )
         # sort the filtered result by workload
         # pick up the lowest one as dest server
         if not destination_hosts:
             # for instance.
-            LOG.warning("No proper target host could be found, it might "
-                        "be because of there's no enough CPU/Memory/DISK")
+            LOG.warning(
+                "No proper target host could be found, it might "
+                "be because of there's no enough CPU/Memory/DISK"
+            )
             return self.solution
-        destination_hosts = sorted(destination_hosts,
-                                   key=lambda x: (x[self._meter]))
+        destination_hosts = sorted(
+            destination_hosts, key=lambda x: (x[self._meter])
+        )
         # always use the host with lowerest CPU utilization
         mig_destination_node = destination_hosts[0]['compute_node']
         # generate solution to migrate the instance to the dest server,
         if self.compute_model.migrate_instance(
-                instance_src, source_node, mig_destination_node):
+            instance_src, source_node, mig_destination_node
+        ):
             self.add_action_migrate(
-                instance_src,
-                'live',
-                source_node,
-                mig_destination_node)
+                instance_src, 'live', source_node, mig_destination_node
+            )
             self.instance_migrations_count += 1
 
     def post_execute(self):
@@ -363,7 +404,7 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
         self.solution.model = self.compute_model
         self.solution.set_efficacy_indicators(
             instance_migrations_count=self.instance_migrations_count,
-            instances_count=len(self.compute_model.get_all_instances())
+            instances_count=len(self.compute_model.get_all_instances()),
         )
 
         LOG.debug(self.compute_model.to_string())
diff --git a/watcher/decision_engine/strategy/strategies/workload_stabilization.py b/watcher/decision_engine/strategy/strategies/workload_stabilization.py
index 0dc87d910..ceab24360 100644
--- a/watcher/decision_engine/strategy/strategies/workload_stabilization.py
+++ b/watcher/decision_engine/strategy/strategies/workload_stabilization.py
@@ -41,9 +41,9 @@ def _set_memoize(conf):
     oslo_cache.configure(conf)
     region = oslo_cache.create_region()
     configured_region = oslo_cache.configure_cache_region(conf, region)
-    return oslo_cache.core.get_memoization_decorator(conf,
-                                                     configured_region,
-                                                     'cache')
+    return oslo_cache.core.get_memoization_decorator(
+        conf, configured_region, 'cache'
+    )
 
 
 class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
@@ -70,8 +70,12 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
 
     MEMOIZE = _set_memoize(CONF)
 
-    DATASOURCE_METRICS = ['host_cpu_usage', 'instance_cpu_usage',
-                          'instance_ram_usage', 'host_ram_usage']
+    DATASOURCE_METRICS = [
+        'host_cpu_usage',
+        'instance_cpu_usage',
+        'instance_ram_usage',
+        'host_ram_usage',
+    ]
 
     def __init__(self, config, osc=None):
         """Workload Stabilization control using live migration
@@ -119,96 +123,96 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
                     "type": "array",
                     "items": {
                         "type": "string",
-                        "enum": ["instance_cpu_usage", "instance_ram_usage"]
+                        "enum": ["instance_cpu_usage", "instance_ram_usage"],
                     },
-                    "default": ["instance_cpu_usage"]
+                    "default": ["instance_cpu_usage"],
                 },
                 "thresholds": {
                     "description": "Dict where key is a metric and value "
-                                   "is a trigger value.",
+                    "is a trigger value.",
                     "type": "object",
                     "properties": {
                         "instance_cpu_usage": {
                             "type": "number",
                             "minimum": 0,
-                            "maximum": 1
+                            "maximum": 1,
                         },
                         "instance_ram_usage": {
                             "type": "number",
                             "minimum": 0,
-                            "maximum": 1
-                        }
+                            "maximum": 1,
+                        },
+                    },
+                    "default": {
+                        "instance_cpu_usage": 0.1,
+                        "instance_ram_usage": 0.1,
                     },
-                    "default": {"instance_cpu_usage": 0.1,
-                                "instance_ram_usage": 0.1}
                 },
                 "weights": {
                     "description": "These weights used to calculate "
-                                   "common standard deviation. Name of weight"
-                                   " contains meter name and _weight suffix.",
+                    "common standard deviation. Name of weight"
+                    " contains meter name and _weight suffix.",
                     "type": "object",
                     "properties": {
                         "instance_cpu_usage_weight": {
                             "type": "number",
                             "minimum": 0,
-                            "maximum": 1
+                            "maximum": 1,
                         },
                         "instance_ram_usage_weight": {
                             "type": "number",
                             "minimum": 0,
-                            "maximum": 1
-                        }
+                            "maximum": 1,
+                        },
+                    },
+                    "default": {
+                        "instance_cpu_usage_weight": 1.0,
+                        "instance_ram_usage_weight": 1.0,
                     },
-                    "default": {"instance_cpu_usage_weight": 1.0,
-                                "instance_ram_usage_weight": 1.0}
                 },
                 "instance_metrics": {
                     "description": "Mapping to get hardware statistics using"
-                                   " instance metrics",
+                    " instance metrics",
                     "type": "object",
-                    "default": {"instance_cpu_usage": "host_cpu_usage",
-                                "instance_ram_usage": "host_ram_usage"}
+                    "default": {
+                        "instance_cpu_usage": "host_cpu_usage",
+                        "instance_ram_usage": "host_ram_usage",
+                    },
                 },
                 "host_choice": {
                     "description": "Method of host's choice. There are cycle,"
-                                   " retry and fullsearch methods. "
-                                   "Cycle will iterate hosts in cycle. "
-                                   "Retry will get some hosts random "
-                                   "(count defined in retry_count option). "
-                                   "Fullsearch will return each host "
-                                   "from list.",
+                    " retry and fullsearch methods. "
+                    "Cycle will iterate hosts in cycle. "
+                    "Retry will get some hosts random "
+                    "(count defined in retry_count option). "
+                    "Fullsearch will return each host "
+                    "from list.",
                     "type": "string",
-                    "default": "retry"
+                    "default": "retry",
                 },
                 "retry_count": {
                     "description": "Count of random returned hosts",
                     "type": "number",
                     "minimum": 1,
-                    "default": 1
+                    "default": 1,
                 },
                 "periods": {
                     "description": "These periods are used to get statistic "
-                                   "aggregation for instance and host "
-                                   "metrics. The period is simply a repeating"
-                                   " interval of time into which the samples"
-                                   " are grouped for aggregation. Watcher "
-                                   "uses only the last period of all received"
-                                   " ones.",
+                    "aggregation for instance and host "
+                    "metrics. The period is simply a repeating"
+                    " interval of time into which the samples"
+                    " are grouped for aggregation. Watcher "
+                    "uses only the last period of all received"
+                    " ones.",
                     "type": "object",
                     "properties": {
-                        "instance": {
-                            "type": "integer",
-                            "minimum": 0
-                        },
-                        "compute_node": {
-                            "type": "integer",
-                            "minimum": 0
-                        },
+                        "instance": {"type": "integer", "minimum": 0},
+                        "compute_node": {"type": "integer", "minimum": 0},
                         "node": {
                             "type": "integer",
                             # node is deprecated
                             "minimum": 0,
-                            "default": 0
+                            "default": 0,
                         },
                     },
                     "default": {
@@ -216,44 +220,35 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
                         "compute_node": 600,
                         # node is deprecated
                         "node": 0,
-                    }
+                    },
                 },
                 "aggregation_method": {
                     "description": "Function used to aggregate multiple "
-                                   "measures into an aggregate. For example, "
-                                   "the min aggregation method will aggregate "
-                                   "the values of different measures to the "
-                                   "minimum value of all the measures in the "
-                                   "time range.",
+                    "measures into an aggregate. For example, "
+                    "the min aggregation method will aggregate "
+                    "the values of different measures to the "
+                    "minimum value of all the measures in the "
+                    "time range.",
                     "type": "object",
                     "properties": {
-                        "instance": {
-                            "type": "string",
-                            "default": 'mean'
-                        },
-                        "compute_node": {
-                            "type": "string",
-                            "default": 'mean'
-                        },
+                        "instance": {"type": "string", "default": 'mean'},
+                        "compute_node": {"type": "string", "default": 'mean'},
                         # node is deprecated
-                        "node": {
-                            "type": "string",
-                            "default": ''
-                        },
+                        "node": {"type": "string", "default": ''},
                     },
                     "default": {
                         "instance": 'mean',
                         "compute_node": 'mean',
                         # node is deprecated
                         "node": '',
-                    }
+                    },
                 },
                 "granularity": {
                     "description": "The time between two measures in an "
-                                   "aggregated timeseries of a metric.",
+                    "aggregated timeseries of a metric.",
                     "type": "number",
                     "minimum": 0,
-                    "default": 300
+                    "default": 300,
                 },
             }
         }
@@ -266,8 +261,9 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
         :param host_vcpus: int
         :return: float value
         """
-        return (instance_load['instance_cpu_usage'] *
-                (instance_load['vcpus'] / float(host_vcpus)))
+        return instance_load['instance_cpu_usage'] * (
+            instance_load['vcpus'] / float(host_vcpus)
+        )
 
     @MEMOIZE
     def get_instance_load(self, instance):
@@ -280,20 +276,30 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
         instance_load = {'uuid': instance.uuid, 'vcpus': instance.vcpus}
         for meter in self.metrics:
             avg_meter = self.datasource_backend.statistic_aggregation(
-                instance, 'instance', meter, self.periods['instance'],
-                self.aggregation_method['instance'], self.granularity)
+                instance,
+                'instance',
+                meter,
+                self.periods['instance'],
+                self.aggregation_method['instance'],
+                self.granularity,
+            )
             if avg_meter is None:
                 LOG.warning(
                     "No values returned by %(resource_id)s "
-                    "for %(metric_name)s", dict(
-                        resource_id=instance.uuid, metric_name=meter))
+                    "for %(metric_name)s",
+                    dict(resource_id=instance.uuid, metric_name=meter),
+                )
                 return
             if meter == 'instance_cpu_usage':
                 avg_meter /= float(100)
-            LOG.debug('Load of %(metric)s for %(instance)s is %(value)s',
-                      {'metric': meter,
-                       'instance': instance.uuid,
-                       'value': avg_meter})
+            LOG.debug(
+                'Load of %(metric)s for %(instance)s is %(value)s',
+                {
+                    'metric': meter,
+                    'instance': instance.uuid,
+                    'value': avg_meter,
+                },
+            )
             instance_load[meter] = avg_meter
         return instance_load
 
@@ -302,16 +308,20 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
         for host in normalized_hosts:
             if 'instance_ram_usage' in normalized_hosts[host]:
                 node = self.compute_model.get_node_by_uuid(host)
-                normalized_hosts[host]['instance_ram_usage'] \
-                    /= float(node.memory)
+                normalized_hosts[host]['instance_ram_usage'] /= float(
+                    node.memory
+                )
 
         return normalized_hosts
 
     def get_available_nodes(self):
         nodes = self.compute_model.get_all_compute_nodes().items()
-        return {node_uuid: node for node_uuid, node in nodes
-                if node.state == element.ServiceState.ONLINE.value and
-                node.status == element.ServiceState.ENABLED.value}
+        return {
+            node_uuid: node
+            for node_uuid, node in nodes
+            if node.state == element.ServiceState.ONLINE.value
+            and node.status == element.ServiceState.ENABLED.value
+        }
 
     def get_hosts_load(self):
         """Get load of every available host by gathering instances load"""
@@ -324,12 +334,19 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
                 avg_meter = None
                 meter_name = self.instance_metrics[metric]
                 avg_meter = self.datasource_backend.statistic_aggregation(
-                    node, 'compute_node', self.instance_metrics[metric],
+                    node,
+                    'compute_node',
+                    self.instance_metrics[metric],
                     self.periods['compute_node'],
-                    self.aggregation_method['compute_node'], self.granularity)
+                    self.aggregation_method['compute_node'],
+                    self.granularity,
+                )
                 if avg_meter is None:
-                    LOG.warning('No values returned by node %s for %s',
-                                node_id, meter_name)
+                    LOG.warning(
+                        'No values returned by node %s for %s',
+                        node_id,
+                        meter_name,
+                    )
                     del hosts_load[node_id]
                     break
                 else:
@@ -337,10 +354,10 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
                         avg_meter /= oslo_utils.units.Ki
                     if meter_name == 'host_cpu_usage':
                         avg_meter /= 100
-                LOG.debug('Load of %(metric)s for %(node)s is %(value)s',
-                          {'metric': metric,
-                           'node': node_id,
-                           'value': avg_meter})
+                LOG.debug(
+                    'Load of %(metric)s for %(node)s is %(value)s',
+                    {'metric': metric, 'node': node_id, 'value': avg_meter},
+                )
                 hosts_load[node_id][metric] = avg_meter
         return hosts_load
 
@@ -369,8 +386,12 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
             except KeyError as exc:
                 LOG.exception(exc)
                 raise exception.WatcherException(
-                    _("Incorrect mapping: could not find associated weight"
-                      " for %s in weight dict.") % metric)
+                    _(
+                        "Incorrect mapping: could not find associated weight"
+                        " for %s in weight dict."
+                    )
+                    % metric
+                )
         return weighted_sd
 
     def calculate_migration_case(self, hosts, instance, src_node, dst_node):
@@ -394,9 +415,11 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
         for metric in self.metrics:
             if metric == 'instance_cpu_usage':
                 new_hosts[src_node.uuid][metric] -= (
-                    self.transform_instance_cpu(instance_load, s_host_vcpus))
+                    self.transform_instance_cpu(instance_load, s_host_vcpus)
+                )
                 new_hosts[dst_node.uuid][metric] += (
-                    self.transform_instance_cpu(instance_load, d_host_vcpus))
+                    self.transform_instance_cpu(instance_load, d_host_vcpus)
+                )
             else:
                 new_hosts[src_node.uuid][metric] -= instance_load[metric]
                 new_hosts[dst_node.uuid][metric] += instance_load[metric]
@@ -418,6 +441,7 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
 
     def simulate_migrations(self, hosts):
         """Make sorted list of pairs instance:dst_host"""
+
         def yield_nodes(nodes):
             if self.host_choice == 'cycle':
                 for i in itertools.cycle(nodes):
@@ -440,17 +464,22 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
             for instance in self.compute_model.get_node_instances(src_node):
                 # NOTE: skip exclude instance when migrating
                 if instance.watcher_exclude:
-                    LOG.debug("Instance is excluded by scope, "
-                              "skipped: %s", instance.uuid)
+                    LOG.debug(
+                        "Instance is excluded by scope, skipped: %s",
+                        instance.uuid,
+                    )
                     continue
-                if instance.state not in [element.InstanceState.ACTIVE.value,
-                                          element.InstanceState.PAUSED.value]:
+                if instance.state not in [
+                    element.InstanceState.ACTIVE.value,
+                    element.InstanceState.PAUSED.value,
+                ]:
                     continue
                 min_sd_case = {'value': current_weighted_sd}
                 for dst_host in next(node_list):
                     dst_node = self.compute_model.get_node_by_uuid(dst_host)
                     sd_case = self.calculate_migration_case(
-                        hosts, instance, src_node, dst_node)
+                        hosts, instance, src_node, dst_node
+                    )
                     if sd_case is None:
                         break
 
@@ -458,8 +487,11 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
 
                     if weighted_sd < min_sd_case['value']:
                         min_sd_case = {
-                            'host': dst_node.uuid, 'value': weighted_sd,
-                            's_host': src_node.uuid, 'instance': instance.uuid}
+                            'host': dst_node.uuid,
+                            'value': weighted_sd,
+                            's_host': src_node.uuid,
+                            'instance': instance.uuid,
+                        }
                         instance_host_map.append(min_sd_case)
                 if sd_case is None:
                     continue
@@ -471,36 +503,43 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
         normalized_load = self.normalize_hosts_load(hosts_load)
         for metric in self.metrics:
             metric_sd = self.get_sd(normalized_load, metric)
-            LOG.info("Standard deviation for %(metric)s is %(sd)s.",
-                     {'metric': metric, 'sd': metric_sd})
+            LOG.info(
+                "Standard deviation for %(metric)s is %(sd)s.",
+                {'metric': metric, 'sd': metric_sd},
+            )
             if metric_sd > float(self.thresholds[metric]):
-                LOG.info("Standard deviation of %(metric)s exceeds"
-                         " appropriate threshold %(threshold)s by %(sd)s.",
-                         {'metric': metric,
-                          'threshold': float(self.thresholds[metric]),
-                          'sd': metric_sd})
+                LOG.info(
+                    "Standard deviation of %(metric)s exceeds"
+                    " appropriate threshold %(threshold)s by %(sd)s.",
+                    {
+                        'metric': metric,
+                        'threshold': float(self.thresholds[metric]),
+                        'sd': metric_sd,
+                    },
+                )
                 LOG.info("Launching workload optimization...")
                 self.sd_before_audit = metric_sd
                 return self.simulate_migrations(hosts_load)
 
-    def create_migration_instance(self, mig_instance, mig_source_node,
-                                  mig_destination_node):
+    def create_migration_instance(
+        self, mig_instance, mig_source_node, mig_destination_node
+    ):
         """Create migration VM"""
         if self.compute_model.migrate_instance(
-                mig_instance, mig_source_node, mig_destination_node):
-            self.add_action_migrate(mig_instance, 'live',
-                                    mig_source_node,
-                                    mig_destination_node)
+            mig_instance, mig_source_node, mig_destination_node
+        ):
+            self.add_action_migrate(
+                mig_instance, 'live', mig_source_node, mig_destination_node
+            )
             self.instance_migrations_count += 1
 
     def migrate(self, instance_uuid, src_host, dst_host):
         mig_instance = self.compute_model.get_instance_by_uuid(instance_uuid)
-        mig_source_node = self.compute_model.get_node_by_uuid(
-            src_host)
-        mig_destination_node = self.compute_model.get_node_by_uuid(
-            dst_host)
-        self.create_migration_instance(mig_instance, mig_source_node,
-                                       mig_destination_node)
+        mig_source_node = self.compute_model.get_node_by_uuid(src_host)
+        mig_destination_node = self.compute_model.get_node_by_uuid(dst_host)
+        self.create_migration_instance(
+            mig_instance, mig_source_node, mig_destination_node
+        )
 
     def fill_solution(self):
         self.solution.model = self.compute_model
@@ -519,15 +558,20 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
 
         # backwards compatibility for node parameter with aggregate.
         if self.aggregation_method['node']:
-            LOG.warning('Parameter node has been renamed to compute_node and '
-                        'will be removed in next release.')
-            self.aggregation_method['compute_node'] = \
-                self.aggregation_method['node']
+            LOG.warning(
+                'Parameter node has been renamed to compute_node and '
+                'will be removed in next release.'
+            )
+            self.aggregation_method['compute_node'] = self.aggregation_method[
+                'node'
+            ]
 
         # backwards compatibility for node parameter with period.
         if self.periods['node'] != 0:
-            LOG.warning('Parameter node has been renamed to compute_node and '
-                        'will be removed in next release.')
+            LOG.warning(
+                'Parameter node has been renamed to compute_node and '
+                'will be removed in next release.'
+            )
             self.periods['compute_node'] = self.periods['node']
 
     def do_execute(self, audit=None):
@@ -538,37 +582,49 @@ class WorkloadStabilization(base.WorkloadStabilizationBaseStrategy):
             balanced = False
             for instance_host in migration:
                 instance = self.compute_model.get_instance_by_uuid(
-                    instance_host['instance'])
+                    instance_host['instance']
+                )
                 src_node = self.compute_model.get_node_by_uuid(
-                    instance_host['s_host'])
+                    instance_host['s_host']
+                )
                 dst_node = self.compute_model.get_node_by_uuid(
-                    instance_host['host'])
+                    instance_host['host']
+                )
                 if instance.disk > dst_node.disk:
                     continue
                 instance_load = self.calculate_migration_case(
-                    hosts_load, instance, src_node, dst_node)
+                    hosts_load, instance, src_node, dst_node
+                )
                 weighted_sd = self.calculate_weighted_sd(instance_load[:-1])
                 if weighted_sd < min_sd:
                     min_sd = weighted_sd
                     hosts_load = instance_load[-1]
-                    LOG.info("Migration of %(instance_uuid)s from %(s_host)s "
-                             "to %(host)s reduces standard deviation to "
-                             "%(min_sd)s.",
-                             {'instance_uuid': instance_host['instance'],
-                              's_host': instance_host['s_host'],
-                              'host': instance_host['host'],
-                              'min_sd': min_sd})
-                    self.migrate(instance_host['instance'],
-                                 instance_host['s_host'],
-                                 instance_host['host'])
+                    LOG.info(
+                        "Migration of %(instance_uuid)s from %(s_host)s "
+                        "to %(host)s reduces standard deviation to "
+                        "%(min_sd)s.",
+                        {
+                            'instance_uuid': instance_host['instance'],
+                            's_host': instance_host['s_host'],
+                            'host': instance_host['host'],
+                            'min_sd': min_sd,
+                        },
+                    )
+                    self.migrate(
+                        instance_host['instance'],
+                        instance_host['s_host'],
+                        instance_host['host'],
+                    )
                     self.sd_after_audit = min_sd
 
                 for metric, value in zip(self.metrics, instance_load[:-1]):
                     if value < float(self.thresholds[metric]):
-                        LOG.info("At least one of metrics' values fell "
-                                 "below the threshold values. "
-                                 "Workload Stabilization has successfully "
-                                 "completed optimization process.")
+                        LOG.info(
+                            "At least one of metrics' values fell "
+                            "below the threshold values. "
+                            "Workload Stabilization has successfully "
+                            "completed optimization process."
+                        )
                         balanced = True
                         break
                 if balanced:
diff --git a/watcher/decision_engine/strategy/strategies/zone_migration.py b/watcher/decision_engine/strategy/strategies/zone_migration.py
index ad2f73b64..0b9133f13 100644
--- a/watcher/decision_engine/strategy/strategies/zone_migration.py
+++ b/watcher/decision_engine/strategy/strategies/zone_migration.py
@@ -46,7 +46,6 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
     """
 
     def __init__(self, config, osc=None):
-
         super().__init__(config, osc)
         self._nova = None
         self._cinder = None
@@ -94,18 +93,18 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
                         "properties": {
                             "src_node": {
                                 "description": "Compute node from which"
-                                               " instances migrate",
-                                "type": "string"
+                                " instances migrate",
+                                "type": "string",
                             },
                             "dst_node": {
                                 "description": "Compute node to which "
-                                               "instances migrate",
-                                "type": "string"
-                            }
+                                "instances migrate",
+                                "type": "string",
+                            },
                         },
                         "required": ["src_node"],
-                        "additionalProperties": False
-                    }
+                        "additionalProperties": False,
+                    },
                 },
                 "storage_pools": {
                     "type": "array",
@@ -114,83 +113,95 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
                         "properties": {
                             "src_pool": {
                                 "description": "Storage pool from which"
-                                               " volumes migrate",
-                                "type": "string"
+                                " volumes migrate",
+                                "type": "string",
                             },
                             "dst_pool": {
                                 "description": "Storage pool to which"
-                                               " volumes migrate",
-                                "type": "string"
+                                " volumes migrate",
+                                "type": "string",
                             },
                             "src_type": {
                                 "description": "Volume type from which"
-                                               " volumes migrate",
-                                "type": "string"
+                                " volumes migrate",
+                                "type": "string",
                             },
                             "dst_type": {
                                 "description": "Volume type to which"
-                                               " volumes migrate",
-                                "type": "string"
-                            }
+                                " volumes migrate",
+                                "type": "string",
+                            },
                         },
                         "oneOf": [
                             {
                                 "required": ["src_pool", "dst_pool"],
-                                "not": {"required": ["dst_type"]}
+                                "not": {"required": ["dst_type"]},
                             },
                             {
                                 "required": ["src_pool", "dst_type"],
-                                "not": {"required": ["dst_pool"]}
-                            }
+                                "not": {"required": ["dst_pool"]},
+                            },
                         ],
-                        "additionalProperties": False
-                    }
+                        "additionalProperties": False,
+                    },
                 },
                 "parallel_total": {
                     "description": "The number of actions to be run in"
-                                   " parallel in total",
-                    "type": "integer", "minimum": 0, "default": 6
+                    " parallel in total",
+                    "type": "integer",
+                    "minimum": 0,
+                    "default": 6,
                 },
                 "parallel_per_node": {
                     "description": "The number of actions to be run in"
-                                   " parallel per compute node",
-                    "type": "integer", "minimum": 0, "default": 2
+                    " parallel per compute node",
+                    "type": "integer",
+                    "minimum": 0,
+                    "default": 2,
                 },
                 "parallel_per_pool": {
                     "description": "The number of actions to be run in"
-                                   " parallel per storage host",
-                    "type": "integer", "minimum": 0, "default": 2
+                    " parallel per storage host",
+                    "type": "integer",
+                    "minimum": 0,
+                    "default": 2,
                 },
                 "priority": {
                     "description": "List prioritizes instances and volumes",
                     "type": "object",
                     "properties": {
                         "project": {
-                            "type": "array", "items": {"type": "string"}
+                            "type": "array",
+                            "items": {"type": "string"},
                         },
                         "compute_node": {
-                            "type": "array", "items": {"type": "string"}
+                            "type": "array",
+                            "items": {"type": "string"},
                         },
                         "storage_pool": {
-                            "type": "array", "items": {"type": "string"}
+                            "type": "array",
+                            "items": {"type": "string"},
                         },
                         "compute": {
-                            "enum": ["vcpu_num", "mem_size", "disk_size",
-                                     "created_at"]
+                            "enum": [
+                                "vcpu_num",
+                                "mem_size",
+                                "disk_size",
+                                "created_at",
+                            ]
                         },
-                        "storage": {
-                            "enum": ["size", "created_at"]
-                        }
+                        "storage": {"enum": ["size", "created_at"]},
                     },
-                    "additionalProperties": False
+                    "additionalProperties": False,
                 },
                 "with_attached_volume": {
                     "description": "instance migrates just after attached"
-                                   " volumes or not",
-                    "type": "boolean", "default": False
+                    " volumes or not",
+                    "type": "boolean",
+                    "default": False,
                 },
             },
-            "additionalProperties": False
+            "additionalProperties": False,
         }
 
     @property
@@ -269,50 +280,59 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
         return self._cinder
 
     def get_available_compute_nodes(self):
-        default_node_scope = [element.ServiceState.ENABLED.value,
-                              element.ServiceState.DISABLED.value]
-        return {uuid: cn for uuid, cn in
-                self.compute_model.get_all_compute_nodes().items()
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        default_node_scope = [
+            element.ServiceState.ENABLED.value,
+            element.ServiceState.DISABLED.value,
+        ]
+        return {
+            uuid: cn
+            for uuid, cn in self.compute_model.get_all_compute_nodes().items()
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
     def get_available_storage_nodes(self):
-        default_node_scope = [element.ServiceState.ENABLED.value,
-                              element.ServiceState.DISABLED.value]
-        return {uuid: cn for uuid, cn in
-                self.storage_model.get_all_storage_nodes().items()
-                if cn.state == element.ServiceState.ONLINE.value and
-                cn.status in default_node_scope}
+        default_node_scope = [
+            element.ServiceState.ENABLED.value,
+            element.ServiceState.DISABLED.value,
+        ]
+        return {
+            uuid: cn
+            for uuid, cn in self.storage_model.get_all_storage_nodes().items()
+            if cn.state == element.ServiceState.ONLINE.value
+            and cn.status in default_node_scope
+        }
 
     def pre_execute(self):
         self._pre_execute()
         LOG.debug(self.storage_model.to_string())
 
     def do_execute(self, audit=None):
-        """Strategy execution phase
-
-        """
+        """Strategy execution phase"""
         filtered_targets = self.filtered_targets()
         self.set_migration_count(filtered_targets)
 
         total_limit = self.parallel_total
         per_node_limit = self.parallel_per_node
         per_pool_limit = self.parallel_per_pool
-        action_counter = ActionCounter(total_limit,
-                                       per_pool_limit, per_node_limit)
+        action_counter = ActionCounter(
+            total_limit, per_pool_limit, per_node_limit
+        )
 
         instance_targets = filtered_targets.get(INSTANCE, [])
         if VOLUME in filtered_targets:
-            self.volumes_migration(filtered_targets[VOLUME], action_counter,
-                                   instance_targets)
+            self.volumes_migration(
+                filtered_targets[VOLUME], action_counter, instance_targets
+            )
         if INSTANCE in filtered_targets:
-            self.instances_migration(instance_targets,
-                                     action_counter)
+            self.instances_migration(instance_targets, action_counter)
 
-        LOG.debug("action total: %s, pools: %s, nodes %s ",
-                  action_counter.total_count,
-                  action_counter.per_pool_count,
-                  action_counter.per_node_count)
+        LOG.debug(
+            "action total: %s, pools: %s, nodes %s ",
+            action_counter.total_count,
+            action_counter.per_pool_count,
+            action_counter.per_node_count,
+        )
 
     def post_execute(self):
         """Post-execution phase
@@ -327,7 +347,7 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
             volume_migrate_count=self.volume_count,
             planned_volume_migrate_count=self.planned_volume_count,
             volume_update_count=self.volume_count,
-            planned_volume_update_count=self.planned_volume_count
+            planned_volume_update_count=self.planned_volume_count,
         )
 
     def set_migration_count(self, targets):
@@ -347,8 +367,9 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
     def is_live(self, instance):
         status = instance.status
         state = instance.vm_state
-        return (status == status_ACTIVE and state == ACTIVE
-                ) or (status == status_PAUSED and state == PAUSED)
+        return (status == status_ACTIVE and state == ACTIVE) or (
+            status == status_PAUSED and state == PAUSED
+        )
 
     def is_cold(self, instance):
         status = instance.status
@@ -422,8 +443,11 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
 
             pool = getattr(volume, 'os-vol-host-attr:host')
             if action_counter.is_pool_max(pool):
-                LOG.debug("%s has objects to be migrated, but it has"
-                          " reached the limit of parallelization.", pool)
+                LOG.debug(
+                    "%s has objects to be migrated, but it has"
+                    " reached the limit of parallelization.",
+                    pool,
+                )
                 continue
 
             src_type = volume.volume_type
@@ -434,12 +458,16 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
             if dst_type is None or src_type == dst_type:
                 if dst_pool is None:
                     type_msg = (
-                        "" if dst_type is None else
-                        f"it already has type {dst_type} and ")
+                        ""
+                        if dst_type is None
+                        else f"it already has type {dst_type} and "
+                    )
                     LOG.info(
                         "volume %s will not be migrated because %s'dst_pool' "
                         "was not specified for src_pool %s",
-                        volume.name, type_msg, pool
+                        volume.name,
+                        type_msg,
+                        pool,
                     )
                     continue
                 self._volume_migrate(volume, dst_pool)
@@ -460,7 +488,8 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
                         # of it
                         LOG.debug(
                             "Could not find instance %s it will not be "
-                            "considered for migration", instance_id
+                            "considered for migration",
+                            instance_id,
                         )
                         continue
                     if instance_id in instance_target_ids:
@@ -470,11 +499,12 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
             action_counter.add_pool(pool)
 
     def instances_migration(self, instances, action_counter):
-
         for instance in instances:
             if self._instance_migration_exists(instance.uuid):
-                LOG.debug("A migration action for instance %s already exist",
-                          instance.uuid)
+                LOG.debug(
+                    "A migration action for instance %s already exist",
+                    instance.uuid,
+                )
                 continue
             src_node = instance.host
 
@@ -483,8 +513,11 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
                 break
 
             if action_counter.is_node_max(src_node):
-                LOG.debug("%s has objects to be migrated, but it has"
-                          " reached the limit of parallelization.", src_node)
+                LOG.debug(
+                    "%s has objects to be migrated, but it has"
+                    " reached the limit of parallelization.",
+                    src_node,
+                )
                 continue
 
             dst_node = self.get_dst_node(src_node)
@@ -496,9 +529,11 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
             action_counter.add_node(src_node)
 
     def _live_migration(self, instance, src_node, dst_node):
-        parameters = {"migration_type": "live",
-                      "source_node": src_node,
-                      "resource_name": instance.name}
+        parameters = {
+            "migration_type": "live",
+            "source_node": src_node,
+            "resource_name": instance.name,
+        }
         if dst_node:
             # if dst_node is None, do not add it to the parameters for the
             # migration action, and let Nova figure out the destination node
@@ -506,13 +541,16 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
         self.solution.add_action(
             action_type="migrate",
             resource_id=instance.uuid,
-            input_parameters=parameters)
+            input_parameters=parameters,
+        )
         self.planned_live_count += 1
 
     def _cold_migration(self, instance, src_node, dst_node):
-        parameters = {"migration_type": "cold",
-                      "source_node": src_node,
-                      "resource_name": instance.name}
+        parameters = {
+            "migration_type": "cold",
+            "source_node": src_node,
+            "resource_name": instance.name,
+        }
         if dst_node:
             # if dst_node is None, do not add it to the parameters for the
             # migration action, and let Nova figure out the destination node
@@ -520,35 +558,44 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
         self.solution.add_action(
             action_type="migrate",
             resource_id=instance.uuid,
-            input_parameters=parameters)
+            input_parameters=parameters,
+        )
         self.planned_cold_count += 1
 
     def _instance_migration_exists(self, instance_id):
         for action in self.solution.actions:
             resource_id = action['input_parameters'].get('resource_id', None)
-            if (action['action_type'] == 'migrate' and
-                    resource_id == instance_id):
+            if (
+                action['action_type'] == 'migrate'
+                and resource_id == instance_id
+            ):
                 return True
         return False
 
     def _volume_migrate(self, volume, dst_pool):
-        parameters = {"migration_type": "migrate",
-                      "destination_node": dst_pool,
-                      "resource_name": volume.name}
+        parameters = {
+            "migration_type": "migrate",
+            "destination_node": dst_pool,
+            "resource_name": volume.name,
+        }
         self.solution.add_action(
             action_type="volume_migrate",
             resource_id=volume.id,
-            input_parameters=parameters)
+            input_parameters=parameters,
+        )
         self.planned_volume_count += 1
 
     def _volume_retype(self, volume, dst_type):
-        parameters = {"migration_type": "retype",
-                      "destination_type": dst_type,
-                      "resource_name": volume.name}
+        parameters = {
+            "migration_type": "retype",
+            "destination_type": dst_type,
+            "resource_name": volume.name,
+        }
         self.solution.add_action(
             action_type="volume_migrate",
             resource_id=volume.id,
-            input_parameters=parameters)
+            input_parameters=parameters,
+        )
         self.planned_volume_count += 1
 
     def get_src_node_list(self):
@@ -559,8 +606,12 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
         if not self.migrate_compute_nodes:
             return None
 
-        return [v for dic in self.migrate_compute_nodes
-                for k, v in dic.items() if k == "src_node"]
+        return [
+            v
+            for dic in self.migrate_compute_nodes
+            for k, v in dic.items()
+            if k == "src_node"
+        ]
 
     def get_src_pool_list(self):
         """Get src pools from migrate_storage_pools
@@ -568,8 +619,12 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
         :returns: src pool name list
         """
 
-        return [v for dic in self.migrate_storage_pools
-                for k, v in dic.items() if k == "src_pool"]
+        return [
+            v
+            for dic in self.migrate_storage_pools
+            for k, v in dic.items()
+            if k == "src_pool"
+        ]
 
     def get_instances(self):
         """Get migrate target instances
@@ -582,18 +637,22 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
         if not src_node_list:
             return None
 
-        return [i for i in self.nova.get_instance_list()
-                if i.host in src_node_list and
-                self.compute_model.has_node(i.uuid)]
+        return [
+            i
+            for i in self.nova.get_instance_list()
+            if i.host in src_node_list and self.compute_model.has_node(i.uuid)
+        ]
 
     def get_volumes(self):
         """Get migrate target volumes
 
         :returns: volume list on src pools and storage scope
         """
+
         def _is_src_type(volume, src_type):
-            return (src_type is None or
-                    (src_type is not None and volume.volume_type == src_type))
+            return src_type is None or (
+                src_type is not None and volume.volume_type == src_type
+            )
 
         target_volumes = []
         for volume in self.cinder.get_volume_list():
@@ -604,8 +663,9 @@ class ZoneMigration(base.ZoneMigrationBaseStrategy):
             for migrate_input in self.migrate_storage_pools:
                 src_pool = migrate_input["src_pool"]
                 src_type = migrate_input.get("src_type")
-                if (getattr(volume, 'os-vol-host-attr:host') == src_pool and
-                        _is_src_type(volume, src_type)):
+                if getattr(
+                    volume, 'os-vol-host-attr:host'
+                ) == src_pool and _is_src_type(volume, src_type):
                     target_volumes.append(volume)
                     # once the volume satisfies one the storage_pools
                     # inputs, we don't need to check the rest
@@ -703,8 +763,11 @@ class ActionCounter:
         if not self.is_total_max() and not self.is_pool_max(pool):
             self.per_pool_count[pool] += 1
             self.total_count += 1
-            LOG.debug("total: %s, per_pool: %s",
-                      self.total_count, self.per_pool_count)
+            LOG.debug(
+                "total: %s, per_pool: %s",
+                self.total_count,
+                self.per_pool_count,
+            )
             return True
         return False
 
@@ -720,8 +783,11 @@ class ActionCounter:
         if not self.is_total_max() and not self.is_node_max(node):
             self.per_node_count[node] += 1
             self.total_count += 1
-            LOG.debug("total: %s, per_node: %s",
-                      self.total_count, self.per_node_count)
+            LOG.debug(
+                "total: %s, per_node: %s",
+                self.total_count,
+                self.per_node_count,
+            )
             return True
         return False
 
@@ -739,8 +805,11 @@ class ActionCounter:
         """
         if pool not in self.per_pool_count:
             self.per_pool_count[pool] = 0
-        LOG.debug("the number of parallel per pool %s is %s ",
-                  pool, self.per_pool_count[pool])
+        LOG.debug(
+            "the number of parallel per pool %s is %s ",
+            pool,
+            self.per_pool_count[pool],
+        )
         LOG.debug("per pool limit is %s", self.per_pool_limit)
         return self.per_pool_count[pool] >= self.per_pool_limit
 
@@ -802,9 +871,7 @@ class SortMovingToFrontFilter(BaseFilter):
     """This is to move to front if a condition is True"""
 
     def exec_filter(self, items, sort_key):
-        return self.sort_moving_to_front(items,
-                                         sort_key,
-                                         self.compare_func)
+        return self.sort_moving_to_front(items, sort_key, self.compare_func)
 
     def sort_moving_to_front(self, items, sort_key=None, compare_func=None):
         if not compare_func or not sort_key:
@@ -945,22 +1012,29 @@ class ComputeSpecSortFilter(BaseFilter):
         flavors = self.nova.get_flavor_list()
 
         if sort_key == 'mem_size':
-            result = sorted(items,
-                            key=lambda x: float(self.get_mem_size(x, flavors)),
-                            reverse=True)
+            result = sorted(
+                items,
+                key=lambda x: float(self.get_mem_size(x, flavors)),
+                reverse=True,
+            )
         elif sort_key == 'vcpu_num':
-            result = sorted(items,
-                            key=lambda x: float(self.get_vcpu_num(x, flavors)),
-                            reverse=True)
+            result = sorted(
+                items,
+                key=lambda x: float(self.get_vcpu_num(x, flavors)),
+                reverse=True,
+            )
         elif sort_key == 'disk_size':
-            result = sorted(items,
-                            key=lambda x: float(
-                                self.get_disk_size(x, flavors)),
-                            reverse=True)
+            result = sorted(
+                items,
+                key=lambda x: float(self.get_disk_size(x, flavors)),
+                reverse=True,
+            )
         elif sort_key == 'created_at':
-            result = sorted(items,
-                            key=lambda x: timeutils.parse_isotime(x.created),
-                            reverse=False)
+            result = sorted(
+                items,
+                key=lambda x: timeutils.parse_isotime(x.created),
+                reverse=False,
+            )
 
         return result
 
@@ -1024,13 +1098,14 @@ class StorageSpecSortFilter(BaseFilter):
             return result
 
         if sort_key == 'created_at':
-            result = sorted(items,
-                            key=lambda x: timeutils.parse_isotime(
-                                getattr(x, sort_key)),
-                            reverse=False)
+            result = sorted(
+                items,
+                key=lambda x: timeutils.parse_isotime(getattr(x, sort_key)),
+                reverse=False,
+            )
         else:
-            result = sorted(items,
-                            key=lambda x: float(getattr(x, sort_key)),
-                            reverse=True)
+            result = sorted(
+                items, key=lambda x: float(getattr(x, sort_key)), reverse=True
+            )
         LOG.debug(result)
         return result
diff --git a/watcher/decision_engine/sync.py b/watcher/decision_engine/sync.py
index 54d0ec859..e20690717 100644
--- a/watcher/decision_engine/sync.py
+++ b/watcher/decision_engine/sync.py
@@ -27,16 +27,18 @@ from watcher.decision_engine.scoring import scoring_factory
 LOG = log.getLogger(__name__)
 
 GoalMapping = collections.namedtuple(
-    'GoalMapping', ['name', 'display_name', 'efficacy_specification'])
+    'GoalMapping', ['name', 'display_name', 'efficacy_specification']
+)
 StrategyMapping = collections.namedtuple(
-    'StrategyMapping',
-    ['name', 'goal_name', 'display_name', 'parameters_spec'])
+    'StrategyMapping', ['name', 'goal_name', 'display_name', 'parameters_spec']
+)
 ScoringEngineMapping = collections.namedtuple(
-    'ScoringEngineMapping',
-    ['name', 'description', 'metainfo'])
+    'ScoringEngineMapping', ['name', 'description', 'metainfo']
+)
 
 IndicatorSpec = collections.namedtuple(
-    'IndicatorSpec', ['name', 'description', 'unit', 'schema'])
+    'IndicatorSpec', ['name', 'description', 'unit', 'schema']
+)
 
 
 class Syncer:
@@ -79,11 +81,15 @@ class Syncer:
         if self._available_strategies is None:
             self._available_strategies = objects.Strategy.list(self.ctx)
             goal_ids = [g.id for g in self.available_goals]
-            stale_strategies = [s for s in self._available_strategies
-                                if s.goal_id not in goal_ids]
+            stale_strategies = [
+                s
+                for s in self._available_strategies
+                if s.goal_id not in goal_ids
+            ]
             for s in stale_strategies:
-                LOG.info("Can't find Goal id %d of strategy %s",
-                         s.goal_id, s.name)
+                LOG.info(
+                    "Can't find Goal id %d of strategy %s", s.goal_id, s.name
+                )
                 s.soft_delete()
                 self._available_strategies.remove(s)
         return self._available_strategies
@@ -92,8 +98,9 @@ class Syncer:
     def available_scoringengines(self):
         """Scoring Engines loaded from DB"""
         if self._available_scoringengines is None:
-            self._available_scoringengines = (objects.ScoringEngine
-                                              .list(self.ctx))
+            self._available_scoringengines = objects.ScoringEngine.list(
+                self.ctx
+            )
         return self._available_scoringengines
 
     @property
@@ -106,7 +113,9 @@ class Syncer:
                     display_name=g.display_name,
                     efficacy_specification=tuple(
                         IndicatorSpec(**item)
-                        for item in g.efficacy_specification)): g
+                        for item in g.efficacy_specification
+                    ),
+                ): g
                 for g in self.available_goals
             }
         return self._available_goals_map
@@ -117,9 +126,11 @@ class Syncer:
             goals_map = {g.id: g.name for g in self.available_goals}
             self._available_strategies_map = {
                 StrategyMapping(
-                    name=s.name, goal_name=goals_map[s.goal_id],
+                    name=s.name,
+                    goal_name=goals_map[s.goal_id],
                     display_name=s.display_name,
-                    parameters_spec=str(s.parameters_spec)): s
+                    parameters_spec=str(s.parameters_spec),
+                ): s
                 for s in self.available_strategies
             }
         return self._available_strategies_map
@@ -129,8 +140,8 @@ class Syncer:
         if self._available_scoringengines_map is None:
             self._available_scoringengines_map = {
                 ScoringEngineMapping(
-                    name=s.id, description=s.description,
-                    metainfo=s.metainfo): s
+                    name=s.id, description=s.description, metainfo=s.metainfo
+                ): s
                 for s in self.available_scoringengines
             }
         return self._available_scoringengines_map
@@ -149,9 +160,11 @@ class Syncer:
             self.goal_mapping.update(self._sync_goal(goal_map))
 
         for strategy_name, strategy_map in strategies_map.items():
-            if (strategy_map in self.available_strategies_map and
-                    strategy_map.goal_name not in
-                    [g.name for g in self.goal_mapping.values()]):
+            if (
+                strategy_map in self.available_strategies_map
+                and strategy_map.goal_name
+                not in [g.name for g in self.goal_mapping.values()]
+            ):
                 LOG.info("Strategy %s already exists", strategy_name)
                 continue
 
@@ -159,8 +172,7 @@ class Syncer:
 
         for se_name, se_map in scoringengines_map.items():
             if se_map in self.available_scoringengines_map:
-                LOG.info("Scoring Engine %s already exists",
-                         se_name)
+                LOG.info("Scoring Engine %s already exists", se_name)
                 continue
 
             self.se_mapping.update(self._sync_scoringengine(se_map))
@@ -172,8 +184,9 @@ class Syncer:
         goal_name = goal_map.name
         goal_mapping = dict()
         # Goals that are matching by name with the given discovered goal name
-        matching_goals = [g for g in self.available_goals
-                          if g.name == goal_name]
+        matching_goals = [
+            g for g in self.available_goals if g.name == goal_name
+        ]
         stale_goals = self._soft_delete_stale_goals(goal_map, matching_goals)
 
         if stale_goals or not matching_goals:
@@ -182,7 +195,8 @@ class Syncer:
             goal.display_name = goal_map.display_name
             goal.efficacy_specification = [
                 indicator._asdict()
-                for indicator in goal_map.efficacy_specification]
+                for indicator in goal_map.efficacy_specification
+            ]
             goal.create()
             LOG.info("Goal %s created", goal_name)
 
@@ -203,10 +217,12 @@ class Syncer:
 
         # Strategies that are matching by name with the given
         # discovered strategy name
-        matching_strategies = [s for s in self.available_strategies
-                               if s.name == strategy_name]
+        matching_strategies = [
+            s for s in self.available_strategies if s.name == strategy_name
+        ]
         stale_strategies = self._soft_delete_stale_strategies(
-            strategy_map, matching_strategies)
+            strategy_map, matching_strategies
+        )
 
         if stale_strategies or not matching_strategies:
             strategy = objects.Strategy(self.ctx)
@@ -229,10 +245,14 @@ class Syncer:
         scoringengine_name = scoringengine_map.name
         se_mapping = dict()
         # Scoring Engines matching by id with discovered Scoring engine
-        matching_scoringengines = [se for se in self.available_scoringengines
-                                   if se.name == scoringengine_name]
+        matching_scoringengines = [
+            se
+            for se in self.available_scoringengines
+            if se.name == scoringengine_name
+        ]
         stale_scoringengines = self._soft_delete_stale_scoringengines(
-            scoringengine_map, matching_scoringengines)
+            scoringengine_map, matching_scoringengines
+        )
 
         if stale_scoringengines or not matching_scoringengines:
             scoringengine = objects.ScoringEngine(self.ctx)
@@ -243,8 +263,9 @@ class Syncer:
             LOG.info("Scoring Engine %s created", scoringengine_name)
 
             # Updating the internal states
-            self.available_scoringengines_map[scoringengine] = \
+            self.available_scoringengines_map[scoringengine] = (
                 scoringengine_map
+            )
             # Map the old scoring engine names to the new (equivalent) SE
             for matching_scoringengine in matching_scoringengines:
                 se_mapping[matching_scoringengine.name] = scoringengine
@@ -277,56 +298,63 @@ class Syncer:
         # and soft delete stale audits and action plans
         for stale_audit_template in self.stale_audit_templates_map.values():
             stale_audit_template.save()
-            LOG.info("Audit Template '%s' synced",
-                     stale_audit_template.name)
+            LOG.info("Audit Template '%s' synced", stale_audit_template.name)
 
         for stale_audit in self.stale_audits_map.values():
             stale_audit.save()
-            LOG.info("Stale audit '%s' synced and cancelled",
-                     stale_audit.uuid)
+            LOG.info("Stale audit '%s' synced and cancelled", stale_audit.uuid)
 
         for stale_action_plan in self.stale_action_plans_map.values():
             stale_action_plan.save()
-            LOG.info("Stale action plan '%s' synced and cancelled",
-                     stale_action_plan.uuid)
+            LOG.info(
+                "Stale action plan '%s' synced and cancelled",
+                stale_action_plan.uuid,
+            )
 
     def _find_stale_audit_templates_due_to_goal(self):
         for goal_id, synced_goal in self.goal_mapping.items():
             filters = {"goal_id": goal_id}
             stale_audit_templates = objects.AuditTemplate.list(
-                self.ctx, filters=filters)
+                self.ctx, filters=filters
+            )
 
             # Update the goal ID for the stale audit templates (w/o saving)
             for audit_template in stale_audit_templates:
                 if audit_template.id not in self.stale_audit_templates_map:
                     audit_template.goal_id = synced_goal.id
                     self.stale_audit_templates_map[audit_template.id] = (
-                        audit_template)
+                        audit_template
+                    )
                 else:
                     self.stale_audit_templates_map[
-                        audit_template.id].goal_id = synced_goal.id
+                        audit_template.id
+                    ].goal_id = synced_goal.id
 
     def _find_stale_audit_templates_due_to_strategy(self):
         for strategy_id, synced_strategy in self.strategy_mapping.items():
             filters = {"strategy_id": strategy_id}
             stale_audit_templates = objects.AuditTemplate.list(
-                self.ctx, filters=filters)
+                self.ctx, filters=filters
+            )
 
             # Update strategy IDs for all stale audit templates (w/o saving)
             for audit_template in stale_audit_templates:
                 if audit_template.id not in self.stale_audit_templates_map:
                     audit_template.strategy_id = synced_strategy.id
                     self.stale_audit_templates_map[audit_template.id] = (
-                        audit_template)
+                        audit_template
+                    )
                 else:
                     self.stale_audit_templates_map[
-                        audit_template.id].strategy_id = synced_strategy.id
+                        audit_template.id
+                    ].strategy_id = synced_strategy.id
 
     def _find_stale_audits_due_to_goal(self):
         for goal_id, synced_goal in self.goal_mapping.items():
             filters = {"goal_id": goal_id}
             stale_audits = objects.Audit.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
 
             # Update the goal ID for the stale audits (w/o saving)
             for audit in stale_audits:
@@ -340,7 +368,8 @@ class Syncer:
         for strategy_id, synced_strategy in self.strategy_mapping.items():
             filters = {"strategy_id": strategy_id}
             stale_audits = objects.Audit.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
             # Update strategy IDs for all stale audits (w/o saving)
             for audit in stale_audits:
                 if audit.id not in self.stale_audits_map:
@@ -349,15 +378,18 @@ class Syncer:
                     self.stale_audits_map[audit.id] = audit
                 else:
                     self.stale_audits_map[
-                        audit.id].strategy_id = synced_strategy.id
+                        audit.id
+                    ].strategy_id = synced_strategy.id
                     self.stale_audits_map[
-                        audit.id].state = objects.audit.State.CANCELLED
+                        audit.id
+                    ].state = objects.audit.State.CANCELLED
 
     def _find_stale_action_plans_due_to_strategy(self):
         for strategy_id, synced_strategy in self.strategy_mapping.items():
             filters = {"strategy_id": strategy_id}
             stale_action_plans = objects.ActionPlan.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
 
             # Update strategy IDs for all stale action plans (w/o saving)
             for action_plan in stale_action_plans:
@@ -367,16 +399,18 @@ class Syncer:
                     self.stale_action_plans_map[action_plan.id] = action_plan
                 else:
                     self.stale_action_plans_map[
-                        action_plan.id].strategy_id = synced_strategy.id
+                        action_plan.id
+                    ].strategy_id = synced_strategy.id
                     self.stale_action_plans_map[
-                        action_plan.id].state = (
-                            objects.action_plan.State.CANCELLED)
+                        action_plan.id
+                    ].state = objects.action_plan.State.CANCELLED
 
     def _find_stale_action_plans_due_to_audit(self):
         for audit_id, synced_audit in self.stale_audits_map.items():
             filters = {"audit_id": audit_id}
             stale_action_plans = objects.ActionPlan.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
 
             # Update audit IDs for all stale action plans (w/o saving)
             for action_plan in stale_action_plans:
@@ -386,15 +420,18 @@ class Syncer:
                     self.stale_action_plans_map[action_plan.id] = action_plan
                 else:
                     self.stale_action_plans_map[
-                        action_plan.id].audit_id = synced_audit.id
+                        action_plan.id
+                    ].audit_id = synced_audit.id
                     self.stale_action_plans_map[
-                        action_plan.id].state = (
-                            objects.action_plan.State.CANCELLED)
+                        action_plan.id
+                    ].state = objects.action_plan.State.CANCELLED
 
     def _soft_delete_removed_goals(self):
         removed_goals = [
-            g for g in self.available_goals
-            if g.name not in self.discovered_map['goals']]
+            g
+            for g in self.available_goals
+            if g.name not in self.discovered_map['goals']
+        ]
         for removed_goal in removed_goals:
             removed_goal.soft_delete()
             filters = {"goal_id": removed_goal.id}
@@ -403,25 +440,32 @@ class Syncer:
             for at in invalid_ats:
                 LOG.warning(
                     "Audit Template '%(audit_template)s' references a "
-                    "goal that does not exist", audit_template=at.uuid)
+                    "goal that does not exist",
+                    audit_template=at.uuid,
+                )
 
             stale_audits = objects.Audit.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
             for audit in stale_audits:
                 LOG.warning(
-                    "Audit '%(audit)s' references a "
-                    "goal that does not exist", audit=audit.uuid)
+                    "Audit '%(audit)s' references a goal that does not exist",
+                    audit=audit.uuid,
+                )
                 if audit.id not in self.stale_audits_map:
                     audit.state = objects.audit.State.CANCELLED
                     self.stale_audits_map[audit.id] = audit
                 else:
                     self.stale_audits_map[
-                        audit.id].state = objects.audit.State.CANCELLED
+                        audit.id
+                    ].state = objects.audit.State.CANCELLED
 
     def _soft_delete_removed_strategies(self):
         removed_strategies = [
-            s for s in self.available_strategies
-            if s.name not in self.discovered_map['strategies']]
+            s
+            for s in self.available_strategies
+            if s.name not in self.discovered_map['strategies']
+        ]
 
         for removed_strategy in removed_strategies:
             removed_strategy.soft_delete()
@@ -431,7 +475,8 @@ class Syncer:
                 LOG.info(
                     "Audit Template '%(audit_template)s' references a "
                     "strategy that does not exist",
-                    audit_template=at.uuid)
+                    audit_template=at.uuid,
+                )
                 # In this case we can reset the strategy ID to None
                 # so the audit template can still achieve the same goal
                 # but with a different strategy
@@ -442,37 +487,45 @@ class Syncer:
                     self.stale_audit_templates_map[at.id].strategy_id = None
 
             stale_audits = objects.Audit.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
             for audit in stale_audits:
                 LOG.warning(
                     "Audit '%(audit)s' references a "
-                    "strategy that does not exist", audit=audit.uuid)
+                    "strategy that does not exist",
+                    audit=audit.uuid,
+                )
                 if audit.id not in self.stale_audits_map:
                     audit.state = objects.audit.State.CANCELLED
                     self.stale_audits_map[audit.id] = audit
                 else:
                     self.stale_audits_map[
-                        audit.id].state = objects.audit.State.CANCELLED
+                        audit.id
+                    ].state = objects.audit.State.CANCELLED
 
             stale_action_plans = objects.ActionPlan.list(
-                self.ctx, filters=filters, eager=True)
+                self.ctx, filters=filters, eager=True
+            )
             for action_plan in stale_action_plans:
                 LOG.warning(
                     "Action Plan '%(action_plan)s' references a "
                     "strategy that does not exist",
-                    action_plan=action_plan.uuid)
+                    action_plan=action_plan.uuid,
+                )
                 if action_plan.id not in self.stale_action_plans_map:
                     action_plan.state = objects.action_plan.State.CANCELLED
                     self.stale_action_plans_map[action_plan.id] = action_plan
                 else:
                     self.stale_action_plans_map[
-                        action_plan.id].state = (
-                            objects.action_plan.State.CANCELLED)
+                        action_plan.id
+                    ].state = objects.action_plan.State.CANCELLED
 
     def _soft_delete_removed_scoringengines(self):
         removed_se = [
-            se for se in self.available_scoringengines
-            if se.name not in self.discovered_map['scoringengines']]
+            se
+            for se in self.available_scoringengines
+            if se.name not in self.discovered_map['scoringengines']
+        ]
         for se in removed_se:
             LOG.info("Scoring Engine %s removed", se.name)
             se.soft_delete()
@@ -484,7 +537,8 @@ class Syncer:
         discovered_map = {
             "goals": goals_map,
             "strategies": strategies_map,
-            "scoringengines": scoringengines_map}
+            "scoringengines": scoringengines_map,
+        }
         goal_loader = default.DefaultGoalLoader()
         implemented_goals = goal_loader.list_available()
 
@@ -497,21 +551,26 @@ class Syncer:
                 display_name=goal_cls.get_translatable_display_name(),
                 efficacy_specification=tuple(
                     IndicatorSpec(**indicator.to_dict())
-                    for indicator in goal_cls.get_efficacy_specification(
-                    ).get_indicators_specifications()))
+                    for indicator in (
+                        goal_cls.get_efficacy_specification().get_indicators_specifications()
+                    )
+                ),
+            )
 
         for strategy_cls in implemented_strategies.values():
             strategies_map[strategy_cls.get_name()] = StrategyMapping(
                 name=strategy_cls.get_name(),
                 goal_name=strategy_cls.get_goal_name(),
                 display_name=strategy_cls.get_translatable_display_name(),
-                parameters_spec=str(strategy_cls.get_schema()))
+                parameters_spec=str(strategy_cls.get_schema()),
+            )
 
         for se in scoring_factory.get_scoring_engine_list():
             scoringengines_map[se.get_name()] = ScoringEngineMapping(
                 name=se.get_name(),
                 description=se.get_description(),
-                metainfo=se.get_metainfo())
+                metainfo=se.get_metainfo(),
+            )
 
         return discovered_map
 
@@ -531,8 +590,10 @@ class Syncer:
 
         stale_goals = []
         for matching_goal in matching_goals:
-            if (matching_goal.efficacy_specification == goal_efficacy_spec and
-                    matching_goal.display_name == goal_display_name):
+            if (
+                matching_goal.efficacy_specification == goal_efficacy_spec
+                and matching_goal.display_name == goal_display_name
+            ):
                 LOG.info("Goal %s unchanged", goal_name)
             else:
                 LOG.info("Goal %s modified", goal_name)
@@ -548,10 +609,12 @@ class Syncer:
 
         stale_strategies = []
         for matching_strategy in matching_strategies:
-            if (matching_strategy.display_name == strategy_display_name and
-                    matching_strategy.goal_id not in self.goal_mapping and
-                    matching_strategy.parameters_spec ==
-                    ast.literal_eval(parameters_spec)):
+            if (
+                matching_strategy.display_name == strategy_display_name
+                and matching_strategy.goal_id not in self.goal_mapping
+                and matching_strategy.parameters_spec
+                == ast.literal_eval(parameters_spec)
+            ):
                 LOG.info("Strategy %s unchanged", strategy_name)
             else:
                 LOG.info("Strategy %s modified", strategy_name)
@@ -561,15 +624,18 @@ class Syncer:
         return stale_strategies
 
     def _soft_delete_stale_scoringengines(
-            self, scoringengine_map, matching_scoringengines):
+        self, scoringengine_map, matching_scoringengines
+    ):
         se_name = scoringengine_map.name
         se_description = scoringengine_map.description
         se_metainfo = scoringengine_map.metainfo
 
         stale_scoringengines = []
         for matching_scoringengine in matching_scoringengines:
-            if (matching_scoringengine.description == se_description and
-                    matching_scoringengine.metainfo == se_metainfo):
+            if (
+                matching_scoringengine.description == se_description
+                and matching_scoringengine.metainfo == se_metainfo
+            ):
                 LOG.info("Scoring Engine %s unchanged", se_name)
             else:
                 LOG.info("Scoring Engine %s modified", se_name)
diff --git a/watcher/decision_engine/threading.py b/watcher/decision_engine/threading.py
index 0d2fed48f..112b96955 100644
--- a/watcher/decision_engine/threading.py
+++ b/watcher/decision_engine/threading.py
@@ -34,8 +34,9 @@ class DecisionEngineThreadPool(metaclass=service.Singleton):
 
     def __init__(self):
         self.amount_workers = CONF.watcher_decision_engine.max_general_workers
-        self._threadpool = (
-            executor.get_futurist_pool_executor(self.amount_workers))
+        self._threadpool = executor.get_futurist_pool_executor(
+            self.amount_workers
+        )
 
     def submit(self, fn, *args, **kwargs):
         """Will submit the job to the underlying threadpool
@@ -47,8 +48,9 @@ class DecisionEngineThreadPool(metaclass=service.Singleton):
         :rtype: :py:class"`futurist.GreenFuture`
         """
         # Statistics from the threadpool
-        executor.log_executor_stats(self._threadpool,
-                                    name="decision-engine-pool")
+        executor.log_executor_stats(
+            self._threadpool, name="decision-engine-pool"
+        )
         return self._threadpool.submit(fn, *args, **kwargs)
 
     @staticmethod
@@ -74,11 +76,13 @@ class DecisionEngineThreadPool(metaclass=service.Singleton):
         futures = copy.copy(futures)
 
         DecisionEngineThreadPool.do_while_futures_modify(
-            futures, fn, *args, futures_timeout=futures_timeout, **kwargs)
+            futures, fn, *args, futures_timeout=futures_timeout, **kwargs
+        )
 
     @staticmethod
-    def do_while_futures_modify(futures, fn, *args,
-                                futures_timeout=None, **kwargs):
+    def do_while_futures_modify(
+        futures, fn, *args, futures_timeout=None, **kwargs
+    ):
         """Do while to execute a function upon completion from a collection
 
         Will execute the specified function with its arguments when one of the
@@ -101,8 +105,10 @@ class DecisionEngineThreadPool(metaclass=service.Singleton):
             # In this scenario, we cancel the remaining pending futures and
             # break the loop, otherwise it may stay in the loop indefinitely.
             if not len(waits[0]):
-                LOG.warning("No futures finished during the timeout period, "
-                            "aborting remaining pending futures")
+                LOG.warning(
+                    "No futures finished during the timeout period, "
+                    "aborting remaining pending futures"
+                )
                 for future in waits[1]:
                     future.cancel()
                 break
diff --git a/watcher/eventlet.py b/watcher/eventlet.py
index 921de3ef5..d8f48baa7 100644
--- a/watcher/eventlet.py
+++ b/watcher/eventlet.py
@@ -27,14 +27,16 @@ def _monkey_patch():
     # patching. eventlet processes environment variables at import-time.
     # as such any eventlet configuration should happen here if needed.
     import eventlet
+
     eventlet.monkey_patch()
     global MONKEY_PATCHED
     MONKEY_PATCHED = True
 
 
 def _is_patching_enabled():
-    if (os.environ.get('OS_WATCHER_DISABLE_EVENTLET_PATCHING', '').lower()
-            not in ('1', 'true', 'yes', 'y')):
+    if os.environ.get(
+        'OS_WATCHER_DISABLE_EVENTLET_PATCHING', ''
+    ).lower() not in ('1', 'true', 'yes', 'y'):
         return True
     return False
 
diff --git a/watcher/hacking/checks.py b/watcher/hacking/checks.py
index 142f73722..4d1c2cd66 100644
--- a/watcher/hacking/checks.py
+++ b/watcher/hacking/checks.py
@@ -40,8 +40,8 @@ def flake8ext(f):
 
 _all_log_levels = {
     'reserved': '_',  # this should never be used with a log unless
-                      # it is a variable used for a log message and
-                      # a exception
+    # it is a variable used for a log message and
+    # a exception
     'error': '_LE',
     'info': '_LI',
     'warning': '_LW',
@@ -53,13 +53,11 @@ _all_hints = set(_all_log_levels.values())
 
 def _regex_for_level(level, hint):
     return r".*LOG\.{level}\(\s*(({wrong_hints})\(|'|\")".format(
-        level=level,
-        wrong_hints='|'.join(_all_hints - {hint}),
+        level=level, wrong_hints='|'.join(_all_hints - {hint})
     )
 
 
-log_warn = re.compile(
-    r"(.)*LOG\.(warn)\(\s*('|\"|_)")
+log_warn = re.compile(r"(.)*LOG\.(warn)\(\s*('|\"|_)")
 unittest_imports_dot = re.compile(r"\bimport[\s]+unittest\b")
 unittest_imports_from = re.compile(r"\bfrom[\s]+unittest\b")
 re_redundant_import_alias = re.compile(r".*import (.+) as \1$")
@@ -115,20 +113,24 @@ def check_assert_called_once_with(logical_line, filename):
 
         check_calls = ['.assertcalledonce', '.calledoncewith']
         if any(x for x in check_calls if x in uncased_line):
-            msg = ("N322: Possible use of no-op mock method. "
-                   "please use assert_called_once_with.")
+            msg = (
+                "N322: Possible use of no-op mock method. "
+                "please use assert_called_once_with."
+            )
             yield (0, msg)
 
         if '.asserthascalled' in uncased_line:
-            msg = ("N322: Possible use of no-op mock method. "
-                   "please use assert_has_calls.")
+            msg = (
+                "N322: Possible use of no-op mock method. "
+                "please use assert_has_calls."
+            )
             yield (0, msg)
 
 
 @flake8ext
 def check_python3_no_iteritems(logical_line):
     if re.search(r".*\.iteritems\(\)", logical_line):
-        msg = ("N327: Use dict.items() instead of dict.iteritems().")
+        msg = "N327: Use dict.items() instead of dict.iteritems()."
         yield (0, msg)
 
 
@@ -136,12 +138,16 @@ def check_python3_no_iteritems(logical_line):
 def check_asserttrue(logical_line, filename):
     if 'watcher/tests/' in filename:
         if re.search(r"assertEqual\(\s*True,[^,]*(,[^,]*)?\)", logical_line):
-            msg = ("N328: Use assertTrue(observed) instead of "
-                   "assertEqual(True, observed)")
+            msg = (
+                "N328: Use assertTrue(observed) instead of "
+                "assertEqual(True, observed)"
+            )
             yield (0, msg)
         if re.search(r"assertEqual\([^,]*,\s*True(,[^,]*)?\)", logical_line):
-            msg = ("N328: Use assertTrue(observed) instead of "
-                   "assertEqual(True, observed)")
+            msg = (
+                "N328: Use assertTrue(observed) instead of "
+                "assertEqual(True, observed)"
+            )
             yield (0, msg)
 
 
@@ -149,21 +155,27 @@ def check_asserttrue(logical_line, filename):
 def check_assertfalse(logical_line, filename):
     if 'watcher/tests/' in filename:
         if re.search(r"assertEqual\(\s*False,[^,]*(,[^,]*)?\)", logical_line):
-            msg = ("N329: Use assertFalse(observed) instead of "
-                   "assertEqual(False, observed)")
+            msg = (
+                "N329: Use assertFalse(observed) instead of "
+                "assertEqual(False, observed)"
+            )
             yield (0, msg)
         if re.search(r"assertEqual\([^,]*,\s*False(,[^,]*)?\)", logical_line):
-            msg = ("N329: Use assertFalse(observed) instead of "
-                   "assertEqual(False, observed)")
+            msg = (
+                "N329: Use assertFalse(observed) instead of "
+                "assertEqual(False, observed)"
+            )
             yield (0, msg)
 
 
 @flake8ext
 def check_assertempty(logical_line, filename):
     if 'watcher/tests/' in filename:
-        msg = ("N330: Use assertEqual(*empty*, observed) instead of "
-               "assertEqual(observed, *empty*). *empty* contains "
-               "{}, [], (), set(), '', \"\"")
+        msg = (
+            "N330: Use assertEqual(*empty*, observed) instead of "
+            "assertEqual(observed, *empty*). *empty* contains "
+            "{}, [], (), set(), '', \"\""
+        )
         empties = r"(\[\s*\]|\{\s*\}|\(\s*\)|set\(\s*\)|'\s*'|\"\s*\")"
         reg = rf"assertEqual\(([^,]*,\s*)+?{empties}\)\s*$"
         if re.search(reg, logical_line):
@@ -173,20 +185,26 @@ def check_assertempty(logical_line, filename):
 @flake8ext
 def check_assertisinstance(logical_line, filename):
     if 'watcher/tests/' in filename:
-        if re.search(r"assertTrue\(\s*isinstance\(\s*[^,]*,\s*[^,]*\)\)",
-                     logical_line):
-            msg = ("N331: Use assertIsInstance(observed, type) instead "
-                   "of assertTrue(isinstance(observed, type))")
+        if re.search(
+            r"assertTrue\(\s*isinstance\(\s*[^,]*,\s*[^,]*\)\)", logical_line
+        ):
+            msg = (
+                "N331: Use assertIsInstance(observed, type) instead "
+                "of assertTrue(isinstance(observed, type))"
+            )
             yield (0, msg)
 
 
 @flake8ext
 def check_assertequal_for_httpcode(logical_line, filename):
-    msg = ("N332: Use assertEqual(expected_http_code, observed_http_code) "
-           "instead of assertEqual(observed_http_code, expected_http_code)")
+    msg = (
+        "N332: Use assertEqual(expected_http_code, observed_http_code) "
+        "instead of assertEqual(observed_http_code, expected_http_code)"
+    )
     if 'watcher/tests/' in filename:
-        if re.search(r"assertEqual\(\s*[^,]*,[^,]*HTTP[^\.]*\.code\s*\)",
-                     logical_line):
+        if re.search(
+            r"assertEqual\(\s*[^,]*,[^,]*HTTP[^\.]*\.code\s*\)", logical_line
+        ):
             yield (0, msg)
 
 
@@ -212,12 +230,16 @@ def check_oslo_i18n_wrapper(logical_line, filename, noqa):
     modulename = os.path.normpath(filename).split('/')[0]
     bad_i18n_module = f'{modulename}.i18n'
 
-    if (len(split_line) > 1 and split_line[0] in ('import', 'from')):
-        if (split_line[1] == bad_i18n_module or
-            modulename != 'watcher' and split_line[1] in ('watcher.i18n',
-                                                          'watcher._i18n')):
-            msg = (f"N340: {split_line[1]} is found. Use "
-                   f"{modulename}._i18n instead.")
+    if len(split_line) > 1 and split_line[0] in ('import', 'from'):
+        if (
+            split_line[1] == bad_i18n_module
+            or modulename != 'watcher'
+            and split_line[1] in ('watcher.i18n', 'watcher._i18n')
+        ):
+            msg = (
+                f"N340: {split_line[1]} is found. Use "
+                f"{modulename}._i18n instead."
+            )
             yield (0, msg)
 
 
@@ -249,14 +271,19 @@ def check_builtins_gettext(logical_line, tokens, filename, lines, noqa):
         i18n_import_line_found = False
         for line in lines:
             split_line = [elm.rstrip(',') for elm in line.split()]
-            if (len(split_line) > 1 and split_line[0] == 'from' and
-                    split_line[1] == i18n_wrapper and
-                    '_' in split_line):
+            if (
+                len(split_line) > 1
+                and split_line[0] == 'from'
+                and split_line[1] == i18n_wrapper
+                and '_' in split_line
+            ):
                 i18n_import_line_found = True
                 break
         if not i18n_import_line_found:
-            msg = ("N341: _ from python builtins module is used. "
-                   f"Use _ from {i18n_wrapper} instead.")
+            msg = (
+                "N341: _ from python builtins module is used. "
+                f"Use _ from {i18n_wrapper} instead."
+            )
             yield (0, msg)
 
 
diff --git a/watcher/notifications/action.py b/watcher/notifications/action.py
index bc8fece33..e71679dc8 100644
--- a/watcher/notifications/action.py
+++ b/watcher/notifications/action.py
@@ -34,16 +34,13 @@ CONF = cfg.CONF
 class ActionPayload(notificationbase.NotificationPayloadBase):
     SCHEMA = {
         'uuid': ('action', 'uuid'),
-
         'action_type': ('action', 'action_type'),
         'input_parameters': ('action', 'input_parameters'),
         'state': ('action', 'state'),
         'parents': ('action', 'parents'),
-
         'created_at': ('action', 'created_at'),
         'updated_at': ('action', 'updated_at'),
         'deleted_at': ('action', 'deleted_at'),
-
         'status_message': ('action', 'status_message'),
     }
 
@@ -60,7 +57,6 @@ class ActionPayload(notificationbase.NotificationPayloadBase):
         'action_plan_uuid': wfields.UUIDField(),
         'action_plan': wfields.ObjectField('TerseActionPlanPayload'),
         'status_message': wfields.StringField(nullable=True),
-
         'created_at': wfields.DateTimeField(nullable=True),
         'updated_at': wfields.DateTimeField(nullable=True),
         'deleted_at': wfields.DateTimeField(nullable=True),
@@ -92,9 +88,7 @@ class ActionCreatePayload(ActionPayload):
     fields = {}
 
     def __init__(self, action, action_plan):
-        super().__init__(
-            action=action,
-            action_plan=action_plan)
+        super().__init__(action=action, action_plan=action_plan)
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -102,15 +96,12 @@ class ActionUpdatePayload(ActionPayload):
     # Version 1.0: Initial version
     # Version 1.1: Added 'status_message' field
     VERSION = '1.1'
-    fields = {
-        'state_update': wfields.ObjectField('ActionStateUpdatePayload'),
-    }
+    fields = {'state_update': wfields.ObjectField('ActionStateUpdatePayload')}
 
     def __init__(self, action, state_update, action_plan):
         super().__init__(
-            action=action,
-            state_update=state_update,
-            action_plan=action_plan)
+            action=action, state_update=state_update, action_plan=action_plan
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -118,15 +109,10 @@ class ActionExecutionPayload(ActionPayload):
     # Version 1.0: Initial version
     # Version 1.1: Added 'status_message' field
     VERSION = '1.1'
-    fields = {
-        'fault': wfields.ObjectField('ExceptionPayload', nullable=True),
-    }
+    fields = {'fault': wfields.ObjectField('ExceptionPayload', nullable=True)}
 
     def __init__(self, action, action_plan, **kwargs):
-        super().__init__(
-            action=action,
-            action_plan=action_plan,
-            **kwargs)
+        super().__init__(action=action, action_plan=action_plan, **kwargs)
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -134,15 +120,10 @@ class ActionCancelPayload(ActionPayload):
     # Version 1.0: Initial version
     # Version 1.1: Added 'status_message' field
     VERSION = '1.1'
-    fields = {
-        'fault': wfields.ObjectField('ExceptionPayload', nullable=True),
-    }
+    fields = {'fault': wfields.ObjectField('ExceptionPayload', nullable=True)}
 
     def __init__(self, action, action_plan, **kwargs):
-        super().__init__(
-            action=action,
-            action_plan=action_plan,
-            **kwargs)
+        super().__init__(action=action, action_plan=action_plan, **kwargs)
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -153,9 +134,7 @@ class ActionDeletePayload(ActionPayload):
     fields = {}
 
     def __init__(self, action, action_plan):
-        super().__init__(
-            action=action,
-            action_plan=action_plan)
+        super().__init__(action=action, action_plan=action_plan)
 
 
 @notificationbase.notification_sample('action-execution-error.json')
@@ -166,9 +145,7 @@ class ActionExecutionNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionExecutionPayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionExecutionPayload')}
 
 
 @notificationbase.notification_sample('action-create.json')
@@ -177,9 +154,7 @@ class ActionCreateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionCreatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionCreatePayload')}
 
 
 @notificationbase.notification_sample('action-update.json')
@@ -188,9 +163,7 @@ class ActionUpdateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionUpdatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionUpdatePayload')}
 
 
 @notificationbase.notification_sample('action-delete.json')
@@ -199,9 +172,7 @@ class ActionDeleteNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionDeletePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionDeletePayload')}
 
 
 @notificationbase.notification_sample('action-cancel-error.json')
@@ -212,9 +183,7 @@ class ActionCancelNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionCancelPayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionCancelPayload')}
 
 
 def _get_action_plan_payload(action):
@@ -223,18 +192,21 @@ def _get_action_plan_payload(action):
     audit = None
     try:
         action_plan = action.action_plan
-        audit = objects.Audit.get(wcontext.make_context(show_deleted=True),
-                                  action_plan.audit_id)
+        audit = objects.Audit.get(
+            wcontext.make_context(show_deleted=True), action_plan.audit_id
+        )
         if audit.strategy_id:
             strategy_uuid = objects.Strategy.get(
-                wcontext.make_context(show_deleted=True),
-                audit.strategy_id).uuid
+                wcontext.make_context(show_deleted=True), audit.strategy_id
+            ).uuid
     except NotImplementedError:
         raise exception.EagerlyLoadedActionRequired(action=action.uuid)
 
     action_plan_payload = ap_notifications.TerseActionPlanPayload(
         action_plan=action_plan,
-        audit_uuid=audit.uuid, strategy_uuid=strategy_uuid)
+        audit_uuid=audit.uuid,
+        strategy_uuid=strategy_uuid,
+    )
 
     return action_plan_payload
 
@@ -244,25 +216,26 @@ def send_create(context, action, service='infra-optim', host=None):
     action_plan_payload = _get_action_plan_payload(action)
 
     versioned_payload = ActionCreatePayload(
-        action=action,
-        action_plan=action_plan_payload,
+        action=action, action_plan=action_plan_payload
     )
 
     notification = ActionCreateNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='action',
-            action=wfields.NotificationAction.CREATE),
+            object='action', action=wfields.NotificationAction.CREATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_update(context, action, service='infra-optim',
-                host=None, old_state=None):
+def send_update(
+    context, action, service='infra-optim', host=None, old_state=None
+):
     """Emit an action.update notification."""
     action_plan_payload = _get_action_plan_payload(action)
 
@@ -270,9 +243,11 @@ def send_update(context, action, service='infra-optim',
         old_state=old_state,
         state=action.state if old_state else None,
         status_message=(
-            action.status_message if old_state and
-            action.status_message else None)
-        )
+            action.status_message
+            if old_state and action.status_message
+            else None
+        ),
+    )
 
     versioned_payload = ActionUpdatePayload(
         action=action,
@@ -283,12 +258,13 @@ def send_update(context, action, service='infra-optim',
     notification = ActionUpdateNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='action',
-            action=wfields.NotificationAction.UPDATE),
+            object='action', action=wfields.NotificationAction.UPDATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
@@ -298,26 +274,32 @@ def send_delete(context, action, service='infra-optim', host=None):
     action_plan_payload = _get_action_plan_payload(action)
 
     versioned_payload = ActionDeletePayload(
-        action=action,
-        action_plan=action_plan_payload,
+        action=action, action_plan=action_plan_payload
     )
 
     notification = ActionDeleteNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='action',
-            action=wfields.NotificationAction.DELETE),
+            object='action', action=wfields.NotificationAction.DELETE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_execution_notification(context, action, notification_action, phase,
-                                priority=wfields.NotificationPriority.INFO,
-                                service='infra-optim', host=None):
+def send_execution_notification(
+    context,
+    action,
+    notification_action,
+    phase,
+    priority=wfields.NotificationPriority.INFO,
+    service='infra-optim',
+    host=None,
+):
     """Emit an action execution notification."""
     action_plan_payload = _get_action_plan_payload(action)
 
@@ -326,28 +308,32 @@ def send_execution_notification(context, action, notification_action, phase,
         fault = exception_notifications.ExceptionPayload.from_exception()
 
     versioned_payload = ActionExecutionPayload(
-        action=action,
-        action_plan=action_plan_payload,
-        fault=fault,
+        action=action, action_plan=action_plan_payload, fault=fault
     )
 
     notification = ActionExecutionNotification(
         priority=priority,
         event_type=notificationbase.EventType(
-            object='action',
-            action=notification_action,
-            phase=phase),
+            object='action', action=notification_action, phase=phase
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_cancel_notification(context, action, notification_action, phase,
-                             priority=wfields.NotificationPriority.INFO,
-                             service='infra-optim', host=None):
+def send_cancel_notification(
+    context,
+    action,
+    notification_action,
+    phase,
+    priority=wfields.NotificationPriority.INFO,
+    service='infra-optim',
+    host=None,
+):
     """Emit an action cancel notification."""
     action_plan_payload = _get_action_plan_payload(action)
 
@@ -356,20 +342,18 @@ def send_cancel_notification(context, action, notification_action, phase,
         fault = exception_notifications.ExceptionPayload.from_exception()
 
     versioned_payload = ActionCancelPayload(
-        action=action,
-        action_plan=action_plan_payload,
-        fault=fault,
+        action=action, action_plan=action_plan_payload, fault=fault
     )
 
     notification = ActionCancelNotification(
         priority=priority,
         event_type=notificationbase.EventType(
-            object='action',
-            action=notification_action,
-            phase=phase),
+            object='action', action=notification_action, phase=phase
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
diff --git a/watcher/notifications/action_plan.py b/watcher/notifications/action_plan.py
index daa08559c..527402448 100644
--- a/watcher/notifications/action_plan.py
+++ b/watcher/notifications/action_plan.py
@@ -35,11 +35,9 @@ CONF = cfg.CONF
 class TerseActionPlanPayload(notificationbase.NotificationPayloadBase):
     SCHEMA = {
         'uuid': ('action_plan', 'uuid'),
-
         'state': ('action_plan', 'state'),
         'global_efficacy': ('action_plan', 'global_efficacy'),
         'status_message': ('action_plan', 'status_message'),
-
         'created_at': ('action_plan', 'created_at'),
         'updated_at': ('action_plan', 'updated_at'),
         'deleted_at': ('action_plan', 'deleted_at'),
@@ -57,16 +55,13 @@ class TerseActionPlanPayload(notificationbase.NotificationPayloadBase):
         'audit_uuid': wfields.UUIDField(),
         'strategy_uuid': wfields.UUIDField(nullable=True),
         'status_message': wfields.StringField(nullable=True),
-
         'created_at': wfields.DateTimeField(nullable=True),
         'updated_at': wfields.DateTimeField(nullable=True),
         'deleted_at': wfields.DateTimeField(nullable=True),
     }
 
     def __init__(self, action_plan, audit=None, strategy=None, **kwargs):
-        super().__init__(audit=audit,
-                         strategy=strategy,
-                         **kwargs)
+        super().__init__(audit=audit, strategy=strategy, **kwargs)
         self.populate_schema(action_plan=action_plan)
 
 
@@ -74,11 +69,9 @@ class TerseActionPlanPayload(notificationbase.NotificationPayloadBase):
 class ActionPlanPayload(TerseActionPlanPayload):
     SCHEMA = {
         'uuid': ('action_plan', 'uuid'),
-
         'state': ('action_plan', 'state'),
         'global_efficacy': ('action_plan', 'global_efficacy'),
         'status_message': ('action_plan', 'status_message'),
-
         'created_at': ('action_plan', 'created_at'),
         'updated_at': ('action_plan', 'updated_at'),
         'deleted_at': ('action_plan', 'deleted_at'),
@@ -101,8 +94,7 @@ class ActionPlanPayload(TerseActionPlanPayload):
         if strategy and not kwargs.get('strategy_uuid'):
             kwargs['strategy_uuid'] = strategy.uuid
 
-        super().__init__(
-            action_plan, audit=audit, strategy=strategy, **kwargs)
+        super().__init__(action_plan, audit=audit, strategy=strategy, **kwargs)
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -128,9 +120,8 @@ class ActionPlanCreatePayload(ActionPlanPayload):
 
     def __init__(self, action_plan, audit, strategy):
         super().__init__(
-            action_plan=action_plan,
-            audit=audit,
-            strategy=strategy)
+            action_plan=action_plan, audit=audit, strategy=strategy
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -140,7 +131,7 @@ class ActionPlanUpdatePayload(ActionPlanPayload):
     # Version 1.2: Added 'status_message' field
     VERSION = '1.2'
     fields = {
-        'state_update': wfields.ObjectField('ActionPlanStateUpdatePayload'),
+        'state_update': wfields.ObjectField('ActionPlanStateUpdatePayload')
     }
 
     def __init__(self, action_plan, state_update, audit, strategy):
@@ -148,7 +139,8 @@ class ActionPlanUpdatePayload(ActionPlanPayload):
             action_plan=action_plan,
             state_update=state_update,
             audit=audit,
-            strategy=strategy)
+            strategy=strategy,
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -157,16 +149,12 @@ class ActionPlanActionPayload(ActionPlanPayload):
     # Version 1.1: Changed global_efficacy_type
     # Version 1.2: Added 'status_message' field
     VERSION = '1.2'
-    fields = {
-        'fault': wfields.ObjectField('ExceptionPayload', nullable=True),
-    }
+    fields = {'fault': wfields.ObjectField('ExceptionPayload', nullable=True)}
 
     def __init__(self, action_plan, audit, strategy, **kwargs):
         super().__init__(
-            action_plan=action_plan,
-            audit=audit,
-            strategy=strategy,
-            **kwargs)
+            action_plan=action_plan, audit=audit, strategy=strategy, **kwargs
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -179,9 +167,8 @@ class ActionPlanDeletePayload(ActionPlanPayload):
 
     def __init__(self, action_plan, audit, strategy):
         super().__init__(
-            action_plan=action_plan,
-            audit=audit,
-            strategy=strategy)
+            action_plan=action_plan, audit=audit, strategy=strategy
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -190,16 +177,12 @@ class ActionPlanCancelPayload(ActionPlanPayload):
     # Version 1.1: Changed global_efficacy_type
     # Version 1.2: Added 'status_message' field
     VERSION = '1.2'
-    fields = {
-        'fault': wfields.ObjectField('ExceptionPayload', nullable=True),
-    }
+    fields = {'fault': wfields.ObjectField('ExceptionPayload', nullable=True)}
 
     def __init__(self, action_plan, audit, strategy, **kwargs):
         super().__init__(
-            action_plan=action_plan,
-            audit=audit,
-            strategy=strategy,
-            **kwargs)
+            action_plan=action_plan, audit=audit, strategy=strategy, **kwargs
+        )
 
 
 @notificationbase.notification_sample('action_plan-execution-error.json')
@@ -210,9 +193,7 @@ class ActionPlanActionNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionPlanActionPayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionPlanActionPayload')}
 
 
 @notificationbase.notification_sample('action_plan-create.json')
@@ -221,9 +202,7 @@ class ActionPlanCreateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionPlanCreatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionPlanCreatePayload')}
 
 
 @notificationbase.notification_sample('action_plan-update.json')
@@ -232,9 +211,7 @@ class ActionPlanUpdateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionPlanUpdatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionPlanUpdatePayload')}
 
 
 @notificationbase.notification_sample('action_plan-delete.json')
@@ -243,9 +220,7 @@ class ActionPlanDeleteNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionPlanDeletePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionPlanDeletePayload')}
 
 
 @notificationbase.notification_sample('action_plan-cancel-error.json')
@@ -256,9 +231,7 @@ class ActionPlanCancelNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ActionPlanCancelPayload')
-    }
+    fields = {'payload': wfields.ObjectField('ActionPlanCancelPayload')}
 
 
 def _get_common_payload(action_plan):
@@ -269,15 +242,19 @@ def _get_common_payload(action_plan):
         strategy = action_plan.strategy
     except NotImplementedError:
         raise exception.EagerlyLoadedActionPlanRequired(
-            action_plan=action_plan.uuid)
+            action_plan=action_plan.uuid
+        )
 
     goal = objects.Goal.get(
-        wcontext.make_context(show_deleted=True), audit.goal_id)
+        wcontext.make_context(show_deleted=True), audit.goal_id
+    )
     audit_payload = audit_notifications.TerseAuditPayload(
-        audit=audit, goal_uuid=goal.uuid)
+        audit=audit, goal_uuid=goal.uuid
+    )
 
     strategy_payload = strategy_notifications.StrategyPayload(
-        strategy=strategy)
+        strategy=strategy
+    )
 
     return audit_payload, strategy_payload
 
@@ -287,26 +264,26 @@ def send_create(context, action_plan, service='infra-optim', host=None):
     audit_payload, strategy_payload = _get_common_payload(action_plan)
 
     versioned_payload = ActionPlanCreatePayload(
-        action_plan=action_plan,
-        audit=audit_payload,
-        strategy=strategy_payload,
+        action_plan=action_plan, audit=audit_payload, strategy=strategy_payload
     )
 
     notification = ActionPlanCreateNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='action_plan',
-            action=wfields.NotificationAction.CREATE),
+            object='action_plan', action=wfields.NotificationAction.CREATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_update(context, action_plan, service='infra-optim',
-                host=None, old_state=None):
+def send_update(
+    context, action_plan, service='infra-optim', host=None, old_state=None
+):
     """Emit an action_plan.update notification."""
     audit_payload, strategy_payload = _get_common_payload(action_plan)
 
@@ -314,9 +291,11 @@ def send_update(context, action_plan, service='infra-optim',
         old_state=old_state,
         state=action_plan.state if old_state else None,
         status_message=(
-            action_plan.status_message if old_state and
-            action_plan.status_message else None)
-        )
+            action_plan.status_message
+            if old_state and action_plan.status_message
+            else None
+        ),
+    )
 
     versioned_payload = ActionPlanUpdatePayload(
         action_plan=action_plan,
@@ -328,12 +307,13 @@ def send_update(context, action_plan, service='infra-optim',
     notification = ActionPlanUpdateNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='action_plan',
-            action=wfields.NotificationAction.UPDATE),
+            object='action_plan', action=wfields.NotificationAction.UPDATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
@@ -343,27 +323,32 @@ def send_delete(context, action_plan, service='infra-optim', host=None):
     audit_payload, strategy_payload = _get_common_payload(action_plan)
 
     versioned_payload = ActionPlanDeletePayload(
-        action_plan=action_plan,
-        audit=audit_payload,
-        strategy=strategy_payload,
+        action_plan=action_plan, audit=audit_payload, strategy=strategy_payload
     )
 
     notification = ActionPlanDeleteNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='action_plan',
-            action=wfields.NotificationAction.DELETE),
+            object='action_plan', action=wfields.NotificationAction.DELETE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_action_notification(context, action_plan, action, phase=None,
-                             priority=wfields.NotificationPriority.INFO,
-                             service='infra-optim', host=None):
+def send_action_notification(
+    context,
+    action_plan,
+    action,
+    phase=None,
+    priority=wfields.NotificationPriority.INFO,
+    service='infra-optim',
+    host=None,
+):
     """Emit an action_plan action notification."""
     audit_payload, strategy_payload = _get_common_payload(action_plan)
 
@@ -381,20 +366,26 @@ def send_action_notification(context, action_plan, action, phase=None,
     notification = ActionPlanActionNotification(
         priority=priority,
         event_type=notificationbase.EventType(
-            object='action_plan',
-            action=action,
-            phase=phase),
+            object='action_plan', action=action, phase=phase
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_cancel_notification(context, action_plan, action, phase=None,
-                             priority=wfields.NotificationPriority.INFO,
-                             service='infra-optim', host=None):
+def send_cancel_notification(
+    context,
+    action_plan,
+    action,
+    phase=None,
+    priority=wfields.NotificationPriority.INFO,
+    service='infra-optim',
+    host=None,
+):
     """Emit an action_plan cancel notification."""
     audit_payload, strategy_payload = _get_common_payload(action_plan)
 
@@ -412,12 +403,12 @@ def send_cancel_notification(context, action_plan, action, phase=None,
     notification = ActionPlanCancelNotification(
         priority=priority,
         event_type=notificationbase.EventType(
-            object='action_plan',
-            action=action,
-            phase=phase),
+            object='action_plan', action=action, phase=phase
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
diff --git a/watcher/notifications/audit.py b/watcher/notifications/audit.py
index b3930d07e..df3f2a51f 100644
--- a/watcher/notifications/audit.py
+++ b/watcher/notifications/audit.py
@@ -41,11 +41,9 @@ class TerseAuditPayload(notificationbase.NotificationPayloadBase):
         'scope': ('audit', 'scope'),
         'auto_trigger': ('audit', 'auto_trigger'),
         'next_run_time': ('audit', 'next_run_time'),
-
         'created_at': ('audit', 'created_at'),
         'updated_at': ('audit', 'updated_at'),
         'deleted_at': ('audit', 'deleted_at'),
-
         'status_message': ('audit', 'status_message'),
     }
 
@@ -69,17 +67,16 @@ class TerseAuditPayload(notificationbase.NotificationPayloadBase):
         'strategy_uuid': wfields.UUIDField(nullable=True),
         'auto_trigger': wfields.BooleanField(),
         'next_run_time': wfields.DateTimeField(nullable=True),
-
         'created_at': wfields.DateTimeField(nullable=True),
         'updated_at': wfields.DateTimeField(nullable=True),
         'deleted_at': wfields.DateTimeField(nullable=True),
-
         'status_message': wfields.StringField(nullable=True),
     }
 
     def __init__(self, audit, goal_uuid, strategy_uuid=None, **kwargs):
         super().__init__(
-            goal_uuid=goal_uuid, strategy_uuid=strategy_uuid, **kwargs)
+            goal_uuid=goal_uuid, strategy_uuid=strategy_uuid, **kwargs
+        )
         self.populate_schema(audit=audit)
 
 
@@ -95,11 +92,9 @@ class AuditPayload(TerseAuditPayload):
         'scope': ('audit', 'scope'),
         'auto_trigger': ('audit', 'auto_trigger'),
         'next_run_time': ('audit', 'next_run_time'),
-
         'created_at': ('audit', 'created_at'),
         'updated_at': ('audit', 'updated_at'),
         'deleted_at': ('audit', 'deleted_at'),
-
         'status_message': ('audit', 'status_message'),
     }
 
@@ -122,9 +117,7 @@ class AuditPayload(TerseAuditPayload):
         if strategy and not kwargs.get('strategy_uuid'):
             kwargs['strategy_uuid'] = strategy.uuid
 
-        super().__init__(
-            audit=audit, goal=goal,
-            strategy=strategy, **kwargs)
+        super().__init__(audit=audit, goal=goal, strategy=strategy, **kwargs)
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -151,10 +144,8 @@ class AuditCreatePayload(AuditPayload):
 
     def __init__(self, audit, goal, strategy):
         super().__init__(
-            audit=audit,
-            goal=goal,
-            goal_uuid=goal.uuid,
-            strategy=strategy)
+            audit=audit, goal=goal, goal_uuid=goal.uuid, strategy=strategy
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -164,9 +155,7 @@ class AuditUpdatePayload(AuditPayload):
     #              Added 'next_run_time' field
     # Version 1.2: Added 'status_message' string field
     VERSION = '1.2'
-    fields = {
-        'state_update': wfields.ObjectField('AuditStateUpdatePayload'),
-    }
+    fields = {'state_update': wfields.ObjectField('AuditStateUpdatePayload')}
 
     def __init__(self, audit, state_update, goal, strategy):
         super().__init__(
@@ -174,7 +163,8 @@ class AuditUpdatePayload(AuditPayload):
             state_update=state_update,
             goal=goal,
             goal_uuid=goal.uuid,
-            strategy=strategy)
+            strategy=strategy,
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -184,9 +174,7 @@ class AuditActionPayload(AuditPayload):
     #              Added 'next_run_time' field
     # Version 1.2: Added 'status_message' string field
     VERSION = '1.2'
-    fields = {
-        'fault': wfields.ObjectField('ExceptionPayload', nullable=True),
-    }
+    fields = {'fault': wfields.ObjectField('ExceptionPayload', nullable=True)}
 
     def __init__(self, audit, goal, strategy, **kwargs):
         super().__init__(
@@ -194,7 +182,8 @@ class AuditActionPayload(AuditPayload):
             goal=goal,
             goal_uuid=goal.uuid,
             strategy=strategy,
-            **kwargs)
+            **kwargs,
+        )
 
 
 @base.WatcherObjectRegistry.register_notification
@@ -208,10 +197,8 @@ class AuditDeletePayload(AuditPayload):
 
     def __init__(self, audit, goal, strategy):
         super().__init__(
-            audit=audit,
-            goal=goal,
-            goal_uuid=goal.uuid,
-            strategy=strategy)
+            audit=audit, goal=goal, goal_uuid=goal.uuid, strategy=strategy
+        )
 
 
 @notificationbase.notification_sample('audit-strategy-error.json')
@@ -222,9 +209,7 @@ class AuditActionNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('AuditActionPayload')
-    }
+    fields = {'payload': wfields.ObjectField('AuditActionPayload')}
 
 
 @notificationbase.notification_sample('audit-create.json')
@@ -233,9 +218,7 @@ class AuditCreateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('AuditCreatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('AuditCreatePayload')}
 
 
 @notificationbase.notification_sample('audit-update.json')
@@ -244,9 +227,7 @@ class AuditUpdateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('AuditUpdatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('AuditUpdatePayload')}
 
 
 @notificationbase.notification_sample('audit-delete.json')
@@ -255,9 +236,7 @@ class AuditDeleteNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('AuditDeletePayload')
-    }
+    fields = {'payload': wfields.ObjectField('AuditDeletePayload')}
 
 
 def _get_common_payload(audit):
@@ -275,7 +254,8 @@ def _get_common_payload(audit):
     strategy_payload = None
     if strategy:
         strategy_payload = strategy_notifications.StrategyPayload(
-            strategy=strategy)
+            strategy=strategy
+        )
 
     return goal_payload, strategy_payload
 
@@ -285,26 +265,26 @@ def send_create(context, audit, service='infra-optim', host=None):
     goal_payload, strategy_payload = _get_common_payload(audit)
 
     versioned_payload = AuditCreatePayload(
-        audit=audit,
-        goal=goal_payload,
-        strategy=strategy_payload,
+        audit=audit, goal=goal_payload, strategy=strategy_payload
     )
 
     notification = AuditCreateNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='audit',
-            action=wfields.NotificationAction.CREATE),
+            object='audit', action=wfields.NotificationAction.CREATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_update(context, audit, service='infra-optim',
-                host=None, old_state=None):
+def send_update(
+    context, audit, service='infra-optim', host=None, old_state=None
+):
     """Emit an audit.update notification."""
     goal_payload, strategy_payload = _get_common_payload(audit)
 
@@ -312,8 +292,11 @@ def send_update(context, audit, service='infra-optim',
         old_state=old_state,
         state=audit.state if old_state else None,
         status_message=(
-            audit.status_message if old_state and
-            audit.status_message else None))
+            audit.status_message
+            if old_state and audit.status_message
+            else None
+        ),
+    )
 
     versioned_payload = AuditUpdatePayload(
         audit=audit,
@@ -325,12 +308,13 @@ def send_update(context, audit, service='infra-optim',
     notification = AuditUpdateNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='audit',
-            action=wfields.NotificationAction.UPDATE),
+            object='audit', action=wfields.NotificationAction.UPDATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
@@ -339,27 +323,32 @@ def send_delete(context, audit, service='infra-optim', host=None):
     goal_payload, strategy_payload = _get_common_payload(audit)
 
     versioned_payload = AuditDeletePayload(
-        audit=audit,
-        goal=goal_payload,
-        strategy=strategy_payload,
+        audit=audit, goal=goal_payload, strategy=strategy_payload
     )
 
     notification = AuditDeleteNotification(
         priority=wfields.NotificationPriority.INFO,
         event_type=notificationbase.EventType(
-            object='audit',
-            action=wfields.NotificationAction.DELETE),
+            object='audit', action=wfields.NotificationAction.DELETE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
 
 
-def send_action_notification(context, audit, action, phase=None,
-                             priority=wfields.NotificationPriority.INFO,
-                             service='infra-optim', host=None):
+def send_action_notification(
+    context,
+    audit,
+    action,
+    phase=None,
+    priority=wfields.NotificationPriority.INFO,
+    service='infra-optim',
+    host=None,
+):
     """Emit an audit action notification."""
     goal_payload, strategy_payload = _get_common_payload(audit)
 
@@ -368,21 +357,18 @@ def send_action_notification(context, audit, action, phase=None,
         fault = exception_notifications.ExceptionPayload.from_exception()
 
     versioned_payload = AuditActionPayload(
-        audit=audit,
-        goal=goal_payload,
-        strategy=strategy_payload,
-        fault=fault,
+        audit=audit, goal=goal_payload, strategy=strategy_payload, fault=fault
     )
 
     notification = AuditActionNotification(
         priority=priority,
         event_type=notificationbase.EventType(
-            object='audit',
-            action=action,
-            phase=phase),
+            object='audit', action=action, phase=phase
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
diff --git a/watcher/notifications/base.py b/watcher/notifications/base.py
index 4677b6b7f..76b3ad8ab 100644
--- a/watcher/notifications/base.py
+++ b/watcher/notifications/base.py
@@ -30,7 +30,7 @@ NOTIFY_LEVELS = {
     wfields.NotificationPriority.INFO: 1,
     wfields.NotificationPriority.WARNING: 2,
     wfields.NotificationPriority.ERROR: 3,
-    wfields.NotificationPriority.CRITICAL: 4
+    wfields.NotificationPriority.CRITICAL: 4,
 }
 
 
@@ -58,7 +58,6 @@ class NotificationObject(base.WatcherObject):
 
 @base.WatcherObjectRegistry.register_notification
 class EventType(NotificationObject):
-
     # Version 1.0: Initial version
     # Version 1.1: Added STRATEGY action in NotificationAction enum
     # Version 1.2: Added PLANNER action in NotificationAction enum
@@ -82,6 +81,7 @@ class EventType(NotificationObject):
 @base.WatcherObjectRegistry.register_if(False)
 class NotificationPayloadBase(NotificationObject):
     """Base class for the payload of versioned notifications."""
+
     # SCHEMA defines how to populate the payload fields. It is a dictionary
     # where every key value pair has the following format:
     # <payload_field_name>: (<data_source_name>,
@@ -169,8 +169,10 @@ class NotificationBase(NotificationObject):
         """
         if not CONF.notification_level:
             return False
-        return (NOTIFY_LEVELS[self.priority] >=
-                NOTIFY_LEVELS[CONF.notification_level])
+        return (
+            NOTIFY_LEVELS[self.priority]
+            >= NOTIFY_LEVELS[CONF.notification_level]
+        )
 
     def _emit(self, context, event_type, publisher_id, payload):
         notifier = rpc.get_notifier(publisher_id)
@@ -184,7 +186,8 @@ class NotificationBase(NotificationObject):
             return
         if not self.payload.populated:
             raise exception.NotificationPayloadError(
-                class_name=self.__class__.__name__)
+                class_name=self.__class__.__name__
+            )
         # Note(gibi): notification payload will be a newly populated object
         # therefore every field of it will look changed so this does not carry
         # any extra information so we drop this from the payload.
@@ -194,7 +197,8 @@ class NotificationBase(NotificationObject):
             context,
             event_type=self.event_type.to_notification_event_type_field(),
             publisher_id=f'{self.publisher.binary}:{self.publisher.host}',
-            payload=self.payload.obj_to_primitive())
+            payload=self.payload.obj_to_primitive(),
+        )
 
 
 def notification_sample(sample):
@@ -207,10 +211,12 @@ def notification_sample(sample):
                    doc/notification_samples/ directory in the watcher
                    repository root.
     """
+
     def wrap(cls):
         if not getattr(cls, 'samples', None):
             cls.samples = [sample]
         else:
             cls.samples.append(sample)
         return cls
+
     return wrap
diff --git a/watcher/notifications/exception.py b/watcher/notifications/exception.py
index fccc8b6b5..6d40c0ed7 100644
--- a/watcher/notifications/exception.py
+++ b/watcher/notifications/exception.py
@@ -26,7 +26,7 @@ class ExceptionPayload(notificationbase.NotificationPayloadBase):
         'module_name': wfields.StringField(),
         'function_name': wfields.StringField(),
         'exception': wfields.StringField(),
-        'exception_message': wfields.StringField()
+        'exception_message': wfields.StringField(),
     }
 
     @classmethod
@@ -40,7 +40,8 @@ class ExceptionPayload(notificationbase.NotificationPayloadBase):
             function_name=trace[3],
             module_name=inspect.getmodule(trace[0]).__name__,
             exception=fault.__class__.__name__,
-            exception_message=str(fault))
+            exception_message=str(fault),
+        )
 
 
 @notificationbase.notification_sample('infra-optim-exception.json')
@@ -48,6 +49,4 @@ class ExceptionPayload(notificationbase.NotificationPayloadBase):
 class ExceptionNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
-    fields = {
-        'payload': wfields.ObjectField('ExceptionPayload')
-    }
+    fields = {'payload': wfields.ObjectField('ExceptionPayload')}
diff --git a/watcher/notifications/goal.py b/watcher/notifications/goal.py
index 415e9fe91..7872f45b9 100644
--- a/watcher/notifications/goal.py
+++ b/watcher/notifications/goal.py
@@ -27,7 +27,6 @@ class GoalPayload(notificationbase.NotificationPayloadBase):
         'name': ('goal', 'name'),
         'display_name': ('goal', 'display_name'),
         'efficacy_specification': ('goal', 'efficacy_specification'),
-
         'created_at': ('goal', 'created_at'),
         'updated_at': ('goal', 'updated_at'),
         'deleted_at': ('goal', 'deleted_at'),
@@ -41,7 +40,6 @@ class GoalPayload(notificationbase.NotificationPayloadBase):
         'name': wfields.StringField(),
         'display_name': wfields.StringField(),
         'efficacy_specification': wfields.FlexibleListOfDictField(),
-
         'created_at': wfields.DateTimeField(nullable=True),
         'updated_at': wfields.DateTimeField(nullable=True),
         'deleted_at': wfields.DateTimeField(nullable=True),
diff --git a/watcher/notifications/service.py b/watcher/notifications/service.py
index 74ac4ca09..19fdf17c6 100644
--- a/watcher/notifications/service.py
+++ b/watcher/notifications/service.py
@@ -25,7 +25,6 @@ CONF = cfg.CONF
 
 @base.WatcherObjectRegistry.register_notification
 class ServicePayload(notificationbase.NotificationPayloadBase):
-
     SCHEMA = {
         'sevice_host': ('failed_service', 'host'),
         'name': ('failed_service', 'name'),
@@ -42,7 +41,9 @@ class ServicePayload(notificationbase.NotificationPayloadBase):
     def __init__(self, failed_service, status_update, **kwargs):
         super().__init__(
             failed_service=failed_service,
-            status_update=status_update, **kwargs)
+            status_update=status_update,
+            **kwargs,
+        )
         self.populate_schema(failed_service=failed_service)
 
 
@@ -61,13 +62,13 @@ class ServiceUpdatePayload(ServicePayload):
     # Version 1.0: Initial version
     VERSION = '1.0'
     fields = {
-        'status_update': wfields.ObjectField('ServiceStatusUpdatePayload'),
+        'status_update': wfields.ObjectField('ServiceStatusUpdatePayload')
     }
 
     def __init__(self, failed_service, status_update):
         super().__init__(
-            failed_service=failed_service,
-            status_update=status_update)
+            failed_service=failed_service, status_update=status_update
+        )
 
 
 @notificationbase.notification_sample('service-update.json')
@@ -76,38 +77,38 @@ class ServiceUpdateNotification(notificationbase.NotificationBase):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
-    fields = {
-        'payload': wfields.ObjectField('ServiceUpdatePayload')
-    }
+    fields = {'payload': wfields.ObjectField('ServiceUpdatePayload')}
 
 
-def send_service_update(context, failed_service, state,
-                        service='infra-optim',
-                        host=None):
+def send_service_update(
+    context, failed_service, state, service='infra-optim', host=None
+):
     """Emit an service failed notification."""
     if state == o_service.ServiceStatus.FAILED:
         priority = wfields.NotificationPriority.WARNING
         status_update = ServiceStatusUpdatePayload(
             old_state=o_service.ServiceStatus.ACTIVE,
-            state=o_service.ServiceStatus.FAILED)
+            state=o_service.ServiceStatus.FAILED,
+        )
     else:
         priority = wfields.NotificationPriority.INFO
         status_update = ServiceStatusUpdatePayload(
             old_state=o_service.ServiceStatus.FAILED,
-            state=o_service.ServiceStatus.ACTIVE)
+            state=o_service.ServiceStatus.ACTIVE,
+        )
     versioned_payload = ServiceUpdatePayload(
-        failed_service=failed_service,
-        status_update=status_update
+        failed_service=failed_service, status_update=status_update
     )
 
     notification = ServiceUpdateNotification(
         priority=priority,
         event_type=notificationbase.EventType(
-            object='service',
-            action=wfields.NotificationAction.UPDATE),
+            object='service', action=wfields.NotificationAction.UPDATE
+        ),
         publisher=notificationbase.NotificationPublisher(
-            host=host or CONF.host,
-            binary=service),
-        payload=versioned_payload)
+            host=host or CONF.host, binary=service
+        ),
+        payload=versioned_payload,
+    )
 
     notification.emit(context)
diff --git a/watcher/notifications/strategy.py b/watcher/notifications/strategy.py
index d850b88bb..242a2c92e 100644
--- a/watcher/notifications/strategy.py
+++ b/watcher/notifications/strategy.py
@@ -27,7 +27,6 @@ class StrategyPayload(notificationbase.NotificationPayloadBase):
         'name': ('strategy', 'name'),
         'display_name': ('strategy', 'display_name'),
         'parameters_spec': ('strategy', 'parameters_spec'),
-
         'created_at': ('strategy', 'created_at'),
         'updated_at': ('strategy', 'updated_at'),
         'deleted_at': ('strategy', 'deleted_at'),
@@ -41,7 +40,6 @@ class StrategyPayload(notificationbase.NotificationPayloadBase):
         'name': wfields.StringField(),
         'display_name': wfields.StringField(),
         'parameters_spec': wfields.FlexibleDictField(nullable=True),
-
         'created_at': wfields.DateTimeField(nullable=True),
         'updated_at': wfields.DateTimeField(nullable=True),
         'deleted_at': wfields.DateTimeField(nullable=True),
diff --git a/watcher/objects/action.py b/watcher/objects/action.py
index aecdd07b3..bab43a69f 100644
--- a/watcher/objects/action.py
+++ b/watcher/objects/action.py
@@ -34,9 +34,11 @@ class State:
 
 
 @base.WatcherObjectRegistry.register
-class Action(base.WatcherPersistentObject, base.WatcherObject,
-             base.WatcherObjectDictCompat):
-
+class Action(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     # Version 1.1: Added 'action_plan' object field
     # Version 2.0: Removed 'next' object field, Added 'parents' object field
@@ -54,12 +56,9 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
         'state': wfields.StringField(nullable=True),
         'parents': wfields.ListOfStringsField(nullable=True),
         'status_message': wfields.StringField(nullable=True),
-
         'action_plan': wfields.ObjectField('ActionPlan', nullable=True),
     }
-    object_fields = {
-        'action_plan': (objects.ActionPlan, 'action_plan_id'),
-    }
+    object_fields = {'action_plan': (objects.ActionPlan, 'action_plan_id')}
 
     @base.remotable_classmethod
     def get(cls, context, action_id, eager=False):
@@ -102,8 +101,16 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
         return action
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None, eager=False):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Return a list of Action objects.
 
         :param context: Security context.
@@ -115,16 +122,20 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
         :param eager: Load object fields if True (Default: False)
         :returns: a list of :class:`Action` object.
         """
-        db_actions = cls.dbapi.get_action_list(context,
-                                               limit=limit,
-                                               marker=marker,
-                                               filters=filters,
-                                               sort_key=sort_key,
-                                               sort_dir=sort_dir,
-                                               eager=eager)
+        db_actions = cls.dbapi.get_action_list(
+            context,
+            limit=limit,
+            marker=marker,
+            filters=filters,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+            eager=eager,
+        )
 
-        return [cls._from_db_object(cls(context), obj, eager=eager)
-                for obj in db_actions]
+        return [
+            cls._from_db_object(cls(context), obj, eager=eager)
+            for obj in db_actions
+        ]
 
     @base.remotable
     def create(self):
@@ -178,7 +189,8 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
         self.save()
         db_obj = self.dbapi.soft_delete_action(self.uuid)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
 
         notifications.action.send_delete(self.obj_context, self)
diff --git a/watcher/objects/action_description.py b/watcher/objects/action_description.py
index 7aa5e28f0..336c102fe 100644
--- a/watcher/objects/action_description.py
+++ b/watcher/objects/action_description.py
@@ -21,9 +21,11 @@ from watcher.objects import fields as wfields
 
 
 @base.WatcherObjectRegistry.register
-class ActionDescription(base.WatcherPersistentObject, base.WatcherObject,
-                        base.WatcherObjectDictCompat):
-
+class ActionDescription(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
@@ -50,7 +52,8 @@ class ActionDescription(base.WatcherPersistentObject, base.WatcherObject,
         """
         if utils.is_int_like(action_id):
             db_action = cls.dbapi.get_action_description_by_id(
-                context, action_id)
+                context, action_id
+            )
             action = ActionDescription._from_db_object(cls(context), db_action)
             return action
         else:
@@ -66,13 +69,21 @@ class ActionDescription(base.WatcherPersistentObject, base.WatcherObject,
         """
 
         db_action = cls.dbapi.get_action_description_by_type(
-            context, action_type)
+            context, action_type
+        )
         action = cls._from_db_object(cls(context), db_action)
         return action
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+    ):
         """Return a list of :class:`ActionDescription` objects.
 
         :param context: Security context. NOTE: This should only
@@ -94,7 +105,8 @@ class ActionDescription(base.WatcherPersistentObject, base.WatcherObject,
             limit=limit,
             marker=marker,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+        )
 
         return [cls._from_db_object(cls(context), obj) for obj in db_actions]
 
@@ -128,13 +140,16 @@ class ActionDescription(base.WatcherPersistentObject, base.WatcherObject,
         """
         current = self.get(self._context, action_id=self.id)
         for field in self.fields:
-            if (hasattr(self, base.get_attrname(field)) and
-                    self[field] != current[field]):
+            if (
+                hasattr(self, base.get_attrname(field))
+                and self[field] != current[field]
+            ):
                 self[field] = current[field]
 
     def soft_delete(self):
         """Soft Delete the :class:`ActionDescription` from the DB."""
         db_obj = self.dbapi.soft_delete_action_description(self.id)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
diff --git a/watcher/objects/action_plan.py b/watcher/objects/action_plan.py
index 9d734896d..ec3e49ca0 100644
--- a/watcher/objects/action_plan.py
+++ b/watcher/objects/action_plan.py
@@ -70,6 +70,7 @@ state may be one of the following:
    **RECOMMENDED** state and was superseded by the
    :ref:`Administrator <administrator_definition>`
 """
+
 import datetime
 
 from oslo_utils import timeutils
@@ -102,9 +103,11 @@ class State:
 
 
 @base.WatcherObjectRegistry.register
-class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
-                 base.WatcherObjectDictCompat):
-
+class ActionPlan(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     # Version 1.1: Added 'audit' and 'strategy' object field
     # Version 1.2: audit_id is not nullable anymore
@@ -124,7 +127,6 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         'state': wfields.StringField(nullable=True),
         'global_efficacy': wfields.FlexibleListOfDictField(nullable=True),
         'hostname': wfields.StringField(nullable=True),
-
         'audit': wfields.ObjectField('Audit', nullable=True),
         'strategy': wfields.ObjectField('Strategy', nullable=True),
         'status_message': wfields.StringField(nullable=True),
@@ -192,9 +194,11 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`ActionPlan` object.
         """  # noqa: E501
         db_action_plan = cls.dbapi.get_action_plan_by_id(
-            context, action_plan_id, eager=eager)
+            context, action_plan_id, eager=eager
+        )
         action_plan = cls._from_db_object(
-            cls(context), db_action_plan, eager=eager)
+            cls(context), db_action_plan, eager=eager
+        )
         return action_plan
 
     @base.remotable_classmethod
@@ -207,14 +211,24 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`ActionPlan` object.
         """  # noqa: E501
         db_action_plan = cls.dbapi.get_action_plan_by_uuid(
-            context, uuid, eager=eager)
+            context, uuid, eager=eager
+        )
         action_plan = cls._from_db_object(
-            cls(context), db_action_plan, eager=eager)
+            cls(context), db_action_plan, eager=eager
+        )
         return action_plan
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None, eager=False):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Return a list of ActionPlan objects.
 
         :param context: Security context.
@@ -226,16 +240,20 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         :param eager: Load object fields if True (Default: False)
         :returns: a list of :class:`ActionPlan` object.
         """
-        db_action_plans = cls.dbapi.get_action_plan_list(context,
-                                                         limit=limit,
-                                                         marker=marker,
-                                                         filters=filters,
-                                                         sort_key=sort_key,
-                                                         sort_dir=sort_dir,
-                                                         eager=eager)
+        db_action_plans = cls.dbapi.get_action_plan_list(
+            context,
+            limit=limit,
+            marker=marker,
+            filters=filters,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+            eager=eager,
+        )
 
-        return [cls._from_db_object(cls(context), obj, eager=eager)
-                for obj in db_action_plans]
+        return [
+            cls._from_db_object(cls(context), obj, eager=eager)
+            for obj in db_action_plans
+        ]
 
     @base.remotable
     def create(self):
@@ -258,8 +276,8 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
     def destroy(self):
         """Delete the action plan from the DB"""
         related_efficacy_indicators = objects.EfficacyIndicator.list(
-            context=self._context,
-            filters={"action_plan_uuid": self.uuid})
+            context=self._context, filters={"action_plan_uuid": self.uuid}
+        )
 
         # Cascade soft_delete of related efficacy indicators
         for related_efficacy_indicator in related_efficacy_indicators:
@@ -278,12 +296,14 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         updates = self.obj_get_changes()
         db_obj = self.dbapi.update_action_plan(self.uuid, updates)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
 
         def _notify():
             notifications.action_plan.send_update(
-                self._context, self, old_state=self.old_state)
+                self._context, self, old_state=self.old_state
+            )
 
         _notify()
 
@@ -307,15 +327,16 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         related_actions = objects.Action.list(
             context=self._context,
             filters={"action_plan_uuid": self.uuid},
-            eager=True)
+            eager=True,
+        )
 
         # Cascade soft_delete of related actions
         for related_action in related_actions:
             related_action.soft_delete()
 
         related_efficacy_indicators = objects.EfficacyIndicator.list(
-            context=self._context,
-            filters={"action_plan_uuid": self.uuid})
+            context=self._context, filters={"action_plan_uuid": self.uuid}
+        )
 
         # Cascade soft_delete of related efficacy indicators
         for related_efficacy_indicator in related_efficacy_indicators:
@@ -325,7 +346,8 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
         self.save()
         db_obj = self.dbapi.soft_delete_action_plan(self.uuid)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
 
         def _notify():
@@ -336,14 +358,17 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
 
 class StateManager:
     def check_expired(self, context):
-        action_plan_expiry = (
-            CONF.watcher_decision_engine.action_plan_expiry)
+        action_plan_expiry = CONF.watcher_decision_engine.action_plan_expiry
         date_created = timeutils.utcnow() - datetime.timedelta(
-            hours=action_plan_expiry)
-        filters = {'state__eq': State.RECOMMENDED,
-                   'created_at__lt': date_created}
+            hours=action_plan_expiry
+        )
+        filters = {
+            'state__eq': State.RECOMMENDED,
+            'created_at__lt': date_created,
+        }
         action_plans = objects.ActionPlan.list(
-            context, filters=filters, eager=True)
+            context, filters=filters, eager=True
+        )
         for action_plan in action_plans:
             action_plan.state = State.SUPERSEDED
             action_plan.save()
diff --git a/watcher/objects/audit.py b/watcher/objects/audit.py
index 795e93710..c2ec11424 100644
--- a/watcher/objects/audit.py
+++ b/watcher/objects/audit.py
@@ -78,9 +78,11 @@ class AuditType(enum.Enum):
 
 
 @base.WatcherObjectRegistry.register
-class Audit(base.WatcherPersistentObject, base.WatcherObject,
-            base.WatcherObjectDictCompat):
-
+class Audit(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     # Version 1.1: Added 'goal' and 'strategy' object field
     # Version 1.2: Added 'auto_trigger' boolean field
@@ -107,16 +109,15 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
         'goal_id': wfields.IntegerField(),
         'strategy_id': wfields.IntegerField(nullable=True),
         'auto_trigger': wfields.BooleanField(),
-        'next_run_time': wfields.DateTimeField(nullable=True,
-                                               tzinfo_aware=False),
+        'next_run_time': wfields.DateTimeField(
+            nullable=True, tzinfo_aware=False
+        ),
         'hostname': wfields.StringField(nullable=True),
         'start_time': wfields.DateTimeField(nullable=True, tzinfo_aware=False),
         'end_time': wfields.DateTimeField(nullable=True, tzinfo_aware=False),
         'force': wfields.BooleanField(default=False, nullable=False),
-
         'goal': wfields.ObjectField('Goal', nullable=True),
         'strategy': wfields.ObjectField('Strategy', nullable=True),
-
         'status_message': wfields.StringField(nullable=True),
     }
 
@@ -241,8 +242,16 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
         return audit
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None, eager=False):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Return a list of Audit objects.
 
         :param context: Security context. NOTE: This should only
@@ -260,15 +269,19 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a list of :class:`Audit` object.
 
         """
-        db_audits = cls.dbapi.get_audit_list(context,
-                                             limit=limit,
-                                             marker=marker,
-                                             filters=filters,
-                                             sort_key=sort_key,
-                                             sort_dir=sort_dir,
-                                             eager=eager)
-        return [cls._from_db_object(cls(context), obj, eager=eager)
-                for obj in db_audits]
+        db_audits = cls.dbapi.get_audit_list(
+            context,
+            limit=limit,
+            marker=marker,
+            filters=filters,
+            sort_key=sort_key,
+            sort_dir=sort_dir,
+            eager=eager,
+        )
+        return [
+            cls._from_db_object(cls(context), obj, eager=eager)
+            for obj in db_audits
+        ]
 
     @base.remotable
     def create(self):
@@ -303,12 +316,14 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
         updates = self.obj_get_changes()
         db_obj = self.dbapi.update_audit(self.uuid, updates)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
 
         def _notify():
             notifications.audit.send_update(
-                self._context, self, old_state=self.old_state)
+                self._context, self, old_state=self.old_state
+            )
 
         _notify()
 
@@ -333,7 +348,8 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
         self.save()
         db_obj = self.dbapi.soft_delete_audit(self.uuid)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
 
         def _notify():
@@ -343,19 +359,26 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
 
 
 class AuditStateTransitionManager:
-
     TRANSITIONS = {
         State.PENDING: [State.ONGOING, State.CANCELLED],
-        State.ONGOING: [State.FAILED, State.SUCCEEDED,
-                        State.CANCELLED, State.SUSPENDED],
+        State.ONGOING: [
+            State.FAILED,
+            State.SUCCEEDED,
+            State.CANCELLED,
+            State.SUSPENDED,
+        ],
         State.FAILED: [State.DELETED],
         State.SUCCEEDED: [State.DELETED],
         State.CANCELLED: [State.DELETED],
         State.SUSPENDED: [State.ONGOING, State.DELETED],
     }
 
-    INACTIVE_STATES = (State.CANCELLED, State.DELETED,
-                       State.FAILED, State.SUSPENDED)
+    INACTIVE_STATES = (
+        State.CANCELLED,
+        State.DELETED,
+        State.FAILED,
+        State.SUSPENDED,
+    )
 
     def check_transition(self, initial, new):
         return new in self.TRANSITIONS.get(initial, [])
diff --git a/watcher/objects/audit_template.py b/watcher/objects/audit_template.py
index 12cc9eea9..a5fc8755f 100644
--- a/watcher/objects/audit_template.py
+++ b/watcher/objects/audit_template.py
@@ -55,9 +55,11 @@ from watcher.objects import fields as wfields
 
 
 @base.WatcherObjectRegistry.register
-class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
-                    base.WatcherObjectDictCompat):
-
+class AuditTemplate(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     # Version 1.1: Added 'goal' and 'strategy' object field
     VERSION = '1.1'
@@ -72,7 +74,6 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         'scope': wfields.FlexibleListOfDictField(nullable=True),
         'goal_id': wfields.IntegerField(),
         'strategy_id': wfields.IntegerField(nullable=True),
-
         'goal': wfields.ObjectField('Goal', nullable=True),
         'strategy': wfields.ObjectField('Strategy', nullable=True),
     }
@@ -118,9 +119,11 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`AuditTemplate` object.
         """
         db_audit_template = cls.dbapi.get_audit_template_by_id(
-            context, audit_template_id, eager=eager)
+            context, audit_template_id, eager=eager
+        )
         audit_template = cls._from_db_object(
-            cls(context), db_audit_template, eager=eager)
+            cls(context), db_audit_template, eager=eager
+        )
         return audit_template
 
     @base.remotable_classmethod
@@ -138,9 +141,11 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`AuditTemplate` object.
         """
         db_audit_template = cls.dbapi.get_audit_template_by_uuid(
-            context, uuid, eager=eager)
+            context, uuid, eager=eager
+        )
         audit_template = cls._from_db_object(
-            cls(context), db_audit_template, eager=eager)
+            cls(context), db_audit_template, eager=eager
+        )
         return audit_template
 
     @base.remotable_classmethod
@@ -153,14 +158,24 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`AuditTemplate` object.
         """
         db_audit_template = cls.dbapi.get_audit_template_by_name(
-            context, name, eager=eager)
+            context, name, eager=eager
+        )
         audit_template = cls._from_db_object(
-            cls(context), db_audit_template, eager=eager)
+            cls(context), db_audit_template, eager=eager
+        )
         return audit_template
 
     @base.remotable_classmethod
-    def list(cls, context, filters=None, limit=None, marker=None,
-             sort_key=None, sort_dir=None, eager=False):
+    def list(
+        cls,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Return a list of :class:`AuditTemplate` objects.
 
         :param context: Security context. NOTE: This should only
@@ -184,10 +199,13 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
             marker=marker,
             sort_key=sort_key,
             sort_dir=sort_dir,
-            eager=eager)
+            eager=eager,
+        )
 
-        return [cls._from_db_object(cls(context), obj, eager=eager)
-                for obj in db_audit_templates]
+        return [
+            cls._from_db_object(cls(context), obj, eager=eager)
+            for obj in db_audit_templates
+        ]
 
     @base.remotable
     def create(self):
@@ -236,5 +254,6 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         """Soft Delete the :class:`AuditTemplate` from the DB"""
         db_obj = self.dbapi.soft_delete_audit_template(self.uuid)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
diff --git a/watcher/objects/base.py b/watcher/objects/base.py
index b05d6b33a..f91524619 100644
--- a/watcher/objects/base.py
+++ b/watcher/objects/base.py
@@ -44,7 +44,8 @@ class WatcherObjectRegistry(ovo_base.VersionedObjectRegistry):
             setattr(objects, cls.obj_name(), cls)
         else:
             cur_version = versionutils.convert_version_to_tuple(
-                getattr(objects, cls.obj_name()).VERSION)
+                getattr(objects, cls.obj_name()).VERSION
+            )
             if version >= cur_version:
                 setattr(objects, cls.obj_name(), cls)
 
@@ -85,8 +86,8 @@ class WatcherObject(ovo_base.VersionedObject):
 
     def as_dict(self):
         return {
-            k: getattr(self, k) for k in self.fields
-            if self.obj_attr_is_set(k)}
+            k: getattr(self, k) for k in self.fields if self.obj_attr_is_set(k)
+        }
 
 
 class WatcherObjectDictCompat(ovo_base.VersionedObjectDictCompat):
@@ -102,6 +103,7 @@ class WatcherPersistentObject:
 
     This adds the fields that we use in common for all persistent objects.
     """
+
     fields = {
         'created_at': ovo_fields.DateTimeField(nullable=True),
         'updated_at': ovo_fields.DateTimeField(nullable=True),
@@ -128,11 +130,14 @@ class WatcherPersistentObject:
         the loaded object column by column in comparison with the current
         object.
         """
-        fields = (field for field in self.fields
-                  if field not in self.object_fields)
+        fields = (
+            field for field in self.fields if field not in self.object_fields
+        )
         for field in fields:
-            if (self.obj_attr_is_set(field) and
-                    self[field] != loaded_object[field]):
+            if (
+                self.obj_attr_is_set(field)
+                and self[field] != loaded_object[field]
+            ):
                 self[field] = loaded_object[field]
 
     @staticmethod
@@ -157,8 +162,10 @@ class WatcherPersistentObject:
             context = obj._context
             loadable_fields = (
                 (obj_field, related_obj_cls, rel_id)
-                for obj_field, (related_obj_cls, rel_id)
-                in object_fields.items()
+                for obj_field, (
+                    related_obj_cls,
+                    rel_id,
+                ) in object_fields.items()
                 if obj[rel_id]
             )
             for obj_field, related_obj_cls, rel_id in loadable_fields:
@@ -166,7 +173,8 @@ class WatcherPersistentObject:
                     # The object field data was eagerly loaded alongside
                     # the main object data
                     obj[obj_field] = related_obj_cls._from_db_object(
-                        related_obj_cls(context), db_object[obj_field])
+                        related_obj_cls(context), db_object[obj_field]
+                    )
                 else:
                     # The object field data wasn't loaded yet
                     obj[obj_field] = related_obj_cls.get(context, obj[rel_id])
diff --git a/watcher/objects/efficacy_indicator.py b/watcher/objects/efficacy_indicator.py
index 4f9f3094a..6462ae964 100644
--- a/watcher/objects/efficacy_indicator.py
+++ b/watcher/objects/efficacy_indicator.py
@@ -21,8 +21,11 @@ from watcher.objects import fields as wfields
 
 
 @base.WatcherObjectRegistry.register
-class EfficacyIndicator(base.WatcherPersistentObject, base.WatcherObject,
-                        base.WatcherObjectDictCompat):
+class EfficacyIndicator(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
@@ -60,9 +63,11 @@ class EfficacyIndicator(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`EfficacyIndicator` object.
         """
         db_efficacy_indicator = cls.dbapi.get_efficacy_indicator_by_id(
-            context, efficacy_indicator_id)
+            context, efficacy_indicator_id
+        )
         efficacy_indicator = EfficacyIndicator._from_db_object(
-            cls(context), db_efficacy_indicator)
+            cls(context), db_efficacy_indicator
+        )
         return efficacy_indicator
 
     @base.remotable_classmethod
@@ -74,14 +79,23 @@ class EfficacyIndicator(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`EfficacyIndicator` object.
         """
         db_efficacy_indicator = cls.dbapi.get_efficacy_indicator_by_uuid(
-            context, uuid)
+            context, uuid
+        )
         efficacy_indicator = EfficacyIndicator._from_db_object(
-            cls(context), db_efficacy_indicator)
+            cls(context), db_efficacy_indicator
+        )
         return efficacy_indicator
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+    ):
         """Return a list of EfficacyIndicator objects.
 
         :param context: Security context.
@@ -99,10 +113,13 @@ class EfficacyIndicator(base.WatcherPersistentObject, base.WatcherObject,
             marker=marker,
             filters=filters,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+        )
 
-        return [cls._from_db_object(cls(context), obj)
-                for obj in db_efficacy_indicators]
+        return [
+            cls._from_db_object(cls(context), obj)
+            for obj in db_efficacy_indicators
+        ]
 
     @base.remotable
     def create(self, context=None):
diff --git a/watcher/objects/fields.py b/watcher/objects/fields.py
index bd9787b34..c107700c4 100644
--- a/watcher/objects/fields.py
+++ b/watcher/objects/fields.py
@@ -120,11 +120,11 @@ class Json(fields.FieldType):
 class JsonField(fields.AutoTypedField):
     AUTO_TYPE = Json()
 
+
 # ### Notification fields ### #
 
 
 class BaseWatcherEnum(Enum):
-
     ALL = ()
 
     def __init__(self, **kwargs):
@@ -161,8 +161,16 @@ class NotificationAction(BaseWatcherEnum):
 
     CANCEL = 'cancel'
 
-    ALL = (CREATE, UPDATE, EXCEPTION, DELETE, STRATEGY, PLANNER, EXECUTION,
-           CANCEL)
+    ALL = (
+        CREATE,
+        UPDATE,
+        EXCEPTION,
+        DELETE,
+        STRATEGY,
+        PLANNER,
+        EXECUTION,
+        CANCEL,
+    )
 
 
 class NotificationPriorityField(BaseEnumField):
diff --git a/watcher/objects/goal.py b/watcher/objects/goal.py
index 3c102089b..cc698e0c3 100644
--- a/watcher/objects/goal.py
+++ b/watcher/objects/goal.py
@@ -21,8 +21,11 @@ from watcher.objects import fields as wfields
 
 
 @base.WatcherObjectRegistry.register
-class Goal(base.WatcherPersistentObject, base.WatcherObject,
-           base.WatcherObjectDictCompat):
+class Goal(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
@@ -103,8 +106,15 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject,
         return goal
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+    ):
         """Return a list of :class:`Goal` objects.
 
         :param context: Security context. NOTE: This should only
@@ -126,7 +136,8 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject,
             limit=limit,
             marker=marker,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+        )
 
         return [cls._from_db_object(cls(context), obj) for obj in db_goals]
 
@@ -171,5 +182,6 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject,
         """Soft Delete the :class:`Goal` from the DB"""
         db_obj = self.dbapi.soft_delete_goal(self.uuid)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
diff --git a/watcher/objects/scoring_engine.py b/watcher/objects/scoring_engine.py
index 14e865cac..36943bf16 100644
--- a/watcher/objects/scoring_engine.py
+++ b/watcher/objects/scoring_engine.py
@@ -31,8 +31,11 @@ from watcher.objects import fields as wfields
 
 
 @base.WatcherObjectRegistry.register
-class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
-                    base.WatcherObjectDictCompat):
+class ScoringEngine(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
@@ -80,10 +83,11 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`ScoringEngine` object.
         """
         db_scoring_engine = cls.dbapi.get_scoring_engine_by_id(
-            context,
-            scoring_engine_id)
-        scoring_engine = ScoringEngine._from_db_object(cls(context),
-                                                       db_scoring_engine)
+            context, scoring_engine_id
+        )
+        scoring_engine = ScoringEngine._from_db_object(
+            cls(context), db_scoring_engine
+        )
         return scoring_engine
 
     @base.remotable_classmethod
@@ -100,10 +104,11 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`ScoringEngine` object.
         """
         db_scoring_engine = cls.dbapi.get_scoring_engine_by_uuid(
-            context,
-            scoring_engine_uuid)
-        scoring_engine = ScoringEngine._from_db_object(cls(context),
-                                                       db_scoring_engine)
+            context, scoring_engine_uuid
+        )
+        scoring_engine = ScoringEngine._from_db_object(
+            cls(context), db_scoring_engine
+        )
         return scoring_engine
 
     @base.remotable_classmethod
@@ -120,15 +125,23 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
         :returns: a :class:`ScoringEngine` object.
         """
         db_scoring_engine = cls.dbapi.get_scoring_engine_by_name(
-            context,
-            scoring_engine_name)
-        scoring_engine = ScoringEngine._from_db_object(cls(context),
-                                                       db_scoring_engine)
+            context, scoring_engine_name
+        )
+        scoring_engine = ScoringEngine._from_db_object(
+            cls(context), db_scoring_engine
+        )
         return scoring_engine
 
     @base.remotable_classmethod
-    def list(cls, context, filters=None, limit=None, marker=None,
-             sort_key=None, sort_dir=None):
+    def list(
+        cls,
+        context,
+        filters=None,
+        limit=None,
+        marker=None,
+        sort_key=None,
+        sort_dir=None,
+    ):
         """Return a list of :class:`ScoringEngine` objects.
 
         :param context: Security context. NOTE: This should only
@@ -150,9 +163,12 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
             limit=limit,
             marker=marker,
             sort_key=sort_key,
-            sort_dir=sort_dir)
-        return [cls._from_db_object(cls(context), obj)
-                for obj in db_scoring_engines]
+            sort_dir=sort_dir,
+        )
+        return [
+            cls._from_db_object(cls(context), obj)
+            for obj in db_scoring_engines
+        ]
 
     @base.remotable
     def create(self):
@@ -193,5 +209,6 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
         """Soft Delete the :class:`ScoringEngine` from the DB"""
         db_obj = self.dbapi.soft_delete_scoring_engine(self.id)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
diff --git a/watcher/objects/service.py b/watcher/objects/service.py
index 6bf7311aa..986035890 100644
--- a/watcher/objects/service.py
+++ b/watcher/objects/service.py
@@ -26,9 +26,11 @@ class ServiceStatus:
 
 
 @base.WatcherObjectRegistry.register
-class Service(base.WatcherPersistentObject, base.WatcherObject,
-              base.WatcherObjectDictCompat):
-
+class Service(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     VERSION = '1.0'
 
@@ -39,7 +41,8 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
         'name': wfields.StringField(),
         'host': wfields.StringField(),
         'last_seen_up': wfields.DateTimeField(
-            tzinfo_aware=False, nullable=True),
+            tzinfo_aware=False, nullable=True
+        ),
     }
 
     @base.remotable_classmethod
@@ -76,8 +79,15 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
         return service
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+    ):
         """Return a list of :class:`Service` objects.
 
         :param context: Security context. NOTE: This should only
@@ -99,7 +109,8 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
             limit=limit,
             marker=marker,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+        )
 
         return [cls._from_db_object(cls(context), obj) for obj in db_services]
 
@@ -132,13 +143,16 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
         """
         current = self.get(self._context, service_id=self.id)
         for field in self.fields:
-            if (hasattr(self, base.get_attrname(field)) and
-                    self[field] != current[field]):
+            if (
+                hasattr(self, base.get_attrname(field))
+                and self[field] != current[field]
+            ):
                 self[field] = current[field]
 
     def soft_delete(self):
         """Soft Delete the :class:`Service` from the DB."""
         db_obj = self.dbapi.soft_delete_service(self.id)
         obj = self._from_db_object(
-            self.__class__(self._context), db_obj, eager=False)
+            self.__class__(self._context), db_obj, eager=False
+        )
         self.obj_refresh(obj)
diff --git a/watcher/objects/strategy.py b/watcher/objects/strategy.py
index 6ded09de8..b9aad0bf6 100644
--- a/watcher/objects/strategy.py
+++ b/watcher/objects/strategy.py
@@ -22,9 +22,11 @@ from watcher.objects import fields as wfields
 
 
 @base.WatcherObjectRegistry.register
-class Strategy(base.WatcherPersistentObject, base.WatcherObject,
-               base.WatcherObjectDictCompat):
-
+class Strategy(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     # Version 1.0: Initial version
     # Version 1.1: Added Goal object field
     VERSION = '1.1'
@@ -79,7 +81,8 @@ class Strategy(base.WatcherPersistentObject, base.WatcherObject,
         :returns: A :class:`Strategy` object.
         """
         db_strategy = cls.dbapi.get_strategy_by_id(
-            context, strategy_id, eager=eager)
+            context, strategy_id, eager=eager
+        )
         strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)
         return strategy
 
@@ -99,7 +102,8 @@ class Strategy(base.WatcherPersistentObject, base.WatcherObject,
         """
 
         db_strategy = cls.dbapi.get_strategy_by_uuid(
-            context, uuid, eager=eager)
+            context, uuid, eager=eager
+        )
         strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)
         return strategy
 
@@ -114,13 +118,22 @@ class Strategy(base.WatcherPersistentObject, base.WatcherObject,
         """
 
         db_strategy = cls.dbapi.get_strategy_by_name(
-            context, name, eager=eager)
+            context, name, eager=eager
+        )
         strategy = cls._from_db_object(cls(context), db_strategy, eager=eager)
         return strategy
 
     @base.remotable_classmethod
-    def list(cls, context, limit=None, marker=None, filters=None,
-             sort_key=None, sort_dir=None, eager=False):
+    def list(
+        cls,
+        context,
+        limit=None,
+        marker=None,
+        filters=None,
+        sort_key=None,
+        sort_dir=None,
+        eager=False,
+    ):
         """Return a list of :class:`Strategy` objects.
 
         :param context: Security context. NOTE: This should only
@@ -143,10 +156,13 @@ class Strategy(base.WatcherPersistentObject, base.WatcherObject,
             limit=limit,
             marker=marker,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+        )
 
-        return [cls._from_db_object(cls(context), obj, eager=eager)
-                for obj in db_strategies]
+        return [
+            cls._from_db_object(cls(context), obj, eager=eager)
+            for obj in db_strategies
+        ]
 
     @base.remotable
     def create(self, context=None):
@@ -216,10 +232,13 @@ class Strategy(base.WatcherPersistentObject, base.WatcherObject,
         :param eager: Load object fields if True (Default: False)
         """
         current = self.__class__.get_by_id(
-            self._context, strategy_id=self.id, eager=eager)
+            self._context, strategy_id=self.id, eager=eager
+        )
         for field in self.fields:
-            if (hasattr(self, base.get_attrname(field)) and
-                    self[field] != current[field]):
+            if (
+                hasattr(self, base.get_attrname(field))
+                and self[field] != current[field]
+            ):
                 self[field] = current[field]
 
     @base.remotable
diff --git a/watcher/tests/fixtures/db_lock.py b/watcher/tests/fixtures/db_lock.py
index 8d18ff4a5..49fa1ba58 100644
--- a/watcher/tests/fixtures/db_lock.py
+++ b/watcher/tests/fixtures/db_lock.py
@@ -46,7 +46,8 @@ class DatabaseWriteLock(fixtures.Fixture):
         if lock_timeout is not None and lock_timeout <= 0:
             raise ValueError(
                 "lock_timeout must be None or a positive number, "
-                f"got {lock_timeout}")
+                f"got {lock_timeout}"
+            )
         self.lock_timeout = lock_timeout
         self._db_write_lock = threading.RLock()  # Reentrant lock
 
@@ -61,12 +62,14 @@ class DatabaseWriteLock(fixtures.Fixture):
             # Acquire the lock before entering the database session
             acquired = self._db_write_lock.acquire(
                 blocking=True,
-                timeout=self.lock_timeout if self.lock_timeout else -1)
+                timeout=self.lock_timeout if self.lock_timeout else -1,
+            )
 
             if not acquired:
                 raise RuntimeError(
                     f"Failed to acquire database write lock within "
-                    f"{self.lock_timeout} seconds")
+                    f"{self.lock_timeout} seconds"
+                )
 
             try:
                 # Enter the original writer session context
@@ -77,5 +80,8 @@ class DatabaseWriteLock(fixtures.Fixture):
                 self._db_write_lock.release()
 
         # Patch _session_for_write in watcher's db api
-        self.useFixture(fixtures.MockPatchObject(
-            db_api, '_session_for_write', locked_session_for_write))
+        self.useFixture(
+            fixtures.MockPatchObject(
+                db_api, '_session_for_write', locked_session_for_write
+            )
+        )
diff --git a/watcher/tests/fixtures/fakes.py b/watcher/tests/fixtures/fakes.py
index c63c219e4..760195823 100644
--- a/watcher/tests/fixtures/fakes.py
+++ b/watcher/tests/fixtures/fakes.py
@@ -15,23 +15,23 @@ from unittest import mock
 import requests
 
 
-fakeAuthTokenHeaders = {'X-User-Id': '773a902f022949619b5c2f32cd89d419',
-                        'X-Roles': 'admin, ResellerAdmin, _member_',
-                        'X-Project-Id': '5588aebbcdc24e17a061595f80574376',
-                        'X-Project-Name': 'test',
-                        'X-User-Name': 'test',
-                        'X-Auth-Token': '5588aebbcdc24e17a061595f80574376',
-                        'X-Forwarded-For': '10.10.10.10, 11.11.11.11',
-                        'X-Service-Catalog': '{test: 12345}',
-                        'X-Identity-Status': 'Confirmed',
-                        'X-User-Domain-Name': 'domain',
-                        'X-Project-Domain-Id': 'project_domain_id',
-                        'X-User-Domain-Id': 'user_domain_id',
-                        }
+fakeAuthTokenHeaders = {
+    'X-User-Id': '773a902f022949619b5c2f32cd89d419',
+    'X-Roles': 'admin, ResellerAdmin, _member_',
+    'X-Project-Id': '5588aebbcdc24e17a061595f80574376',
+    'X-Project-Name': 'test',
+    'X-User-Name': 'test',
+    'X-Auth-Token': '5588aebbcdc24e17a061595f80574376',
+    'X-Forwarded-For': '10.10.10.10, 11.11.11.11',
+    'X-Service-Catalog': '{test: 12345}',
+    'X-Identity-Status': 'Confirmed',
+    'X-User-Domain-Name': 'domain',
+    'X-Project-Domain-Id': 'project_domain_id',
+    'X-User-Domain-Id': 'user_domain_id',
+}
 
 
 class FakePecanRequest(mock.Mock):
-
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.host_url = 'http://test_url:8080/test'
@@ -48,7 +48,6 @@ class FakePecanRequest(mock.Mock):
 
 
 class FakePecanResponse(mock.Mock):
-
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.status = None
@@ -74,19 +73,20 @@ class FakeService(mock.Mock):
         self.read_only = True
 
     def as_dict(self):
-        return dict(service_type=self.service_type,
-                    user_id=self.user_id,
-                    project_id=self.project_id,
-                    uuid=self.uuid,
-                    id=self.id,
-                    name=self.name,
-                    tags=self.tags,
-                    read_only=self.read_only,
-                    description=self.description)
+        return dict(
+            service_type=self.service_type,
+            user_id=self.user_id,
+            project_id=self.project_id,
+            uuid=self.uuid,
+            id=self.id,
+            name=self.name,
+            tags=self.tags,
+            read_only=self.read_only,
+            description=self.description,
+        )
 
 
 class FakeAuthProtocol(mock.Mock):
-
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.app = FakeApp()
diff --git a/watcher/tests/fixtures/policy_fixture.py b/watcher/tests/fixtures/policy_fixture.py
index f4e15050c..5a46a5d32 100644
--- a/watcher/tests/fixtures/policy_fixture.py
+++ b/watcher/tests/fixtures/policy_fixture.py
@@ -28,11 +28,11 @@ CONF = cfg.CONF
 
 
 class PolicyFixture(fixtures.Fixture):
-
     def _setUp(self):
         self.policy_dir = self.useFixture(fixtures.TempDir())
-        self.policy_file_name = os.path.join(self.policy_dir.path,
-                                             'policy.yaml')
+        self.policy_file_name = os.path.join(
+            self.policy_dir.path, 'policy.yaml'
+        )
         with open(self.policy_file_name, 'w') as policy_file:
             policy_file.write(fake_policy.policy_data)
         policy_opts.set_defaults(CONF)
@@ -42,5 +42,4 @@ class PolicyFixture(fixtures.Fixture):
 
     def set_rules(self, rules):
         policy = watcher_policy._ENFORCER
-        policy.set_rules({k: _parser.parse_rule(v)
-                          for k, v in rules.items()})
+        policy.set_rules({k: _parser.parse_rule(v) for k, v in rules.items()})
diff --git a/watcher/tests/fixtures/watcher.py b/watcher/tests/fixtures/watcher.py
index 5b53b71f5..0f2ea85a9 100644
--- a/watcher/tests/fixtures/watcher.py
+++ b/watcher/tests/fixtures/watcher.py
@@ -88,7 +88,8 @@ class StandardLogging(fixtures.Fixture):
         # Collect logs
         fs = '%(asctime)s %(levelname)s [%(name)s] %(message)s'
         self.logger = self.useFixture(
-            fixtures.FakeLogger(format=fs, level=None))
+            fixtures.FakeLogger(format=fs, level=None)
+        )
         # TODO(sdague): why can't we send level through the fake
         # logger? Tests prove that it breaks, but it's worth getting
         # to the bottom of.
@@ -101,13 +102,15 @@ class StandardLogging(fixtures.Fixture):
             handler.setLevel(std_logging.DEBUG)
 
             # Don't log every single DB migration step
-            std_logging.getLogger(
-                'migrate.versioning.api').setLevel(std_logging.WARNING)
+            std_logging.getLogger('migrate.versioning.api').setLevel(
+                std_logging.WARNING
+            )
             # Or alembic for model comparisons.
             std_logging.getLogger('alembic').setLevel(std_logging.WARNING)
             # Or oslo_db provisioning steps
             std_logging.getLogger('oslo_db.sqlalchemy').setLevel(
-                std_logging.WARNING)
+                std_logging.WARNING
+            )
 
         # At times we end up calling back into main() functions in
         # testing. This has the possibility of calling logging.setup
@@ -118,23 +121,27 @@ class StandardLogging(fixtures.Fixture):
             pass
 
         self.useFixture(
-            fixtures.MonkeyPatch('oslo_log.log.setup', fake_logging_setup))
+            fixtures.MonkeyPatch('oslo_log.log.setup', fake_logging_setup)
+        )
 
 
 class KeystoneClient(fixtures.Fixture):
     """Fixture to mock the keystone client.
 
-       Prevents the OpenStackClients from actually connecting to the
-       keystone server.
-       Mocks the services.get and services.list methods.
+    Prevents the OpenStackClients from actually connecting to the
+    keystone server.
+    Mocks the services.get and services.list methods.
     """
 
     def setUp(self):
         super().setUp()
         mock_osc = mock.patch.object(
-            OpenStackClients, "keystone",
-            return_value=mock.MagicMock(spec=ks_client.Client))
+            OpenStackClients,
+            "keystone",
+            return_value=mock.MagicMock(spec=ks_client.Client),
+        )
         self.m_keystone = mock_osc.start()
         self.m_keystone.return_value.services = mock.MagicMock(
-            spec=ks_service.ServiceManager)
+            spec=ks_service.ServiceManager
+        )
         self.addCleanup(mock_osc.stop)
diff --git a/watcher/tests/unit/__init__.py b/watcher/tests/unit/__init__.py
index f5a8a61b6..fd50434db 100644
--- a/watcher/tests/unit/__init__.py
+++ b/watcher/tests/unit/__init__.py
@@ -28,6 +28,7 @@ eventlet.patch()
 # patching is enabled, it should be patched before calling this
 # function
 from watcher.common import oslo_service_helper as helper  # noqa E402
+
 helper.init_oslo_service_backend()
 
 from watcher import objects  # noqa E402
diff --git a/watcher/tests/unit/api/base.py b/watcher/tests/unit/api/base.py
index 89af0b8ec..9e362b4f6 100644
--- a/watcher/tests/unit/api/base.py
+++ b/watcher/tests/unit/api/base.py
@@ -52,13 +52,16 @@ class FunctionalTest(base.DbTestCase):
 
     def setUp(self):
         super().setUp()
-        cfg.CONF.set_override("auth_version", "v2.0",
-                              group='keystone_authtoken')
-        cfg.CONF.set_override("admin_user", "admin",
-                              group='keystone_authtoken')
+        cfg.CONF.set_override(
+            "auth_version", "v2.0", group='keystone_authtoken'
+        )
+        cfg.CONF.set_override(
+            "admin_user", "admin", group='keystone_authtoken'
+        )
 
-        p_services = mock.patch.object(n_service, "send_service_update",
-                                       new_callable=mock.PropertyMock)
+        p_services = mock.patch.object(
+            n_service, "send_service_update", new_callable=mock.PropertyMock
+        )
         self.m_services = p_services.start()
         self.addCleanup(p_services.stop)
 
@@ -79,19 +82,27 @@ class FunctionalTest(base.DbTestCase):
                 'modules': ['watcher.api'],
                 'hooks': [
                     hooks.ContextHook(),
-                    hooks.NoExceptionTracebackHook()
+                    hooks.NoExceptionTracebackHook(),
                 ],
                 'template_path': f'{root_dir}/api/templates',
                 'enable_acl': enable_acl,
                 'acl_public_routes': ['/', '/v1'],
-            },
+            }
         }
 
         return pecan.testing.load_test_app(self.config)
 
-    def _request_json(self, path, params, expect_errors=False, headers=None,
-                      method="post", extra_environ=None, status=None,
-                      path_prefix=PATH_PREFIX):
+    def _request_json(
+        self,
+        path,
+        params,
+        expect_errors=False,
+        headers=None,
+        method="post",
+        extra_environ=None,
+        status=None,
+        path_prefix=PATH_PREFIX,
+    ):
         """Sends simulated HTTP request to Pecan test app.
 
         :param path: url path of target service
@@ -114,12 +125,19 @@ class FunctionalTest(base.DbTestCase):
             headers=headers,
             status=status,
             extra_environ=extra_environ,
-            expect_errors=expect_errors
+            expect_errors=expect_errors,
         )
         return response
 
-    def put_json(self, path, params, expect_errors=False, headers=None,
-                 extra_environ=None, status=None):
+    def put_json(
+        self,
+        path,
+        params,
+        expect_errors=False,
+        headers=None,
+        extra_environ=None,
+        status=None,
+    ):
         """Sends simulated HTTP PUT request to Pecan test app.
 
         :param path: url path of target service
@@ -131,10 +149,15 @@ class FunctionalTest(base.DbTestCase):
                               with the request
         :param status: expected status code of response
         """
-        return self._request_json(path=path, params=params,
-                                  expect_errors=expect_errors,
-                                  headers=headers, extra_environ=extra_environ,
-                                  status=status, method="put")
+        return self._request_json(
+            path=path,
+            params=params,
+            expect_errors=expect_errors,
+            headers=headers,
+            extra_environ=extra_environ,
+            status=status,
+            method="put",
+        )
 
     def post(self, *args, **kwargs):
         headers = kwargs.pop('headers', {})
@@ -142,8 +165,15 @@ class FunctionalTest(base.DbTestCase):
         kwargs['headers'] = headers
         return self.app.post(*args, **kwargs)
 
-    def post_json(self, path, params, expect_errors=False, headers=None,
-                  extra_environ=None, status=None):
+    def post_json(
+        self,
+        path,
+        params,
+        expect_errors=False,
+        headers=None,
+        extra_environ=None,
+        status=None,
+    ):
         """Sends simulated HTTP POST request to Pecan test app.
 
         :param path: url path of target service
@@ -155,13 +185,25 @@ class FunctionalTest(base.DbTestCase):
                               with the request
         :param status: expected status code of response
         """
-        return self._request_json(path=path, params=params,
-                                  expect_errors=expect_errors,
-                                  headers=headers, extra_environ=extra_environ,
-                                  status=status, method="post")
+        return self._request_json(
+            path=path,
+            params=params,
+            expect_errors=expect_errors,
+            headers=headers,
+            extra_environ=extra_environ,
+            status=status,
+            method="post",
+        )
 
-    def patch_json(self, path, params, expect_errors=False, headers=None,
-                   extra_environ=None, status=None):
+    def patch_json(
+        self,
+        path,
+        params,
+        expect_errors=False,
+        headers=None,
+        extra_environ=None,
+        status=None,
+    ):
         """Sends simulated HTTP PATCH request to Pecan test app.
 
         :param path: url path of target service
@@ -173,13 +215,25 @@ class FunctionalTest(base.DbTestCase):
                               with the request
         :param status: expected status code of response
         """
-        return self._request_json(path=path, params=params,
-                                  expect_errors=expect_errors,
-                                  headers=headers, extra_environ=extra_environ,
-                                  status=status, method="patch")
+        return self._request_json(
+            path=path,
+            params=params,
+            expect_errors=expect_errors,
+            headers=headers,
+            extra_environ=extra_environ,
+            status=status,
+            method="patch",
+        )
 
-    def delete(self, path, expect_errors=False, headers=None,
-               extra_environ=None, status=None, path_prefix=PATH_PREFIX):
+    def delete(
+        self,
+        path,
+        expect_errors=False,
+        headers=None,
+        extra_environ=None,
+        status=None,
+        path_prefix=PATH_PREFIX,
+    ):
         """Sends simulated HTTP DELETE request to Pecan test app.
 
         :param path: url path of target service
@@ -192,16 +246,26 @@ class FunctionalTest(base.DbTestCase):
         :param path_prefix: prefix of the url path
         """
         full_path = path_prefix + path
-        response = self.app.delete(str(full_path),
-                                   headers=headers,
-                                   status=status,
-                                   extra_environ=extra_environ,
-                                   expect_errors=expect_errors)
+        response = self.app.delete(
+            str(full_path),
+            headers=headers,
+            status=status,
+            extra_environ=extra_environ,
+            expect_errors=expect_errors,
+        )
         return response
 
-    def get_json(self, path, expect_errors=False, headers=None,
-                 extra_environ=None, q=[], path_prefix=PATH_PREFIX,
-                 return_json=True, **params):
+    def get_json(
+        self,
+        path,
+        expect_errors=False,
+        headers=None,
+        extra_environ=None,
+        q=[],
+        path_prefix=PATH_PREFIX,
+        return_json=True,
+        **params,
+    ):
         """Sends simulated HTTP GET request to Pecan test app.
 
         :param path: url path of target service
@@ -216,10 +280,7 @@ class FunctionalTest(base.DbTestCase):
         :param params: content for wsgi.input of request
         """
         full_path = path_prefix + path
-        query_params = {'q.field': [],
-                        'q.value': [],
-                        'q.op': [],
-                        }
+        query_params = {'q.field': [], 'q.value': [], 'q.op': []}
         for query in q:
             for name in ['field', 'op', 'value']:
                 query_params[f'q.{name}'].append(query.get(name, ''))
@@ -228,11 +289,13 @@ class FunctionalTest(base.DbTestCase):
         if q:
             all_params.update(query_params)
 
-        response = self.app.get(full_path,
-                                params=all_params,
-                                headers=headers,
-                                extra_environ=extra_environ,
-                                expect_errors=expect_errors)
+        response = self.app.get(
+            full_path,
+            params=all_params,
+            headers=headers,
+            extra_environ=extra_environ,
+            expect_errors=expect_errors,
+        )
         if return_json and not expect_errors:
             response = response.json
         return response
@@ -259,19 +322,11 @@ class AdminRoleTest(base.DbTestCase):
     def setUp(self):
         super().setUp()
         token_info = {
-            'token': {
-                'project': {
-                    'id': 'admin'
-                },
-                'user': {
-                    'id': 'admin'
-                }
-            }
+            'token': {'project': {'id': 'admin'}, 'user': {'id': 'admin'}}
         }
         self.context = watcher_context.RequestContext(
-            auth_token_info=token_info,
-            project_id='admin',
-            user_id='admin')
+            auth_token_info=token_info, project_id='admin', user_id='admin'
+        )
 
         def make_context(*args, **kwargs):
             # If context hasn't been constructed with token_info
@@ -287,7 +342,8 @@ class AdminRoleTest(base.DbTestCase):
             context = watcher_context.RequestContext(*args, **kwargs)
             return watcher_context.RequestContext.from_dict(context.to_dict())
 
-        p = mock.patch.object(watcher_context, 'make_context',
-                              side_effect=make_context)
+        p = mock.patch.object(
+            watcher_context, 'make_context', side_effect=make_context
+        )
         self.mock_make_context = p.start()
         self.addCleanup(p.stop)
diff --git a/watcher/tests/unit/api/test_base.py b/watcher/tests/unit/api/test_base.py
index 161b650f1..8f80a2cd3 100644
--- a/watcher/tests/unit/api/test_base.py
+++ b/watcher/tests/unit/api/test_base.py
@@ -19,14 +19,15 @@ from watcher.tests.unit.api import base
 
 
 class TestBase(base.FunctionalTest):
-
     def test_api_setup(self):
         pass
 
     def test_bad_uri(self):
-        response = self.get_json('/bad/path',
-                                 expect_errors=True,
-                                 headers={"Accept": "application/json"})
+        response = self.get_json(
+            '/bad/path',
+            expect_errors=True,
+            headers={"Accept": "application/json"},
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual("application/json", response.content_type)
         self.assertTrue(response.json['error_message'])
diff --git a/watcher/tests/unit/api/test_config.py b/watcher/tests/unit/api/test_config.py
index 4f6159058..14e590f6c 100644
--- a/watcher/tests/unit/api/test_config.py
+++ b/watcher/tests/unit/api/test_config.py
@@ -21,17 +21,18 @@ from watcher.tests.unit.api import base
 
 
 class TestRoot(base.FunctionalTest):
-
     def test_config_enable_webhooks_auth(self):
         acl_public_routes = ['/']
         cfg.CONF.set_override('enable_webhooks_auth', True, 'api')
         importlib.reload(api_config)
-        self.assertEqual(acl_public_routes,
-                         api_config.app['acl_public_routes'])
+        self.assertEqual(
+            acl_public_routes, api_config.app['acl_public_routes']
+        )
 
     def test_config_disable_webhooks_auth(self):
         acl_public_routes = ['/', '/v1/webhooks/.*']
         cfg.CONF.set_override('enable_webhooks_auth', False, 'api')
         importlib.reload(api_config)
-        self.assertEqual(acl_public_routes,
-                         api_config.app['acl_public_routes'])
+        self.assertEqual(
+            acl_public_routes, api_config.app['acl_public_routes']
+        )
diff --git a/watcher/tests/unit/api/test_hooks.py b/watcher/tests/unit/api/test_hooks.py
index 57d433cbf..278631c57 100644
--- a/watcher/tests/unit/api/test_hooks.py
+++ b/watcher/tests/unit/api/test_hooks.py
@@ -50,12 +50,14 @@ class FakeRequestState:
             'auth_token': headers.get('X-Auth-Token'),
             'roles': headers.get('X-Roles', '').split(','),
         }
-        is_admin = ('admin' in creds['roles'] or
-                    'administrator' in creds['roles'])
+        is_admin = (
+            'admin' in creds['roles'] or 'administrator' in creds['roles']
+        )
         is_public_api = self.request.environ.get('is_public_api', False)
 
         self.request.context = context.RequestContext(
-            is_admin=is_admin, is_public_api=is_public_api, **creds)
+            is_admin=is_admin, is_public_api=is_public_api, **creds
+        )
 
 
 def fake_headers(admin=False):
@@ -77,38 +79,43 @@ def fake_headers(admin=False):
         'X-User-Name': 'foo',
     }
     if admin:
-        headers.update({
-            'X-Project-Name': 'admin',
-            'X-Role': '_member_,admin',
-            'X-Roles': '_member_,admin',
-            'X-Tenant': 'admin',
-            # 'X-Tenant-Name': 'admin',
-            # 'X-Tenant': 'admin'
-            'X-Tenant-Name': 'admin',
-            'X-Tenant-Id': 'c2a3a69d456a412376efdd9dac38',
-            'X-Project-Id': 'c2a3a69d456a412376efdd9dac38',
-        })
+        headers.update(
+            {
+                'X-Project-Name': 'admin',
+                'X-Role': '_member_,admin',
+                'X-Roles': '_member_,admin',
+                'X-Tenant': 'admin',
+                # 'X-Tenant-Name': 'admin',
+                # 'X-Tenant': 'admin'
+                'X-Tenant-Name': 'admin',
+                'X-Tenant-Id': 'c2a3a69d456a412376efdd9dac38',
+                'X-Project-Id': 'c2a3a69d456a412376efdd9dac38',
+            }
+        )
     else:
-        headers.update({
-            'X-Role': '_member_',
-            'X-Roles': '_member_',
-            'X-Tenant': 'foo',
-            'X-Tenant-Name': 'foo',
-            'X-Tenant-Id': 'b4efa69d,4ffa4973863f2eefc094f7f8',
-            'X-Project-Name': 'foo',
-            'X-Project-Id': 'b4efa69d4ffa4973863f2eefc094f7f8',
-        })
+        headers.update(
+            {
+                'X-Role': '_member_',
+                'X-Roles': '_member_',
+                'X-Tenant': 'foo',
+                'X-Tenant-Name': 'foo',
+                'X-Tenant-Id': 'b4efa69d,4ffa4973863f2eefc094f7f8',
+                'X-Project-Name': 'foo',
+                'X-Project-Id': 'b4efa69d4ffa4973863f2eefc094f7f8',
+            }
+        )
     return headers
 
 
 class TestNoExceptionTracebackHook(base.FunctionalTest):
-
-    TRACE = ['Traceback (most recent call last):',
-             '  File "/opt/stack/watcher/watcher/common/rpc/amqp.py",'
-             ' line 434, in _process_data\\n   **args)',
-             '  File "/opt/stack/watcher/watcher/common/rpc/'
-             'dispatcher.py", line 172, in dispatch\\n   result ='
-             ' getattr(proxyobj, method)(ctxt, **kwargs)']
+    TRACE = [
+        'Traceback (most recent call last):',
+        '  File "/opt/stack/watcher/watcher/common/rpc/amqp.py",'
+        ' line 434, in _process_data\\n   **args)',
+        '  File "/opt/stack/watcher/watcher/common/rpc/'
+        'dispatcher.py", line 172, in dispatch\\n   result ='
+        ' getattr(proxyobj, method)(ctxt, **kwargs)',
+    ]
     MSG_WITHOUT_TRACE = "Test exception message."
     MSG_WITH_TRACE = MSG_WITHOUT_TRACE + "\n" + "\n".join(TRACE)
 
@@ -124,14 +131,16 @@ class TestNoExceptionTracebackHook(base.FunctionalTest):
 
         response = self.get_json('/', path_prefix='', expect_errors=True)
 
-        actual_msg = jsonutils.loads(
-            response.json['error_message'])['faultstring']
+        actual_msg = jsonutils.loads(response.json['error_message'])[
+            'faultstring'
+        ]
         self.assertEqual(self.MSG_WITHOUT_TRACE, actual_msg)
 
     def test_hook_remote_error_success(self):
         test_exc_type = 'TestException'
         self.root_convert_mock.side_effect = messaging.rpc.RemoteError(
-            test_exc_type, self.MSG_WITHOUT_TRACE, self.TRACE)
+            test_exc_type, self.MSG_WITHOUT_TRACE, self.TRACE
+        )
 
         response = self.get_json('/', path_prefix='', expect_errors=True)
 
@@ -140,10 +149,12 @@ class TestNoExceptionTracebackHook(base.FunctionalTest):
         # instead of'\n'.join(trace). But since RemoteError is kind of very
         # rare thing (happens due to wrong deserialization settings etc.)
         # we don't care about this garbage.
-        expected_msg = (f"Remote error: {test_exc_type} "
-                        f"{self.MSG_WITHOUT_TRACE}\n['")
-        actual_msg = jsonutils.loads(
-            response.json['error_message'])['faultstring']
+        expected_msg = (
+            f"Remote error: {test_exc_type} {self.MSG_WITHOUT_TRACE}\n['"
+        )
+        actual_msg = jsonutils.loads(response.json['error_message'])[
+            'faultstring'
+        ]
         self.assertEqual(expected_msg, actual_msg)
 
     def _test_hook_without_traceback(self):
@@ -152,8 +163,9 @@ class TestNoExceptionTracebackHook(base.FunctionalTest):
 
         response = self.get_json('/', path_prefix='', expect_errors=True)
 
-        actual_msg = jsonutils.loads(
-            response.json['error_message'])['faultstring']
+        actual_msg = jsonutils.loads(response.json['error_message'])[
+            'faultstring'
+        ]
         self.assertEqual(msg, actual_msg)
 
     def test_hook_without_traceback(self):
@@ -168,8 +180,9 @@ class TestNoExceptionTracebackHook(base.FunctionalTest):
 
         response = self.get_json('/', path_prefix='', expect_errors=True)
 
-        actual_msg = jsonutils.loads(
-            response.json['error_message'])['faultstring']
+        actual_msg = jsonutils.loads(response.json['error_message'])[
+            'faultstring'
+        ]
         return actual_msg
 
     def test_hook_on_serverfault(self):
@@ -189,8 +202,9 @@ class TestNoExceptionTracebackHook(base.FunctionalTest):
 
         response = self.get_json('/', path_prefix='', expect_errors=True)
 
-        actual_msg = jsonutils.loads(
-            response.json['error_message'])['faultstring']
+        actual_msg = jsonutils.loads(response.json['error_message'])[
+            'faultstring'
+        ]
         return actual_msg
 
     def test_hook_on_clientfault(self):
@@ -207,7 +221,8 @@ class TestContextHook(base.FunctionalTest):
     @mock.patch.object(context, 'RequestContext')
     def test_context_hook_not_admin(self, mock_ctx):
         cfg.CONF.set_override(
-            'auth_type', 'password', group='watcher_clients_auth')
+            'auth_type', 'password', group='watcher_clients_auth'
+        )
         headers = fake_headers(admin=False)
         reqstate = FakeRequestState(headers=headers)
         context_hook = hooks.ContextHook()
@@ -222,12 +237,14 @@ class TestContextHook(base.FunctionalTest):
             project_id=headers['X-Project-Id'],
             show_deleted=None,
             auth_token_info=self.token_info,
-            roles=headers['X-Roles'].split(','))
+            roles=headers['X-Roles'].split(','),
+        )
 
     @mock.patch.object(context, 'RequestContext')
     def test_context_hook_admin(self, mock_ctx):
         cfg.CONF.set_override(
-            'auth_type', 'password', group='watcher_clients_auth')
+            'auth_type', 'password', group='watcher_clients_auth'
+        )
         headers = fake_headers(admin=True)
         reqstate = FakeRequestState(headers=headers)
         context_hook = hooks.ContextHook()
@@ -242,12 +259,14 @@ class TestContextHook(base.FunctionalTest):
             project_id=headers['X-Project-Id'],
             show_deleted=None,
             auth_token_info=self.token_info,
-            roles=headers['X-Roles'].split(','))
+            roles=headers['X-Roles'].split(','),
+        )
 
     @mock.patch.object(context, 'RequestContext')
     def test_context_hook_public_api(self, mock_ctx):
         cfg.CONF.set_override(
-            'auth_type', 'password', group='watcher_clients_auth')
+            'auth_type', 'password', group='watcher_clients_auth'
+        )
         headers = fake_headers(admin=True)
         env = {'is_public_api': True}
         reqstate = FakeRequestState(headers=headers, environ=env)
@@ -263,4 +282,5 @@ class TestContextHook(base.FunctionalTest):
             project_id=headers['X-Project-Id'],
             show_deleted=None,
             auth_token_info=self.token_info,
-            roles=headers['X-Roles'].split(','))
+            roles=headers['X-Roles'].split(','),
+        )
diff --git a/watcher/tests/unit/api/test_root.py b/watcher/tests/unit/api/test_root.py
index c0c0a2328..8874110f4 100644
--- a/watcher/tests/unit/api/test_root.py
+++ b/watcher/tests/unit/api/test_root.py
@@ -17,7 +17,6 @@ from watcher.tests.unit.api import base
 
 
 class TestRoot(base.FunctionalTest):
-
     def test_get_root(self):
         data = self.get_json('/', path_prefix='')
         self.assertEqual('v1', data['default_version']['id'])
@@ -32,10 +31,10 @@ class TestRoot(base.FunctionalTest):
 
 
 class TestV1Root(base.FunctionalTest):
-
     def test_get_v1_root_all(self):
         data = self.get_json(
-            '/', headers={'OpenStack-API-Version': 'infra-optim 1.4'})
+            '/', headers={'OpenStack-API-Version': 'infra-optim 1.4'}
+        )
         self.assertEqual('v1', data['id'])
         # Check fields are not empty
         for f in data.keys():
@@ -43,17 +42,30 @@ class TestV1Root(base.FunctionalTest):
         # Check if all known resources are present and there are no extra ones.
         not_resources = ('id', 'links', 'media_types')
         actual_resources = tuple(set(data.keys()) - set(not_resources))
-        expected_resources = ('audit_templates', 'audits', 'actions',
-                              'action_plans', 'data_model', 'scoring_engines',
-                              'services', 'webhooks')
+        expected_resources = (
+            'audit_templates',
+            'audits',
+            'actions',
+            'action_plans',
+            'data_model',
+            'scoring_engines',
+            'services',
+            'webhooks',
+        )
         self.assertEqual(sorted(expected_resources), sorted(actual_resources))
 
-        self.assertIn({'type': 'application/vnd.openstack.watcher.v1+json',
-                       'base': 'application/json'}, data['media_types'])
+        self.assertIn(
+            {
+                'type': 'application/vnd.openstack.watcher.v1+json',
+                'base': 'application/json',
+            },
+            data['media_types'],
+        )
 
     def test_get_v1_root_without_datamodel(self):
         data = self.get_json(
-            '/', headers={'OpenStack-API-Version': 'infra-optim 1.2'})
+            '/', headers={'OpenStack-API-Version': 'infra-optim 1.2'}
+        )
         self.assertEqual('v1', data['id'])
         # Check fields are not empty
         for f in data.keys():
@@ -61,10 +73,20 @@ class TestV1Root(base.FunctionalTest):
         # Check if all known resources are present and there are no extra ones.
         not_resources = ('id', 'links', 'media_types')
         actual_resources = tuple(set(data.keys()) - set(not_resources))
-        expected_resources = ('audit_templates', 'audits', 'actions',
-                              'action_plans', 'scoring_engines',
-                              'services')
+        expected_resources = (
+            'audit_templates',
+            'audits',
+            'actions',
+            'action_plans',
+            'scoring_engines',
+            'services',
+        )
         self.assertEqual(sorted(expected_resources), sorted(actual_resources))
 
-        self.assertIn({'type': 'application/vnd.openstack.watcher.v1+json',
-                       'base': 'application/json'}, data['media_types'])
+        self.assertIn(
+            {
+                'type': 'application/vnd.openstack.watcher.v1+json',
+                'base': 'application/json',
+            },
+            data['media_types'],
+        )
diff --git a/watcher/tests/unit/api/test_utils.py b/watcher/tests/unit/api/test_utils.py
index 81c4ba7e5..8ae9c3dd0 100644
--- a/watcher/tests/unit/api/test_utils.py
+++ b/watcher/tests/unit/api/test_utils.py
@@ -22,20 +22,23 @@ from watcher.tests.unit import base
 
 
 class TestApiUtilsValidScenarios(base.TestCase):
-
     scenarios = [
-        ("limit=None + max_limit=None",
-            {"limit": None, "max_limit": None, "expected": None}),
-        ("limit=None + max_limit=1",
-            {"limit": None, "max_limit": 1, "expected": 1}),
+        (
+            "limit=None + max_limit=None",
+            {"limit": None, "max_limit": None, "expected": None},
+        ),
+        (
+            "limit=None + max_limit=1",
+            {"limit": None, "max_limit": 1, "expected": 1},
+        ),
         # ("limit=0 + max_limit=None",
         #     {"limit": 0, "max_limit": None, "expected": 0}),
-        ("limit=1 + max_limit=None",
-            {"limit": 1, "max_limit": None, "expected": 1}),
-        ("limit=1 + max_limit=1",
-            {"limit": 1, "max_limit": 1, "expected": 1}),
-        ("limit=2 + max_limit=1",
-            {"limit": 2, "max_limit": 1, "expected": 1}),
+        (
+            "limit=1 + max_limit=None",
+            {"limit": 1, "max_limit": None, "expected": 1},
+        ),
+        ("limit=1 + max_limit=1", {"limit": 1, "max_limit": 1, "expected": 1}),
+        ("limit=2 + max_limit=1", {"limit": 2, "max_limit": 1, "expected": 1}),
     ]
 
     def test_validate_limit(self):
@@ -45,10 +48,7 @@ class TestApiUtilsValidScenarios(base.TestCase):
 
 
 class TestApiUtilsInvalidScenarios(base.TestCase):
-
-    scenarios = [
-        ("limit=0 + max_limit=None", {"limit": 0, "max_limit": None}),
-    ]
+    scenarios = [("limit=0 + max_limit=None", {"limit": 0, "max_limit": None})]
 
     def test_validate_limit_invalid_cases(self):
         cfg.CONF.set_override("max_limit", self.max_limit, group="api")
diff --git a/watcher/tests/unit/api/utils.py b/watcher/tests/unit/api/utils.py
index 069146e19..84d1191c5 100644
--- a/watcher/tests/unit/api/utils.py
+++ b/watcher/tests/unit/api/utils.py
@@ -36,28 +36,31 @@ class FakeMemcache:
     _cache = {
         f'tokens/{ADMIN_TOKEN}': {
             'access': {
-                'token': {'id': ADMIN_TOKEN,
-                          'expires': '2100-09-11T00:00:00'},
-                'user': {'id': 'user_id1',
-                         'name': 'user_name1',
-                         'tenantId': '123i2910',
-                         'tenantName': 'mytenant',
-                         'roles': [{'name': 'admin'}]
-                         },
+                'token': {'id': ADMIN_TOKEN, 'expires': '2100-09-11T00:00:00'},
+                'user': {
+                    'id': 'user_id1',
+                    'name': 'user_name1',
+                    'tenantId': '123i2910',
+                    'tenantName': 'mytenant',
+                    'roles': [{'name': 'admin'}],
+                },
             }
         },
         f'tokens/{MEMBER_TOKEN}': {
             'access': {
-                'token': {'id': MEMBER_TOKEN,
-                          'expires': '2100-09-11T00:00:00'},
-                'user': {'id': 'user_id2',
-                         'name': 'user-good',
-                         'tenantId': 'project-good',
-                         'tenantName': 'goodies',
-                         'roles': [{'name': 'Member'}]
-                         }
+                'token': {
+                    'id': MEMBER_TOKEN,
+                    'expires': '2100-09-11T00:00:00',
+                },
+                'user': {
+                    'id': 'user_id2',
+                    'name': 'user-good',
+                    'tenantId': 'project-good',
+                    'tenantName': 'goodies',
+                    'roles': [{'name': 'Member'}],
+                },
             }
-        }
+        },
     }
 
     def __init__(self):
@@ -77,9 +80,7 @@ class FakeMemcache:
 def remove_internal(values, internal):
     # NOTE(yuriyz): internal attributes should not be posted, except uuid
     int_attr = [attr.lstrip('/') for attr in internal if attr != '/uuid']
-    return {
-        k: v for (k, v) in values.items() if k not in int_attr
-    }
+    return {k: v for (k, v) in values.items() if k not in int_attr}
 
 
 def audit_post_data(**kw):
diff --git a/watcher/tests/unit/api/v1/test_actions.py b/watcher/tests/unit/api/v1/test_actions.py
index 6738be5a0..d3b013b26 100644
--- a/watcher/tests/unit/api/v1/test_actions.py
+++ b/watcher/tests/unit/api/v1/test_actions.py
@@ -35,24 +35,24 @@ def post_get_test_action(**kw):
     action = api_utils.action_post_data(**kw)
     action_plan = db_utils.get_test_action_plan()
     del action['action_plan_id']
-    action['action_plan_uuid'] = kw.get('action_plan_uuid',
-                                        action_plan['uuid'])
+    action['action_plan_uuid'] = kw.get(
+        'action_plan_uuid', action_plan['uuid']
+    )
     action['parents'] = None
     return action
 
 
 class TestActionObject(base.TestCase):
-
     def test_action_init(self):
-        action_dict = api_utils.action_post_data(action_plan_id=None,
-                                                 parents=None)
+        action_dict = api_utils.action_post_data(
+            action_plan_id=None, parents=None
+        )
         del action_dict['state']
         action = api_action.Action(**action_dict)
         self.assertEqual(wtypes.Unset, action.state)
 
 
 class TestListAction(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         self.goal = obj_utils.create_test_goal(self.context)
@@ -78,9 +78,11 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_list_with_status_message(self):
         action = obj_utils.create_test_action(
-            self.context, parents=None, status_message='Fake message')
+            self.context, parents=None, status_message='Fake message'
+        )
         response = self.get_json(
-            '/actions', headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            '/actions', headers={'OpenStack-API-Version': 'infra-optim 1.5'}
+        )
         self.assertEqual(action.uuid, response['actions'][0]["uuid"])
         self._assert_action_fields(response['actions'][0])
         # status_message is not in the basic actions list
@@ -88,7 +90,8 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_list_detail_with_hidden_status_message(self):
         action = obj_utils.create_test_action(
-            self.context, status_message='Fake message', parents=None)
+            self.context, status_message='Fake message', parents=None
+        )
         response = self.get_json('/actions/detail')
         self.assertEqual(action.uuid, response['actions'][0]["uuid"])
         self._assert_action_fields(response['actions'][0])
@@ -96,20 +99,24 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_list_detail_with_status_message(self):
         action = obj_utils.create_test_action(
-            self.context, status_message='Fake message', parents=None)
+            self.context, status_message='Fake message', parents=None
+        )
         response = self.get_json(
             '/actions/detail',
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(action.uuid, response['actions'][0]["uuid"])
         self._assert_action_fields(response['actions'][0])
         self.assertEqual(
-            'Fake message', response['actions'][0]["status_message"])
+            'Fake message', response['actions'][0]["status_message"]
+        )
 
     def test_list_soft_deleted(self):
         action = obj_utils.create_test_action(self.context, parents=None)
         action.soft_delete()
-        response = self.get_json('/actions',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/actions', headers={'X-Show-Deleted': 'True'}
+        )
         self.assertEqual(action.uuid, response['actions'][0]["uuid"])
         self._assert_action_fields(response['actions'][0])
 
@@ -127,10 +134,12 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_show_with_status_message(self):
         action = obj_utils.create_test_action(
-            self.context, parents=None, status_message='test')
+            self.context, parents=None, status_message='test'
+        )
         response = self.get_json(
             '/actions/{}'.format(action['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(action.uuid, response['uuid'])
         self.assertEqual(action.action_type, response['action_type'])
         self.assertEqual(action.input_parameters, response['input_parameters'])
@@ -139,10 +148,12 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_show_with_hidden_status_message(self):
         action = obj_utils.create_test_action(
-            self.context, parents=None, status_message='test')
+            self.context, parents=None, status_message='test'
+        )
         response = self.get_json(
             '/actions/{}'.format(action['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.4'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.4'},
+        )
         self.assertEqual(action.uuid, response['uuid'])
         self.assertEqual(action.action_type, response['action_type'])
         self.assertEqual(action.input_parameters, response['input_parameters'])
@@ -153,7 +164,8 @@ class TestListAction(api_base.FunctionalTest):
         action = obj_utils.create_test_action(self.context, parents=None)
         response = self.get_json(
             '/actions/{}'.format(action['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(action.uuid, response['uuid'])
         self.assertEqual(action.action_type, response['action_type'])
         self.assertEqual(action.input_parameters, response['input_parameters'])
@@ -163,13 +175,16 @@ class TestListAction(api_base.FunctionalTest):
     def test_show_soft_deleted(self):
         action = obj_utils.create_test_action(self.context, parents=None)
         action.soft_delete()
-        response = self.get_json('/actions/{}'.format(action['uuid']),
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/actions/{}'.format(action['uuid']),
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(action.uuid, response['uuid'])
         self._assert_action_fields(response)
 
-        response = self.get_json('/actions/{}'.format(action['uuid']),
-                                 expect_errors=True)
+        response = self.get_json(
+            '/actions/{}'.format(action['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_list_detail(self):
@@ -181,8 +196,9 @@ class TestListAction(api_base.FunctionalTest):
     def test_list_detail_soft_deleted(self):
         action = obj_utils.create_test_action(self.context, parents=None)
         action.soft_delete()
-        response = self.get_json('/actions/detail',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/actions/detail', headers={'X-Show-Deleted': 'True'}
+        )
         self.assertEqual(action.uuid, response['actions'][0]["uuid"])
         self._assert_action_fields(response['actions'][0])
 
@@ -191,15 +207,17 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_show_detail(self):
         action = obj_utils.create_test_action(self.context, parents=None)
-        response = self.get_json('/actions/{}/detail'.format(action['uuid']),
-                                 expect_errors=True)
+        response = self.get_json(
+            '/actions/{}/detail'.format(action['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_list_multiple_actions(self):
         action_list = []
         for id_ in range(5):
-            action = obj_utils.create_test_action(self.context, id=id_,
-                                                  uuid=utils.generate_uuid())
+            action = obj_utils.create_test_action(
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_list.append(action.uuid)
         response = self.get_json('/actions')
         self.assertEqual(len(action_list), len(response['actions']))
@@ -208,16 +226,16 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_list_with_action_plan_uuid(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context,
-            id=2,
-            uuid=utils.generate_uuid(),
-            audit_id=1)
+            self.context, id=2, uuid=utils.generate_uuid(), audit_id=1
+        )
         action_list = []
         for id_ in range(5):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=2,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             action_list.append(action.uuid)
         response = self.get_json('/actions')
         self.assertEqual(len(action_list), len(response['actions']))
@@ -226,30 +244,36 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_list_filter_by_audit_uuid(self):
         action_plan_1 = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid())
+            self.context, uuid=utils.generate_uuid()
+        )
         action_list = []
 
         for id_ in range(3):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan_1.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             action_list.append(action.uuid)
 
         audit2 = obj_utils.create_test_audit(
-            self.context, id=2, uuid=utils.generate_uuid(),
-            name=f'My Audit {2}')
-        action_plan_2 = obj_utils.create_test_action_plan(
             self.context,
+            id=2,
             uuid=utils.generate_uuid(),
-            audit_id=audit2.id)
+            name=f'My Audit {2}',
+        )
+        action_plan_2 = obj_utils.create_test_action_plan(
+            self.context, uuid=utils.generate_uuid(), audit_id=audit2.id
+        )
 
         for id_ in range(4, 5, 6):
             obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan_2.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
 
         response = self.get_json(f'/actions?audit_uuid={self.audit.uuid}')
         self.assertEqual(len(action_list), len(response['actions']))
@@ -258,172 +282,190 @@ class TestListAction(api_base.FunctionalTest):
 
     def test_list_filter_by_action_plan_uuid(self):
         action_plan_1 = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
         action_list = []
 
         for id_ in range(3):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan_1.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             action_list.append(action.uuid)
 
         action_plan_2 = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
 
         for id_ in range(4, 5, 6):
             obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan_2.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
 
         response = self.get_json(
-            f'/actions?action_plan_uuid={action_plan_1.uuid}')
+            f'/actions?action_plan_uuid={action_plan_1.uuid}'
+        )
         self.assertEqual(len(action_list), len(response['actions']))
         for action in response['actions']:
             self.assertEqual(action_plan_1.uuid, action['action_plan_uuid'])
 
         response = self.get_json(
-            f'/actions?action_plan_uuid={action_plan_2.uuid}')
+            f'/actions?action_plan_uuid={action_plan_2.uuid}'
+        )
         for action in response['actions']:
             self.assertEqual(action_plan_2.uuid, action['action_plan_uuid'])
 
     def test_list_details_and_filter_by_action_plan_uuid(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
 
         for id_ in range(1, 3):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
 
         response = self.get_json(
-            f'/actions/detail?action_plan_uuid={action_plan.uuid}')
+            f'/actions/detail?action_plan_uuid={action_plan.uuid}'
+        )
         for action in response['actions']:
             self.assertEqual(action_plan.uuid, action['action_plan_uuid'])
 
     def test_list_details_and_filter_by_audit_uuid(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
 
         for id_ in range(1, 3):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
 
         response = self.get_json(
-            f'/actions/detail?audit_uuid={self.audit.uuid}')
+            f'/actions/detail?audit_uuid={self.audit.uuid}'
+        )
         for action in response['actions']:
             self.assertEqual(action_plan.uuid, action['action_plan_uuid'])
 
     def test_list_filter_by_action_plan_and_audit_uuids(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
-        url = (f'/actions?action_plan_uuid={action_plan.uuid}&'
-               f'audit_uuid={self.audit.uuid}')
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
+        url = (
+            f'/actions?action_plan_uuid={action_plan.uuid}&'
+            f'audit_uuid={self.audit.uuid}'
+        )
         response = self.get_json(url, expect_errors=True)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
     def test_list_with_sort_key_uuid(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
 
         actions_list = []
         for id_ in range(1, 3):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             actions_list.append(action)
 
         response = self.get_json('/actions?sort_key={}'.format('uuid'))
         names = [s['uuid'] for s in response['actions']]
 
-        self.assertEqual(
-            sorted([a.uuid for a in actions_list]),
-            names)
+        self.assertEqual(sorted([a.uuid for a in actions_list]), names)
 
     def test_list_with_sort_key_action_plan_uuid(self):
         action_plan_1 = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
 
         action_plan_2 = obj_utils.create_test_action_plan(
-            self.context,
-            uuid=utils.generate_uuid(),
-            audit_id=self.audit.id)
+            self.context, uuid=utils.generate_uuid(), audit_id=self.audit.id
+        )
 
         action_plans_uuid_list = []
-        for id_, action_plan_id in enumerate(itertools.chain.from_iterable([
-                itertools.repeat(action_plan_1.id, 3),
-                itertools.repeat(action_plan_2.id, 2)]), 1):
+        for id_, action_plan_id in enumerate(
+            itertools.chain.from_iterable(
+                [
+                    itertools.repeat(action_plan_1.id, 3),
+                    itertools.repeat(action_plan_2.id, 2),
+                ]
+            ),
+            1,
+        ):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan_id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             action_plans_uuid_list.append(action.action_plan.uuid)
 
         for direction in ['asc', 'desc']:
             response = self.get_json(
-                '/actions?sort_key={}&sort_dir={}'
-                .format('action_plan_uuid', direction))
+                '/actions?sort_key={}&sort_dir={}'.format(
+                    'action_plan_uuid', direction
+                )
+            )
 
-            action_plan_uuids = \
-                [s['action_plan_uuid'] for s in response['actions']]
+            action_plan_uuids = [
+                s['action_plan_uuid'] for s in response['actions']
+            ]
 
             self.assertEqual(
                 sorted(action_plans_uuid_list, reverse=(direction == 'desc')),
                 action_plan_uuids,
-                message=f'Failed on {direction} direction')
+                message=f'Failed on {direction} direction',
+            )
 
     def test_list_sort_key_validation(self):
         response = self.get_json(
-            '/actions?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/actions?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
     def test_list_with_soft_deleted_action_plan_uuid(self):
         action_plan1 = obj_utils.create_test_action_plan(
-            self.context,
-            id=2,
-            uuid=utils.generate_uuid(),
-            audit_id=1)
+            self.context, id=2, uuid=utils.generate_uuid(), audit_id=1
+        )
         action_plan2 = obj_utils.create_test_action_plan(
-            self.context,
-            id=3,
-            uuid=utils.generate_uuid(),
-            audit_id=1)
+            self.context, id=3, uuid=utils.generate_uuid(), audit_id=1
+        )
 
         ap1_action_list = []
         ap2_action_list = []
 
         for id_ in range(0, 2):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan1.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             ap1_action_list.append(action)
 
         for id_ in range(2, 4):
             action = obj_utils.create_test_action(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 action_plan_id=action_plan2.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             ap2_action_list.append(action)
 
         action_plan1.state = objects.action_plan.State.CANCELLED
@@ -435,43 +477,62 @@ class TestListAction(api_base.FunctionalTest):
         self.assertEqual(len(ap2_action_list), len(response['actions']))
 
         # We deleted them so that's normal
-        self.assertEqual([],
-                         [act for act in response['actions']
-                          if act['action_plan_uuid'] == action_plan1.uuid])
+        self.assertEqual(
+            [],
+            [
+                act
+                for act in response['actions']
+                if act['action_plan_uuid'] == action_plan1.uuid
+            ],
+        )
 
         # Here are the 2 actions left
         self.assertEqual(
             {act.as_dict()['uuid'] for act in ap2_action_list},
-            {act['uuid'] for act in response['actions']
-             if act['action_plan_uuid'] == action_plan2.uuid})
+            {
+                act['uuid']
+                for act in response['actions']
+                if act['action_plan_uuid'] == action_plan2.uuid
+            },
+        )
 
     def test_list_with_parents(self):
         action_list = []
         for id_ in range(5):
             if id_ > 0:
                 action = obj_utils.create_test_action(
-                    self.context, id=id_, uuid=utils.generate_uuid(),
-                    parents=[action_list[id_ - 1]])
+                    self.context,
+                    id=id_,
+                    uuid=utils.generate_uuid(),
+                    parents=[action_list[id_ - 1]],
+                )
             else:
                 action = obj_utils.create_test_action(
-                    self.context, id=id_, uuid=utils.generate_uuid(),
-                    parents=[])
+                    self.context,
+                    id=id_,
+                    uuid=utils.generate_uuid(),
+                    parents=[],
+                )
             action_list.append(action.uuid)
         response = self.get_json('/actions')
         response_actions = response['actions']
         for id_ in range(4):
-            self.assertEqual(response_actions[id_]['uuid'],
-                             response_actions[id_ + 1]['parents'][0])
+            self.assertEqual(
+                response_actions[id_]['uuid'],
+                response_actions[id_ + 1]['parents'][0],
+            )
 
     def test_list_without_soft_deleted(self):
         action_list = []
         for id_ in [1, 2, 3]:
-            action = obj_utils.create_test_action(self.context, id=id_,
-                                                  uuid=utils.generate_uuid())
+            action = obj_utils.create_test_action(
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_list.append(action.uuid)
         for id_ in [4, 5]:
-            action = obj_utils.create_test_action(self.context, id=id_,
-                                                  uuid=utils.generate_uuid())
+            action = obj_utils.create_test_action(
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action.soft_delete()
         response = self.get_json('/actions')
         self.assertEqual(3, len(response['actions']))
@@ -481,16 +542,19 @@ class TestListAction(api_base.FunctionalTest):
     def test_list_with_soft_deleted(self):
         action_list = []
         for id_ in [1, 2, 3]:
-            action = obj_utils.create_test_action(self.context, id=id_,
-                                                  uuid=utils.generate_uuid())
+            action = obj_utils.create_test_action(
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_list.append(action.uuid)
         for id_ in [4, 5]:
-            action = obj_utils.create_test_action(self.context, id=id_,
-                                                  uuid=utils.generate_uuid())
+            action = obj_utils.create_test_action(
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action.soft_delete()
             action_list.append(action.uuid)
-        response = self.get_json('/actions',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/actions', headers={'X-Show-Deleted': 'True'}
+        )
         self.assertEqual(5, len(response['actions']))
         uuids = [s['uuid'] for s in response['actions']]
         self.assertEqual(sorted(action_list), sorted(uuids))
@@ -504,15 +568,19 @@ class TestListAction(api_base.FunctionalTest):
         self.assertIn(uuid, response['links'][0]['href'])
         for link in response['links']:
             bookmark = link['rel'] == 'bookmark'
-            self.assertTrue(self.validate_link(
-                link['href'], bookmark=bookmark))
+            self.assertTrue(
+                self.validate_link(link['href'], bookmark=bookmark)
+            )
 
     def test_list_with_limit(self):
         parents = None
         for id_ in range(5):
-            action = obj_utils.create_test_action(self.context, id=id_,
-                                                  uuid=utils.generate_uuid(),
-                                                  parents=parents)
+            action = obj_utils.create_test_action(
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                parents=parents,
+            )
             parents = [action.uuid]
         response = self.get_json('/actions/?limit=3')
         self.assertEqual(3, len(response['actions']))
@@ -520,28 +588,30 @@ class TestListAction(api_base.FunctionalTest):
     def test_list_with_default_max_limit(self):
         cfg.CONF.set_override('max_limit', 3, 'api')
         for id_ in range(5):
-            obj_utils.create_test_action(self.context, id=id_,
-                                         uuid=utils.generate_uuid())
+            obj_utils.create_test_action(
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
         response = self.get_json('/actions')
         self.assertEqual(3, len(response['actions']))
 
 
 class TestPatchAction(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         self.goal = obj_utils.create_test_goal(self.context)
         self.strategy = obj_utils.create_test_strategy(self.context)
         self.audit = obj_utils.create_test_audit(self.context)
         self.action_plan = obj_utils.create_test_action_plan(
-            self.context,
-            state=objects.action_plan.State.PENDING)
+            self.context, state=objects.action_plan.State.PENDING
+        )
         self.action = obj_utils.create_test_action(self.context, parents=None)
         self.mock_action_update = self.useFixture(
             fixtures.MockPatchObject(
-                db_api.BaseConnection, "update_action",
+                db_api.BaseConnection,
+                "update_action",
                 autospec=False,
-                side_effect=self._simulate_rpc_action_update)
+                side_effect=self._simulate_rpc_action_update,
+            )
         ).mock.return_value
 
     def _simulate_rpc_action_update(self, action):
@@ -559,7 +629,8 @@ class TestPatchAction(api_base.FunctionalTest):
             f'/actions/{self.action.uuid}',
             [{'path': '/state', 'value': new_state, 'op': 'replace'}],
             headers={'OpenStack-API-Version': 'infra-optim 1.4'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertTrue(response.json['error_message'])
@@ -574,12 +645,14 @@ class TestPatchAction(api_base.FunctionalTest):
         response = self.patch_json(
             f'/actions/{self.action.uuid}',
             [{'path': '/state', 'value': new_state, 'op': 'replace'}],
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_int)
         self.assertEqual(new_state, response.json['state'])
-        self.assertEqual('Action skipped by user.',
-                         response.json['status_message'])
+        self.assertEqual(
+            'Action skipped by user.', response.json['status_message']
+        )
 
     def test_patch_action_invalid_state_transition(self):
         """Test that invalid state transitions are rejected"""
@@ -589,12 +662,15 @@ class TestPatchAction(api_base.FunctionalTest):
             f'/actions/{self.action.uuid}',
             [{'path': '/state', 'value': new_state, 'op': 'replace'}],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.CONFLICT, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
-        self.assertIn("State transition not allowed: (PENDING -> SUCCEEDED)",
-                      response.json['error_message'])
+        self.assertIn(
+            "State transition not allowed: (PENDING -> SUCCEEDED)",
+            response.json['error_message'],
+        )
 
     def test_patch_action_skip_non_pending_ap(self):
         """Test transition conditions on parent actionplan
@@ -609,28 +685,38 @@ class TestPatchAction(api_base.FunctionalTest):
             f'/actions/{self.action.uuid}',
             [{'path': '/state', 'value': new_state, 'op': 'replace'}],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CONFLICT, response.status_int)
         self.assertTrue(response.json['error_message'])
-        self.assertIn("State update not allowed for actionplan state: ONGOING",
-                      response.json['error_message'])
+        self.assertIn(
+            "State update not allowed for actionplan state: ONGOING",
+            response.json['error_message'],
+        )
 
     def test_patch_action_skip_transition_with_status_message(self):
         """Test that PENDING to SKIPPED transition is allowed"""
         new_state = objects.action.State.SKIPPED
         response = self.patch_json(
             f'/actions/{self.action.uuid}',
-            [{'path': '/state', 'value': new_state, 'op': 'replace'},
-             {'path': '/status_message', 'value': 'test message',
-              'op': 'replace'}],
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            [
+                {'path': '/state', 'value': new_state, 'op': 'replace'},
+                {
+                    'path': '/status_message',
+                    'value': 'test message',
+                    'op': 'replace',
+                },
+            ],
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_int)
         self.assertEqual(new_state, response.json['state'])
         self.assertEqual(
             'Action skipped by user. Reason: test message',
-            response.json['status_message'])
+            response.json['status_message'],
+        )
 
     def test_patch_action_invalid_state_value(self):
         """Test that invalid state values are rejected"""
@@ -639,7 +725,8 @@ class TestPatchAction(api_base.FunctionalTest):
             f'/actions/{self.action.uuid}',
             [{'path': '/state', 'value': invalid_state, 'op': 'replace'}],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -650,25 +737,36 @@ class TestPatchAction(api_base.FunctionalTest):
             f'/actions/{self.action.uuid}',
             [{'path': '/status_message', 'op': 'remove'}],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
-        self.assertIn("is a mandatory attribute and can not be removed",
-                      response.json['error_message'])
+        self.assertIn(
+            "is a mandatory attribute and can not be removed",
+            response.json['error_message'],
+        )
 
     def test_patch_action_status_message_not_allowed(self):
         """Test status_message cannot be patched directly when not SKIPPED"""
         response = self.patch_json(
             f'/actions/{self.action.uuid}',
-            [{'path': '/status_message', 'value': 'test message',
-              'op': 'replace'}],
+            [
+                {
+                    'path': '/status_message',
+                    'value': 'test message',
+                    'op': 'replace',
+                }
+            ],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.CONFLICT, response.status_int)
         self.assertEqual('application/json', response.content_type)
-        self.assertIn("status_message update only allowed when action state "
-                      "is SKIPPED", response.json['error_message'])
+        self.assertIn(
+            "status_message update only allowed when action state is SKIPPED",
+            response.json['error_message'],
+        )
         self.assertIsNone(self.action.status_message)
 
     def test_patch_action_one_allowed_one_not_allowed(self):
@@ -676,15 +774,21 @@ class TestPatchAction(api_base.FunctionalTest):
         new_state = objects.action.State.SKIPPED
         response = self.patch_json(
             f'/actions/{self.action.uuid}',
-            [{'path': '/state', 'value': new_state, 'op': 'replace'},
-             {'path': '/action_plan_id', 'value': 56, 'op': 'replace'}],
+            [
+                {'path': '/state', 'value': new_state, 'op': 'replace'},
+                {'path': '/action_plan_id', 'value': 56, 'op': 'replace'},
+            ],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
-        self.assertIn("\'/action_plan_id\' is not an allowed attribute and "
-                      "can not be updated", response.json['error_message'])
+        self.assertIn(
+            "'/action_plan_id' is not an allowed attribute and "
+            "can not be updated",
+            response.json['error_message'],
+        )
         self.assertIsNone(self.action.status_message)
 
     def test_patch_action_status_message_allowed_when_skipped(self):
@@ -693,29 +797,41 @@ class TestPatchAction(api_base.FunctionalTest):
         new_state = objects.action.State.SKIPPED
         response = self.patch_json(
             f'/actions/{self.action.uuid}',
-            [{'path': '/state', 'value': new_state, 'op': 'replace'},
-             {'path': '/status_message', 'value': 'initial message',
-              'op': 'replace'}],
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            [
+                {'path': '/state', 'value': new_state, 'op': 'replace'},
+                {
+                    'path': '/status_message',
+                    'value': 'initial message',
+                    'op': 'replace',
+                },
+            ],
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(HTTPStatus.OK, response.status_int)
         self.assertEqual(new_state, response.json['state'])
 
         # Now update status_message while in SKIPPED state
         response = self.patch_json(
             f'/actions/{self.action.uuid}',
-            [{'path': '/status_message', 'value': 'updated message',
-              'op': 'replace'}],
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            [
+                {
+                    'path': '/status_message',
+                    'value': 'updated message',
+                    'op': 'replace',
+                }
+            ],
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(HTTPStatus.OK, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(new_state, response.json['state'])
         self.assertEqual(
             'Action skipped by user. Reason: updated message',
-            response.json['status_message'])
+            response.json['status_message'],
+        )
 
 
 class TestActionPolicyEnforcement(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -724,54 +840,72 @@ class TestActionPolicyEnforcement(api_base.FunctionalTest):
         obj_utils.create_test_action_plan(self.context)
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "action:get_all", self.get_json, '/actions',
-            expect_errors=True)
+            "action:get_all", self.get_json, '/actions', expect_errors=True
+        )
 
     def test_policy_disallow_get_one(self):
         action = obj_utils.create_test_action(self.context)
         self._common_policy_check(
-            "action:get", self.get_json,
+            "action:get",
+            self.get_json,
             f'/actions/{action.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "action:detail", self.get_json,
+            "action:detail",
+            self.get_json,
             '/actions/detail',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_patch(self):
         action = obj_utils.create_test_action(self.context)
         self._common_policy_check(
-            "action:update", self.patch_json,
+            "action:update",
+            self.patch_json,
             f'/actions/{action.uuid}',
-            [{'path': '/state', 'value': objects.action.State.SKIPPED,
-              'op': 'replace'}],
+            [
+                {
+                    'path': '/state',
+                    'value': objects.action.State.SKIPPED,
+                    'op': 'replace',
+                }
+            ],
             headers={'OpenStack-API-Version': 'infra-optim 1.5'},
-            expect_errors=True)
+            expect_errors=True,
+        )
 
 
-class TestActionPolicyEnforcementWithAdminContext(TestListAction,
-                                                  api_base.AdminRoleTest):
-
+class TestActionPolicyEnforcementWithAdminContext(
+    TestListAction, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "action:detail": "rule:default",
-            "action:get": "rule:default",
-            "action:get_all": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "action:detail": "rule:default",
+                "action:get": "rule:default",
+                "action:get_all": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_actions_plans.py b/watcher/tests/unit/api/v1/test_actions_plans.py
index b5c4bf4fe..f2ac9748f 100644
--- a/watcher/tests/unit/api/v1/test_actions_plans.py
+++ b/watcher/tests/unit/api/v1/test_actions_plans.py
@@ -28,7 +28,6 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestListActionPlan(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -41,25 +40,30 @@ class TestListActionPlan(api_base.FunctionalTest):
 
     def _assert_action_plans_fields(self, action_plan):
         action_plan_fields = [
-            'uuid', 'audit_uuid', 'strategy_uuid', 'strategy_name',
-            'state', 'global_efficacy', 'efficacy_indicators']
+            'uuid',
+            'audit_uuid',
+            'strategy_uuid',
+            'strategy_name',
+            'state',
+            'global_efficacy',
+            'efficacy_indicators',
+        ]
         for field in action_plan_fields:
             self.assertIn(field, action_plan)
 
     def test_one(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         response = self.get_json('/action_plans')
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
         self.assertNotIn('status_message', response['action_plans'][0])
 
     def test_one_with_status_message(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            self.context, headers={'OpenStack-API-Version': 'infra-optim 1.5'}
+        )
         response = self.get_json('/action_plans')
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
         # status_message is not in the basic action_plans list
         self.assertNotIn('status_message', response['action_plans'][0])
@@ -67,10 +71,10 @@ class TestListActionPlan(api_base.FunctionalTest):
     def test_one_soft_deleted(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         action_plan.soft_delete()
-        response = self.get_json('/action_plans',
-                                 headers={'X-Show-Deleted': 'True'})
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+        response = self.get_json(
+            '/action_plans', headers={'X-Show-Deleted': 'True'}
+        )
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
 
         response = self.get_json('/action_plans')
@@ -79,26 +83,36 @@ class TestListActionPlan(api_base.FunctionalTest):
     def test_get_one_ok(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         obj_utils.create_test_efficacy_indicator(
-            self.context, action_plan_id=action_plan['id'])
+            self.context, action_plan_id=action_plan['id']
+        )
         response = self.get_json(
-            '/action_plans/{}'.format(action_plan['uuid']))
+            '/action_plans/{}'.format(action_plan['uuid'])
+        )
         self.assertEqual(action_plan.uuid, response['uuid'])
         self._assert_action_plans_fields(response)
         self.assertEqual(
-            [{'description': 'Test indicator',
-              'name': 'test_indicator',
-              'value': 0.0,
-              'unit': '%'}],
-            response['efficacy_indicators'])
+            [
+                {
+                    'description': 'Test indicator',
+                    'name': 'test_indicator',
+                    'value': 0.0,
+                    'unit': '%',
+                }
+            ],
+            response['efficacy_indicators'],
+        )
 
     def test_get_one_ok_with_status_message(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         obj_utils.create_test_efficacy_indicator(
-            self.context, action_plan_id=action_plan['id'])
+            self.context, action_plan_id=action_plan['id']
+        )
         response = self.get_json(
             '/action_plans/{}'.format(action_plan['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(action_plan.uuid, response['uuid'])
         self._assert_action_plans_fields(response)
         self.assertEqual("Fake message", response['status_message'])
@@ -106,10 +120,12 @@ class TestListActionPlan(api_base.FunctionalTest):
     def test_get_one_ok_with_empty_status_message(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         obj_utils.create_test_efficacy_indicator(
-            self.context, action_plan_id=action_plan['id'])
+            self.context, action_plan_id=action_plan['id']
+        )
         response = self.get_json(
             '/action_plans/{}'.format(action_plan['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(action_plan.uuid, response['uuid'])
         self._assert_action_plans_fields(response)
         self.assertIsNone(response['status_message'])
@@ -119,53 +135,56 @@ class TestListActionPlan(api_base.FunctionalTest):
         action_plan.soft_delete()
         response = self.get_json(
             '/action_plans/{}'.format(action_plan['uuid']),
-            headers={'X-Show-Deleted': 'True'})
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(action_plan.uuid, response['uuid'])
         self._assert_action_plans_fields(response)
 
         response = self.get_json(
-            '/action_plans/{}'.format(action_plan['uuid']),
-            expect_errors=True)
+            '/action_plans/{}'.format(action_plan['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         response = self.get_json('/action_plans/detail')
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
         self.assertNotIn('status_message', response['action_plans'][0])
 
     def test_detail_with_status_message(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         response = self.get_json(
             '/action_plans/detail',
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
         self.assertEqual(
-            "Fake message", response['action_plans'][0]['status_message'])
+            "Fake message", response['action_plans'][0]['status_message']
+        )
 
     def test_detail_with_hidden_status_message(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         response = self.get_json(
             '/action_plans/detail',
-            headers={'OpenStack-API-Version': 'infra-optim 1.4'})
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+            headers={'OpenStack-API-Version': 'infra-optim 1.4'},
+        )
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
         self.assertNotIn('status_message', response['action_plans'][0])
 
     def test_detail_soft_deleted(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         action_plan.soft_delete()
-        response = self.get_json('/action_plans/detail',
-                                 headers={'X-Show-Deleted': 'True'})
-        self.assertEqual(action_plan.uuid,
-                         response['action_plans'][0]["uuid"])
+        response = self.get_json(
+            '/action_plans/detail', headers={'X-Show-Deleted': 'True'}
+        )
+        self.assertEqual(action_plan.uuid, response['action_plans'][0]["uuid"])
         self._assert_action_plans_fields(response['action_plans'][0])
 
         response = self.get_json('/action_plans/detail')
@@ -175,14 +194,16 @@ class TestListActionPlan(api_base.FunctionalTest):
         action_plan = obj_utils.create_test_action_plan(self.context)
         response = self.get_json(
             '/action_plan/{}/detail'.format(action_plan['uuid']),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         action_plan_list = []
         for id_ in range(5):
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_plan_list.append(action_plan.uuid)
         response = self.get_json('/action_plans')
         self.assertEqual(len(action_plan_list), len(response['action_plans']))
@@ -192,29 +213,41 @@ class TestListActionPlan(api_base.FunctionalTest):
     def test_many_with_soft_deleted_audit_uuid(self):
         action_plan_list = []
         audit1 = obj_utils.create_test_audit(
-            self.context, id=2,
-            uuid=utils.generate_uuid(), name=f'My Audit {2}')
+            self.context,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name=f'My Audit {2}',
+        )
         audit2 = obj_utils.create_test_audit(
-            self.context, id=3,
-            uuid=utils.generate_uuid(), name=f'My Audit {3}')
+            self.context,
+            id=3,
+            uuid=utils.generate_uuid(),
+            name=f'My Audit {3}',
+        )
 
         for id_ in range(0, 2):
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                audit_id=audit1.id)
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                audit_id=audit1.id,
+            )
             action_plan_list.append(action_plan.uuid)
 
         for id_ in range(2, 4):
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                audit_id=audit2.id)
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                audit_id=audit2.id,
+            )
             action_plan_list.append(action_plan.uuid)
 
         new_state = objects.audit.State.CANCELLED
         self.patch_json(
             f'/audits/{audit1.uuid}',
-            [{'path': '/state', 'value': new_state,
-             'op': 'replace'}])
+            [{'path': '/state', 'value': new_state, 'op': 'replace'}],
+        )
         self.delete(f'/audits/{audit1.uuid}')
 
         response = self.get_json('/action_plans')
@@ -232,12 +265,18 @@ class TestListActionPlan(api_base.FunctionalTest):
     def test_many_with_audit_uuid(self):
         action_plan_list = []
         audit = obj_utils.create_test_audit(
-            self.context, id=2,
-            uuid=utils.generate_uuid(), name=f'My Audit {2}')
+            self.context,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name=f'My Audit {2}',
+        )
         for id_ in range(2, 5):
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                audit_id=audit.id)
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                audit_id=audit.id,
+            )
             action_plan_list.append(action_plan.uuid)
         response = self.get_json('/action_plans')
         self.assertEqual(len(action_plan_list), len(response['action_plans']))
@@ -247,22 +286,34 @@ class TestListActionPlan(api_base.FunctionalTest):
     def test_many_with_audit_uuid_filter(self):
         action_plan_list1 = []
         audit1 = obj_utils.create_test_audit(
-            self.context, id=2,
-            uuid=utils.generate_uuid(), name=f'My Audit {2}')
+            self.context,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name=f'My Audit {2}',
+        )
         for id_ in range(2, 5):
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                audit_id=audit1.id)
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                audit_id=audit1.id,
+            )
             action_plan_list1.append(action_plan.uuid)
 
         audit2 = obj_utils.create_test_audit(
-            self.context, id=3,
-            uuid=utils.generate_uuid(), name=f'My Audit {3}')
+            self.context,
+            id=3,
+            uuid=utils.generate_uuid(),
+            name=f'My Audit {3}',
+        )
         action_plan_list2 = []
         for id_ in [5, 6, 7]:
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                audit_id=audit2.id)
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                audit_id=audit2.id,
+            )
             action_plan_list2.append(action_plan.uuid)
 
         response = self.get_json(f'/action_plans?audit_uuid={audit2.uuid}')
@@ -274,11 +325,13 @@ class TestListActionPlan(api_base.FunctionalTest):
         action_plan_list = []
         for id_ in [1, 2, 3]:
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_plan_list.append(action_plan.uuid)
         for id_ in [4, 5]:
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_plan.soft_delete()
         response = self.get_json('/action_plans')
         self.assertEqual(3, len(response['action_plans']))
@@ -289,15 +342,18 @@ class TestListActionPlan(api_base.FunctionalTest):
         action_plan_list = []
         for id_ in [1, 2, 3]:
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_plan_list.append(action_plan.uuid)
         for id_ in [4, 5]:
             action_plan = obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
             action_plan.soft_delete()
             action_plan_list.append(action_plan.uuid)
-        response = self.get_json('/action_plans',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/action_plans', headers={'X-Show-Deleted': 'True'}
+        )
         self.assertEqual(5, len(response['action_plans']))
         uuids = [s['uuid'] for s in response['action_plans']]
         self.assertEqual(sorted(action_plan_list), sorted(uuids))
@@ -306,11 +362,17 @@ class TestListActionPlan(api_base.FunctionalTest):
         audit_list = []
         for id_ in range(2, 5):
             audit = obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
             obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                audit_id=audit.id)
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                audit_id=audit.id,
+            )
             audit_list.append(audit.uuid)
 
         response = self.get_json('/action_plans/?sort_key=audit_uuid')
@@ -321,8 +383,8 @@ class TestListActionPlan(api_base.FunctionalTest):
 
     def test_sort_key_validation(self):
         response = self.get_json(
-            '/action_plans?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/action_plans?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
     def test_links(self):
@@ -334,13 +396,15 @@ class TestListActionPlan(api_base.FunctionalTest):
         self.assertIn(uuid, response['links'][0]['href'])
         for link in response['links']:
             bookmark = link['rel'] == 'bookmark'
-            self.assertTrue(self.validate_link(
-                link['href'], bookmark=bookmark))
+            self.assertTrue(
+                self.validate_link(link['href'], bookmark=bookmark)
+            )
 
     def test_collection_links(self):
         for id_ in range(5):
             obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
         response = self.get_json('/action_plans/?limit=3')
         self.assertEqual(3, len(response['action_plans']))
 
@@ -351,7 +415,8 @@ class TestListActionPlan(api_base.FunctionalTest):
         cfg.CONF.set_override('max_limit', 3, 'api')
         for id_ in range(5):
             obj_utils.create_test_action_plan(
-                self.context, id=id_, uuid=utils.generate_uuid())
+                self.context, id=id_, uuid=utils.generate_uuid()
+            )
         response = self.get_json('/action_plans')
         self.assertEqual(3, len(response['action_plans']))
 
@@ -360,18 +425,17 @@ class TestListActionPlan(api_base.FunctionalTest):
 
 
 class TestDelete(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit(self.context)
-        self.action_plan = obj_utils.create_test_action_plan(
-            self.context)
+        self.action_plan = obj_utils.create_test_action_plan(self.context)
         p = mock.patch.object(db_api.BaseConnection, 'destroy_action_plan')
         self.mock_action_plan_delete = p.start()
-        self.mock_action_plan_delete.side_effect = \
+        self.mock_action_plan_delete.side_effect = (
             self._simulate_rpc_action_plan_delete
+        )
         self.addCleanup(p.stop)
 
     def _simulate_rpc_action_plan_delete(self, audit_uuid):
@@ -379,34 +443,37 @@ class TestDelete(api_base.FunctionalTest):
         action_plan.destroy()
 
     def test_delete_action_plan_without_action(self):
-        response = self.delete(f'/action_plans/{self.action_plan.uuid}',
-                               expect_errors=True)
+        response = self.delete(
+            f'/action_plans/{self.action_plan.uuid}', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
         self.action_plan.state = objects.action_plan.State.SUCCEEDED
         self.action_plan.save()
         self.delete(f'/action_plans/{self.action_plan.uuid}')
-        response = self.get_json(f'/action_plans/{self.action_plan.uuid}',
-                                 expect_errors=True)
+        response = self.get_json(
+            f'/action_plans/{self.action_plan.uuid}', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
 
     def test_delete_action_plan_with_action(self):
-        action = obj_utils.create_test_action(
-            self.context, id=1)
+        action = obj_utils.create_test_action(self.context, id=1)
 
         self.action_plan.state = objects.action_plan.State.SUCCEEDED
         self.action_plan.save()
         self.delete(f'/action_plans/{self.action_plan.uuid}')
-        ap_response = self.get_json(f'/action_plans/{self.action_plan.uuid}',
-                                    expect_errors=True)
+        ap_response = self.get_json(
+            f'/action_plans/{self.action_plan.uuid}', expect_errors=True
+        )
         acts_response = self.get_json(
-            f'/actions/?action_plan_uuid={self.action_plan.uuid}')
+            f'/actions/?action_plan_uuid={self.action_plan.uuid}'
+        )
         act_response = self.get_json(
-            f'/actions/{action.uuid}',
-            expect_errors=True)
+            f'/actions/{action.uuid}', expect_errors=True
+        )
 
         # The action plan does not exist anymore
         self.assertEqual(HTTPStatus.NOT_FOUND, ap_response.status_int)
@@ -428,18 +495,19 @@ class TestDelete(api_base.FunctionalTest):
 
 
 class TestStart(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit(self.context)
         self.action_plan = obj_utils.create_test_action_plan(
-            self.context, state=objects.action_plan.State.RECOMMENDED)
+            self.context, state=objects.action_plan.State.RECOMMENDED
+        )
         p = mock.patch.object(db_api.BaseConnection, 'update_action_plan')
         self.mock_action_plan_update = p.start()
-        self.mock_action_plan_update.side_effect = \
+        self.mock_action_plan_update.side_effect = (
             self._simulate_rpc_action_plan_update
+        )
         self.addCleanup(p.stop)
 
     def _simulate_rpc_action_plan_update(self, action_plan):
@@ -451,7 +519,8 @@ class TestStart(api_base.FunctionalTest):
         mock_policy.return_value = True
         uuid = utils.generate_uuid()
         response = self.post(
-            '/v1/action_plans/{}/{}'.format(uuid, 'start'), expect_errors=True)
+            '/v1/action_plans/{}/{}'.format(uuid, 'start'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -459,34 +528,35 @@ class TestStart(api_base.FunctionalTest):
     @mock.patch('watcher.common.policy.enforce')
     def test_start_action_plan(self, mock_policy):
         mock_policy.return_value = True
-        action = obj_utils.create_test_action(
-            self.context, id=1)
+        action = obj_utils.create_test_action(self.context, id=1)
         self.action_plan.state = objects.action_plan.State.SUCCEEDED
         response = self.post(
             '/v1/action_plans/{}/{}/'.format(self.action_plan.uuid, 'start'),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.OK, response.status_int)
         act_response = self.get_json(
-            f'/actions/{action.uuid}',
-            expect_errors=True)
+            f'/actions/{action.uuid}', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.OK, act_response.status_int)
         self.assertEqual('PENDING', act_response.json['state'])
         self.assertEqual('application/json', act_response.content_type)
 
 
 class TestPatch(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit(self.context)
         self.action_plan = obj_utils.create_test_action_plan(
-            self.context, state=objects.action_plan.State.RECOMMENDED)
+            self.context, state=objects.action_plan.State.RECOMMENDED
+        )
         p = mock.patch.object(db_api.BaseConnection, 'update_action_plan')
         self.mock_action_plan_update = p.start()
-        self.mock_action_plan_update.side_effect = \
+        self.mock_action_plan_update.side_effect = (
             self._simulate_rpc_action_plan_update
+        )
         self.addCleanup(p.stop)
 
     def _simulate_rpc_action_plan_update(self, action_plan):
@@ -499,14 +569,14 @@ class TestPatch(api_base.FunctionalTest):
         mock_utcnow.return_value = test_time
 
         new_state = objects.action_plan.State.DELETED
-        response = self.get_json(
-            f'/action_plans/{self.action_plan.uuid}')
+        response = self.get_json(f'/action_plans/{self.action_plan.uuid}')
         self.assertNotEqual(new_state, response['state'])
 
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/state', 'value': new_state, 'op': 'replace'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
 
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
@@ -515,10 +585,15 @@ class TestPatch(api_base.FunctionalTest):
     def test_replace_non_existent_action_plan_denied(self):
         response = self.patch_json(
             f'/action_plans/{utils.generate_uuid()}',
-            [{'path': '/state',
-              'value': objects.action_plan.State.PENDING,
-              'op': 'replace'}],
-            expect_errors=True)
+            [
+                {
+                    'path': '/state',
+                    'value': objects.action_plan.State.PENDING,
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -527,21 +602,22 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/foo', 'value': 'bar', 'op': 'add'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertTrue(response.json['error_message'])
 
     def test_remove_denied(self):
         # We should not be able to remove the state of an action plan
-        response = self.get_json(
-            f'/action_plans/{self.action_plan.uuid}')
+        response = self.get_json(f'/action_plans/{self.action_plan.uuid}')
         self.assertIsNotNone(response['state'])
 
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/state', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
 
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
@@ -551,7 +627,8 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/uuid', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -560,7 +637,8 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/non-existent', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -568,23 +646,22 @@ class TestPatch(api_base.FunctionalTest):
     @mock.patch.object(aapi.ApplierAPI, 'launch_action_plan')
     def test_replace_state_pending_ok(self, applier_mock):
         new_state = objects.action_plan.State.PENDING
-        response = self.get_json(
-            f'/action_plans/{self.action_plan.uuid}')
+        response = self.get_json(f'/action_plans/{self.action_plan.uuid}')
         self.assertNotEqual(new_state, response['state'])
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
-            [{'path': '/state', 'value': new_state,
-              'op': 'replace'}])
+            [{'path': '/state', 'value': new_state, 'op': 'replace'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
-        applier_mock.assert_called_once_with(mock.ANY,
-                                             self.action_plan.uuid)
+        applier_mock.assert_called_once_with(mock.ANY, self.action_plan.uuid)
 
     def test_replace_status_message_denied(self):
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/status_message', 'value': 'test', 'op': 'replace'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -593,49 +670,58 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/action_plans/{self.action_plan.uuid}',
             [{'path': '/status_message', 'value': 'test', 'op': 'add'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
 
 
 ALLOWED_TRANSITIONS = [
-    {"original_state": objects.action_plan.State.RECOMMENDED,
-     "new_state": objects.action_plan.State.PENDING},
-    {"original_state": objects.action_plan.State.RECOMMENDED,
-     "new_state": objects.action_plan.State.CANCELLED},
-    {"original_state": objects.action_plan.State.ONGOING,
-     "new_state": objects.action_plan.State.CANCELLING},
-    {"original_state": objects.action_plan.State.PENDING,
-     "new_state": objects.action_plan.State.CANCELLED},
+    {
+        "original_state": objects.action_plan.State.RECOMMENDED,
+        "new_state": objects.action_plan.State.PENDING,
+    },
+    {
+        "original_state": objects.action_plan.State.RECOMMENDED,
+        "new_state": objects.action_plan.State.CANCELLED,
+    },
+    {
+        "original_state": objects.action_plan.State.ONGOING,
+        "new_state": objects.action_plan.State.CANCELLING,
+    },
+    {
+        "original_state": objects.action_plan.State.PENDING,
+        "new_state": objects.action_plan.State.CANCELLED,
+    },
 ]
 
 
 class TestPatchStateTransitionDenied(api_base.FunctionalTest):
-
     STATES = [
-        ap_state for ap_state in objects.action_plan.State.__dict__
+        ap_state
+        for ap_state in objects.action_plan.State.__dict__
         if not ap_state.startswith("_")
     ]
 
     scenarios = [
         (
             f"{original_state} -> {new_state}",
-            {"original_state": original_state,
-             "new_state": new_state},
+            {"original_state": original_state, "new_state": new_state},
+        )
+        for original_state, new_state in list(
+            itertools.product(STATES, STATES)
         )
-        for original_state, new_state
-        in list(itertools.product(STATES, STATES))
         # from DELETED to ...
         # NOTE: Any state transition from DELETED (To RECOMMENDED, PENDING,
         # ONGOING, CANCELLED, SUCCEEDED and FAILED) will cause a 404 Not Found
         # because we cannot retrieve them with a GET (soft_deleted state).
         # This is the reason why they are not listed here but they have a
         # special test to cover it
-        if original_state != objects.action_plan.State.DELETED and
-        original_state != new_state and
-        {"original_state": original_state,
-         "new_state": new_state} not in ALLOWED_TRANSITIONS
+        if original_state != objects.action_plan.State.DELETED
+        and original_state != new_state
+        and {"original_state": original_state, "new_state": new_state}
+        not in ALLOWED_TRANSITIONS
     ]
 
     def setUp(self):
@@ -645,18 +731,21 @@ class TestPatchStateTransitionDenied(api_base.FunctionalTest):
         obj_utils.create_test_audit(self.context)
 
     @mock.patch.object(
-        db_api.BaseConnection, 'update_action_plan',
-        mock.Mock(side_effect=lambda ap: ap.save() or ap))
+        db_api.BaseConnection,
+        'update_action_plan',
+        mock.Mock(side_effect=lambda ap: ap.save() or ap),
+    )
     def test_replace_state_pending_denied(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, state=self.original_state)
+            self.context, state=self.original_state
+        )
 
         initial_ap = self.get_json(f'/action_plans/{action_plan.uuid}')
         response = self.patch_json(
             f'/action_plans/{action_plan.uuid}',
-            [{'path': '/state', 'value': self.new_state,
-              'op': 'replace'}],
-            expect_errors=True)
+            [{'path': '/state', 'value': self.new_state, 'op': 'replace'}],
+            expect_errors=True,
+        )
         updated_ap = self.get_json(f'/action_plans/{action_plan.uuid}')
 
         self.assertNotEqual(self.new_state, initial_ap['state'])
@@ -667,12 +756,12 @@ class TestPatchStateTransitionDenied(api_base.FunctionalTest):
 
 
 class TestPatchStateTransitionOk(api_base.FunctionalTest):
-
     scenarios = [
         (
-            "{} -> {}".format(transition["original_state"],
-                              transition["new_state"]),
-            transition
+            "{} -> {}".format(
+                transition["original_state"], transition["new_state"]
+            ),
+            transition,
         )
         for transition in ALLOWED_TRANSITIONS
     ]
@@ -684,18 +773,22 @@ class TestPatchStateTransitionOk(api_base.FunctionalTest):
         obj_utils.create_test_audit(self.context)
 
     @mock.patch.object(
-        db_api.BaseConnection, 'update_action_plan',
-        mock.Mock(side_effect=lambda ap: ap.save() or ap))
+        db_api.BaseConnection,
+        'update_action_plan',
+        mock.Mock(side_effect=lambda ap: ap.save() or ap),
+    )
     @mock.patch.object(aapi.ApplierAPI, 'launch_action_plan', mock.Mock())
     def test_replace_state_pending_ok(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, state=self.original_state)
+            self.context, state=self.original_state
+        )
 
         initial_ap = self.get_json(f'/action_plans/{action_plan.uuid}')
 
         response = self.patch_json(
             f'/action_plans/{action_plan.uuid}',
-            [{'path': '/state', 'value': self.new_state, 'op': 'replace'}])
+            [{'path': '/state', 'value': self.new_state, 'op': 'replace'}],
+        )
         updated_ap = self.get_json(f'/action_plans/{action_plan.uuid}')
         self.assertNotEqual(self.new_state, initial_ap['state'])
         self.assertEqual(self.new_state, updated_ap['state'])
@@ -704,7 +797,6 @@ class TestPatchStateTransitionOk(api_base.FunctionalTest):
 
 
 class TestActionPlanPolicyEnforcement(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -712,63 +804,86 @@ class TestActionPlanPolicyEnforcement(api_base.FunctionalTest):
         obj_utils.create_test_audit(self.context)
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "action_plan:get_all", self.get_json, '/action_plans',
-            expect_errors=True)
+            "action_plan:get_all",
+            self.get_json,
+            '/action_plans',
+            expect_errors=True,
+        )
 
     def test_policy_disallow_get_one(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         self._common_policy_check(
-            "action_plan:get", self.get_json,
+            "action_plan:get",
+            self.get_json,
             f'/action_plans/{action_plan.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "action_plan:detail", self.get_json,
+            "action_plan:detail",
+            self.get_json,
             '/action_plans/detail',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_update(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         self._common_policy_check(
-            "action_plan:update", self.patch_json,
+            "action_plan:update",
+            self.patch_json,
             f'/action_plans/{action_plan.uuid}',
-            [{'path': '/state',
-              'value': objects.action_plan.State.DELETED,
-              'op': 'replace'}],
-            expect_errors=True)
+            [
+                {
+                    'path': '/state',
+                    'value': objects.action_plan.State.DELETED,
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
 
     def test_policy_disallow_delete(self):
         action_plan = obj_utils.create_test_action_plan(self.context)
         self._common_policy_check(
-            "action_plan:delete", self.delete,
-            f'/action_plans/{action_plan.uuid}', expect_errors=True)
+            "action_plan:delete",
+            self.delete,
+            f'/action_plans/{action_plan.uuid}',
+            expect_errors=True,
+        )
 
 
-class TestActionPlanPolicyEnforcementWithAdminContext(TestListActionPlan,
-                                                      api_base.AdminRoleTest):
-
+class TestActionPlanPolicyEnforcementWithAdminContext(
+    TestListActionPlan, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "action_plan:delete": "rule:default",
-            "action_plan:detail": "rule:default",
-            "action_plan:get": "rule:default",
-            "action_plan:get_all": "rule:default",
-            "action_plan:update": "rule:default",
-            "action_plan:start": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "action_plan:delete": "rule:default",
+                "action_plan:detail": "rule:default",
+                "action_plan:get": "rule:default",
+                "action_plan:get_all": "rule:default",
+                "action_plan:update": "rule:default",
+                "action_plan:start": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_audit_templates.py b/watcher/tests/unit/api/v1/test_audit_templates.py
index d3338b083..d420e4b29 100644
--- a/watcher/tests/unit/api/v1/test_audit_templates.py
+++ b/watcher/tests/unit/api/v1/test_audit_templates.py
@@ -46,58 +46,75 @@ def post_get_test_audit_template(**kw):
 
 
 class TestAuditTemplateObject(base.TestCase):
-
     def test_audit_template_init(self):
         audit_template_dict = post_get_test_audit_template()
         del audit_template_dict['name']
         audit_template = api_audit_template.AuditTemplate(
-            **audit_template_dict)
+            **audit_template_dict
+        )
         self.assertEqual(wtypes.Unset, audit_template.name)
 
 
 class FunctionalTestWithSetup(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         self.fake_goal1 = obj_utils.create_test_goal(
-            self.context, id=1, uuid=utils.generate_uuid(), name="dummy_1")
+            self.context, id=1, uuid=utils.generate_uuid(), name="dummy_1"
+        )
         self.fake_goal2 = obj_utils.create_test_goal(
-            self.context, id=2, uuid=utils.generate_uuid(), name="dummy_2")
+            self.context, id=2, uuid=utils.generate_uuid(), name="dummy_2"
+        )
         self.fake_strategy1 = obj_utils.create_test_strategy(
-            self.context, id=1, uuid=utils.generate_uuid(), name="strategy_1",
-            goal_id=self.fake_goal1.id)
+            self.context,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name="strategy_1",
+            goal_id=self.fake_goal1.id,
+        )
         self.fake_strategy2 = obj_utils.create_test_strategy(
-            self.context, id=2, uuid=utils.generate_uuid(), name="strategy_2",
-            goal_id=self.fake_goal2.id)
+            self.context,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name="strategy_2",
+            goal_id=self.fake_goal2.id,
+        )
 
 
 class TestListAuditTemplate(FunctionalTestWithSetup):
-
     def test_empty(self):
         response = self.get_json('/audit_templates')
         self.assertEqual([], response['audit_templates'])
 
     def _assert_audit_template_fields(self, audit_template):
-        audit_template_fields = ['name', 'goal_uuid', 'goal_name',
-                                 'strategy_uuid', 'strategy_name']
+        audit_template_fields = [
+            'name',
+            'goal_uuid',
+            'goal_name',
+            'strategy_uuid',
+            'strategy_name',
+        ]
         for field in audit_template_fields:
             self.assertIn(field, audit_template)
 
     def test_one(self):
         audit_template = obj_utils.create_test_audit_template(
-            self.context, strategy_id=self.fake_strategy1.id)
+            self.context, strategy_id=self.fake_strategy1.id
+        )
         response = self.get_json('/audit_templates')
-        self.assertEqual(audit_template.uuid,
-                         response['audit_templates'][0]["uuid"])
+        self.assertEqual(
+            audit_template.uuid, response['audit_templates'][0]["uuid"]
+        )
         self._assert_audit_template_fields(response['audit_templates'][0])
 
     def test_get_one_soft_deleted_ok(self):
         audit_template = obj_utils.create_test_audit_template(self.context)
         audit_template.soft_delete()
-        response = self.get_json('/audit_templates',
-                                 headers={'X-Show-Deleted': 'True'})
-        self.assertEqual(audit_template.uuid,
-                         response['audit_templates'][0]["uuid"])
+        response = self.get_json(
+            '/audit_templates', headers={'X-Show-Deleted': 'True'}
+        )
+        self.assertEqual(
+            audit_template.uuid, response['audit_templates'][0]["uuid"]
+        )
         self._assert_audit_template_fields(response['audit_templates'][0])
 
         response = self.get_json('/audit_templates')
@@ -106,14 +123,18 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
     def test_get_one_by_uuid(self):
         audit_template = obj_utils.create_test_audit_template(self.context)
         response = self.get_json(
-            '/audit_templates/{}'.format(audit_template['uuid']))
+            '/audit_templates/{}'.format(audit_template['uuid'])
+        )
         self.assertEqual(audit_template.uuid, response['uuid'])
         self._assert_audit_template_fields(response)
 
     def test_get_one_by_name(self):
         audit_template = obj_utils.create_test_audit_template(self.context)
-        response = self.get_json(urlparse.quote(
-            '/audit_templates/{}'.format(audit_template['name'])))
+        response = self.get_json(
+            urlparse.quote(
+                '/audit_templates/{}'.format(audit_template['name'])
+            )
+        )
         self.assertEqual(audit_template.uuid, response['uuid'])
         self._assert_audit_template_fields(response)
 
@@ -122,29 +143,34 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         audit_template.soft_delete()
         response = self.get_json(
             '/audit_templates/{}'.format(audit_template['uuid']),
-            headers={'X-Show-Deleted': 'True'})
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(audit_template.uuid, response['uuid'])
         self._assert_audit_template_fields(response)
 
         response = self.get_json(
             '/audit_templates/{}'.format(audit_template['uuid']),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
         audit_template = obj_utils.create_test_audit_template(self.context)
         response = self.get_json('/audit_templates/detail')
-        self.assertEqual(audit_template.uuid,
-                         response['audit_templates'][0]["uuid"])
+        self.assertEqual(
+            audit_template.uuid, response['audit_templates'][0]["uuid"]
+        )
         self._assert_audit_template_fields(response['audit_templates'][0])
 
     def test_detail_soft_deleted(self):
         audit_template = obj_utils.create_test_audit_template(self.context)
         audit_template.soft_delete()
-        response = self.get_json('/audit_templates/detail',
-                                 headers={'X-Show-Deleted': 'True'})
-        self.assertEqual(audit_template.uuid,
-                         response['audit_templates'][0]["uuid"])
+        response = self.get_json(
+            '/audit_templates/detail', headers={'X-Show-Deleted': 'True'}
+        )
+        self.assertEqual(
+            audit_template.uuid, response['audit_templates'][0]["uuid"]
+        )
         self._assert_audit_template_fields(response['audit_templates'][0])
 
         response = self.get_json('/audit_templates/detail')
@@ -154,32 +180,39 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         audit_template = obj_utils.create_test_audit_template(self.context)
         response = self.get_json(
             '/audit_templates/{}/detail'.format(audit_template['uuid']),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         audit_template_list = []
         for id_ in range(1, 6):
             audit_template = obj_utils.create_test_audit_template(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 uuid=utils.generate_uuid(),
-                name=f'My Audit Template {id_}')
+                name=f'My Audit Template {id_}',
+            )
             audit_template_list.append(audit_template)
 
         response = self.get_json('/audit_templates')
-        self.assertEqual(len(audit_template_list),
-                         len(response['audit_templates']))
+        self.assertEqual(
+            len(audit_template_list), len(response['audit_templates'])
+        )
         uuids = [s['uuid'] for s in response['audit_templates']]
         self.assertEqual(
-            sorted([at.uuid for at in audit_template_list]),
-            sorted(uuids))
+            sorted([at.uuid for at in audit_template_list]), sorted(uuids)
+        )
 
     def test_many_without_soft_deleted(self):
         audit_template_list = []
         for id_ in range(1, 6):
             audit_template = obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'My Audit Template {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit Template {id_}',
+            )
             audit_template_list.append(audit_template)
 
         # We soft delete the ones with ID 4 and 5
@@ -189,27 +222,31 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         self.assertEqual(3, len(response['audit_templates']))
         uuids = [s['uuid'] for s in response['audit_templates']]
         self.assertEqual(
-            sorted([at.uuid for at in audit_template_list[:3]]),
-            sorted(uuids))
+            sorted([at.uuid for at in audit_template_list[:3]]), sorted(uuids)
+        )
 
     def test_many_with_soft_deleted(self):
         audit_template_list = []
         for id_ in range(1, 6):
             audit_template = obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'My Audit Template {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit Template {id_}',
+            )
             audit_template_list.append(audit_template)
 
         # We soft delete the ones with ID 4 and 5
         [at.soft_delete() for at in audit_template_list[3:]]
 
-        response = self.get_json('/audit_templates',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/audit_templates', headers={'X-Show-Deleted': 'True'}
+        )
         self.assertEqual(5, len(response['audit_templates']))
         uuids = [s['uuid'] for s in response['audit_templates']]
         self.assertEqual(
-            sorted([at.uuid for at in audit_template_list]),
-            sorted(uuids))
+            sorted([at.uuid for at in audit_template_list]), sorted(uuids)
+        )
 
     def test_links(self):
         uuid = utils.generate_uuid()
@@ -221,13 +258,17 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         for link in response['links']:
             bookmark = link['rel'] == 'bookmark'
             self.assertTrue(
-                self.validate_link(link['href'], bookmark=bookmark))
+                self.validate_link(link['href'], bookmark=bookmark)
+            )
 
     def test_collection_links(self):
         for id_ in range(5):
             obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'My Audit Template {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit Template {id_}',
+            )
         response = self.get_json('/audit_templates/?limit=3')
         self.assertEqual(3, len(response['audit_templates']))
 
@@ -238,8 +279,11 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         cfg.CONF.set_override('max_limit', 3, 'api')
         for id_ in range(5):
             obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'My Audit Template {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit Template {id_}',
+            )
         response = self.get_json('/audit_templates')
         self.assertEqual(3, len(response['audit_templates']))
 
@@ -247,63 +291,106 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         self.assertIn(next_marker, response['next'])
 
     def test_filter_by_goal_uuid(self):
-        for id_, goal_id in enumerate(itertools.chain.from_iterable([
-                itertools.repeat(self.fake_goal1.id, 3),
-                itertools.repeat(self.fake_goal2.id, 2)]), 1):
+        for id_, goal_id in enumerate(
+            itertools.chain.from_iterable(
+                [
+                    itertools.repeat(self.fake_goal1.id, 3),
+                    itertools.repeat(self.fake_goal2.id, 2),
+                ]
+            ),
+            1,
+        ):
             obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
                 name=f'My Audit Template {id_}',
-                goal_id=goal_id)
+                goal_id=goal_id,
+            )
 
         response = self.get_json(
-            f'/audit_templates?goal={self.fake_goal2.uuid}')
+            f'/audit_templates?goal={self.fake_goal2.uuid}'
+        )
         self.assertEqual(2, len(response['audit_templates']))
 
     def test_filter_by_goal_name(self):
-        for id_, goal_id in enumerate(itertools.chain.from_iterable([
-                itertools.repeat(self.fake_goal1.id, 3),
-                itertools.repeat(self.fake_goal2.id, 2)]), 1):
+        for id_, goal_id in enumerate(
+            itertools.chain.from_iterable(
+                [
+                    itertools.repeat(self.fake_goal1.id, 3),
+                    itertools.repeat(self.fake_goal2.id, 2),
+                ]
+            ),
+            1,
+        ):
             obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
                 name=f'My Audit Template {id_}',
-                goal_id=goal_id)
+                goal_id=goal_id,
+            )
 
         response = self.get_json(
-            f'/audit_templates?goal={self.fake_goal2.name}')
+            f'/audit_templates?goal={self.fake_goal2.name}'
+        )
         self.assertEqual(2, len(response['audit_templates']))
 
     def test_filter_by_strategy_uuid(self):
-        for id_, strategy_id in enumerate(itertools.chain.from_iterable([
-                itertools.repeat(self.fake_strategy1.id, 3),
-                itertools.repeat(self.fake_strategy2.id, 2)]), 1):
+        for id_, strategy_id in enumerate(
+            itertools.chain.from_iterable(
+                [
+                    itertools.repeat(self.fake_strategy1.id, 3),
+                    itertools.repeat(self.fake_strategy2.id, 2),
+                ]
+            ),
+            1,
+        ):
             obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
                 name=f'My Audit Template {id_}',
-                strategy_id=strategy_id)
+                strategy_id=strategy_id,
+            )
 
         response = self.get_json(
-            f'/audit_templates?strategy={self.fake_strategy2.uuid}')
+            f'/audit_templates?strategy={self.fake_strategy2.uuid}'
+        )
         self.assertEqual(2, len(response['audit_templates']))
 
     def test_filter_by_strategy_name(self):
-        for id_, strategy_id in enumerate(itertools.chain.from_iterable([
-                itertools.repeat(self.fake_strategy1.id, 3),
-                itertools.repeat(self.fake_strategy2.id, 2)]), 1):
+        for id_, strategy_id in enumerate(
+            itertools.chain.from_iterable(
+                [
+                    itertools.repeat(self.fake_strategy1.id, 3),
+                    itertools.repeat(self.fake_strategy2.id, 2),
+                ]
+            ),
+            1,
+        ):
             obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
                 name=f'My Audit Template {id_}',
-                strategy_id=strategy_id)
+                strategy_id=strategy_id,
+            )
 
         response = self.get_json(
-            f'/audit_templates?strategy={self.fake_strategy2.name}')
+            f'/audit_templates?strategy={self.fake_strategy2.name}'
+        )
         self.assertEqual(2, len(response['audit_templates']))
 
     def test_many_with_sort_key_name(self):
         audit_template_list = []
         for id_ in range(1, 6):
             audit_template = obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'My Audit Template {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit Template {id_}',
+            )
             audit_template_list.append(audit_template)
 
         response = self.get_json('/audit_templates?sort_key={}'.format('name'))
@@ -311,45 +398,58 @@ class TestListAuditTemplate(FunctionalTestWithSetup):
         names = [s['name'] for s in response['audit_templates']]
 
         self.assertEqual(
-            sorted([at.name for at in audit_template_list]),
-            names)
+            sorted([at.name for at in audit_template_list]), names
+        )
 
     def test_many_with_sort_key_goal_name(self):
         goal_names_list = []
-        for id_, goal_id in enumerate(itertools.chain.from_iterable([
-                itertools.repeat(self.fake_goal1.id, 3),
-                itertools.repeat(self.fake_goal2.id, 2)]), 1):
+        for id_, goal_id in enumerate(
+            itertools.chain.from_iterable(
+                [
+                    itertools.repeat(self.fake_goal1.id, 3),
+                    itertools.repeat(self.fake_goal2.id, 2),
+                ]
+            ),
+            1,
+        ):
             audit_template = obj_utils.create_test_audit_template(
-                self.context, id=id_, uuid=utils.generate_uuid(),
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
                 name=f'My Audit Template {id_}',
-                goal_id=goal_id)
+                goal_id=goal_id,
+            )
             goal_names_list.append(audit_template.goal.name)
 
         for direction in ['asc', 'desc']:
             response = self.get_json(
-                '/audit_templates?sort_key={}&sort_dir={}'
-                .format('goal_name', direction))
+                '/audit_templates?sort_key={}&sort_dir={}'.format(
+                    'goal_name', direction
+                )
+            )
 
             goal_names = [s['goal_name'] for s in response['audit_templates']]
 
             self.assertEqual(
                 sorted(goal_names_list, reverse=(direction == 'desc')),
-                goal_names)
+                goal_names,
+            )
 
     def test_sort_key_validation(self):
         response = self.get_json(
             '/audit_templates?sort_key={}'.format('goal_bad_name'),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
 
 class TestPatch(FunctionalTestWithSetup):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
         self.audit_template = obj_utils.create_test_audit_template(
-            self.context, strategy_id=None)
+            self.context, strategy_id=None
+        )
 
     @mock.patch.object(timeutils, 'utcnow')
     def test_replace_goal_uuid(self, mock_utcnow):
@@ -358,21 +458,24 @@ class TestPatch(FunctionalTestWithSetup):
 
         new_goal_uuid = self.fake_goal2.uuid
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.uuid}')
+            f'/audit_templates/{self.audit_template.uuid}'
+        )
         self.assertNotEqual(new_goal_uuid, response['goal_uuid'])
 
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
-            [{'path': '/goal', 'value': new_goal_uuid,
-              'op': 'replace'}])
+            [{'path': '/goal', 'value': new_goal_uuid, 'op': 'replace'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
 
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.uuid}')
+            f'/audit_templates/{self.audit_template.uuid}'
+        )
         self.assertEqual(new_goal_uuid, response['goal_uuid'])
         return_updated_at = timeutils.parse_isotime(
-            response['updated_at']).replace(tzinfo=None)
+            response['updated_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_updated_at)
 
     @mock.patch.object(timeutils, 'utcnow')
@@ -381,30 +484,39 @@ class TestPatch(FunctionalTestWithSetup):
         mock_utcnow.return_value = test_time
 
         new_goal_uuid = self.fake_goal2.uuid
-        response = self.get_json(urlparse.quote(
-            f'/audit_templates/{self.audit_template.name}'))
+        response = self.get_json(
+            urlparse.quote(f'/audit_templates/{self.audit_template.name}')
+        )
         self.assertNotEqual(new_goal_uuid, response['goal_uuid'])
 
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.name}',
-            [{'path': '/goal', 'value': new_goal_uuid,
-              'op': 'replace'}])
+            [{'path': '/goal', 'value': new_goal_uuid, 'op': 'replace'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
 
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.name}')
+            f'/audit_templates/{self.audit_template.name}'
+        )
         self.assertEqual(new_goal_uuid, response['goal_uuid'])
         return_updated_at = timeutils.parse_isotime(
-            response['updated_at']).replace(tzinfo=None)
+            response['updated_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_updated_at)
 
     def test_replace_non_existent_audit_template(self):
         response = self.patch_json(
             f'/audit_templates/{utils.generate_uuid()}',
-            [{'path': '/goal', 'value': self.fake_goal1.uuid,
-              'op': 'replace'}],
-            expect_errors=True)
+            [
+                {
+                    'path': '/goal',
+                    'value': self.fake_goal1.uuid,
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -413,62 +525,87 @@ class TestPatch(FunctionalTestWithSetup):
         with mock.patch.object(
             self.dbapi,
             'update_audit_template',
-            wraps=self.dbapi.update_audit_template
+            wraps=self.dbapi.update_audit_template,
         ) as cn_mock:
             response = self.patch_json(
                 f'/audit_templates/{self.audit_template.uuid}',
-                [{'path': '/goal', 'value': utils.generate_uuid(),
-                  'op': 'replace'}],
-                expect_errors=True)
+                [
+                    {
+                        'path': '/goal',
+                        'value': utils.generate_uuid(),
+                        'op': 'replace',
+                    }
+                ],
+                expect_errors=True,
+            )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         assert not cn_mock.called
 
     def test_add_goal_uuid(self):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
-            [{'path': '/goal',
-              'value': self.fake_goal2.uuid,
-              'op': 'add'}])
+            [{'path': '/goal', 'value': self.fake_goal2.uuid, 'op': 'add'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_int)
 
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.uuid}')
+            f'/audit_templates/{self.audit_template.uuid}'
+        )
         self.assertEqual(self.fake_goal2.uuid, response['goal_uuid'])
 
     def test_add_strategy_uuid(self):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
-            [{'path': '/strategy',
-              'value': self.fake_strategy1.uuid,
-              'op': 'add'}])
+            [
+                {
+                    'path': '/strategy',
+                    'value': self.fake_strategy1.uuid,
+                    'op': 'add',
+                }
+            ],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_int)
 
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.uuid}')
+            f'/audit_templates/{self.audit_template.uuid}'
+        )
         self.assertEqual(self.fake_strategy1.uuid, response['strategy_uuid'])
 
     def test_replace_strategy_uuid(self):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
-            [{'path': '/strategy',
-              'value': self.fake_strategy2['uuid'],
-              'op': 'replace'}])
+            [
+                {
+                    'path': '/strategy',
+                    'value': self.fake_strategy2['uuid'],
+                    'op': 'replace',
+                }
+            ],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_int)
 
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.uuid}')
+            f'/audit_templates/{self.audit_template.uuid}'
+        )
         self.assertEqual(
-            self.fake_strategy2['uuid'], response['strategy_uuid'])
+            self.fake_strategy2['uuid'], response['strategy_uuid']
+        )
 
     def test_replace_invalid_strategy(self):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
-            [{'path': '/strategy',
-              'value': utils.generate_uuid(),  # Does not exist
-              'op': 'replace'}], expect_errors=True)
+            [
+                {
+                    'path': '/strategy',
+                    'value': utils.generate_uuid(),  # Does not exist
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertTrue(response.json['error_message'])
@@ -477,36 +614,41 @@ class TestPatch(FunctionalTestWithSetup):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
             [{'path': '/foo', 'value': 'bar', 'op': 'add'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertTrue(response.json['error_message'])
 
     def test_remove_strategy(self):
         audit_template = obj_utils.create_test_audit_template(
-            self.context, uuid=utils.generate_uuid(),
+            self.context,
+            uuid=utils.generate_uuid(),
             name=f"AT_{utils.generate_uuid()}",
             goal_id=self.fake_goal1.id,
-            strategy_id=self.fake_strategy1.id)
-        response = self.get_json(
-            f'/audit_templates/{audit_template.uuid}')
+            strategy_id=self.fake_strategy1.id,
+        )
+        response = self.get_json(f'/audit_templates/{audit_template.uuid}')
         self.assertIsNotNone(response['strategy_uuid'])
 
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
-            [{'path': '/strategy', 'op': 'remove'}])
+            [{'path': '/strategy', 'op': 'remove'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
 
     def test_remove_goal(self):
         response = self.get_json(
-            f'/audit_templates/{self.audit_template.uuid}')
+            f'/audit_templates/{self.audit_template.uuid}'
+        )
         self.assertIsNotNone(response['goal_uuid'])
 
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
             [{'path': '/goal', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -515,7 +657,8 @@ class TestPatch(FunctionalTestWithSetup):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
             [{'path': '/uuid', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -524,19 +667,19 @@ class TestPatch(FunctionalTestWithSetup):
         response = self.patch_json(
             f'/audit_templates/{self.audit_template.uuid}',
             [{'path': '/non-existent', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
 
 
 class TestPost(FunctionalTestWithSetup):
-
     @mock.patch.object(timeutils, 'utcnow')
     def test_create_audit_template(self, mock_utcnow):
         audit_template_dict = post_get_test_audit_template(
-            goal=self.fake_goal1.uuid,
-            strategy=self.fake_strategy1.uuid)
+            goal=self.fake_goal1.uuid, strategy=self.fake_strategy1.uuid
+        )
         test_time = datetime.datetime(2000, 1, 1, 0, 0)
         mock_utcnow.return_value = test_time
 
@@ -545,25 +688,29 @@ class TestPost(FunctionalTestWithSetup):
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
         # Check location header
         self.assertIsNotNone(response.location)
-        expected_location = \
-            '/v1/audit_templates/{}'.format(response.json['uuid'])
-        self.assertEqual(urlparse.urlparse(response.location).path,
-                         expected_location)
+        expected_location = '/v1/audit_templates/{}'.format(
+            response.json['uuid']
+        )
+        self.assertEqual(
+            urlparse.urlparse(response.location).path, expected_location
+        )
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
         self.assertNotIn('updated_at', response.json.keys)
         self.assertNotIn('deleted_at', response.json.keys)
         self.assertEqual(self.fake_goal1.uuid, response.json['goal_uuid'])
-        self.assertEqual(self.fake_strategy1.uuid,
-                         response.json['strategy_uuid'])
+        self.assertEqual(
+            self.fake_strategy1.uuid, response.json['strategy_uuid']
+        )
         return_created_at = timeutils.parse_isotime(
-            response.json['created_at']).replace(tzinfo=None)
+            response.json['created_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_created_at)
 
     @mock.patch.object(timeutils, 'utcnow')
     def test_create_audit_template_with_strategy_name(self, mock_utcnow):
         audit_template_dict = post_get_test_audit_template(
-            goal=self.fake_goal1.uuid,
-            strategy=self.fake_strategy1.name)
+            goal=self.fake_goal1.uuid, strategy=self.fake_strategy1.name
+        )
         test_time = datetime.datetime(2000, 1, 1, 0, 0)
         mock_utcnow.return_value = test_time
 
@@ -572,71 +719,94 @@ class TestPost(FunctionalTestWithSetup):
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
         # Check location header
         self.assertIsNotNone(response.location)
-        expected_location = \
-            '/v1/audit_templates/{}'.format(response.json['uuid'])
-        self.assertEqual(urlparse.urlparse(response.location).path,
-                         expected_location)
+        expected_location = '/v1/audit_templates/{}'.format(
+            response.json['uuid']
+        )
+        self.assertEqual(
+            urlparse.urlparse(response.location).path, expected_location
+        )
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
         self.assertNotIn('updated_at', response.json.keys)
         self.assertNotIn('deleted_at', response.json.keys)
         self.assertEqual(self.fake_goal1.uuid, response.json['goal_uuid'])
-        self.assertEqual(self.fake_strategy1.uuid,
-                         response.json['strategy_uuid'])
-        self.assertEqual(self.fake_strategy1.name,
-                         response.json['strategy_name'])
+        self.assertEqual(
+            self.fake_strategy1.uuid, response.json['strategy_uuid']
+        )
+        self.assertEqual(
+            self.fake_strategy1.name, response.json['strategy_name']
+        )
         return_created_at = timeutils.parse_isotime(
-            response.json['created_at']).replace(tzinfo=None)
+            response.json['created_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_created_at)
 
     def test_create_audit_template_validation_with_aggregates(self):
-        scope = [{'compute': [{'host_aggregates': [{'id': '*'}]},
-                              {'availability_zones': [{'name': 'AZ1'},
-                                                      {'name': 'AZ2'}]},
-                              {'exclude': [
-                                  {'instances': [
-                                      {'uuid': 'INSTANCE_1'},
-                                      {'uuid': 'INSTANCE_2'}]},
-                                  {'compute_nodes': [
-                                      {'name': 'Node_1'},
-                                      {'name': 'Node_2'}]},
-                                  {'host_aggregates': [{'id': '*'}]}
-                              ]}
-                              ]
-                  }
-                 ]
+        scope = [
+            {
+                'compute': [
+                    {'host_aggregates': [{'id': '*'}]},
+                    {'availability_zones': [{'name': 'AZ1'}, {'name': 'AZ2'}]},
+                    {
+                        'exclude': [
+                            {
+                                'instances': [
+                                    {'uuid': 'INSTANCE_1'},
+                                    {'uuid': 'INSTANCE_2'},
+                                ]
+                            },
+                            {
+                                'compute_nodes': [
+                                    {'name': 'Node_1'},
+                                    {'name': 'Node_2'},
+                                ]
+                            },
+                            {'host_aggregates': [{'id': '*'}]},
+                        ]
+                    },
+                ]
+            }
+        ]
         audit_template_dict = post_get_test_audit_template(
             goal=self.fake_goal1.uuid,
-            strategy=self.fake_strategy1.uuid, scope=scope)
-        with self.assertRaisesRegex(webtest_app.AppError,
-                                    "be included and excluded together"):
+            strategy=self.fake_strategy1.uuid,
+            scope=scope,
+        )
+        with self.assertRaisesRegex(
+            webtest_app.AppError, "be included and excluded together"
+        ):
             self.post_json('/audit_templates', audit_template_dict)
 
         scope = [{'host_aggregates': [{'id1': '*'}]}]
         audit_template_dict = post_get_test_audit_template(
             goal=self.fake_goal1.uuid,
-            strategy=self.fake_strategy1.uuid, scope=scope)
-        response = self.post_json('/audit_templates',
-                                  audit_template_dict, expect_errors=True)
-        self.assertEqual(HTTPStatus.INTERNAL_SERVER_ERROR,
-                         response.status_int)
+            strategy=self.fake_strategy1.uuid,
+            scope=scope,
+        )
+        response = self.post_json(
+            '/audit_templates', audit_template_dict, expect_errors=True
+        )
+        self.assertEqual(HTTPStatus.INTERNAL_SERVER_ERROR, response.status_int)
 
     def test_create_audit_template_does_autogenerate_id(self):
         audit_template_dict = post_get_test_audit_template(
-            goal=self.fake_goal1.uuid, strategy=None)
+            goal=self.fake_goal1.uuid, strategy=None
+        )
         with mock.patch.object(
             self.dbapi,
             'create_audit_template',
-            wraps=self.dbapi.create_audit_template
+            wraps=self.dbapi.create_audit_template,
         ) as cn_mock:
             response = self.post_json('/audit_templates', audit_template_dict)
-        self.assertEqual(audit_template_dict['goal'],
-                         response.json['goal_uuid'])
+        self.assertEqual(
+            audit_template_dict['goal'], response.json['goal_uuid']
+        )
         # Check that 'id' is not in first arg of positional args
         self.assertNotIn('id', cn_mock.call_args[0][0])
 
     def test_create_audit_template_generate_uuid(self):
         audit_template_dict = post_get_test_audit_template(
-            goal=self.fake_goal1.uuid, strategy=None)
+            goal=self.fake_goal1.uuid, strategy=None
+        )
 
         response = self.post_json('/audit_templates', audit_template_dict)
         self.assertEqual('application/json', response.content_type)
@@ -647,12 +817,14 @@ class TestPost(FunctionalTestWithSetup):
         with mock.patch.object(
             self.dbapi,
             'create_audit_template',
-            wraps=self.dbapi.create_audit_template
+            wraps=self.dbapi.create_audit_template,
         ) as cn_mock:
             audit_template_dict = post_get_test_audit_template(
-                goal_uuid=utils.generate_uuid())
-            response = self.post_json('/audit_templates',
-                                      audit_template_dict, expect_errors=True)
+                goal_uuid=utils.generate_uuid()
+            )
+            response = self.post_json(
+                '/audit_templates', audit_template_dict, expect_errors=True
+            )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         assert not cn_mock.called
 
@@ -660,13 +832,15 @@ class TestPost(FunctionalTestWithSetup):
         with mock.patch.object(
             self.dbapi,
             'create_audit_template',
-            wraps=self.dbapi.create_audit_template
+            wraps=self.dbapi.create_audit_template,
         ) as cn_mock:
             audit_template_dict = post_get_test_audit_template(
                 goal_uuid=self.fake_goal1['uuid'],
-                strategy_uuid=utils.generate_uuid())
-            response = self.post_json('/audit_templates',
-                                      audit_template_dict, expect_errors=True)
+                strategy_uuid=utils.generate_uuid(),
+            )
+            response = self.post_json(
+                '/audit_templates', audit_template_dict, expect_errors=True
+            )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         assert not cn_mock.called
 
@@ -674,13 +848,15 @@ class TestPost(FunctionalTestWithSetup):
         with mock.patch.object(
             self.dbapi,
             'create_audit_template',
-            wraps=self.dbapi.create_audit_template
+            wraps=self.dbapi.create_audit_template,
         ) as cn_mock:
             audit_template_dict = post_get_test_audit_template(
                 goal_uuid=self.fake_goal1['uuid'],
-                strategy=self.fake_strategy2['uuid'])
-            response = self.post_json('/audit_templates',
-                                      audit_template_dict, expect_errors=True)
+                strategy=self.fake_strategy2['uuid'],
+            )
+            response = self.post_json(
+                '/audit_templates', audit_template_dict, expect_errors=True
+            )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         assert not cn_mock.called
 
@@ -688,175 +864,228 @@ class TestPost(FunctionalTestWithSetup):
         with mock.patch.object(
             self.dbapi,
             'create_audit_template',
-            wraps=self.dbapi.create_audit_template
+            wraps=self.dbapi.create_audit_template,
         ) as cn_mock:
             audit_template_dict = post_get_test_audit_template()
-            response = self.post_json('/audit_templates', audit_template_dict,
-                                      expect_errors=True)
+            response = self.post_json(
+                '/audit_templates', audit_template_dict, expect_errors=True
+            )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         assert not cn_mock.called
 
     def test_create_audit_template_with_old_scope(self):
-        scope = [{'host_aggregates': [{'id': '*'}]},
-                 {'availability_zones': [{'name': 'AZ1'},
-                                         {'name': 'AZ2'}]},
-                 {'exclude': [
-                     {'instances': [
-                         {'uuid': 'INSTANCE_1'},
-                         {'uuid': 'INSTANCE_2'}]},
-                     {'compute_nodes': [
-                         {'name': 'Node_1'},
-                         {'name': 'Node_2'}]},
-                 ]}
-                 ]
+        scope = [
+            {'host_aggregates': [{'id': '*'}]},
+            {'availability_zones': [{'name': 'AZ1'}, {'name': 'AZ2'}]},
+            {
+                'exclude': [
+                    {
+                        'instances': [
+                            {'uuid': 'INSTANCE_1'},
+                            {'uuid': 'INSTANCE_2'},
+                        ]
+                    },
+                    {
+                        'compute_nodes': [
+                            {'name': 'Node_1'},
+                            {'name': 'Node_2'},
+                        ]
+                    },
+                ]
+            },
+        ]
         audit_template_dict = post_get_test_audit_template(
             goal=self.fake_goal1.uuid,
-            strategy=self.fake_strategy1.uuid, scope=scope)
-        response = self.post_json('/audit_templates',
-                                  audit_template_dict)
+            strategy=self.fake_strategy1.uuid,
+            scope=scope,
+        )
+        response = self.post_json('/audit_templates', audit_template_dict)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
 
 
 class TestDelete(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
         self.audit_template = obj_utils.create_test_audit_template(
-            self.context)
+            self.context
+        )
 
     @mock.patch.object(timeutils, 'utcnow')
     def test_delete_audit_template_by_uuid(self, mock_utcnow):
         test_time = datetime.datetime(2000, 1, 1, 0, 0)
         mock_utcnow.return_value = test_time
-        self.delete(urlparse.quote(
-            f'/audit_templates/{self.audit_template.uuid}'))
+        self.delete(
+            urlparse.quote(f'/audit_templates/{self.audit_template.uuid}')
+        )
         response = self.get_json(
             urlparse.quote(f'/audit_templates/{self.audit_template.uuid}'),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
 
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          objects.AuditTemplate.get_by_uuid,
-                          self.context,
-                          self.audit_template.uuid)
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            objects.AuditTemplate.get_by_uuid,
+            self.context,
+            self.audit_template.uuid,
+        )
 
         self.context.show_deleted = True
-        at = objects.AuditTemplate.get_by_uuid(self.context,
-                                               self.audit_template.uuid)
+        at = objects.AuditTemplate.get_by_uuid(
+            self.context, self.audit_template.uuid
+        )
         self.assertEqual(self.audit_template.name, at.name)
 
     @mock.patch.object(timeutils, 'utcnow')
     def test_delete_audit_template_by_name(self, mock_utcnow):
         test_time = datetime.datetime(2000, 1, 1, 0, 0)
         mock_utcnow.return_value = test_time
-        self.delete(urlparse.quote(
-            f'/audit_templates/{self.audit_template.name}'))
+        self.delete(
+            urlparse.quote(f'/audit_templates/{self.audit_template.name}')
+        )
         response = self.get_json(
             urlparse.quote(f'/audit_templates/{self.audit_template.name}'),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
 
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          objects.AuditTemplate.get_by_name,
-                          self.context,
-                          self.audit_template.name)
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            objects.AuditTemplate.get_by_name,
+            self.context,
+            self.audit_template.name,
+        )
 
         self.context.show_deleted = True
-        at = objects.AuditTemplate.get_by_name(self.context,
-                                               self.audit_template.name)
+        at = objects.AuditTemplate.get_by_name(
+            self.context, self.audit_template.name
+        )
         self.assertEqual(self.audit_template.uuid, at.uuid)
 
     def test_delete_audit_template_not_found(self):
         uuid = utils.generate_uuid()
-        response = self.delete(
-            f'/audit_templates/{uuid}', expect_errors=True)
+        response = self.delete(f'/audit_templates/{uuid}', expect_errors=True)
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
 
 
 class TestAuditTemplatePolicyEnforcement(api_base.FunctionalTest):
-
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "audit_template:get_all", self.get_json, '/audit_templates',
-            expect_errors=True)
+            "audit_template:get_all",
+            self.get_json,
+            '/audit_templates',
+            expect_errors=True,
+        )
 
     def test_policy_disallow_get_one(self):
         obj_utils.create_test_goal(self.context)
         audit_template = obj_utils.create_test_audit_template(self.context)
         self._common_policy_check(
-            "audit_template:get", self.get_json,
+            "audit_template:get",
+            self.get_json,
             f'/audit_templates/{audit_template.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "audit_template:detail", self.get_json,
+            "audit_template:detail",
+            self.get_json,
             '/audit_templates/detail',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_update(self):
         obj_utils.create_test_goal(self.context)
         audit_template = obj_utils.create_test_audit_template(self.context)
         self._common_policy_check(
-            "audit_template:update", self.patch_json,
+            "audit_template:update",
+            self.patch_json,
             f'/audit_templates/{audit_template.uuid}',
-            [{'path': '/state', 'value': objects.audit.State.SUCCEEDED,
-              'op': 'replace'}], expect_errors=True)
+            [
+                {
+                    'path': '/state',
+                    'value': objects.audit.State.SUCCEEDED,
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
 
     def test_policy_disallow_create(self):
         fake_goal1 = obj_utils.get_test_goal(
-            self.context, id=1, uuid=utils.generate_uuid(), name="dummy_1")
+            self.context, id=1, uuid=utils.generate_uuid(), name="dummy_1"
+        )
         fake_goal1.create()
         fake_strategy1 = obj_utils.get_test_strategy(
-            self.context, id=1, uuid=utils.generate_uuid(), name="strategy_1",
-            goal_id=fake_goal1.id)
+            self.context,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name="strategy_1",
+            goal_id=fake_goal1.id,
+        )
         fake_strategy1.create()
 
         audit_template_dict = post_get_test_audit_template(
-            goal=fake_goal1.uuid,
-            strategy=fake_strategy1.uuid)
+            goal=fake_goal1.uuid, strategy=fake_strategy1.uuid
+        )
         self._common_policy_check(
-            "audit_template:create", self.post_json, '/audit_templates',
-            audit_template_dict, expect_errors=True)
+            "audit_template:create",
+            self.post_json,
+            '/audit_templates',
+            audit_template_dict,
+            expect_errors=True,
+        )
 
     def test_policy_disallow_delete(self):
         obj_utils.create_test_goal(self.context)
         audit_template = obj_utils.create_test_audit_template(self.context)
         self._common_policy_check(
-            "audit_template:delete", self.delete,
-            f'/audit_templates/{audit_template.uuid}', expect_errors=True)
+            "audit_template:delete",
+            self.delete,
+            f'/audit_templates/{audit_template.uuid}',
+            expect_errors=True,
+        )
 
 
-class TestAuditTemplatePolicyWithAdminContext(TestListAuditTemplate,
-                                              api_base.AdminRoleTest):
+class TestAuditTemplatePolicyWithAdminContext(
+    TestListAuditTemplate, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "audit_template:create": "rule:default",
-            "audit_template:delete": "rule:default",
-            "audit_template:detail": "rule:default",
-            "audit_template:get": "rule:default",
-            "audit_template:get_all": "rule:default",
-            "audit_template:update": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "audit_template:create": "rule:default",
+                "audit_template:delete": "rule:default",
+                "audit_template:detail": "rule:default",
+                "audit_template:get": "rule:default",
+                "audit_template:get_all": "rule:default",
+                "audit_template:update": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_audits.py b/watcher/tests/unit/api/v1/test_audits.py
index 4c9a9be2b..094a387ff 100644
--- a/watcher/tests/unit/api/v1/test_audits.py
+++ b/watcher/tests/unit/api/v1/test_audits.py
@@ -42,9 +42,10 @@ def post_get_test_audit(**kw):
     goal = db_utils.get_test_goal()
     del_keys = ['goal_id', 'strategy_id']
     del_keys.extend(kw.get('params_to_exclude', []))
-    add_keys = {'audit_template_uuid': audit_template['uuid'],
-                'goal': goal['uuid'],
-                }
+    add_keys = {
+        'audit_template_uuid': audit_template['uuid'],
+        'goal': goal['uuid'],
+    }
     if kw.get('use_named_goal'):
         add_keys['goal'] = 'TEST'
     for k in add_keys:
@@ -60,10 +61,10 @@ def post_get_test_audit_with_predefined_strategy(**kw):
     strategy = db_utils.get_test_strategy(parameters_spec=spec, id=strategy_id)
     audit = api_utils.audit_post_data(**kw)
     audit_template = db_utils.get_test_audit_template(
-        strategy_id=strategy['id'])
+        strategy_id=strategy['id']
+    )
     del_keys = ['goal_id', 'strategy_id']
-    add_keys = {'audit_template_uuid': audit_template['uuid'],
-                }
+    add_keys = {'audit_template_uuid': audit_template['uuid']}
     for k in del_keys:
         del audit[k]
     for k in add_keys:
@@ -72,18 +73,16 @@ def post_get_test_audit_with_predefined_strategy(**kw):
 
 
 class TestAuditObject(base.TestCase):
-
     def test_audit_init(self):
-        audit_dict = api_utils.audit_post_data(audit_template_id=None,
-                                               goal_id=None,
-                                               strategy_id=None)
+        audit_dict = api_utils.audit_post_data(
+            audit_template_id=None, goal_id=None, strategy_id=None
+        )
         del audit_dict['state']
         audit = api_audit.Audit(**audit_dict)
         self.assertEqual(wtypes.Unset, audit.state)
 
 
 class TestListAudit(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -95,8 +94,13 @@ class TestListAudit(api_base.FunctionalTest):
         self.assertEqual([], response['audits'])
 
     def _assert_audit_fields(self, audit):
-        audit_fields = ['audit_type', 'scope', 'state', 'goal_uuid',
-                        'strategy_uuid']
+        audit_fields = [
+            'audit_type',
+            'scope',
+            'state',
+            'goal_uuid',
+            'strategy_uuid',
+        ]
         for field in audit_fields:
             self.assertIn(field, audit)
 
@@ -108,9 +112,11 @@ class TestListAudit(api_base.FunctionalTest):
 
     def test_list_with_status_message(self):
         audit = obj_utils.create_test_audit(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         response = self.get_json(
-            '/audits', headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            '/audits', headers={'OpenStack-API-Version': 'infra-optim 1.5'}
+        )
         self.assertEqual(audit.uuid, response['audits'][0]["uuid"])
         self._assert_audit_fields(response['audits'][0])
         # status_message is not in the basic actions list
@@ -119,8 +125,7 @@ class TestListAudit(api_base.FunctionalTest):
     def test_one_soft_deleted(self):
         audit = obj_utils.create_test_audit(self.context)
         audit.soft_delete()
-        response = self.get_json('/audits',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json('/audits', headers={'X-Show-Deleted': 'True'})
         self.assertEqual(audit.uuid, response['audits'][0]["uuid"])
         self._assert_audit_fields(response['audits'][0])
 
@@ -136,43 +141,50 @@ class TestListAudit(api_base.FunctionalTest):
 
     def test_get_one_with_status_message(self):
         audit = obj_utils.create_test_audit(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         response = self.get_json(
             '/audits/{}'.format(audit['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(audit.uuid, response['uuid'])
         self._assert_audit_fields(response)
         self.assertEqual('Fake message', response['status_message'])
 
     def test_get_one_with_hidden_status_message(self):
         audit = obj_utils.create_test_audit(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         response = self.get_json(
             '/audits/{}'.format(audit['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.4'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.4'},
+        )
         self.assertEqual(audit.uuid, response['uuid'])
         self._assert_audit_fields(response)
         self.assertNotIn('status_message', response)
 
     def test_get_one_with_empty_status_message(self):
-        audit = obj_utils.create_test_audit(
-            self.context)
+        audit = obj_utils.create_test_audit(self.context)
         response = self.get_json(
             '/audits/{}'.format(audit['uuid']),
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(audit.uuid, response['uuid'])
         self.assertIsNone(response['status_message'])
 
     def test_get_one_soft_deleted(self):
         audit = obj_utils.create_test_audit(self.context)
         audit.soft_delete()
-        response = self.get_json('/audits/{}'.format(audit['uuid']),
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/audits/{}'.format(audit['uuid']),
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(audit.uuid, response['uuid'])
         self._assert_audit_fields(response)
 
-        response = self.get_json('/audits/{}'.format(audit['uuid']),
-                                 expect_errors=True)
+        response = self.get_json(
+            '/audits/{}'.format(audit['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
@@ -184,20 +196,24 @@ class TestListAudit(api_base.FunctionalTest):
 
     def test_detail_with_status_message(self):
         audit = obj_utils.create_test_audit(
-            self.context, status_message='Fake message')
+            self.context, status_message='Fake message'
+        )
         response = self.get_json(
             '/audits/detail',
-            headers={'OpenStack-API-Version': 'infra-optim 1.5'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.5'},
+        )
         self.assertEqual(audit.uuid, response['audits'][0]["uuid"])
         self._assert_audit_fields(response['audits'][0])
         self.assertEqual(
-            'Fake message', response['audits'][0]['status_message'])
+            'Fake message', response['audits'][0]['status_message']
+        )
 
     def test_detail_soft_deleted(self):
         audit = obj_utils.create_test_audit(self.context)
         audit.soft_delete()
-        response = self.get_json('/audits/detail',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json(
+            '/audits/detail', headers={'X-Show-Deleted': 'True'}
+        )
         self.assertEqual(audit.uuid, response['audits'][0]["uuid"])
         self._assert_audit_fields(response['audits'][0])
 
@@ -206,16 +222,20 @@ class TestListAudit(api_base.FunctionalTest):
 
     def test_detail_against_single(self):
         audit = obj_utils.create_test_audit(self.context)
-        response = self.get_json('/audits/{}/detail'.format(audit['uuid']),
-                                 expect_errors=True)
+        response = self.get_json(
+            '/audits/{}/detail'.format(audit['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         audit_list = []
         for id_ in range(5):
             audit = obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
             audit_list.append(audit.uuid)
         response = self.get_json('/audits')
         self.assertEqual(len(audit_list), len(response['audits']))
@@ -226,13 +246,19 @@ class TestListAudit(api_base.FunctionalTest):
         audit_list = []
         for id_ in [1, 2, 3]:
             audit = obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
             audit_list.append(audit.uuid)
         for id_ in [4, 5]:
             audit = obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
             audit.soft_delete()
         response = self.get_json('/audits')
         self.assertEqual(3, len(response['audits']))
@@ -243,17 +269,22 @@ class TestListAudit(api_base.FunctionalTest):
         audit_list = []
         for id_ in [1, 2, 3]:
             audit = obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
             audit_list.append(audit.uuid)
         for id_ in [4, 5]:
             audit = obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
             audit.soft_delete()
             audit_list.append(audit.uuid)
-        response = self.get_json('/audits',
-                                 headers={'X-Show-Deleted': 'True'})
+        response = self.get_json('/audits', headers={'X-Show-Deleted': 'True'})
         self.assertEqual(5, len(response['audits']))
         uuids = [s['uuid'] for s in response['audits']]
         self.assertEqual(sorted(audit_list), sorted(uuids))
@@ -262,12 +293,15 @@ class TestListAudit(api_base.FunctionalTest):
         goal_list = []
         for id_ in range(5):
             goal = obj_utils.create_test_goal(
-                self.context,
-                name=f'gl{id_}',
-                uuid=utils.generate_uuid())
+                self.context, name=f'gl{id_}', uuid=utils.generate_uuid()
+            )
             obj_utils.create_test_audit(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                goal_id=goal.id, name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                goal_id=goal.id,
+                name=f'My Audit {id_}',
+            )
             goal_list.append(goal.uuid)
 
         response = self.get_json('/audits/?sort_key=goal_uuid')
@@ -278,15 +312,15 @@ class TestListAudit(api_base.FunctionalTest):
 
     def test_sort_key_validation(self):
         response = self.get_json(
-            '/audits?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/audits?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
     def test_links(self):
         uuid = utils.generate_uuid()
         obj_utils.create_test_audit(
-            self.context, id=1, uuid=uuid,
-            name=f'My Audit {1}')
+            self.context, id=1, uuid=uuid, name=f'My Audit {1}'
+        )
         response = self.get_json(f'/audits/{uuid}')
         self.assertIn('links', response.keys())
         self.assertEqual(2, len(response['links']))
@@ -294,13 +328,17 @@ class TestListAudit(api_base.FunctionalTest):
         for link in response['links']:
             bookmark = link['rel'] == 'bookmark'
             self.assertTrue(
-                self.validate_link(link['href'], bookmark=bookmark))
+                self.validate_link(link['href'], bookmark=bookmark)
+            )
 
     def test_collection_links(self):
         for id_ in range(5):
             obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
         response = self.get_json('/audits/?limit=3')
         self.assertEqual(3, len(response['audits']))
 
@@ -311,8 +349,11 @@ class TestListAudit(api_base.FunctionalTest):
         cfg.CONF.set_override('max_limit', 3, 'api')
         for id_ in range(5):
             obj_utils.create_test_audit(
-                self.context, id=id_,
-                uuid=utils.generate_uuid(), name=f'My Audit {id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'My Audit {id_}',
+            )
         response = self.get_json('/audits')
         self.assertEqual(3, len(response['audits']))
 
@@ -321,7 +362,6 @@ class TestListAudit(api_base.FunctionalTest):
 
 
 class TestPatch(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -348,22 +388,30 @@ class TestPatch(api_base.FunctionalTest):
 
         response = self.patch_json(
             f'/audits/{self.audit.uuid}',
-            [{'path': '/state', 'value': new_state,
-             'op': 'replace'}])
+            [{'path': '/state', 'value': new_state, 'op': 'replace'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
 
         response = self.get_json(f'/audits/{self.audit.uuid}')
         self.assertEqual(new_state, response['state'])
         return_updated_at = timeutils.parse_isotime(
-            response['updated_at']).replace(tzinfo=None)
+            response['updated_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_updated_at)
 
     def test_replace_non_existent_audit(self):
         response = self.patch_json(
             f'/audits/{utils.generate_uuid()}',
-            [{'path': '/state', 'value': objects.audit.State.SUCCEEDED,
-              'op': 'replace'}], expect_errors=True)
+            [
+                {
+                    'path': '/state',
+                    'value': objects.audit.State.SUCCEEDED,
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -372,7 +420,8 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/audits/{utils.generate_uuid()}',
             [{'path': '/status_message', 'value': 'test', 'op': 'replace'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -381,7 +430,8 @@ class TestPatch(api_base.FunctionalTest):
         new_state = objects.audit.State.SUCCEEDED
         response = self.patch_json(
             f'/audits/{self.audit.uuid}',
-            [{'path': '/state', 'value': new_state, 'op': 'add'}])
+            [{'path': '/state', 'value': new_state, 'op': 'add'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_int)
 
@@ -392,7 +442,8 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/audits/{self.audit.uuid}',
             [{'path': '/foo', 'value': 'bar', 'op': 'add'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertTrue(response.json['error_message'])
@@ -401,8 +452,10 @@ class TestPatch(api_base.FunctionalTest):
         response = self.get_json(f'/audits/{self.audit.uuid}')
         self.assertIsNotNone(response['interval'])
 
-        response = self.patch_json(f'/audits/{self.audit.uuid}',
-                                   [{'path': '/interval', 'op': 'remove'}])
+        response = self.patch_json(
+            f'/audits/{self.audit.uuid}',
+            [{'path': '/interval', 'op': 'remove'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
 
@@ -410,9 +463,11 @@ class TestPatch(api_base.FunctionalTest):
         self.assertIsNone(response['interval'])
 
     def test_remove_uuid(self):
-        response = self.patch_json(f'/audits/{self.audit.uuid}',
-                                   [{'path': '/uuid', 'op': 'remove'}],
-                                   expect_errors=True)
+        response = self.patch_json(
+            f'/audits/{self.audit.uuid}',
+            [{'path': '/uuid', 'op': 'remove'}],
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -421,7 +476,8 @@ class TestPatch(api_base.FunctionalTest):
         response = self.patch_json(
             f'/audits/{self.audit.uuid}',
             [{'path': '/non-existent', 'op': 'remove'}],
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -430,28 +486,30 @@ class TestPatch(api_base.FunctionalTest):
 ALLOWED_TRANSITIONS = [
     {"original_state": key, "new_state": value}
     for key, values in (
-        objects.audit.AuditStateTransitionManager.TRANSITIONS.items())
-    for value in values]
+        objects.audit.AuditStateTransitionManager.TRANSITIONS.items()
+    )
+    for value in values
+]
 
 
 class TestPatchStateTransitionDenied(api_base.FunctionalTest):
-
     STATES = [
-        ap_state for ap_state in objects.audit.State.__dict__
+        ap_state
+        for ap_state in objects.audit.State.__dict__
         if not ap_state.startswith("_")
     ]
 
     scenarios = [
         (
             f"{original_state} -> {new_state}",
-            {"original_state": original_state,
-             "new_state": new_state},
+            {"original_state": original_state, "new_state": new_state},
         )
-        for original_state, new_state
-        in list(itertools.product(STATES, STATES))
-        if original_state != new_state and
-        {"original_state": original_state,
-         "new_state": new_state} not in ALLOWED_TRANSITIONS
+        for original_state, new_state in list(
+            itertools.product(STATES, STATES)
+        )
+        if original_state != new_state
+        and {"original_state": original_state, "new_state": new_state}
+        not in ALLOWED_TRANSITIONS
     ]
 
     def setUp(self):
@@ -459,8 +517,9 @@ class TestPatchStateTransitionDenied(api_base.FunctionalTest):
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit_template(self.context)
-        self.audit = obj_utils.create_test_audit(self.context,
-                                                 state=self.original_state)
+        self.audit = obj_utils.create_test_audit(
+            self.context, state=self.original_state
+        )
         p = mock.patch.object(db_api.BaseConnection, 'update_audit')
         self.mock_audit_update = p.start()
         self.mock_audit_update.side_effect = self._simulate_rpc_audit_update
@@ -476,9 +535,9 @@ class TestPatchStateTransitionDenied(api_base.FunctionalTest):
 
         response = self.patch_json(
             f'/audits/{self.audit.uuid}',
-            [{'path': '/state', 'value': self.new_state,
-              'op': 'replace'}],
-            expect_errors=True)
+            [{'path': '/state', 'value': self.new_state, 'op': 'replace'}],
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_code)
         self.assertTrue(response.json['error_message'])
@@ -488,12 +547,12 @@ class TestPatchStateTransitionDenied(api_base.FunctionalTest):
 
 
 class TestPatchStateTransitionOk(api_base.FunctionalTest):
-
     scenarios = [
         (
-            "{} -> {}".format(transition["original_state"],
-                              transition["new_state"]),
-            transition
+            "{} -> {}".format(
+                transition["original_state"], transition["new_state"]
+            ),
+            transition,
         )
         for transition in ALLOWED_TRANSITIONS
     ]
@@ -503,8 +562,9 @@ class TestPatchStateTransitionOk(api_base.FunctionalTest):
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit_template(self.context)
-        self.audit = obj_utils.create_test_audit(self.context,
-                                                 state=self.original_state)
+        self.audit = obj_utils.create_test_audit(
+            self.context, state=self.original_state
+        )
         p = mock.patch.object(db_api.BaseConnection, 'update_audit')
         self.mock_audit_update = p.start()
         self.mock_audit_update.side_effect = self._simulate_rpc_audit_update
@@ -524,20 +584,20 @@ class TestPatchStateTransitionOk(api_base.FunctionalTest):
 
         response = self.patch_json(
             f'/audits/{self.audit.uuid}',
-            [{'path': '/state', 'value': self.new_state,
-             'op': 'replace'}])
+            [{'path': '/state', 'value': self.new_state, 'op': 'replace'}],
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.OK, response.status_code)
 
         response = self.get_json(f'/audits/{self.audit.uuid}')
         self.assertEqual(self.new_state, response['state'])
         return_updated_at = timeutils.parse_isotime(
-            response['updated_at']).replace(tzinfo=None)
+            response['updated_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_updated_at)
 
 
 class TestPostBase(api_base.FunctionalTest):
-
     def _simulate_rpc_audit_create(self, audit):
         audit.create()
         return audit
@@ -549,8 +609,7 @@ class TestPostBase(api_base.FunctionalTest):
         obj_utils.create_test_audit_template(self.context)
         p = mock.patch.object(db_api.BaseConnection, 'create_audit')
         self.mock_create_audit = p.start()
-        self.mock_create_audit.side_effect = (
-            self._simulate_rpc_audit_create)
+        self.mock_create_audit.side_effect = self._simulate_rpc_audit_create
         self.addCleanup(p.stop)
 
     def prepare_audit_template_strategy_with_parameter(self, fake_spec=None):
@@ -564,33 +623,39 @@ class TestPostBase(api_base.FunctionalTest):
                         "maximum": 10.2,
                     }
                 },
-                'required': ['fake1']
+                'required': ['fake1'],
             }
         template_uuid = 'e74c40e0-d825-11e2-a28f-0800200c9a67'
         strategy_uuid = 'e74c40e0-d825-11e2-a28f-0800200c9a68'
         template_name = 'my template'
         strategy_name = 'my strategy'
         strategy_id = 3
-        strategy = db_utils.get_test_strategy(parameters_spec=fake_spec,
-                                              id=strategy_id,
-                                              uuid=strategy_uuid,
-                                              name=strategy_name)
-        obj_utils.create_test_strategy(self.context,
-                                       parameters_spec=fake_spec,
-                                       id=strategy_id,
-                                       uuid=strategy_uuid,
-                                       name=strategy_name)
-        obj_utils.create_test_audit_template(self.context,
-                                             strategy_id=strategy_id,
-                                             uuid=template_uuid,
-                                             name='name')
+        strategy = db_utils.get_test_strategy(
+            parameters_spec=fake_spec,
+            id=strategy_id,
+            uuid=strategy_uuid,
+            name=strategy_name,
+        )
+        obj_utils.create_test_strategy(
+            self.context,
+            parameters_spec=fake_spec,
+            id=strategy_id,
+            uuid=strategy_uuid,
+            name=strategy_name,
+        )
+        obj_utils.create_test_audit_template(
+            self.context,
+            strategy_id=strategy_id,
+            uuid=template_uuid,
+            name='name',
+        )
         audit_template = db_utils.get_test_audit_template(
-            strategy_id=strategy['id'], uuid=template_uuid, name=template_name)
+            strategy_id=strategy['id'], uuid=template_uuid, name=template_name
+        )
         return audit_template
 
 
 class TestPost(TestPostBase):
-
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
     @mock.patch('oslo_utils.timeutils.utcnow')
     def test_create_audit(self, mock_utcnow, mock_trigger_audit):
@@ -600,8 +665,16 @@ class TestPost(TestPostBase):
 
         audit_dict = post_get_test_audit(
             state=objects.audit.State.PENDING,
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ],
+        )
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
@@ -609,20 +682,22 @@ class TestPost(TestPostBase):
         # Check location header
         self.assertIsNotNone(response.location)
         expected_location = '/v1/audits/{}'.format(response.json['uuid'])
-        self.assertEqual(urlparse.urlparse(response.location).path,
-                         expected_location)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(
+            urlparse.urlparse(response.location).path, expected_location
+        )
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertNotIn('updated_at', response.json.keys)
         self.assertNotIn('deleted_at', response.json.keys)
         return_created_at = timeutils.parse_isotime(
-            response.json['created_at']).replace(tzinfo=None)
+            response.json['created_at']
+        ).replace(tzinfo=None)
         self.assertEqual(test_time, return_created_at)
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
     @mock.patch('oslo_utils.timeutils.utcnow')
-    def test_create_audit_with_state_not_allowed(self, mock_utcnow,
-                                                 mock_trigger_audit):
+    def test_create_audit_with_state_not_allowed(
+        self, mock_utcnow, mock_trigger_audit
+    ):
         mock_trigger_audit.return_value = mock.ANY
         test_time = datetime.datetime(2000, 1, 1, 0, 0)
         mock_utcnow.return_value = test_time
@@ -641,8 +716,15 @@ class TestPost(TestPostBase):
 
         audit_dict = post_get_test_audit(
             state=objects.audit.State.PENDING,
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+            ],
+        )
 
         response = self.post_json('/audits', audit_dict, expect_errors=True)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
@@ -654,15 +736,21 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname',
-                               'audit_template_uuid'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'audit_template_uuid',
+            ]
+        )
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
@@ -670,15 +758,22 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname',
-                               'audit_template_uuid', 'strategy'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'audit_template_uuid',
+                'strategy',
+            ]
+        )
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
@@ -686,16 +781,22 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname',
-                               'audit_template_uuid'],
-            use_named_goal=True)
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'audit_template_uuid',
+            ],
+            use_named_goal=True,
+        )
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
 
     @mock.patch('oslo_utils.timeutils.utcnow')
@@ -704,17 +805,27 @@ class TestPost(TestPostBase):
         mock_utcnow.return_value = test_time
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         # Make the audit template UUID some garbage value
         audit_dict['audit_template_uuid'] = (
-            '01234567-8910-1112-1314-151617181920')
+            '01234567-8910-1112-1314-151617181920'
+        )
 
         response = self.post_json('/audits', audit_dict, expect_errors=True)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual("application/json", response.content_type)
-        expected_error_msg = ('The audit template UUID or name specified is '
-                              'invalid')
+        expected_error_msg = (
+            'The audit template UUID or name specified is invalid'
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
 
@@ -724,12 +835,20 @@ class TestPost(TestPostBase):
 
         audit_dict = post_get_test_audit(
             state=objects.audit.State.PENDING,
-            params_to_exclude=['uuid', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ],
+        )
         state = audit_dict['state']
         del audit_dict['state']
-        with mock.patch.object(self.dbapi, 'create_audit',
-                               wraps=self.dbapi.create_audit) as cn_mock:
+        with mock.patch.object(
+            self.dbapi, 'create_audit', wraps=self.dbapi.create_audit
+        ) as cn_mock:
             response = self.post_json('/audits', audit_dict)
             self.assertEqual(state, response.json['state'])
             cn_mock.assert_called_once_with(mock.ANY)
@@ -741,14 +860,21 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
@@ -756,46 +882,67 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         audit_dict['audit_type'] = objects.audit.AuditType.CONTINUOUS.value
         audit_dict['interval'] = '1200'
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertEqual(audit_dict['interval'], response.json['interval'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_continuous_audit_with_cron_interval(self,
-                                                        mock_trigger_audit):
+    def test_create_continuous_audit_with_cron_interval(
+        self, mock_trigger_audit
+    ):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         audit_dict['audit_type'] = objects.audit.AuditType.CONTINUOUS.value
         audit_dict['interval'] = '* * * * *'
 
         response = self.post_json('/audits', audit_dict)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertEqual(audit_dict['interval'], response.json['interval'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_continuous_audit_with_wrong_interval(self,
-                                                         mock_trigger_audit):
+    def test_create_continuous_audit_with_wrong_interval(
+        self, mock_trigger_audit
+    ):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         audit_dict['audit_type'] = objects.audit.AuditType.CONTINUOUS.value
         audit_dict['interval'] = 'zxc'
 
@@ -804,8 +951,9 @@ class TestPost(TestPostBase):
         self.assertEqual(HTTPStatus.INTERNAL_SERVER_ERROR, response.status_int)
         # NOTE(dviroel): this error message check was shortened to try avoid
         # future breakages. See bug #2089866 for more details.
-        expected_error_msg = ('columns has to be specified for iterator '
-                              'expression.')
+        expected_error_msg = (
+            'columns has to be specified for iterator expression.'
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
 
@@ -814,15 +962,24 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         audit_dict['audit_type'] = objects.audit.AuditType.CONTINUOUS.value
 
         response = self.post_json('/audits', audit_dict, expect_errors=True)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
-        expected_error_msg = ('Interval of audit must be specified '
-                              'for CONTINUOUS.')
+        expected_error_msg = (
+            'Interval of audit must be specified for CONTINUOUS.'
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
 
@@ -831,8 +988,15 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         audit_dict['audit_type'] = objects.audit.AuditType.ONESHOT.value
 
         response = self.post_json('/audits', audit_dict, expect_errors=True)
@@ -843,12 +1007,21 @@ class TestPost(TestPostBase):
         self.assertIn(expected_error_msg, response.json['error_message'])
 
     def test_create_audit_trigger_decision_engine(self):
-        with mock.patch.object(deapi.DecisionEngineAPI,
-                               'trigger_audit') as de_mock:
+        with mock.patch.object(
+            deapi.DecisionEngineAPI, 'trigger_audit'
+        ) as de_mock:
             audit_dict = post_get_test_audit(
                 state=objects.audit.State.PENDING,
-                params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                                   'next_run_time', 'hostname', 'goal'])
+                params_to_exclude=[
+                    'uuid',
+                    'state',
+                    'interval',
+                    'scope',
+                    'next_run_time',
+                    'hostname',
+                    'goal',
+                ],
+            )
             response = self.post_json('/audits', audit_dict)
             de_mock.assert_called_once_with(mock.ANY, response.json['uuid'])
 
@@ -865,29 +1038,40 @@ class TestPost(TestPostBase):
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
     def test_create_audit_parameters_no_predefined_strategy(
-            self, mock_trigger_audit):
+        self, mock_trigger_audit
+    ):
         mock_trigger_audit.return_value = mock.ANY
         audit_dict = post_get_test_audit(
             parameters={'name': 'Tom'},
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ],
+        )
 
         response = self.post_json('/audits', audit_dict, expect_errors=True)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
-        expected_error_msg = ('Specify parameters but no predefined '
-                              'strategy for audit, or no '
-                              'parameter spec in predefined strategy')
+        expected_error_msg = (
+            'Specify parameters but no predefined '
+            'strategy for audit, or no '
+            'parameter spec in predefined strategy'
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
         mock_trigger_audit.assert_not_called()
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_parameters_no_schema(
-            self, mock_trigger_audit):
+    def test_create_audit_parameters_no_schema(self, mock_trigger_audit):
         mock_trigger_audit.return_value = mock.ANY
         audit_dict = post_get_test_audit_with_predefined_strategy(
-            parameters={'name': 'Tom'})
+            parameters={'name': 'Tom'}
+        )
         del audit_dict['uuid']
         del audit_dict['state']
         del audit_dict['interval']
@@ -898,25 +1082,35 @@ class TestPost(TestPostBase):
         response = self.post_json('/audits', audit_dict, expect_errors=True)
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
-        expected_error_msg = ('Specify parameters but no predefined '
-                              'strategy for audit, or no '
-                              'parameter spec in predefined strategy')
+        expected_error_msg = (
+            'Specify parameters but no predefined '
+            'strategy for audit, or no '
+            'parameter spec in predefined strategy'
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
         mock_trigger_audit.assert_not_called()
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_with_parameter_not_allowed(
-            self, mock_trigger_audit):
+    def test_create_audit_with_parameter_not_allowed(self, mock_trigger_audit):
         mock_trigger_audit.return_value = mock.ANY
         audit_template = self.prepare_audit_template_strategy_with_parameter()
 
         audit_dict = api_utils.audit_post_data(
-            parameters={'fake1': 1, 'fake2': "hello"})
+            parameters={'fake1': 1, 'fake2': "hello"}
+        )
 
         audit_dict['audit_template_uuid'] = audit_template['uuid']
-        del_keys = ['uuid', 'goal_id', 'strategy_id', 'state', 'interval',
-                    'scope', 'next_run_time', 'hostname']
+        del_keys = [
+            'uuid',
+            'goal_id',
+            'strategy_id',
+            'state',
+            'interval',
+            'scope',
+            'next_run_time',
+            'hostname',
+        ]
         for k in del_keys:
             del audit_dict[k]
 
@@ -929,17 +1123,23 @@ class TestPost(TestPostBase):
         mock_trigger_audit.assert_not_called()
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_with_missing_parameter(
-            self, mock_trigger_audit):
+    def test_create_audit_with_missing_parameter(self, mock_trigger_audit):
         mock_trigger_audit.return_value = mock.ANY
         audit_template = self.prepare_audit_template_strategy_with_parameter()
 
-        audit_dict = api_utils.audit_post_data(
-            parameters={})
+        audit_dict = api_utils.audit_post_data(parameters={})
 
         audit_dict['audit_template_uuid'] = audit_template['uuid']
-        del_keys = ['uuid', 'goal_id', 'strategy_id', 'state', 'interval',
-                    'scope', 'next_run_time', 'hostname']
+        del_keys = [
+            'uuid',
+            'goal_id',
+            'strategy_id',
+            'state',
+            'interval',
+            'scope',
+            'next_run_time',
+            'hostname',
+        ]
         for k in del_keys:
             del audit_dict[k]
 
@@ -947,7 +1147,8 @@ class TestPost(TestPostBase):
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual("application/json", response.content_type)
         expected_error_msg = (
-            "Invalid parameters for strategy: 'fake1' is a required property")
+            "Invalid parameters for strategy: 'fake1' is a required property"
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
         mock_trigger_audit.assert_not_called()
@@ -960,8 +1161,15 @@ class TestPost(TestPostBase):
         mock_utcnow.return_value = test_time
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
         normal_name = 'this audit name is just for test'
         # long_name length exceeds 63 characters
         long_name = normal_name + audit_dict['uuid']
@@ -981,14 +1189,21 @@ class TestPost(TestPostBase):
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
     def test_create_continuous_audit_with_start_end_time(
-            self, mock_trigger_audit):
+        self, mock_trigger_audit
+    ):
         mock_trigger_audit.return_value = mock.ANY
         start_time = datetime.datetime(2018, 3, 1, 0, 0)
         end_time = datetime.datetime(2018, 4, 1, 0, 0)
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal']
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
         )
         audit_dict['audit_type'] = objects.audit.AuditType.CONTINUOUS.value
         audit_dict['interval'] = '1200'
@@ -998,17 +1213,17 @@ class TestPost(TestPostBase):
         response = self.post_json(
             '/audits',
             audit_dict,
-            headers={'OpenStack-API-Version': 'infra-optim 1.1'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.1'},
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
-        self.assertEqual(objects.audit.State.PENDING,
-                         response.json['state'])
+        self.assertEqual(objects.audit.State.PENDING, response.json['state'])
         self.assertEqual(audit_dict['interval'], response.json['interval'])
         self.assertTrue(utils.is_uuid_like(response.json['uuid']))
         return_start_time = timeutils.parse_isotime(
-            response.json['start_time'])
-        return_end_time = timeutils.parse_isotime(
-            response.json['end_time'])
+            response.json['start_time']
+        )
+        return_end_time = timeutils.parse_isotime(response.json['end_time'])
         iso_start_time = start_time.astimezone(timezone.utc)
         iso_end_time = end_time.astimezone(timezone.utc)
 
@@ -1017,14 +1232,21 @@ class TestPost(TestPostBase):
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
     def test_create_continuous_audit_with_start_end_time_incompatible_version(
-            self, mock_trigger_audit):
+        self, mock_trigger_audit
+    ):
         mock_trigger_audit.return_value = mock.ANY
         start_time = datetime.datetime(2018, 3, 1, 0, 0)
         end_time = datetime.datetime(2018, 4, 1, 0, 0)
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal']
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
         )
         audit_dict['audit_type'] = objects.audit.AuditType.CONTINUOUS.value
         audit_dict['interval'] = '1200'
@@ -1035,7 +1257,8 @@ class TestPost(TestPostBase):
             '/audits',
             audit_dict,
             headers={'OpenStack-API-Version': 'infra-optim 1.0'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.NOT_ACCEPTABLE, response.status_int)
         expected_error_msg = 'Request not acceptable.'
@@ -1048,13 +1271,22 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
 
         response = self.post_json(
             '/audits',
             audit_dict,
-            headers={'OpenStack-API-Version': 'infra-optim 1.2'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.2'},
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
         self.assertFalse(response.json['force'])
@@ -1064,14 +1296,23 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ]
+        )
 
         audit_dict['force'] = True
         response = self.post_json(
             '/audits',
             audit_dict,
-            headers={'OpenStack-API-Version': 'infra-optim 1.2'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.2'},
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
         self.assertTrue(response.json['force'])
@@ -1081,15 +1322,25 @@ class TestPost(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
 
         audit_dict = post_get_test_audit(
-            params_to_exclude=['uuid', 'state', 'interval', 'scope',
-                               'next_run_time', 'hostname', 'goal',
-                               'audit_template_uuid', 'name'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'interval',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+                'audit_template_uuid',
+                'name',
+            ]
+        )
 
         response = self.post_json(
             '/audits',
             audit_dict,
             expect_errors=True,
-            headers={'OpenStack-API-Version': 'infra-optim 1.2'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.2'},
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         expected_msg = 'A valid goal or audit_template_id must be provided'
@@ -1099,7 +1350,6 @@ class TestPost(TestPostBase):
 
 
 class TestDelete(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -1123,10 +1373,11 @@ class TestDelete(api_base.FunctionalTest):
         new_state = objects.audit.State.ONGOING
         self.patch_json(
             f'/audits/{self.audit.uuid}',
-            [{'path': '/state', 'value': new_state,
-             'op': 'replace'}])
-        response = self.delete(f'/audits/{self.audit.uuid}',
-                               expect_errors=True)
+            [{'path': '/state', 'value': new_state, 'op': 'replace'}],
+        )
+        response = self.delete(
+            f'/audits/{self.audit.uuid}', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -1134,11 +1385,12 @@ class TestDelete(api_base.FunctionalTest):
         new_state = objects.audit.State.CANCELLED
         self.patch_json(
             f'/audits/{self.audit.uuid}',
-            [{'path': '/state', 'value': new_state,
-             'op': 'replace'}])
+            [{'path': '/state', 'value': new_state, 'op': 'replace'}],
+        )
         self.delete(f'/audits/{self.audit.uuid}')
-        response = self.get_json(f'/audits/{self.audit.uuid}',
-                                 expect_errors=True)
+        response = self.get_json(
+            f'/audits/{self.audit.uuid}', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -1146,10 +1398,12 @@ class TestDelete(api_base.FunctionalTest):
         self.context.show_deleted = True
         audit = objects.Audit.get_by_uuid(self.context, self.audit.uuid)
 
-        return_deleted_at = \
-            audit['deleted_at'].strftime('%Y-%m-%dT%H:%M:%S.%f')
-        self.assertEqual(test_time.strftime('%Y-%m-%dT%H:%M:%S.%f'),
-                         return_deleted_at)
+        return_deleted_at = audit['deleted_at'].strftime(
+            '%Y-%m-%dT%H:%M:%S.%f'
+        )
+        self.assertEqual(
+            test_time.strftime('%Y-%m-%dT%H:%M:%S.%f'), return_deleted_at
+        )
         self.assertEqual(objects.audit.State.DELETED, audit['state'])
 
     def test_delete_audit_not_found(self):
@@ -1161,79 +1415,108 @@ class TestDelete(api_base.FunctionalTest):
 
 
 class TestAuditPolicyEnforcement(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "audit:get_all", self.get_json, '/audits',
-            expect_errors=True)
+            "audit:get_all", self.get_json, '/audits', expect_errors=True
+        )
 
     def test_policy_disallow_get_one(self):
         audit = obj_utils.create_test_audit(self.context)
         self._common_policy_check(
-            "audit:get", self.get_json,
+            "audit:get",
+            self.get_json,
             f'/audits/{audit.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "audit:detail", self.get_json,
-            '/audits/detail',
-            expect_errors=True)
+            "audit:detail", self.get_json, '/audits/detail', expect_errors=True
+        )
 
     def test_policy_disallow_update(self):
         audit = obj_utils.create_test_audit(self.context)
         self._common_policy_check(
-            "audit:update", self.patch_json,
+            "audit:update",
+            self.patch_json,
             f'/audits/{audit.uuid}',
-            [{'path': '/state', 'value': objects.audit.State.SUCCEEDED,
-             'op': 'replace'}], expect_errors=True)
+            [
+                {
+                    'path': '/state',
+                    'value': objects.audit.State.SUCCEEDED,
+                    'op': 'replace',
+                }
+            ],
+            expect_errors=True,
+        )
 
     def test_policy_disallow_create(self):
         audit_dict = post_get_test_audit(
             state=objects.audit.State.PENDING,
-            params_to_exclude=['uuid', 'state', 'scope',
-                               'next_run_time', 'hostname', 'goal'])
+            params_to_exclude=[
+                'uuid',
+                'state',
+                'scope',
+                'next_run_time',
+                'hostname',
+                'goal',
+            ],
+        )
         self._common_policy_check(
-            "audit:create", self.post_json, '/audits', audit_dict,
-            expect_errors=True)
+            "audit:create",
+            self.post_json,
+            '/audits',
+            audit_dict,
+            expect_errors=True,
+        )
 
     def test_policy_disallow_delete(self):
         audit = obj_utils.create_test_audit(self.context)
         self._common_policy_check(
-            "audit:delete", self.delete,
-            f'/audits/{audit.uuid}', expect_errors=True)
+            "audit:delete",
+            self.delete,
+            f'/audits/{audit.uuid}',
+            expect_errors=True,
+        )
 
 
-class TestAuditEnforcementWithAdminContext(TestListAudit,
-                                           api_base.AdminRoleTest):
-
+class TestAuditEnforcementWithAdminContext(
+    TestListAudit, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "audit:create": "rule:default",
-            "audit:delete": "rule:default",
-            "audit:detail": "rule:default",
-            "audit:get": "rule:default",
-            "audit:get_all": "rule:default",
-            "audit:update": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "audit:create": "rule:default",
+                "audit:delete": "rule:default",
+                "audit:detail": "rule:default",
+                "audit:get": "rule:default",
+                "audit:get_all": "rule:default",
+                "audit:update": "rule:default",
+            }
+        )
 
 
 class TestAuditZoneMigration(TestPostBase):
@@ -1246,18 +1529,27 @@ class TestAuditZoneMigration(TestPostBase):
     def _prepare_audit_params(self, parameters):
         audit_templ = self.prepare_audit_template_strategy_with_parameter(
             fake_spec=self.zm_spec
-            )
+        )
         audit_dict = api_utils.audit_post_data(parameters=parameters)
         audit_dict['audit_template_uuid'] = audit_templ['uuid']
-        del_keys = ['uuid', 'goal_id', 'strategy_id', 'state',
-                    'interval', 'scope', 'next_run_time', 'hostname']
+        del_keys = [
+            'uuid',
+            'goal_id',
+            'strategy_id',
+            'state',
+            'interval',
+            'scope',
+            'next_run_time',
+            'hostname',
+        ]
         for k in del_keys:
             del audit_dict[k]
         return audit_dict
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_zone_migration_without_dst_pool(self,
-                                                          mock_trigger_audit):
+    def test_create_audit_zone_migration_without_dst_pool(
+        self, mock_trigger_audit
+    ):
         """Verify zone migration audit with dst_type instead of dst_pool.
 
         Tests that an audit can be created with storage pool parameters
@@ -1268,11 +1560,13 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"src_pool": "src_pool_name",
-                     "src_type": "src_type_name",
-                     "dst_type": "dst_type_name"}
-                ]
-            }
+                {
+                    "src_pool": "src_pool_name",
+                    "src_type": "src_type_name",
+                    "dst_type": "dst_type_name",
+                }
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
@@ -1281,8 +1575,9 @@ class TestAuditZoneMigration(TestPostBase):
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_zone_migration_without_src_pool(self,
-                                                          mock_trigger_audit):
+    def test_create_audit_zone_migration_without_src_pool(
+        self, mock_trigger_audit
+    ):
         """Verify zone migration audit rejects missing src_pool.
 
         Tests that an audit creation fails with BAD_REQUEST when storage
@@ -1292,28 +1587,29 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"dst_pool": "dst_pool_name",
-                     "src_type": "src_type_name"}
-                ]
-            }
+                {"dst_pool": "dst_pool_name", "src_type": "src_type_name"}
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
-        response = self.post_json('/audits', audit_input_dict,
-                                  expect_errors=True)
+        response = self.post_json(
+            '/audits', audit_input_dict, expect_errors=True
+        )
         self.assertEqual("application/json", response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         expected_error_msgs = (
             "is not valid under any of the given schemas",
-            "Failed validating 'oneOf' in schema"
+            "Failed validating 'oneOf' in schema",
         )
         for expected_error_msg in expected_error_msgs:
             self.assertIn(expected_error_msg, response.json['error_message'])
         mock_trigger_audit.assert_not_called()
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_zone_migration_without_dst_type(self,
-                                                          mock_trigger_audit):
+    def test_create_audit_zone_migration_without_dst_type(
+        self, mock_trigger_audit
+    ):
         """Verify zone migration audit with dst_pool instead of dst_type.
 
         Tests that an audit can be created with storage pool parameters
@@ -1324,22 +1620,26 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"src_pool": "src_pool_name",
-                     "src_type": "src_type_name",
-                     "dst_pool": "dst_pool_name"}
-                ]
-            }
+                {
+                    "src_pool": "src_pool_name",
+                    "src_type": "src_type_name",
+                    "dst_pool": "dst_pool_name",
+                }
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
-        response = self.post_json('/audits', audit_input_dict,
-                                  expect_errors=True)
+        response = self.post_json(
+            '/audits', audit_input_dict, expect_errors=True
+        )
         self.assertEqual("application/json", response.content_type)
         self.assertEqual(HTTPStatus.CREATED, response.status_int)
 
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
-    def test_create_audit_zone_migration_without_src_type(self,
-                                                          mock_trigger_audit):
+    def test_create_audit_zone_migration_without_src_type(
+        self, mock_trigger_audit
+    ):
         """Verify zone migration audit accepts optional src_type.
 
         Tests that an audit can be created with storage pool parameters
@@ -1350,11 +1650,9 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"dst_pool": "dst_pool_name",
-                     "src_pool": "src_pool_name",
-                     }
-                ]
-            }
+                {"dst_pool": "dst_pool_name", "src_pool": "src_pool_name"}
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
@@ -1376,20 +1674,20 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"dst_type": "dst_type_name",
-                     "dst_pool": "dst_pool_name"}
-                ]
-            }
+                {"dst_type": "dst_type_name", "dst_pool": "dst_pool_name"}
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
-        response = self.post_json('/audits', audit_input_dict,
-                                  expect_errors=True)
+        response = self.post_json(
+            '/audits', audit_input_dict, expect_errors=True
+        )
         self.assertEqual("application/json", response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         expected_error_msgs = (
             "is not valid under any of the given schemas",
-            "Failed validating 'oneOf' in schema"
+            "Failed validating 'oneOf' in schema",
         )
         for expected_error_msg in expected_error_msgs:
             self.assertIn(expected_error_msg, response.json['error_message'])
@@ -1409,20 +1707,20 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"src_type": "src_type_name",
-                     "src_pool": "src_pool_name"}
-                ]
-            }
+                {"src_type": "src_type_name", "src_pool": "src_pool_name"}
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
-        response = self.post_json('/audits', audit_input_dict,
-                                  expect_errors=True)
+        response = self.post_json(
+            '/audits', audit_input_dict, expect_errors=True
+        )
         self.assertEqual("application/json", response.content_type)
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         expected_error_msgs = (
             "is not valid under any of the given schemas",
-            "Failed validating 'oneOf' in schema"
+            "Failed validating 'oneOf' in schema",
         )
         for expected_error_msg in expected_error_msgs:
             self.assertIn(expected_error_msg, response.json['error_message'])
@@ -1442,14 +1740,18 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"src_pool": "src_pool_name",
-                     "src_type": "src_type_name",
-                     "dst_type": "dst_type_name"},
-                    {"src_pool": "src_pool_name",
-                     "src_type": "src_type_name2",
-                     "dst_pool": "dst_type_name"},
-                ]
-            }
+                {
+                    "src_pool": "src_pool_name",
+                    "src_type": "src_type_name",
+                    "dst_type": "dst_type_name",
+                },
+                {
+                    "src_pool": "src_pool_name",
+                    "src_type": "src_type_name2",
+                    "dst_pool": "dst_type_name",
+                },
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
@@ -1471,14 +1773,18 @@ class TestAuditZoneMigration(TestPostBase):
         mock_trigger_audit.return_value = mock.ANY
         zm_params = {
             'storage_pools': [
-                    {"src_pool": "src_pool_name",
-                     "src_type": "src_type_name",
-                     "dst_type": "dst_type_name"},
-                    {"src_pool": "src_pool_name",
-                     "dst_type": "dst_type_name2",
-                     "dst_pool": "dst_type_name"},
-                ]
-            }
+                {
+                    "src_pool": "src_pool_name",
+                    "src_type": "src_type_name",
+                    "dst_type": "dst_type_name",
+                },
+                {
+                    "src_pool": "src_pool_name",
+                    "dst_type": "dst_type_name2",
+                    "dst_pool": "dst_type_name",
+                },
+            ]
+        }
 
         audit_input_dict = self._prepare_audit_params(zm_params)
 
@@ -1489,7 +1795,7 @@ class TestAuditZoneMigration(TestPostBase):
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         expected_error_msgs = (
             "is not valid under any of the given schemas",
-            "Failed validating 'oneOf' in schema"
+            "Failed validating 'oneOf' in schema",
         )
         for expected_error_msg in expected_error_msgs:
             self.assertIn(expected_error_msg, response.json['error_message'])
diff --git a/watcher/tests/unit/api/v1/test_data_model.py b/watcher/tests/unit/api/v1/test_data_model.py
index d43455e1d..efea3eda6 100644
--- a/watcher/tests/unit/api/v1/test_data_model.py
+++ b/watcher/tests/unit/api/v1/test_data_model.py
@@ -27,33 +27,32 @@ from watcher.tests.unit.decision_engine.model import faker_cluster_state
 
 
 class TestListDataModel(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         p_dcapi = mock.patch.object(deapi, 'DecisionEngineAPI')
         self.mock_dcapi = p_dcapi.start()
         self.fake_response = {'context': [{'server_uuid': 'fake_uuid'}]}
-        self.mock_dcapi().get_data_model_info.return_value = (
-            self.fake_response)
+        self.mock_dcapi().get_data_model_info.return_value = self.fake_response
         self.addCleanup(p_dcapi.stop)
 
     def test_get_all(self):
         response = self.get_json(
             '/data_model/?data_model_type=compute',
-            headers={'OpenStack-API-Version': 'infra-optim 1.3'})
+            headers={'OpenStack-API-Version': 'infra-optim 1.3'},
+        )
         self.assertEqual(self.fake_response, response)
 
     def test_get_all_not_acceptable(self):
         response = self.get_json(
             '/data_model/?data_model_type=compute',
             headers={'OpenStack-API-Version': 'infra-optim 1.2'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_ACCEPTABLE, response.status_int)
 
 
 @ddt.ddt
 class TestListDataModelResponse(api_base.FunctionalTest):
-
     NODE_FIELDS_1_3 = [
         'node_disabled_reason',
         'node_hostname',
@@ -68,7 +67,7 @@ class TestListDataModelResponse(api_base.FunctionalTest):
         'node_memory_ratio',
         'node_vcpu_ratio',
         'node_disk_ratio',
-        'node_uuid'
+        'node_uuid',
     ]
 
     # Map of API version to expected node fields
@@ -88,12 +87,12 @@ class TestListDataModelResponse(api_base.FunctionalTest):
         'server_metadata',
         'server_project_id',
         'server_locked',
-        'server_uuid'
+        'server_uuid',
     ]
 
     SERVER_FIELDS_1_6 = [
         'server_pinned_az',
-        'server_flavor_extra_specs'
+        'server_flavor_extra_specs',
     ] + SERVER_FIELDS_1_3
 
     # Map of API version to expected server fields
@@ -119,7 +118,8 @@ class TestListDataModelResponse(api_base.FunctionalTest):
         infra_max_version = 'infra-optim ' + version
         response = self.get_json(
             '/data_model/?data_model_type=compute',
-            headers={'OpenStack-API-Version': infra_max_version})
+            headers={'OpenStack-API-Version': infra_max_version},
+        )
 
         server_info = response.get("context")[0]
         expected_keys = self.NODE_FIELDS_MAP[version]
@@ -137,18 +137,19 @@ class TestListDataModelResponse(api_base.FunctionalTest):
         infra_max_version = 'infra-optim ' + version
         response = self.get_json(
             '/data_model/?data_model_type=compute',
-            headers={'OpenStack-API-Version': infra_max_version})
+            headers={'OpenStack-API-Version': infra_max_version},
+        )
 
         server_info = response.get("context")[0]
-        expected_keys = (self.NODE_FIELDS_MAP[version] +
-                         self.SERVER_FIELDS_MAP[version])
+        expected_keys = (
+            self.NODE_FIELDS_MAP[version] + self.SERVER_FIELDS_MAP[version]
+        )
 
         self.assertEqual(len(response.get("context")), 2)
         self.assertEqual(set(expected_keys), set(server_info.keys()))
 
 
 class TestDataModelPolicyEnforcement(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         p_dcapi = mock.patch.object(deapi, 'DecisionEngineAPI')
@@ -156,31 +157,40 @@ class TestDataModelPolicyEnforcement(api_base.FunctionalTest):
         self.addCleanup(p_dcapi.stop)
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "data_model:get_all", self.get_json,
+            "data_model:get_all",
+            self.get_json,
             "/data_model/?data_model_type=compute",
             headers={'OpenStack-API-Version': 'infra-optim 1.3'},
-            expect_errors=True)
+            expect_errors=True,
+        )
 
 
 class TestDataModelEnforcementWithAdminContext(
-        TestListDataModel, api_base.AdminRoleTest):
-
+    TestListDataModel, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "data_model:get_all": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "data_model:get_all": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_goals.py b/watcher/tests/unit/api/v1/test_goals.py
index 04c7afebe..9f998d0eb 100644
--- a/watcher/tests/unit/api/v1/test_goals.py
+++ b/watcher/tests/unit/api/v1/test_goals.py
@@ -22,10 +22,13 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestListGoal(api_base.FunctionalTest):
-
     def _assert_goal_fields(self, goal):
-        goal_fields = ['uuid', 'name', 'display_name',
-                       'efficacy_specification']
+        goal_fields = [
+            'uuid',
+            'name',
+            'display_name',
+            'efficacy_specification',
+        ]
         for field in goal_fields:
             self.assertIn(field, goal)
 
@@ -44,8 +47,9 @@ class TestListGoal(api_base.FunctionalTest):
 
     def test_get_one_by_name(self):
         goal = obj_utils.create_test_goal(self.context)
-        response = self.get_json(urlparse.quote(
-            '/goals/{}'.format(goal['name'])))
+        response = self.get_json(
+            urlparse.quote('/goals/{}'.format(goal['name']))
+        )
         self.assertEqual(goal.uuid, response['uuid'])
         self._assert_goal_fields(response)
 
@@ -54,13 +58,14 @@ class TestListGoal(api_base.FunctionalTest):
         goal.soft_delete()
         response = self.get_json(
             '/goals/{}'.format(goal['uuid']),
-            headers={'X-Show-Deleted': 'True'})
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(goal.uuid, response['uuid'])
         self._assert_goal_fields(response)
 
         response = self.get_json(
-            '/goals/{}'.format(goal['uuid']),
-            expect_errors=True)
+            '/goals/{}'.format(goal['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
@@ -71,17 +76,20 @@ class TestListGoal(api_base.FunctionalTest):
 
     def test_detail_against_single(self):
         goal = obj_utils.create_test_goal(self.context)
-        response = self.get_json(f'/goals/{goal.uuid}/detail',
-                                 expect_errors=True)
+        response = self.get_json(
+            f'/goals/{goal.uuid}/detail', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         goal_list = []
         for idx in range(1, 6):
             goal = obj_utils.create_test_goal(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'GOAL_{idx}')
+                name=f'GOAL_{idx}',
+            )
             goal_list.append(goal.uuid)
         response = self.get_json('/goals')
         self.assertGreater(len(response['goals']), 2)
@@ -90,13 +98,19 @@ class TestListGoal(api_base.FunctionalTest):
         goal_list = []
         for id_ in [1, 2, 3]:
             goal = obj_utils.create_test_goal(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'GOAL_{id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'GOAL_{id_}',
+            )
             goal_list.append(goal.uuid)
         for id_ in [4, 5]:
             goal = obj_utils.create_test_goal(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'GOAL_{id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'GOAL_{id_}',
+            )
             goal.soft_delete()
         response = self.get_json('/goals')
         self.assertEqual(3, len(response['goals']))
@@ -106,18 +120,22 @@ class TestListGoal(api_base.FunctionalTest):
     def test_goals_collection_links(self):
         for idx in range(1, 6):
             obj_utils.create_test_goal(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'GOAL_{idx}')
+                name=f'GOAL_{idx}',
+            )
         response = self.get_json('/goals/?limit=2')
         self.assertEqual(2, len(response['goals']))
 
     def test_goals_collection_links_default_limit(self):
         for idx in range(1, 6):
             obj_utils.create_test_goal(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'GOAL_{idx}')
+                name=f'GOAL_{idx}',
+            )
         cfg.CONF.set_override('max_limit', 3, 'api')
         response = self.get_json('/goals')
         self.assertEqual(3, len(response['goals']))
@@ -126,9 +144,11 @@ class TestListGoal(api_base.FunctionalTest):
         goal_list = []
         for idx in range(1, 6):
             goal = obj_utils.create_test_goal(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'GOAL_{idx}')
+                name=f'GOAL_{idx}',
+            )
             goal_list.append(goal.uuid)
 
         response = self.get_json('/goals/?sort_key=uuid')
@@ -139,52 +159,59 @@ class TestListGoal(api_base.FunctionalTest):
 
     def test_sort_key_validation(self):
         response = self.get_json(
-            '/goals?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/goals?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
 
 class TestGoalPolicyEnforcement(api_base.FunctionalTest):
-
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "goal:get_all", self.get_json, '/goals',
-            expect_errors=True)
+            "goal:get_all", self.get_json, '/goals', expect_errors=True
+        )
 
     def test_policy_disallow_get_one(self):
         goal = obj_utils.create_test_goal(self.context)
         self._common_policy_check(
-            "goal:get", self.get_json,
+            "goal:get",
+            self.get_json,
             f'/goals/{goal.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "goal:detail", self.get_json,
-            '/goals/detail',
-            expect_errors=True)
+            "goal:detail", self.get_json, '/goals/detail', expect_errors=True
+        )
 
 
-class TestGoalPolicyEnforcementWithAdminContext(TestListGoal,
-                                                api_base.AdminRoleTest):
-
+class TestGoalPolicyEnforcementWithAdminContext(
+    TestListGoal, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "goal:detail": "rule:default",
-            "goal:get_all": "rule:default",
-            "goal:get_one": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "goal:detail": "rule:default",
+                "goal:get_all": "rule:default",
+                "goal:get_one": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_microversions.py b/watcher/tests/unit/api/v1/test_microversions.py
index a761a9131..4d95717f1 100644
--- a/watcher/tests/unit/api/v1/test_microversions.py
+++ b/watcher/tests/unit/api/v1/test_microversions.py
@@ -25,10 +25,14 @@ MAX_VER = versions.max_version_string()
 
 
 class TestMicroversions(api_base.FunctionalTest):
-
     controller_list_response = [
-        'scoring_engines', 'audit_templates', 'audits', 'actions',
-        'action_plans', 'services']
+        'scoring_engines',
+        'audit_templates',
+        'audits',
+        'actions',
+        'action_plans',
+        'services',
+    ]
 
     def setUp(self):
         super().setUp()
@@ -36,75 +40,101 @@ class TestMicroversions(api_base.FunctionalTest):
     def test_wrong_major_version(self):
         response = self.get_json(
             '/',
-            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE,
-                                                        '10'])},
-            expect_errors=True, return_json=False)
+            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE, '10'])},
+            expect_errors=True,
+            return_json=False,
+        )
         self.assertEqual('application/json', response.content_type)
         self.assertEqual(HTTPStatus.NOT_ACCEPTABLE, response.status_int)
-        expected_error_msg = ('Invalid value for'
-                              ' OpenStack-API-Version header')
+        expected_error_msg = 'Invalid value for OpenStack-API-Version header'
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
 
     def test_extend_initial_version_with_micro(self):
         response = self.get_json(
             '/',
-            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE,
-                                                        '1'])},
-            return_json=False)
+            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE, '1'])},
+            return_json=False,
+        )
         self.assertEqual(response.headers[H_MIN_VER], MIN_VER)
         self.assertEqual(response.headers[H_MAX_VER], MAX_VER)
-        self.assertEqual(response.headers[H_RESP_VER],
-                         ' '.join([SERVICE_TYPE, MIN_VER]))
-        self.assertTrue(all(x in response.json.keys() for x in
-                            self.controller_list_response))
+        self.assertEqual(
+            response.headers[H_RESP_VER], ' '.join([SERVICE_TYPE, MIN_VER])
+        )
+        self.assertTrue(
+            all(
+                x in response.json.keys()
+                for x in self.controller_list_response
+            )
+        )
 
     def test_without_microversion(self):
         response = self.get_json('/', return_json=False)
         self.assertEqual(response.headers[H_MIN_VER], MIN_VER)
         self.assertEqual(response.headers[H_MAX_VER], MAX_VER)
-        self.assertEqual(response.headers[H_RESP_VER],
-                         ' '.join([SERVICE_TYPE, MIN_VER]))
-        self.assertTrue(all(x in response.json.keys() for x in
-                            self.controller_list_response))
+        self.assertEqual(
+            response.headers[H_RESP_VER], ' '.join([SERVICE_TYPE, MIN_VER])
+        )
+        self.assertTrue(
+            all(
+                x in response.json.keys()
+                for x in self.controller_list_response
+            )
+        )
 
     def test_new_client_new_api(self):
         response = self.get_json(
             '/',
-            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE,
-                                                        '1.1'])},
-            return_json=False)
+            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE, '1.1'])},
+            return_json=False,
+        )
         self.assertEqual(response.headers[H_MIN_VER], MIN_VER)
         self.assertEqual(response.headers[H_MAX_VER], MAX_VER)
-        self.assertEqual(response.headers[H_RESP_VER],
-                         ' '.join([SERVICE_TYPE, '1.1']))
-        self.assertTrue(all(x in response.json.keys() for x in
-                            self.controller_list_response))
+        self.assertEqual(
+            response.headers[H_RESP_VER], ' '.join([SERVICE_TYPE, '1.1'])
+        )
+        self.assertTrue(
+            all(
+                x in response.json.keys()
+                for x in self.controller_list_response
+            )
+        )
 
     def test_latest_microversion(self):
         response = self.get_json(
             '/',
-            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE,
-                                                        'latest'])},
-            return_json=False)
+            headers={
+                'OpenStack-API-Version': ' '.join([SERVICE_TYPE, 'latest'])
+            },
+            return_json=False,
+        )
         self.assertEqual(response.headers[H_MIN_VER], MIN_VER)
         self.assertEqual(response.headers[H_MAX_VER], MAX_VER)
-        self.assertEqual(response.headers[H_RESP_VER],
-                         ' '.join([SERVICE_TYPE, MAX_VER]))
-        self.assertTrue(all(x in response.json.keys() for x in
-                            self.controller_list_response))
+        self.assertEqual(
+            response.headers[H_RESP_VER], ' '.join([SERVICE_TYPE, MAX_VER])
+        )
+        self.assertTrue(
+            all(
+                x in response.json.keys()
+                for x in self.controller_list_response
+            )
+        )
 
     def test_unsupported_version(self):
         response = self.get_json(
             '/',
-            headers={'OpenStack-API-Version': ' '.join([SERVICE_TYPE,
-                                                        '1.999'])},
-            expect_errors=True)
+            headers={
+                'OpenStack-API-Version': ' '.join([SERVICE_TYPE, '1.999'])
+            },
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_ACCEPTABLE, response.status_int)
         self.assertEqual(response.headers[H_MIN_VER], MIN_VER)
         self.assertEqual(response.headers[H_MAX_VER], MAX_VER)
-        expected_error_msg = ('Version 1.999 was requested but the minor '
-                              'version is not supported by this service. '
-                              'The supported version range is')
+        expected_error_msg = (
+            'Version 1.999 was requested but the minor '
+            'version is not supported by this service. '
+            'The supported version range is'
+        )
         self.assertTrue(response.json['error_message'])
         self.assertIn(expected_error_msg, response.json['error_message'])
diff --git a/watcher/tests/unit/api/v1/test_scoring_engines.py b/watcher/tests/unit/api/v1/test_scoring_engines.py
index e8dc01d04..c18ca9238 100644
--- a/watcher/tests/unit/api/v1/test_scoring_engines.py
+++ b/watcher/tests/unit/api/v1/test_scoring_engines.py
@@ -21,7 +21,6 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestListScoringEngine(api_base.FunctionalTest):
-
     def _assert_scoring_engine_fields(self, scoring_engine):
         scoring_engine_fields = ['uuid', 'name', 'description']
         for field in scoring_engine_fields:
@@ -31,7 +30,8 @@ class TestListScoringEngine(api_base.FunctionalTest):
         scoring_engine = obj_utils.create_test_scoring_engine(self.context)
         response = self.get_json('/scoring_engines')
         self.assertEqual(
-            scoring_engine.name, response['scoring_engines'][0]['name'])
+            scoring_engine.name, response['scoring_engines'][0]['name']
+        )
         self._assert_scoring_engine_fields(response['scoring_engines'][0])
 
     def test_get_one_soft_deleted(self):
@@ -39,13 +39,15 @@ class TestListScoringEngine(api_base.FunctionalTest):
         scoring_engine.soft_delete()
         response = self.get_json(
             '/scoring_engines/{}'.format(scoring_engine['name']),
-            headers={'X-Show-Deleted': 'True'})
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(scoring_engine.name, response['name'])
         self._assert_scoring_engine_fields(response)
 
         response = self.get_json(
             '/scoring_engines/{}'.format(scoring_engine['name']),
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
@@ -53,45 +55,66 @@ class TestListScoringEngine(api_base.FunctionalTest):
         scoring_engine = obj_utils.create_test_scoring_engine(self.context)
         response = self.get_json('/scoring_engines/detail')
         self.assertEqual(
-            scoring_engine.name, response['scoring_engines'][0]['name'])
+            scoring_engine.name, response['scoring_engines'][0]['name']
+        )
         self._assert_scoring_engine_fields(response['scoring_engines'][0])
         for scoring_engine in response['scoring_engines']:
             self.assertTrue(
-                all(val is not None for key, val in scoring_engine.items()
-                    if key in ['uuid', 'name', 'description', 'metainfo']))
+                all(
+                    val is not None
+                    for key, val in scoring_engine.items()
+                    if key in ['uuid', 'name', 'description', 'metainfo']
+                )
+            )
 
     def test_detail_against_single(self):
         scoring_engine = obj_utils.create_test_scoring_engine(self.context)
         response = self.get_json(
-            f'/scoring_engines/{scoring_engine.id}/detail',
-            expect_errors=True)
+            f'/scoring_engines/{scoring_engine.id}/detail', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         scoring_engine_list = []
         for idx in range(1, 6):
             scoring_engine = obj_utils.create_test_scoring_engine(
-                self.context, id=idx, uuid=utils.generate_uuid(),
-                name=str(idx), description=f'SE_{idx}')
+                self.context,
+                id=idx,
+                uuid=utils.generate_uuid(),
+                name=str(idx),
+                description=f'SE_{idx}',
+            )
             scoring_engine_list.append(scoring_engine.name)
         response = self.get_json('/scoring_engines')
         self.assertEqual(5, len(response['scoring_engines']))
         for scoring_engine in response['scoring_engines']:
             self.assertTrue(
-                all(val is not None for key, val in scoring_engine.items()
-                    if key in ['name', 'description', 'metainfo']))
+                all(
+                    val is not None
+                    for key, val in scoring_engine.items()
+                    if key in ['name', 'description', 'metainfo']
+                )
+            )
 
     def test_many_without_soft_deleted(self):
         scoring_engine_list = []
         for id_ in [1, 2, 3]:
             scoring_engine = obj_utils.create_test_scoring_engine(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=str(id_), description=f'SE_{id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=str(id_),
+                description=f'SE_{id_}',
+            )
             scoring_engine_list.append(scoring_engine.name)
         for id_ in [4, 5]:
             scoring_engine = obj_utils.create_test_scoring_engine(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=str(id_), description=f'SE_{id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=str(id_),
+                description=f'SE_{id_}',
+            )
             scoring_engine.soft_delete()
         response = self.get_json('/scoring_engines')
         self.assertEqual(3, len(response['scoring_engines']))
@@ -101,16 +124,24 @@ class TestListScoringEngine(api_base.FunctionalTest):
     def test_scoring_engines_collection_links(self):
         for idx in range(1, 6):
             obj_utils.create_test_scoring_engine(
-                self.context, id=idx, uuid=utils.generate_uuid(),
-                name=str(idx), description=f'SE_{idx}')
+                self.context,
+                id=idx,
+                uuid=utils.generate_uuid(),
+                name=str(idx),
+                description=f'SE_{idx}',
+            )
         response = self.get_json('/scoring_engines/?limit=2')
         self.assertEqual(2, len(response['scoring_engines']))
 
     def test_scoring_engines_collection_links_default_limit(self):
         for idx in range(1, 6):
             obj_utils.create_test_scoring_engine(
-                self.context, id=idx, uuid=utils.generate_uuid(),
-                name=str(idx), description=f'SE_{idx}')
+                self.context,
+                id=idx,
+                uuid=utils.generate_uuid(),
+                name=str(idx),
+                description=f'SE_{idx}',
+            )
         cfg.CONF.set_override('max_limit', 3, 'api')
         response = self.get_json('/scoring_engines')
         self.assertEqual(3, len(response['scoring_engines']))
@@ -119,8 +150,12 @@ class TestListScoringEngine(api_base.FunctionalTest):
         scoring_engine_list = []
         for idx in range(1, 6):
             scoring_engine = obj_utils.create_test_scoring_engine(
-                self.context, id=idx, uuid=utils.generate_uuid(),
-                name=str(idx), description=f'SE_{idx}')
+                self.context,
+                id=idx,
+                uuid=utils.generate_uuid(),
+                name=str(idx),
+                description=f'SE_{idx}',
+            )
             scoring_engine_list.append(scoring_engine.uuid)
 
         response = self.get_json('/scoring_engines/?sort_key=uuid')
@@ -131,52 +166,65 @@ class TestListScoringEngine(api_base.FunctionalTest):
 
     def test_sort_key_validation(self):
         response = self.get_json(
-            '/goals?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/goals?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
 
 class TestScoringEnginePolicyEnforcement(api_base.FunctionalTest):
-
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "scoring_engine:get_all", self.get_json, '/scoring_engines',
-            expect_errors=True)
+            "scoring_engine:get_all",
+            self.get_json,
+            '/scoring_engines',
+            expect_errors=True,
+        )
 
     def test_policy_disallow_get_one(self):
         se = obj_utils.create_test_scoring_engine(self.context)
         self._common_policy_check(
-            "scoring_engine:get", self.get_json,
+            "scoring_engine:get",
+            self.get_json,
             f'/scoring_engines/{se.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "scoring_engine:detail", self.get_json,
+            "scoring_engine:detail",
+            self.get_json,
             '/scoring_engines/detail',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
 
 class TestScoringEnginePolicyEnforcementWithAdminContext(
-        TestListScoringEngine, api_base.AdminRoleTest):
-
+    TestListScoringEngine, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "scoring_engine:detail": "rule:default",
-            "scoring_engine:get": "rule:default",
-            "scoring_engine:get_all": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "scoring_engine:detail": "rule:default",
+                "scoring_engine:get": "rule:default",
+                "scoring_engine:get_all": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_services.py b/watcher/tests/unit/api/v1/test_services.py
index 56a467568..c9bf83045 100644
--- a/watcher/tests/unit/api/v1/test_services.py
+++ b/watcher/tests/unit/api/v1/test_services.py
@@ -21,7 +21,6 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestListService(api_base.FunctionalTest):
-
     def _assert_service_fields(self, service):
         service_fields = ['id', 'name', 'host', 'status']
         for field in service_fields:
@@ -42,8 +41,9 @@ class TestListService(api_base.FunctionalTest):
 
     def test_get_one_by_name(self):
         service = obj_utils.create_test_service(self.context)
-        response = self.get_json(urlparse.quote(
-            '/services/{}'.format(service['name'])))
+        response = self.get_json(
+            urlparse.quote('/services/{}'.format(service['name']))
+        )
         self.assertEqual(service.id, response['id'])
         self._assert_service_fields(response)
 
@@ -52,13 +52,14 @@ class TestListService(api_base.FunctionalTest):
         service.soft_delete()
         response = self.get_json(
             '/services/{}'.format(service['id']),
-            headers={'X-Show-Deleted': 'True'})
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(service.id, response['id'])
         self._assert_service_fields(response)
 
         response = self.get_json(
-            '/services/{}'.format(service['id']),
-            expect_errors=True)
+            '/services/{}'.format(service['id']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
@@ -68,46 +69,57 @@ class TestListService(api_base.FunctionalTest):
         self._assert_service_fields(response['services'][0])
         for service in response['services']:
             self.assertTrue(
-                all(val is not None for key, val in service.items()
-                    if key in ['id', 'name', 'host', 'status'])
+                all(
+                    val is not None
+                    for key, val in service.items()
+                    if key in ['id', 'name', 'host', 'status']
+                )
             )
 
     def test_detail_against_single(self):
         service = obj_utils.create_test_service(self.context)
-        response = self.get_json(f'/services/{service.id}/detail',
-                                 expect_errors=True)
+        response = self.get_json(
+            f'/services/{service.id}/detail', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         service_list = []
         for idx in range(1, 4):
             service = obj_utils.create_test_service(
-                self.context, id=idx, host='CONTROLLER1',
-                name=f'SERVICE_{idx}')
+                self.context, id=idx, host='CONTROLLER1', name=f'SERVICE_{idx}'
+            )
             service_list.append(service.id)
         for idx in range(1, 4):
             service = obj_utils.create_test_service(
-                self.context, id=3+idx, host='CONTROLLER2',
-                name=f'SERVICE_{idx}')
+                self.context,
+                id=3 + idx,
+                host='CONTROLLER2',
+                name=f'SERVICE_{idx}',
+            )
             service_list.append(service.id)
         response = self.get_json('/services')
         self.assertEqual(6, len(response['services']))
         for service in response['services']:
             self.assertTrue(
-                all(val is not None for key, val in service.items()
-                    if key in ['id', 'name', 'host', 'status']))
+                all(
+                    val is not None
+                    for key, val in service.items()
+                    if key in ['id', 'name', 'host', 'status']
+                )
+            )
 
     def test_many_without_soft_deleted(self):
         service_list = []
         for id_ in [1, 2, 3]:
             service = obj_utils.create_test_service(
-                self.context, id=id_, host='CONTROLLER',
-                name=f'SERVICE_{id_}')
+                self.context, id=id_, host='CONTROLLER', name=f'SERVICE_{id_}'
+            )
             service_list.append(service.id)
         for id_ in [4, 5]:
             service = obj_utils.create_test_service(
-                self.context, id=id_, host='CONTROLLER',
-                name=f'SERVICE_{id_}')
+                self.context, id=id_, host='CONTROLLER', name=f'SERVICE_{id_}'
+            )
             service.soft_delete()
         response = self.get_json('/services')
         self.assertEqual(3, len(response['services']))
@@ -117,18 +129,16 @@ class TestListService(api_base.FunctionalTest):
     def test_services_collection_links(self):
         for idx in range(1, 6):
             obj_utils.create_test_service(
-                self.context, id=idx,
-                host='CONTROLLER',
-                name=f'SERVICE_{idx}')
+                self.context, id=idx, host='CONTROLLER', name=f'SERVICE_{idx}'
+            )
         response = self.get_json('/services/?limit=2')
         self.assertEqual(2, len(response['services']))
 
     def test_services_collection_links_default_limit(self):
         for idx in range(1, 6):
             obj_utils.create_test_service(
-                self.context, id=idx,
-                host='CONTROLLER',
-                name=f'SERVICE_{idx}')
+                self.context, id=idx, host='CONTROLLER', name=f'SERVICE_{idx}'
+            )
         cfg.CONF.set_override('max_limit', 3, 'api')
         response = self.get_json('/services')
         self.assertEqual(3, len(response['services']))
@@ -137,8 +147,8 @@ class TestListService(api_base.FunctionalTest):
         service_list = []
         for id_ in range(1, 4):
             service = obj_utils.create_test_service(
-                self.context, id=id_, host='CONTROLLER',
-                name=f'SERVICE_{id_}')
+                self.context, id=id_, host='CONTROLLER', name=f'SERVICE_{id_}'
+            )
             service_list.append(service.name)
 
         response = self.get_json('/services/?sort_key=name')
@@ -149,52 +159,62 @@ class TestListService(api_base.FunctionalTest):
 
     def test_sort_key_validation(self):
         response = self.get_json(
-            '/services?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/services?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
 
 class TestServicePolicyEnforcement(api_base.FunctionalTest):
-
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "service:get_all", self.get_json, '/services',
-            expect_errors=True)
+            "service:get_all", self.get_json, '/services', expect_errors=True
+        )
 
     def test_policy_disallow_get_one(self):
         service = obj_utils.create_test_service(self.context)
         self._common_policy_check(
-            "service:get", self.get_json,
+            "service:get",
+            self.get_json,
             f'/services/{service.id}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "service:detail", self.get_json,
+            "service:detail",
+            self.get_json,
             '/services/detail',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
 
-class TestServiceEnforcementWithAdminContext(TestListService,
-                                             api_base.AdminRoleTest):
-
+class TestServiceEnforcementWithAdminContext(
+    TestListService, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "service:detail": "rule:default",
-            "service:get": "rule:default",
-            "service:get_all": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "service:detail": "rule:default",
+                "service:get": "rule:default",
+                "service:get_all": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_strategies.py b/watcher/tests/unit/api/v1/test_strategies.py
index 36c3fdfb4..0d3864f8c 100644
--- a/watcher/tests/unit/api/v1/test_strategies.py
+++ b/watcher/tests/unit/api/v1/test_strategies.py
@@ -24,11 +24,11 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestListStrategy(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         self.fake_goal = obj_utils.create_test_goal(
-            self.context, uuid=utils.generate_uuid())
+            self.context, uuid=utils.generate_uuid()
+        )
 
     def _assert_strategy_fields(self, strategy):
         strategy_fields = ['uuid', 'name', 'display_name', 'goal_uuid']
@@ -39,22 +39,45 @@ class TestListStrategy(api_base.FunctionalTest):
     def test_state(self, mock_strategy_info):
         strategy = obj_utils.create_test_strategy(self.context)
         mock_state = [
-            {"type": "Datasource", "mandatory": True, "comment": "",
-             "state": "gnocchi: True"},
-            {"type": "Metrics", "mandatory": False, "comment": "",
-             "state": [{"compute.node.cpu.percent": "available"},
-                       {"cpu_util": "available"}]},
-            {"type": "CDM", "mandatory": True, "comment": "",
-             "state": [{"compute_model": "available"},
-                       {"storage_model": "not available"}]},
-            {"type": "Name", "mandatory": "", "comment": "",
-             "state": strategy.name}
+            {
+                "type": "Datasource",
+                "mandatory": True,
+                "comment": "",
+                "state": "gnocchi: True",
+            },
+            {
+                "type": "Metrics",
+                "mandatory": False,
+                "comment": "",
+                "state": [
+                    {"compute.node.cpu.percent": "available"},
+                    {"cpu_util": "available"},
+                ],
+            },
+            {
+                "type": "CDM",
+                "mandatory": True,
+                "comment": "",
+                "state": [
+                    {"compute_model": "available"},
+                    {"storage_model": "not available"},
+                ],
+            },
+            {
+                "type": "Name",
+                "mandatory": "",
+                "comment": "",
+                "state": strategy.name,
+            },
         ]
 
         mock_strategy_info.return_value = mock_state
         response = self.get_json(f'/strategies/{strategy.uuid}/state')
-        strategy_name = [requirement["state"] for requirement in response
-                         if requirement["type"] == "Name"][0]
+        strategy_name = [
+            requirement["state"]
+            for requirement in response
+            if requirement["type"] == "Name"
+        ][0]
         self.assertEqual(strategy.name, strategy_name)
 
     def test_one(self):
@@ -72,8 +95,9 @@ class TestListStrategy(api_base.FunctionalTest):
 
     def test_get_one_by_name(self):
         strategy = obj_utils.create_test_strategy(self.context)
-        response = self.get_json(urlparse.quote(
-            '/strategies/{}'.format(strategy['name'])))
+        response = self.get_json(
+            urlparse.quote('/strategies/{}'.format(strategy['name']))
+        )
         self.assertEqual(strategy.uuid, response['uuid'])
         self._assert_strategy_fields(response)
 
@@ -82,13 +106,14 @@ class TestListStrategy(api_base.FunctionalTest):
         strategy.soft_delete()
         response = self.get_json(
             '/strategies/{}'.format(strategy['uuid']),
-            headers={'X-Show-Deleted': 'True'})
+            headers={'X-Show-Deleted': 'True'},
+        )
         self.assertEqual(strategy.uuid, response['uuid'])
         self._assert_strategy_fields(response)
 
         response = self.get_json(
-            '/strategies/{}'.format(strategy['uuid']),
-            expect_errors=True)
+            '/strategies/{}'.format(strategy['uuid']), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_detail(self):
@@ -98,41 +123,58 @@ class TestListStrategy(api_base.FunctionalTest):
         self._assert_strategy_fields(response['strategies'][0])
         for strategy in response['strategies']:
             self.assertTrue(
-                all(val is not None for key, val in strategy.items()
-                    if key in ['uuid', 'name', 'display_name', 'goal_uuid']))
+                all(
+                    val is not None
+                    for key, val in strategy.items()
+                    if key in ['uuid', 'name', 'display_name', 'goal_uuid']
+                )
+            )
 
     def test_detail_against_single(self):
         strategy = obj_utils.create_test_strategy(self.context)
-        response = self.get_json(f'/strategies/{strategy.uuid}/detail',
-                                 expect_errors=True)
+        response = self.get_json(
+            f'/strategies/{strategy.uuid}/detail', expect_errors=True
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
 
     def test_many(self):
         strategy_list = []
         for idx in range(1, 6):
             strategy = obj_utils.create_test_strategy(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'STRATEGY_{idx}')
+                name=f'STRATEGY_{idx}',
+            )
             strategy_list.append(strategy.uuid)
         response = self.get_json('/strategies')
         self.assertEqual(5, len(response['strategies']))
         for strategy in response['strategies']:
             self.assertTrue(
-                all(val is not None for key, val in strategy.items()
-                    if key in ['uuid', 'name', 'display_name', 'goal_uuid']))
+                all(
+                    val is not None
+                    for key, val in strategy.items()
+                    if key in ['uuid', 'name', 'display_name', 'goal_uuid']
+                )
+            )
 
     def test_many_without_soft_deleted(self):
         strategy_list = []
         for id_ in [1, 2, 3]:
             strategy = obj_utils.create_test_strategy(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'STRATEGY_{id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'STRATEGY_{id_}',
+            )
             strategy_list.append(strategy.uuid)
         for id_ in [4, 5]:
             strategy = obj_utils.create_test_strategy(
-                self.context, id=id_, uuid=utils.generate_uuid(),
-                name=f'STRATEGY_{id_}')
+                self.context,
+                id=id_,
+                uuid=utils.generate_uuid(),
+                name=f'STRATEGY_{id_}',
+            )
             strategy.soft_delete()
         response = self.get_json('/strategies')
         self.assertEqual(3, len(response['strategies']))
@@ -142,46 +184,50 @@ class TestListStrategy(api_base.FunctionalTest):
     def test_strategies_collection_links(self):
         for idx in range(1, 6):
             obj_utils.create_test_strategy(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'STRATEGY_{idx}')
+                name=f'STRATEGY_{idx}',
+            )
         response = self.get_json('/strategies/?limit=2')
         self.assertEqual(2, len(response['strategies']))
 
     def test_strategies_collection_links_default_limit(self):
         for idx in range(1, 6):
             obj_utils.create_test_strategy(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'STRATEGY_{idx}')
+                name=f'STRATEGY_{idx}',
+            )
         cfg.CONF.set_override('max_limit', 3, 'api')
         response = self.get_json('/strategies')
         self.assertEqual(3, len(response['strategies']))
 
     def test_filter_by_goal_uuid(self):
         goal1 = obj_utils.create_test_goal(
-            self.context,
-            id=2,
-            uuid=utils.generate_uuid(),
-            name='My_Goal 1')
+            self.context, id=2, uuid=utils.generate_uuid(), name='My_Goal 1'
+        )
         goal2 = obj_utils.create_test_goal(
-            self.context,
-            id=3,
-            uuid=utils.generate_uuid(),
-            name='My Goal 2')
+            self.context, id=3, uuid=utils.generate_uuid(), name='My Goal 2'
+        )
 
         for id_ in range(1, 3):
             obj_utils.create_test_strategy(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 uuid=utils.generate_uuid(),
                 name=f'Goal {id_}',
-                goal_id=goal1['id'])
+                goal_id=goal1['id'],
+            )
         for id_ in range(3, 5):
             obj_utils.create_test_strategy(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 uuid=utils.generate_uuid(),
                 name=f'Goal {id_}',
-                goal_id=goal2['id'])
+                goal_id=goal2['id'],
+            )
 
         response = self.get_json('/strategies/?goal={}'.format(goal1['uuid']))
 
@@ -192,28 +238,28 @@ class TestListStrategy(api_base.FunctionalTest):
 
     def test_filter_by_goal_name(self):
         goal1 = obj_utils.create_test_goal(
-            self.context,
-            id=2,
-            uuid=utils.generate_uuid(),
-            name='My_Goal 1')
+            self.context, id=2, uuid=utils.generate_uuid(), name='My_Goal 1'
+        )
         goal2 = obj_utils.create_test_goal(
-            self.context,
-            id=3,
-            uuid=utils.generate_uuid(),
-            name='My Goal 2')
+            self.context, id=3, uuid=utils.generate_uuid(), name='My Goal 2'
+        )
 
         for id_ in range(1, 3):
             obj_utils.create_test_strategy(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 uuid=utils.generate_uuid(),
                 name=f'Goal {id_}',
-                goal_id=goal1['id'])
+                goal_id=goal1['id'],
+            )
         for id_ in range(3, 5):
             obj_utils.create_test_strategy(
-                self.context, id=id_,
+                self.context,
+                id=id_,
                 uuid=utils.generate_uuid(),
                 name=f'Goal {id_}',
-                goal_id=goal2['id'])
+                goal_id=goal2['id'],
+            )
 
         response = self.get_json('/strategies/?goal={}'.format(goal1['name']))
 
@@ -226,9 +272,11 @@ class TestListStrategy(api_base.FunctionalTest):
         goals_uuid_list = []
         for idx in range(1, 6):
             strategy = obj_utils.create_test_strategy(
-                self.context, id=idx,
+                self.context,
+                id=idx,
                 uuid=utils.generate_uuid(),
-                name=f'STRATEGY_{idx}')
+                name=f'STRATEGY_{idx}',
+            )
             goals_uuid_list.append(strategy.goal.uuid)
 
         response = self.get_json('/strategies/?sort_key=goal_uuid')
@@ -239,65 +287,81 @@ class TestListStrategy(api_base.FunctionalTest):
 
     def test_sort_key_validation(self):
         response = self.get_json(
-            '/strategies?sort_key={}'.format('bad_name'),
-            expect_errors=True)
+            '/strategies?sort_key={}'.format('bad_name'), expect_errors=True
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
 
 
 class TestStrategyPolicyEnforcement(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         self.fake_goal = obj_utils.create_test_goal(
-            self.context, uuid=utils.generate_uuid())
+            self.context, uuid=utils.generate_uuid()
+        )
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            rule: "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                rule: "rule:default",
+            }
+        )
         response = func(*arg, **kwarg)
         self.assertEqual(HTTPStatus.FORBIDDEN, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(
             f"Policy doesn't allow {rule} to be performed.",
-            jsonutils.loads(response.json['error_message'])['faultstring'])
+            jsonutils.loads(response.json['error_message'])['faultstring'],
+        )
 
     def test_policy_disallow_get_all(self):
         self._common_policy_check(
-            "strategy:get_all", self.get_json, '/strategies',
-            expect_errors=True)
+            "strategy:get_all",
+            self.get_json,
+            '/strategies',
+            expect_errors=True,
+        )
 
     def test_policy_disallow_get_one(self):
         strategy = obj_utils.create_test_strategy(self.context)
         self._common_policy_check(
-            "strategy:get", self.get_json,
+            "strategy:get",
+            self.get_json,
             f'/strategies/{strategy.uuid}',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_detail(self):
         self._common_policy_check(
-            "strategy:detail", self.get_json,
+            "strategy:detail",
+            self.get_json,
             '/strategies/detail',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
     def test_policy_disallow_state(self):
         strategy = obj_utils.create_test_strategy(self.context)
         self._common_policy_check(
-            "strategy:get", self.get_json,
+            "strategy:get",
+            self.get_json,
             f'/strategies/{strategy.uuid}/state',
-            expect_errors=True)
+            expect_errors=True,
+        )
 
 
 class TestStrategyEnforcementWithAdminContext(
-        TestListStrategy, api_base.AdminRoleTest):
-
+    TestListStrategy, api_base.AdminRoleTest
+):
     def setUp(self):
         super().setUp()
-        self.policy.set_rules({
-            "admin_api": "(role:admin or role:administrator)",
-            "default": "rule:admin_api",
-            "strategy:detail": "rule:default",
-            "strategy:get": "rule:default",
-            "strategy:get_all": "rule:default",
-            "strategy:state": "rule:default"})
+        self.policy.set_rules(
+            {
+                "admin_api": "(role:admin or role:administrator)",
+                "default": "rule:admin_api",
+                "strategy:detail": "rule:default",
+                "strategy:get": "rule:default",
+                "strategy:get_all": "rule:default",
+                "strategy:state": "rule:default",
+            }
+        )
diff --git a/watcher/tests/unit/api/v1/test_types.py b/watcher/tests/unit/api/v1/test_types.py
index c53c54b79..d6c32a850 100644
--- a/watcher/tests/unit/api/v1/test_types.py
+++ b/watcher/tests/unit/api/v1/test_types.py
@@ -28,29 +28,30 @@ from watcher.tests.unit import base
 
 
 class TestUuidType(base.TestCase):
-
     def test_valid_uuid(self):
         test_uuid = '1a1a1a1a-2b2b-3c3c-4d4d-5e5e5e5e5e5e'
         self.assertEqual(test_uuid, types.UuidType.validate(test_uuid))
 
     def test_invalid_uuid(self):
-        self.assertRaises(exception.InvalidUUID,
-                          types.UuidType.validate, 'invalid-uuid')
+        self.assertRaises(
+            exception.InvalidUUID, types.UuidType.validate, 'invalid-uuid'
+        )
 
 
 class TestNameType(base.TestCase):
-
     def test_valid_name(self):
         test_name = 'hal-9000'
         self.assertEqual(test_name, types.NameType.validate(test_name))
 
     def test_invalid_name(self):
-        self.assertRaises(exception.InvalidName,
-                          types.NameType.validate, '-this is not valid-')
+        self.assertRaises(
+            exception.InvalidName,
+            types.NameType.validate,
+            '-this is not valid-',
+        )
 
 
 class TestUuidOrNameType(base.TestCase):
-
     @mock.patch.object(utils, 'is_uuid_like')
     @mock.patch.object(utils, 'is_hostname_safe')
     def test_valid_uuid(self, host_mock, uuid_mock):
@@ -70,8 +71,11 @@ class TestUuidOrNameType(base.TestCase):
         host_mock.assert_called_once_with(test_name)
 
     def test_invalid_uuid_or_name(self):
-        self.assertRaises(exception.InvalidUuidOrName,
-                          types.UuidOrNameType.validate, 'inval#uuid%or*name')
+        self.assertRaises(
+            exception.InvalidUuidOrName,
+            types.UuidOrNameType.validate,
+            'inval#uuid%or*name',
+        )
 
 
 class MyPatchType(types.JsonPatchType):
@@ -113,7 +117,6 @@ class MyRoot(wsme.WSRoot):
 
 
 class TestJsonPatchType(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.app = webtest.TestApp(MyRoot(['restjson']).wsgiapp())
@@ -123,22 +126,23 @@ class TestJsonPatchType(base.TestCase):
             '/test',
             params=params,
             headers={'Accept': 'application/json'},
-            expect_errors=expect_errors
+            expect_errors=expect_errors,
         )
 
     def test_valid_patches(self):
-        valid_patches = [{'path': '/extra/foo', 'op': 'remove'},
-                         {'path': '/extra/foo', 'op': 'add', 'value': 'bar'},
-                         {'path': '/str', 'op': 'replace', 'value': 'bar'},
-                         {'path': '/bool', 'op': 'add', 'value': True},
-                         {'path': '/int', 'op': 'add', 'value': 1},
-                         {'path': '/float', 'op': 'add', 'value': 0.123},
-                         {'path': '/list', 'op': 'add', 'value': [1, 2]},
-                         {'path': '/none', 'op': 'add', 'value': None},
-                         {'path': '/empty_dict', 'op': 'add', 'value': {}},
-                         {'path': '/empty_list', 'op': 'add', 'value': []},
-                         {'path': '/dict', 'op': 'add',
-                          'value': {'cat': 'meow'}}]
+        valid_patches = [
+            {'path': '/extra/foo', 'op': 'remove'},
+            {'path': '/extra/foo', 'op': 'add', 'value': 'bar'},
+            {'path': '/str', 'op': 'replace', 'value': 'bar'},
+            {'path': '/bool', 'op': 'add', 'value': True},
+            {'path': '/int', 'op': 'add', 'value': 1},
+            {'path': '/float', 'op': 'add', 'value': 0.123},
+            {'path': '/list', 'op': 'add', 'value': [1, 2]},
+            {'path': '/none', 'op': 'add', 'value': None},
+            {'path': '/empty_dict', 'op': 'add', 'value': {}},
+            {'path': '/empty_list', 'op': 'add', 'value': []},
+            {'path': '/dict', 'op': 'add', 'value': {'cat': 'meow'}},
+        ]
         ret = self._patch_json(valid_patches, False)
         self.assertEqual(HTTPStatus.OK, ret.status_int)
         self.assertEqual(valid_patches, ret.json)
@@ -150,8 +154,7 @@ class TestJsonPatchType(base.TestCase):
         self.assertTrue(ret.json['faultstring'])
 
     def test_cannot_update_internal_dict_attr(self):
-        patch = [{'path': '/internal', 'op': 'replace',
-                 'value': 'foo'}]
+        patch = [{'path': '/internal', 'op': 'replace', 'value': 'foo'}]
         ret = self._patch_json(patch, True)
         self.assertEqual(HTTPStatus.BAD_REQUEST, ret.status_int)
         self.assertTrue(ret.json['faultstring'])
@@ -215,7 +218,6 @@ class MyAllowedRoot(wsme.WSRoot):
 
 
 class TestAllowedJsonPatchType(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.app = webtest.TestApp(MyAllowedRoot(['restjson']).wsgiapp())
@@ -225,7 +227,7 @@ class TestAllowedJsonPatchType(base.TestCase):
             '/test',
             params=params,
             headers={'Accept': 'application/json'},
-            expect_errors=expect_errors
+            expect_errors=expect_errors,
         )
 
     def test_not_allowed_patches(self):
@@ -259,7 +261,6 @@ class TestAllowedJsonPatchType(base.TestCase):
 
 
 class TestBooleanType(base.TestCase):
-
     def test_valid_true_values(self):
         v = types.BooleanType()
         self.assertTrue(v.validate("true"))
@@ -289,7 +290,6 @@ class TestBooleanType(base.TestCase):
 
 
 class TestJsonType(base.TestCase):
-
     def test_valid_values(self):
         vt = types.jsontype
         value = vt.validate("hello")
diff --git a/watcher/tests/unit/api/v1/test_utils.py b/watcher/tests/unit/api/v1/test_utils.py
index 2638db54a..a19b0c78b 100644
--- a/watcher/tests/unit/api/v1/test_utils.py
+++ b/watcher/tests/unit/api/v1/test_utils.py
@@ -25,7 +25,6 @@ CONF = cfg.CONF
 
 
 class TestApiUtils(base.TestCase):
-
     def test_validate_limit(self):
         limit = utils.validate_limit(10)
         self.assertEqual(10, 10)
@@ -48,9 +47,9 @@ class TestApiUtils(base.TestCase):
             self.fail(exc)
 
         # invalid sort_dir parameter
-        self.assertRaises(wsme.exc.ClientSideError,
-                          utils.validate_sort_dir,
-                          'fake-sort')
+        self.assertRaises(
+            wsme.exc.ClientSideError, utils.validate_sort_dir, 'fake-sort'
+        )
 
     def test_validate_search_filters(self):
         allowed_fields = ["allowed", "authorized"]
@@ -67,5 +66,8 @@ class TestApiUtils(base.TestCase):
         test_filters = {"allowed": 1, "unauthorized": 2}
 
         self.assertRaises(
-            wsme.exc.ClientSideError, utils.validate_search_filters,
-            test_filters, allowed_fields)
+            wsme.exc.ClientSideError,
+            utils.validate_search_filters,
+            test_filters,
+            allowed_fields,
+        )
diff --git a/watcher/tests/unit/api/v1/test_webhooks.py b/watcher/tests/unit/api/v1/test_webhooks.py
index 831a716c6..7515652c2 100644
--- a/watcher/tests/unit/api/v1/test_webhooks.py
+++ b/watcher/tests/unit/api/v1/test_webhooks.py
@@ -20,7 +20,6 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestPost(api_base.FunctionalTest):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context)
@@ -30,20 +29,23 @@ class TestPost(api_base.FunctionalTest):
     @mock.patch.object(deapi.DecisionEngineAPI, 'trigger_audit')
     def test_trigger_audit(self, mock_trigger_audit):
         audit = obj_utils.create_test_audit(
-            self.context,
-            audit_type=objects.audit.AuditType.EVENT.value)
+            self.context, audit_type=objects.audit.AuditType.EVENT.value
+        )
         response = self.post_json(
-            '/webhooks/{}'.format(audit['uuid']), {},
-            headers={'OpenStack-API-Version': 'infra-optim 1.4'})
+            '/webhooks/{}'.format(audit['uuid']),
+            {},
+            headers={'OpenStack-API-Version': 'infra-optim 1.4'},
+        )
         self.assertEqual(HTTPStatus.ACCEPTED, response.status_int)
-        mock_trigger_audit.assert_called_once_with(
-            mock.ANY, audit['uuid'])
+        mock_trigger_audit.assert_called_once_with(mock.ANY, audit['uuid'])
 
     def test_trigger_audit_with_no_audit(self):
         response = self.post_json(
-            '/webhooks/no-audit', {},
+            '/webhooks/no-audit',
+            {},
             headers={'OpenStack-API-Version': 'infra-optim 1.4'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.NOT_FOUND, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -51,9 +53,11 @@ class TestPost(api_base.FunctionalTest):
     def test_trigger_audit_with_not_allowed_audittype(self):
         audit = obj_utils.create_test_audit(self.context)
         response = self.post_json(
-            '/webhooks/{}'.format(audit['uuid']), {},
+            '/webhooks/{}'.format(audit['uuid']),
+            {},
             headers={'OpenStack-API-Version': 'infra-optim 1.4'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
@@ -62,11 +66,14 @@ class TestPost(api_base.FunctionalTest):
         audit = obj_utils.create_test_audit(
             self.context,
             audit_type=objects.audit.AuditType.EVENT.value,
-            state=objects.audit.State.FAILED)
+            state=objects.audit.State.FAILED,
+        )
         response = self.post_json(
-            '/webhooks/{}'.format(audit['uuid']), {},
+            '/webhooks/{}'.format(audit['uuid']),
+            {},
             headers={'OpenStack-API-Version': 'infra-optim 1.4'},
-            expect_errors=True)
+            expect_errors=True,
+        )
         self.assertEqual(HTTPStatus.BAD_REQUEST, response.status_int)
         self.assertEqual('application/json', response.content_type)
         self.assertTrue(response.json['error_message'])
diff --git a/watcher/tests/unit/applier/action_plan/test_default_action_handler.py b/watcher/tests/unit/applier/action_plan/test_default_action_handler.py
index 8b126841b..b77c7dcc8 100644
--- a/watcher/tests/unit/applier/action_plan/test_default_action_handler.py
+++ b/watcher/tests/unit/applier/action_plan/test_default_action_handler.py
@@ -29,7 +29,6 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestDefaultActionPlanHandler(base.DbTestCase):
-
     class FakeApplierException(Exception):
         pass
 
@@ -37,44 +36,55 @@ class TestDefaultActionPlanHandler(base.DbTestCase):
         super().setUp()
 
         p_action_plan_notifications = mock.patch.object(
-            notifications, 'action_plan', autospec=True)
+            notifications, 'action_plan', autospec=True
+        )
         self.m_action_plan_notifications = p_action_plan_notifications.start()
         self.addCleanup(p_action_plan_notifications.stop)
 
         obj_utils.create_test_goal(self.context)
         self.strategy = obj_utils.create_test_strategy(self.context)
         self.audit = obj_utils.create_test_audit(
-            self.context, strategy_id=self.strategy.id)
+            self.context, strategy_id=self.strategy.id
+        )
         self.action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
-            strategy_id=self.strategy.id)
+            self.context, audit_id=self.audit.id, strategy_id=self.strategy.id
+        )
         self.action = obj_utils.create_test_action(
-            self.context, action_plan_id=self.action_plan.id,
+            self.context,
+            action_plan_id=self.action_plan.id,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
 
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
     def test_launch_action_plan(self, m_get_action_plan):
         m_get_action_plan.return_value = self.action_plan
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
 
         expected_calls = [
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.END)]
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+        ]
 
         self.assertEqual(ap_objects.State.SUCCEEDED, self.action_plan.state)
 
         self.assertEqual(
             expected_calls,
-            self.m_action_plan_notifications
-                .send_action_notification
-                .call_args_list)
+            self.m_action_plan_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(ap_applier.DefaultApplier, "execute")
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
@@ -82,25 +92,32 @@ class TestDefaultActionPlanHandler(base.DbTestCase):
         m_get_action_plan.return_value = self.action_plan
         m_execute.side_effect = self.FakeApplierException
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
 
         expected_calls = [
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      priority=objects.fields.NotificationPriority.ERROR,
-                      phase=objects.fields.NotificationPhase.ERROR)]
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                priority=objects.fields.NotificationPriority.ERROR,
+                phase=objects.fields.NotificationPhase.ERROR,
+            ),
+        ]
 
         self.assertEqual(ap_objects.State.FAILED, self.action_plan.state)
 
         self.assertEqual(
             expected_calls,
-            self.m_action_plan_notifications
-                .send_action_notification
-                .call_args_list)
+            self.m_action_plan_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
     def test_cancel_action_plan(self, m_get_action_plan):
@@ -108,7 +125,8 @@ class TestDefaultActionPlanHandler(base.DbTestCase):
         self.action_plan.state = ap_objects.State.CANCELLED
         self.action_plan.save()
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
         action = self.action.get_by_uuid(self.context, self.action.uuid)
         self.assertEqual(ap_objects.State.CANCELLED, self.action_plan.state)
@@ -116,106 +134,141 @@ class TestDefaultActionPlanHandler(base.DbTestCase):
 
     @mock.patch.object(ap_applier.DefaultApplier, "execute")
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
-    def test_cancel_action_plan_with_exception(self, m_get_action_plan,
-                                               m_execute):
+    def test_cancel_action_plan_with_exception(
+        self, m_get_action_plan, m_execute
+    ):
         m_get_action_plan.return_value = self.action_plan
         m_execute.side_effect = exception.ActionPlanCancelled(
-            self.action_plan.uuid)
+            self.action_plan.uuid
+        )
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
         self.assertEqual(ap_objects.State.CANCELLED, self.action_plan.state)
 
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
     @mock.patch.object(objects.Action, "list")
-    def test_launch_action_plan_failed_actions(self, m_action_list,
-                                               m_get_action_plan):
+    def test_launch_action_plan_failed_actions(
+        self, m_action_list, m_get_action_plan
+    ):
         m_get_action_plan.return_value = self.action_plan
         failed_action = self.action
         failed_action.state = objects.action.State.FAILED
         m_action_list.return_value = [failed_action]
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
         expected_calls = [
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      priority=objects.fields.NotificationPriority.ERROR,
-                      phase=objects.fields.NotificationPhase.ERROR)]
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                priority=objects.fields.NotificationPriority.ERROR,
+                phase=objects.fields.NotificationPhase.ERROR,
+            ),
+        ]
 
         self.assertEqual(ap_objects.State.FAILED, self.action_plan.state)
         self.assertEqual(
             expected_calls,
-            self.m_action_plan_notifications
-                .send_action_notification
-                .call_args_list)
+            self.m_action_plan_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
-    def test_launch_action_plan_skipped_actions(self,
-                                                m_get_action_plan):
+    def test_launch_action_plan_skipped_actions(self, m_get_action_plan):
         m_get_action_plan.return_value = self.action_plan
         skipped_action = obj_utils.create_test_action(
-            self.context, action_plan_id=self.action_plan.id,
+            self.context,
+            action_plan_id=self.action_plan.id,
             action_type='nop',
             uuid=utils.generate_uuid(),
-            input_parameters={'message': 'hello World',
-                              'skip_pre_condition': True})
+            input_parameters={
+                'message': 'hello World',
+                'skip_pre_condition': True,
+            },
+        )
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
         expected_calls = [
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.END)
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.END,
+            ),
         ]
 
         self.assertEqual(
             self.action.get_by_uuid(self.context, skipped_action.uuid).state,
-            objects.action.State.SKIPPED)
+            objects.action.State.SKIPPED,
+        )
         self.assertEqual(ap_objects.State.SUCCEEDED, self.action_plan.state)
-        self.assertEqual(self.action_plan.status_message,
-                         "One or more actions were skipped.")
+        self.assertEqual(
+            self.action_plan.status_message,
+            "One or more actions were skipped.",
+        )
         self.assertEqual(
             expected_calls,
-            self.m_action_plan_notifications
-                .send_action_notification
-                .call_args_list)
+            self.m_action_plan_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
-    def test_launch_action_plan_manual_skipped_actions(self,
-                                                       m_get_action_plan):
+    def test_launch_action_plan_manual_skipped_actions(
+        self, m_get_action_plan
+    ):
         m_get_action_plan.return_value = self.action_plan
         skipped_action = obj_utils.create_test_action(
-            self.context, action_plan_id=self.action_plan.id,
+            self.context,
+            action_plan_id=self.action_plan.id,
             action_type='nop',
             uuid=utils.generate_uuid(),
             state=objects.action.State.SKIPPED,
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         command = default.DefaultActionPlanHandler(
-            self.context, mock.MagicMock(), self.action_plan.uuid)
+            self.context, mock.MagicMock(), self.action_plan.uuid
+        )
         command.execute()
         expected_calls = [
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.action_plan,
-                      action=objects.fields.NotificationAction.EXECUTION,
-                      phase=objects.fields.NotificationPhase.END)
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.action_plan,
+                action=objects.fields.NotificationAction.EXECUTION,
+                phase=objects.fields.NotificationPhase.END,
+            ),
         ]
         self.assertEqual(
             self.action.get_by_uuid(self.context, skipped_action.uuid).state,
-            objects.action.State.SKIPPED)
+            objects.action.State.SKIPPED,
+        )
         self.assertEqual(ap_objects.State.SUCCEEDED, self.action_plan.state)
-        self.assertEqual(self.action_plan.status_message,
-                         "One or more actions were skipped.")
+        self.assertEqual(
+            self.action_plan.status_message,
+            "One or more actions were skipped.",
+        )
         self.assertEqual(
             expected_calls,
-            self.m_action_plan_notifications
-                .send_action_notification
-                .call_args_list)
+            self.m_action_plan_notifications.send_action_notification.call_args_list,
+        )
diff --git a/watcher/tests/unit/applier/actions/test_change_node_power_state.py b/watcher/tests/unit/applier/actions/test_change_node_power_state.py
index 02f4fe232..20f2dca35 100644
--- a/watcher/tests/unit/applier/actions/test_change_node_power_state.py
+++ b/watcher/tests/unit/applier/actions/test_change_node_power_state.py
@@ -29,7 +29,6 @@ COMPUTE_NODE = "compute-1"
 
 
 class TestChangeNodePowerState(base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -47,43 +46,45 @@ class TestChangeNodePowerState(base.TestCase):
             baction.BaseAction.RESOURCE_ID: COMPUTE_NODE,
             "state": m_constants.PowerState.ON.value,
         }
-        self.action = change_node_power_state.ChangeNodePowerState(
-            mock.Mock())
+        self.action = change_node_power_state.ChangeNodePowerState(mock.Mock())
         self.action.input_parameters = self.input_parameters
 
     def test_parameters_down(self):
         self.action.input_parameters = {
             baction.BaseAction.RESOURCE_ID: COMPUTE_NODE,
-            self.action.STATE:
-                m_constants.PowerState.OFF.value}
+            self.action.STATE: m_constants.PowerState.OFF.value,
+        }
         self.assertTrue(self.action.validate_parameters())
 
     def test_parameters_up(self):
         self.action.input_parameters = {
             baction.BaseAction.RESOURCE_ID: COMPUTE_NODE,
-            self.action.STATE:
-                m_constants.PowerState.ON.value}
+            self.action.STATE: m_constants.PowerState.ON.value,
+        }
         self.assertTrue(self.action.validate_parameters())
 
     def test_parameters_exception_wrong_state(self):
         self.action.input_parameters = {
             baction.BaseAction.RESOURCE_ID: COMPUTE_NODE,
-            self.action.STATE: 'error'}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+            self.action.STATE: 'error',
+        }
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_resource_id_empty(self):
         self.action.input_parameters = {
-            self.action.STATE:
-                m_constants.PowerState.ON.value,
+            self.action.STATE: m_constants.PowerState.ON.value
         }
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_applies_add_extra(self):
         self.action.input_parameters = {"extra": "failed"}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_change_service_state_pre_condition(self):
         try:
@@ -98,13 +99,14 @@ class TestChangeNodePowerState(base.TestCase):
             self.fail(exc)
 
     def test_execute_node_service_state_with_poweron_target(self):
-        self.action.input_parameters["state"] = (
-            m_constants.PowerState.ON.value)
+        self.action.input_parameters["state"] = m_constants.PowerState.ON.value
         mock_nodes = [
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.OFF),
+                power_state=m_constants.PowerState.OFF
+            ),
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.ON)
+                power_state=m_constants.PowerState.ON
+            ),
         ]
         self._metal_helper.get_node.side_effect = mock_nodes
 
@@ -112,19 +114,24 @@ class TestChangeNodePowerState(base.TestCase):
         self.assertTrue(result)
 
         mock_nodes[0].set_power_state.assert_called_once_with(
-            m_constants.PowerState.ON.value)
+            m_constants.PowerState.ON.value
+        )
 
     def test_execute_change_node_state_with_poweroff_target(self):
         self.action.input_parameters["state"] = (
-            m_constants.PowerState.OFF.value)
+            m_constants.PowerState.OFF.value
+        )
 
         mock_nodes = [
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.ON),
+                power_state=m_constants.PowerState.ON
+            ),
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.ON),
+                power_state=m_constants.PowerState.ON
+            ),
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.OFF)
+                power_state=m_constants.PowerState.OFF
+            ),
         ]
         self._metal_helper.get_node.side_effect = mock_nodes
 
@@ -132,39 +139,47 @@ class TestChangeNodePowerState(base.TestCase):
         self.assertTrue(result)
 
         mock_nodes[0].set_power_state.assert_called_once_with(
-            m_constants.PowerState.OFF.value)
+            m_constants.PowerState.OFF.value
+        )
 
     def test_revert_change_node_state_with_poweron_target(self):
-        self.action.input_parameters["state"] = (
-            m_constants.PowerState.ON.value)
+        self.action.input_parameters["state"] = m_constants.PowerState.ON.value
 
         mock_nodes = [
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.ON),
+                power_state=m_constants.PowerState.ON
+            ),
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.ON),
+                power_state=m_constants.PowerState.ON
+            ),
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.OFF)
+                power_state=m_constants.PowerState.OFF
+            ),
         ]
         self._metal_helper.get_node.side_effect = mock_nodes
 
         self.action.revert()
 
         mock_nodes[0].set_power_state.assert_called_once_with(
-            m_constants.PowerState.OFF.value)
+            m_constants.PowerState.OFF.value
+        )
 
     def test_revert_change_node_state_with_poweroff_target(self):
         self.action.input_parameters["state"] = (
-            m_constants.PowerState.OFF.value)
+            m_constants.PowerState.OFF.value
+        )
         mock_nodes = [
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.OFF),
+                power_state=m_constants.PowerState.OFF
+            ),
             fake_metal_helper.get_mock_metal_node(
-                power_state=m_constants.PowerState.ON)
+                power_state=m_constants.PowerState.ON
+            ),
         ]
         self._metal_helper.get_node.side_effect = mock_nodes
 
         self.action.revert()
 
         mock_nodes[0].set_power_state.assert_called_once_with(
-            m_constants.PowerState.ON.value)
+            m_constants.PowerState.ON.value
+        )
diff --git a/watcher/tests/unit/applier/actions/test_change_nova_service_state.py b/watcher/tests/unit/applier/actions/test_change_nova_service_state.py
index e916ebd26..9c1b34bc4 100644
--- a/watcher/tests/unit/applier/actions/test_change_nova_service_state.py
+++ b/watcher/tests/unit/applier/actions/test_change_nova_service_state.py
@@ -28,7 +28,6 @@ from watcher.tests.unit.common import utils as test_utils
 
 
 class TestChangeNovaServiceState(test_utils.NovaResourcesMixin, base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -40,9 +39,11 @@ class TestChangeNovaServiceState(test_utils.NovaResourcesMixin, base.TestCase):
         self.m_osc_cls.return_value = self.m_osc
 
         m_openstack_clients = mock.patch.object(
-            clients, "OpenStackClients", self.m_osc_cls)
+            clients, "OpenStackClients", self.m_osc_cls
+        )
         m_nova_helper = mock.patch.object(
-            nova_helper, "NovaHelper", self.m_helper_cls)
+            nova_helper, "NovaHelper", self.m_helper_cls
+        )
 
         m_openstack_clients.start()
         m_nova_helper.start()
@@ -55,45 +56,52 @@ class TestChangeNovaServiceState(test_utils.NovaResourcesMixin, base.TestCase):
             "state": element.ServiceState.ENABLED.value,
         }
         self.action = change_nova_service_state.ChangeNovaServiceState(
-            mock.Mock())
+            mock.Mock()
+        )
         self.action.input_parameters = self.input_parameters
 
     def test_parameters_down(self):
         self.action.input_parameters = {
             baction.BaseAction.RESOURCE_ID: "compute-1",
-            self.action.STATE: element.ServiceState.DISABLED.value}
+            self.action.STATE: element.ServiceState.DISABLED.value,
+        }
         self.assertTrue(self.action.validate_parameters())
 
     def test_parameters_up(self):
         self.action.input_parameters = {
             baction.BaseAction.RESOURCE_ID: "compute-1",
-            self.action.STATE: element.ServiceState.ENABLED.value}
+            self.action.STATE: element.ServiceState.ENABLED.value,
+        }
         self.assertTrue(self.action.validate_parameters())
 
     def test_parameters_exception_wrong_state(self):
         self.action.input_parameters = {
             baction.BaseAction.RESOURCE_ID: "compute-1",
-            self.action.STATE: 'error'}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+            self.action.STATE: 'error',
+        }
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_resource_id_empty(self):
         self.action.input_parameters = {
-            self.action.STATE: element.ServiceState.ENABLED.value,
+            self.action.STATE: element.ServiceState.ENABLED.value
         }
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_applies_add_extra(self):
         self.action.input_parameters = {"extra": "failed"}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_change_service_state_pre_condition_enable(self):
         svc1 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
-                host='compute-1',
-                status=element.ServiceState.DISABLED.value)
+                host='compute-1', status=element.ServiceState.DISABLED.value
+            )
         )
         self.m_helper.get_service_list.return_value = [svc1]
         self.action.pre_condition()
@@ -101,11 +109,12 @@ class TestChangeNovaServiceState(test_utils.NovaResourcesMixin, base.TestCase):
 
     def test_change_service_state_pre_condition_disable(self):
         self.action.input_parameters["state"] = (
-            element.ServiceState.DISABLED.value)
+            element.ServiceState.DISABLED.value
+        )
         svc1 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
-                host='compute-1',
-                status=element.ServiceState.ENABLED.value)
+                host='compute-1', status=element.ServiceState.ENABLED.value
+            )
         )
         self.m_helper.get_service_list.return_value = [svc1]
         self.action.pre_condition()
@@ -114,27 +123,29 @@ class TestChangeNovaServiceState(test_utils.NovaResourcesMixin, base.TestCase):
     def test_change_service_state_pre_condition_skipped_not_found(self):
         svc1 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
-                host='compute-2',
-                status=element.ServiceState.DISABLED.value)
+                host='compute-2', status=element.ServiceState.DISABLED.value
+            )
         )
         self.m_helper.get_service_list.return_value = [svc1]
         self.assertRaisesRegex(
             exception.ActionSkipped,
             "nova-compute service compute-1 not found",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
         self.m_helper.get_service_list.assert_called_once_with()
 
     def test_change_service_state_pre_condition_skipped_state(self):
         svc1 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
-                host='compute-1',
-                status=element.ServiceState.ENABLED.value)
+                host='compute-1', status=element.ServiceState.ENABLED.value
+            )
         )
         self.m_helper.get_service_list.return_value = [svc1]
         self.assertRaisesRegex(
             exception.ActionSkipped,
             "nova-compute service compute-1 is already in state enabled",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
         self.m_helper.get_service_list.assert_called_once_with()
 
     def test_change_service_state_post_condition(self):
@@ -148,33 +159,37 @@ class TestChangeNovaServiceState(test_utils.NovaResourcesMixin, base.TestCase):
 
         self.m_helper_cls.assert_called_once_with(osc=self.m_osc)
         self.m_helper.enable_service_nova_compute.assert_called_once_with(
-            "compute-1")
+            "compute-1"
+        )
 
     def test_execute_change_service_state_with_disable_target(self):
         self.action.input_parameters["state"] = (
-            element.ServiceState.DISABLED.value)
-        self.action.input_parameters["disabled_reason"] = (
-            "watcher_disabled")
+            element.ServiceState.DISABLED.value
+        )
+        self.action.input_parameters["disabled_reason"] = "watcher_disabled"
         self.action.execute()
 
         self.m_helper_cls.assert_called_once_with(osc=self.m_osc)
         self.m_helper.disable_service_nova_compute.assert_called_once_with(
-            "compute-1", "watcher_disabled")
+            "compute-1", "watcher_disabled"
+        )
 
     def test_revert_change_service_state_with_enable_target(self):
-        self.action.input_parameters["disabled_reason"] = (
-            "watcher_disabled")
+        self.action.input_parameters["disabled_reason"] = "watcher_disabled"
         self.action.revert()
 
         self.m_helper_cls.assert_called_once_with(osc=self.m_osc)
         self.m_helper.disable_service_nova_compute.assert_called_once_with(
-            "compute-1", "watcher_disabled")
+            "compute-1", "watcher_disabled"
+        )
 
     def test_revert_change_service_state_with_disable_target(self):
         self.action.input_parameters["state"] = (
-            element.ServiceState.DISABLED.value)
+            element.ServiceState.DISABLED.value
+        )
         self.action.revert()
 
         self.m_helper_cls.assert_called_once_with(osc=self.m_osc)
         self.m_helper.enable_service_nova_compute.assert_called_once_with(
-            "compute-1")
+            "compute-1"
+        )
diff --git a/watcher/tests/unit/applier/actions/test_migration.py b/watcher/tests/unit/applier/actions/test_migration.py
index a2b43724f..8a86cd2ef 100644
--- a/watcher/tests/unit/applier/actions/test_migration.py
+++ b/watcher/tests/unit/applier/actions/test_migration.py
@@ -27,7 +27,6 @@ from watcher.tests.unit.common import utils as test_utils
 
 
 class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
-
     INSTANCE_UUID = "45a37aeb-95ab-4ddb-a305-7d9f62c2f5ba"
 
     def setUp(self):
@@ -41,9 +40,11 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
         self.m_osc_cls.return_value = self.m_osc
 
         m_openstack_clients = mock.patch.object(
-            clients, "OpenStackClients", self.m_osc_cls)
+            clients, "OpenStackClients", self.m_osc_cls
+        )
         m_nova_helper = mock.patch.object(
-            nova_helper, "NovaHelper", self.m_helper_cls)
+            nova_helper, "NovaHelper", self.m_helper_cls
+        )
 
         m_openstack_clients.start()
         m_nova_helper.start()
@@ -70,81 +71,96 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
         self.action_cold.input_parameters = self.input_parameters_cold
 
     def test_parameters(self):
-        params = {baction.BaseAction.RESOURCE_ID:
-                  self.INSTANCE_UUID,
-                  self.action.MIGRATION_TYPE: 'live',
-                  self.action.DESTINATION_NODE: 'compute-2',
-                  self.action.SOURCE_NODE: 'compute-3'}
+        params = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            self.action.MIGRATION_TYPE: 'live',
+            self.action.DESTINATION_NODE: 'compute-2',
+            self.action.SOURCE_NODE: 'compute-3',
+        }
         self.action.input_parameters = params
         self.assertTrue(self.action.validate_parameters())
 
     def test_parameters_cold(self):
-        params = {baction.BaseAction.RESOURCE_ID:
-                  self.INSTANCE_UUID,
-                  self.action.MIGRATION_TYPE: 'cold',
-                  self.action.DESTINATION_NODE: 'compute-2',
-                  self.action.SOURCE_NODE: 'compute-3'}
+        params = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            self.action.MIGRATION_TYPE: 'cold',
+            self.action.DESTINATION_NODE: 'compute-2',
+            self.action.SOURCE_NODE: 'compute-3',
+        }
         self.action_cold.input_parameters = params
         self.assertTrue(self.action_cold.validate_parameters())
 
     def test_parameters_exception_empty_fields(self):
-        parameters = {baction.BaseAction.RESOURCE_ID: None,
-                      'migration_type': None,
-                      'source_node': None,
-                      'destination_node': None}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: None,
+            'migration_type': None,
+            'source_node': None,
+            'destination_node': None,
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_exception_migration_type(self):
-        parameters = {baction.BaseAction.RESOURCE_ID:
-                      self.INSTANCE_UUID,
-                      'migration_type': 'unknown',
-                      'source_node': 'compute-2',
-                      'destination_node': 'compute-3'}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            'migration_type': 'unknown',
+            'source_node': 'compute-2',
+            'destination_node': 'compute-3',
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_exception_source_node(self):
-        parameters = {baction.BaseAction.RESOURCE_ID:
-                      self.INSTANCE_UUID,
-                      'migration_type': 'live',
-                      'source_node': None,
-                      'destination_node': 'compute-3'}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            'migration_type': 'live',
+            'source_node': None,
+            'destination_node': 'compute-3',
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_destination_node_none(self):
-        parameters = {baction.BaseAction.RESOURCE_ID:
-                      self.INSTANCE_UUID,
-                      'migration_type': 'live',
-                      'source_node': 'compute-1',
-                      'destination_node': None}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            'migration_type': 'live',
+            'source_node': 'compute-1',
+            'destination_node': None,
+        }
         self.action.input_parameters = parameters
         self.assertTrue(self.action.validate_parameters)
 
     def test_parameters_exception_resource_id(self):
-        parameters = {baction.BaseAction.RESOURCE_ID: "EFEF",
-                      'migration_type': 'live',
-                      'source_node': 'compute-2',
-                      'destination_node': 'compute-3'}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: "EFEF",
+            'migration_type': 'live',
+            'source_node': 'compute-2',
+            'destination_node': 'compute-3',
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_migration_pre_condition_success(self):
         """Test successful pre_condition with all checks passing"""
-        parameters = {baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
-                      'migration_type': 'live',
-                      'source_node': 'compute1-hostname',
-                      'destination_node': 'compute2-hostname'}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            'migration_type': 'live',
+            'source_node': 'compute1-hostname',
+            'destination_node': 'compute2-hostname',
+        }
         self.action.input_parameters = parameters
         instance_info = {
             'id': self.INSTANCE_UUID,
             'status': 'ACTIVE',
-            'compute_host': 'compute1-hostname'
+            'compute_host': 'compute1-hostname',
         }
         instance = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**instance_info)
@@ -154,9 +170,7 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             'id': 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
             'status': 'enabled',
             'name': 'compute1-hostname',
-            'service_details': {
-                'host': 'compute1-hostname'
-            }
+            'service_details': {'host': 'compute1-hostname'},
         }
         compute_node = nova_helper.Hypervisor.from_openstacksdk(
             self.create_openstacksdk_hypervisor(**compute_node_info)
@@ -175,14 +189,15 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertRaisesRegex(
             exception.ActionSkipped,
             f"Instance {self.INSTANCE_UUID} not found",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_pre_condition_instance_on_wrong_host(self):
         """Test pre_condition fails when instance is on wrong host"""
         instance_info = {
             'id': self.INSTANCE_UUID,
             'status': 'ACTIVE',
-            'compute_host': 'wrong-hostname'
+            'compute_host': 'wrong-hostname',
         }
         instance = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**instance_info)
@@ -194,14 +209,15 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             exception.ActionSkipped,
             f"Instance {self.INSTANCE_UUID} is not running on source node "
             r"compute1-hostname \(currently on wrong-hostname\)",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_pre_condition_destination_node_not_found(self):
         """Test pre_condition fails when destination node doesn't exist"""
         instance_info = {
             'id': self.INSTANCE_UUID,
             'status': 'ACTIVE',
-            'compute_host': 'compute1-hostname'
+            'compute_host': 'compute1-hostname',
         }
         instance = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**instance_info)
@@ -209,19 +225,21 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
 
         self.m_helper.find_instance.return_value = instance
         self.m_helper.get_compute_node_by_hostname.side_effect = (
-            exception.ComputeNodeNotFound(name='compute2-hostname'))
+            exception.ComputeNodeNotFound(name='compute2-hostname')
+        )
 
         self.assertRaisesRegex(
             exception.ActionExecutionFailure,
             "Destination node compute2-hostname not found",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_pre_condition_destination_node_disabled(self):
         """Test pre_condition fails when destination node is disabled"""
         instance_info = {
             'id': self.INSTANCE_UUID,
             'status': 'ACTIVE',
-            'compute_host': 'compute1-hostname'
+            'compute_host': 'compute1-hostname',
         }
         instance = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**instance_info)
@@ -231,9 +249,7 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             'id': 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
             'status': 'disabled',
             'name': 'compute2-hostname',
-            'service_details': {
-                'host': 'compute2-hostname'
-            }
+            'service_details': {'host': 'compute2-hostname'},
         }
         compute_node = nova_helper.Hypervisor.from_openstacksdk(
             self.create_openstacksdk_hypervisor(**compute_node_info)
@@ -245,14 +261,15 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertRaisesRegex(
             exception.ActionExecutionFailure,
             "Destination node compute2-hostname is not in enabled state",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_pre_condition_live_migration_wrong_status(self):
         """Test pre_condition fails live migration with non-ACTIVE status"""
         instance_info = {
             'id': self.INSTANCE_UUID,
             'status': 'SHUTOFF',
-            'compute_host': 'compute1-hostname'
+            'compute_host': 'compute1-hostname',
         }
         instance = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**instance_info)
@@ -262,9 +279,7 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             'id': 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
             'status': 'enabled',
             'name': 'compute2-hostname',
-            'service_details': {
-                'host': 'compute2-hostname'
-            }
+            'service_details': {'host': 'compute2-hostname'},
         }
         compute_node = nova_helper.Hypervisor.from_openstacksdk(
             self.create_openstacksdk_hypervisor(**compute_node_info)
@@ -277,14 +292,15 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             exception.ActionExecutionFailure,
             f"Live migration requires instance {self.INSTANCE_UUID} to be in "
             r"ACTIVE status \(current status: SHUTOFF\)",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_pre_condition_no_destination_node(self):
         """Test pre_condition with no destination node specified"""
         instance_info = {
             'id': self.INSTANCE_UUID,
             'status': 'ACTIVE',
-            'compute_host': 'compute1-hostname'
+            'compute_host': 'compute1-hostname',
         }
         instance = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**instance_info)
@@ -318,7 +334,8 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             name=self.INSTANCE_UUID
         )
         exc = self.assertRaises(
-            exception.InstanceNotFound, self.action.execute)
+            exception.InstanceNotFound, self.action.execute
+        )
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
         self.assertEqual(self.INSTANCE_UUID, exc.kwargs["name"])
 
@@ -327,7 +344,8 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             name=self.INSTANCE_UUID
         )
         exc = self.assertRaises(
-            exception.InstanceNotFound, self.action_cold.execute)
+            exception.InstanceNotFound, self.action_cold.execute
+        )
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
         self.assertEqual(self.INSTANCE_UUID, exc.kwargs["name"])
 
@@ -340,8 +358,8 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             self.fail(exc)
 
         self.m_helper.live_migrate_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID,
-            dest_hostname="compute2-hostname")
+            instance_id=self.INSTANCE_UUID, dest_hostname="compute2-hostname"
+        )
 
     def test_execute_cold_migration(self):
         self.m_helper.find_instance.return_value = self.INSTANCE_UUID
@@ -351,11 +369,9 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
         except Exception as exc:
             self.fail(exc)
 
-        self.m_helper.watcher_non_live_migrate_instance.\
-            assert_called_once_with(
-                instance_id=self.INSTANCE_UUID,
-                dest_hostname="compute2-hostname"
-            )
+        self.m_helper.watcher_non_live_migrate_instance.assert_called_once_with(
+            instance_id=self.INSTANCE_UUID, dest_hostname="compute2-hostname"
+        )
 
     def test_revert_live_migration(self):
         self.m_helper.find_instance.return_value = self.INSTANCE_UUID
@@ -364,8 +380,7 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
 
         self.m_helper_cls.assert_called_once_with(osc=self.m_osc)
         self.m_helper.live_migrate_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID,
-            dest_hostname="compute1-hostname"
+            instance_id=self.INSTANCE_UUID, dest_hostname="compute1-hostname"
         )
 
     def test_revert_cold_migration(self):
@@ -374,11 +389,9 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
         self.action_cold.revert()
 
         self.m_helper_cls.assert_called_once_with(osc=self.m_osc)
-        self.m_helper.watcher_non_live_migrate_instance.\
-            assert_called_once_with(
-                instance_id=self.INSTANCE_UUID,
-                dest_hostname="compute1-hostname"
-            )
+        self.m_helper.watcher_non_live_migrate_instance.assert_called_once_with(
+            instance_id=self.INSTANCE_UUID, dest_hostname="compute1-hostname"
+        )
 
     def test_abort_live_migrate(self):
         migration = mock.MagicMock()
@@ -392,19 +405,22 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
             self.fail(exc)
 
         self.m_helper.abort_live_migrate.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID, source="compute1-hostname",
-            destination="compute2-hostname")
+            instance_id=self.INSTANCE_UUID,
+            source="compute1-hostname",
+            destination="compute2-hostname",
+        )
 
     def test_execute_live_migration_failure_instance_not_found(self):
         # Live migration fails but instance doesn't exist (idempotent)
         self.m_helper.find_instance.side_effect = (
-            exception.ComputeResourceNotFound(self.INSTANCE_UUID))
+            exception.ComputeResourceNotFound(self.INSTANCE_UUID)
+        )
         self.m_helper.live_migrate_instance.return_value = False
 
         self.assertRaisesRegex(
             exception.InstanceNotFound,
             f"The instance '{self.INSTANCE_UUID}' could not be found",
-            self.action.execute
+            self.action.execute,
         )
 
         # Should check instance existence
@@ -413,13 +429,14 @@ class TestMigration(test_utils.NovaResourcesMixin, base.TestCase):
     def test_execute_cold_migration_failure_instance_not_found(self):
         # Cold migration fails but instance doesn't exist (idempotent)
         self.m_helper.find_instance.side_effect = (
-            exception.ComputeResourceNotFound(self.INSTANCE_UUID))
+            exception.ComputeResourceNotFound(self.INSTANCE_UUID)
+        )
         self.m_helper.watcher_non_live_migrate_instance.return_value = False
 
         self.assertRaisesRegex(
             exception.InstanceNotFound,
             f"The instance '{self.INSTANCE_UUID}' could not be found",
-            self.action.execute
+            self.action.execute,
         )
         # Should check instance existence
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
diff --git a/watcher/tests/unit/applier/actions/test_resize.py b/watcher/tests/unit/applier/actions/test_resize.py
index 972328c92..311465eca 100644
--- a/watcher/tests/unit/applier/actions/test_resize.py
+++ b/watcher/tests/unit/applier/actions/test_resize.py
@@ -25,7 +25,6 @@ from watcher.tests.unit import base
 
 
 class TestResize(base.TestCase):
-
     INSTANCE_UUID = "94ae2f92-b7fd-4da7-9e97-f13504ae98c4"
 
     def setUp(self):
@@ -39,9 +38,11 @@ class TestResize(base.TestCase):
         self.r_osc_cls.return_value = self.r_osc
 
         r_openstack_clients = mock.patch.object(
-            clients, "OpenStackClients", self.r_osc_cls)
+            clients, "OpenStackClients", self.r_osc_cls
+        )
         r_nova_helper = mock.patch.object(
-            nova_helper, "NovaHelper", self.r_helper_cls)
+            nova_helper, "NovaHelper", self.r_helper_cls
+        )
 
         r_openstack_clients.start()
         r_nova_helper.start()
@@ -57,40 +58,49 @@ class TestResize(base.TestCase):
         self.action.input_parameters = self.input_parameters
 
     def test_parameters(self):
-        params = {baction.BaseAction.RESOURCE_ID:
-                  self.INSTANCE_UUID,
-                  self.action.FLAVOR: 'x1'}
+        params = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            self.action.FLAVOR: 'x1',
+        }
         self.action.input_parameters = params
         self.assertTrue(self.action.validate_parameters())
 
     def test_parameters_exception_empty_fields(self):
-        parameters = {baction.BaseAction.RESOURCE_ID:
-                      self.INSTANCE_UUID,
-                      self.action.FLAVOR: None}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            self.action.FLAVOR: None,
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_exception_flavor(self):
-        parameters = {baction.BaseAction.RESOURCE_ID:
-                      self.INSTANCE_UUID,
-                      self.action.FLAVOR: None}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            self.action.FLAVOR: None,
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_exception_resource_id(self):
-        parameters = {baction.BaseAction.RESOURCE_ID: "EFEF",
-                      self.action.FLAVOR: 'x1'}
+        parameters = {
+            baction.BaseAction.RESOURCE_ID: "EFEF",
+            self.action.FLAVOR: 'x1',
+        }
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_execute_resize(self):
         self.r_helper.find_instance.return_value = self.INSTANCE_UUID
         self.action.execute()
         self.r_helper.resize_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID, flavor='x1')
+            instance_id=self.INSTANCE_UUID, flavor='x1'
+        )
 
     def test_pre_condition_success(self):
         """Test pre_condition succeeds when instance and flavor exist"""
@@ -106,7 +116,8 @@ class TestResize(base.TestCase):
         self.assertRaisesRegex(
             exception.ActionSkipped,
             f"Instance {self.INSTANCE_UUID} not found",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_pre_condition_flavor_not_found(self):
         """Test pre_condition fails when flavor doesn't exist"""
@@ -116,7 +127,8 @@ class TestResize(base.TestCase):
         self.assertRaisesRegex(
             exception.ActionExecutionFailure,
             "Flavor x1 not found",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
     def test_execute_resize_failure_instance_not_found(self):
         # Resize fails but instance doesn't exist (idempotent)
@@ -128,7 +140,7 @@ class TestResize(base.TestCase):
         self.assertRaisesRegex(
             exception.InstanceNotFound,
             f"The instance '{self.INSTANCE_UUID}' could not be found",
-            self.action.execute
+            self.action.execute,
         )
 
         # Should check instance existence
diff --git a/watcher/tests/unit/applier/actions/test_sleep.py b/watcher/tests/unit/applier/actions/test_sleep.py
index 91f6c6f33..bcf5cef7c 100644
--- a/watcher/tests/unit/applier/actions/test_sleep.py
+++ b/watcher/tests/unit/applier/actions/test_sleep.py
@@ -33,15 +33,18 @@ class TestSleep(base.TestCase):
 
     def test_parameters_duration_empty(self):
         self.s.input_parameters = {self.s.DURATION: None}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.s.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.s.validate_parameters
+        )
 
     def test_parameters_wrong_parameter(self):
         self.s.input_parameters = {self.s.DURATION: "ef"}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.s.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.s.validate_parameters
+        )
 
     def test_parameters_add_field(self):
         self.s.input_parameters = {self.s.DURATION: 1.0, "not_required": "nop"}
-        self.assertRaises(jsonschema.ValidationError,
-                          self.s.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.s.validate_parameters
+        )
diff --git a/watcher/tests/unit/applier/actions/test_stop.py b/watcher/tests/unit/applier/actions/test_stop.py
index b09391126..ed636ae2e 100644
--- a/watcher/tests/unit/applier/actions/test_stop.py
+++ b/watcher/tests/unit/applier/actions/test_stop.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.common import utils as test_utils
 
 
 class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
-
     INSTANCE_UUID = "45a37aeb-95ab-4ddb-a305-7d9f62c2f5ba"
 
     def setUp(self):
@@ -33,15 +32,15 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
 
         self.m_helper = self.useFixture(
             fixtures.MockPatch(
-                "watcher.common.nova_helper.NovaHelper",
-                autospec=False)).mock.return_value
+                "watcher.common.nova_helper.NovaHelper", autospec=False
+            )
+        ).mock.return_value
 
         self.input_parameters = {
-            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
+            baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID
         }
         self.instance = self.create_openstacksdk_server(
-            id=self.INSTANCE_UUID,
-            status='ACTIVE'
+            id=self.INSTANCE_UUID, status='ACTIVE'
         )
         self.action = stop.Stop(mock.Mock())
         self.action.input_parameters = self.input_parameters
@@ -54,20 +53,23 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
     def test_parameters_exception_empty_resource_id(self):
         parameters = {baction.BaseAction.RESOURCE_ID: None}
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_exception_invalid_uuid_format(self):
         parameters = {baction.BaseAction.RESOURCE_ID: "invalid-uuid"}
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_parameters_exception_missing_resource_id(self):
         parameters = {}
         self.action.input_parameters = parameters
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action.validate_parameters
+        )
 
     def test_instance_uuid_property(self):
         self.assertEqual(self.INSTANCE_UUID, self.action.instance_uuid)
@@ -80,7 +82,8 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertRaisesRegex(
             exception.ActionSkipped,
             f"Instance {self.INSTANCE_UUID} not found",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
 
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
 
@@ -92,7 +95,8 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertRaisesRegex(
             exception.ActionSkipped,
             f"Instance {self.INSTANCE_UUID} is already stopped",
-            self.action.pre_condition)
+            self.action.pre_condition,
+        )
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
 
     def test_pre_condition_instance_active(self):
@@ -117,7 +121,8 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
 
         self.assertTrue(result)
         self.m_helper.stop_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
 
     def test_execute_stop_failure_instance_exists(self):
         # Instance exists but stop operation fails
@@ -129,14 +134,16 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
         # Should return False when stop fails and instance still exists
         self.assertFalse(result)
         self.m_helper.stop_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
         # Should check instance existence after stop failure
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
 
     def test_execute_stop_failure_instance_not_found(self):
         # Stop operation fails but instance doesn't exist (idempotent)
         self.m_helper.find_instance.side_effect = (
-            exception.ComputeResourceNotFound())
+            exception.ComputeResourceNotFound()
+        )
         self.m_helper.stop_instance.return_value = False
 
         result = self.action.execute()
@@ -144,7 +151,8 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
         # Return True when stop fails but instance doesn't exist (idempotent)
         self.assertTrue(result)
         self.m_helper.stop_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
         # Should check instance existence after stop failure
         self.m_helper.find_instance.assert_called_once_with(self.INSTANCE_UUID)
 
@@ -156,7 +164,8 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
         # Execute should return False when Nova API fails, not raise exception
         self.assertFalse(result)
         self.m_helper.stop_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
 
     def test_revert_success(self):
         self.m_helper.start_instance.return_value = True
@@ -166,20 +175,23 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertTrue(result)
         # revert method doesn't call find_instance - it directly tries to start
         self.m_helper.start_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
 
     def test_revert_instance_not_found(self):
         # The revert method doesn't check for instance existence,
         # it just tries to start and may fail gracefully
         self.m_helper.start_instance.side_effect = exception.InstanceNotFound(
-            name=self.INSTANCE_UUID)
+            name=self.INSTANCE_UUID
+        )
 
         result = self.action.revert()
 
         # Should return False when start fails due to instance not found
         self.assertFalse(result)
         self.m_helper.start_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
 
     def test_revert_start_failure(self):
         self.m_helper.start_instance.return_value = False
@@ -188,7 +200,8 @@ class TestStop(test_utils.NovaResourcesMixin, base.TestCase):
 
         self.assertFalse(result)
         self.m_helper.start_instance.assert_called_once_with(
-            instance_id=self.INSTANCE_UUID)
+            instance_id=self.INSTANCE_UUID
+        )
 
     def test_revert_nova_exception(self):
         self.m_helper.start_instance.side_effect = Exception("Start failed")
diff --git a/watcher/tests/unit/applier/actions/test_volume_migration.py b/watcher/tests/unit/applier/actions/test_volume_migration.py
index 99744785b..6aa07b7e3 100644
--- a/watcher/tests/unit/applier/actions/test_volume_migration.py
+++ b/watcher/tests/unit/applier/actions/test_volume_migration.py
@@ -29,7 +29,6 @@ from watcher.tests.unit import base
 
 
 class TestMigration(base.TestCase):
-
     VOLUME_UUID = "45a37aeb-95ab-4ddb-a305-7d9f62c2f5ba"
     INSTANCE_UUID = "45a37aec-85ab-4dda-a303-7d9f62c2f5bb"
 
@@ -53,15 +52,19 @@ class TestMigration(base.TestCase):
         self.m_k_helper_cls.return_value = self.m_k_helper
 
         m_openstack_clients = mock.patch.object(
-            clients, "OpenStackClients", self.m_osc_cls)
+            clients, "OpenStackClients", self.m_osc_cls
+        )
         m_nova_helper = mock.patch.object(
-            nova_helper, "NovaHelper", self.m_n_helper_cls)
+            nova_helper, "NovaHelper", self.m_n_helper_cls
+        )
 
         m_cinder_helper = mock.patch.object(
-            cinder_helper, "CinderHelper", self.m_c_helper_cls)
+            cinder_helper, "CinderHelper", self.m_c_helper_cls
+        )
 
         m_keystone_helper = mock.patch.object(
-            keystone_helper, "KeystoneHelper", self.m_k_helper_cls)
+            keystone_helper, "KeystoneHelper", self.m_k_helper_cls
+        )
 
         m_openstack_clients.start()
         m_nova_helper.start()
@@ -114,8 +117,9 @@ class TestMigration(base.TestCase):
         volume.availability_zone = kwargs.get('availability_zone', 'nova')
         volume.attachments = kwargs.get('attachments', [])
         volume.volume_type = kwargs.get('volume_type', 'default-type')
-        setattr(volume, 'os-vol-host-attr:host',
-                kwargs.get('host', 'current-host'))
+        setattr(
+            volume, 'os-vol-host-attr:host', kwargs.get('host', 'current-host')
+        )
         return volume
 
     @staticmethod
@@ -126,40 +130,46 @@ class TestMigration(base.TestCase):
         return instance
 
     def test_parameters_swap(self):
-        params = {baction.BaseAction.RESOURCE_ID:
-                  self.VOLUME_UUID,
-                  self.action.MIGRATION_TYPE: 'swap',
-                  self.action.DESTINATION_NODE: None,
-                  self.action.DESTINATION_TYPE: 'type-1'}
+        params = {
+            baction.BaseAction.RESOURCE_ID: self.VOLUME_UUID,
+            self.action.MIGRATION_TYPE: 'swap',
+            self.action.DESTINATION_NODE: None,
+            self.action.DESTINATION_TYPE: 'type-1',
+        }
         self.action_swap.input_parameters = params
         self.assertTrue(self.action_swap.validate_parameters)
 
     def test_parameters_migrate(self):
-        params = {baction.BaseAction.RESOURCE_ID:
-                  self.VOLUME_UUID,
-                  self.action.MIGRATION_TYPE: 'migrate',
-                  self.action.DESTINATION_NODE: 'node-1',
-                  self.action.DESTINATION_TYPE: None}
+        params = {
+            baction.BaseAction.RESOURCE_ID: self.VOLUME_UUID,
+            self.action.MIGRATION_TYPE: 'migrate',
+            self.action.DESTINATION_NODE: 'node-1',
+            self.action.DESTINATION_TYPE: None,
+        }
         self.action_migrate.input_parameters = params
         self.assertTrue(self.action_migrate.validate_parameters)
 
     def test_parameters_retype(self):
-        params = {baction.BaseAction.RESOURCE_ID:
-                  self.VOLUME_UUID,
-                  self.action.MIGRATION_TYPE: 'retype',
-                  self.action.DESTINATION_NODE: None,
-                  self.action.DESTINATION_TYPE: 'type-1'}
+        params = {
+            baction.BaseAction.RESOURCE_ID: self.VOLUME_UUID,
+            self.action.MIGRATION_TYPE: 'retype',
+            self.action.DESTINATION_NODE: None,
+            self.action.DESTINATION_TYPE: 'type-1',
+        }
         self.action_retype.input_parameters = params
         self.assertTrue(self.action_retype.validate_parameters)
 
     def test_parameters_exception_resource_id(self):
-        params = {baction.BaseAction.RESOURCE_ID: "EFEF",
-                  self.action.MIGRATION_TYPE: 'swap',
-                  self.action.DESTINATION_NODE: None,
-                  self.action.DESTINATION_TYPE: 'type-1'}
+        params = {
+            baction.BaseAction.RESOURCE_ID: "EFEF",
+            self.action.MIGRATION_TYPE: 'swap',
+            self.action.DESTINATION_NODE: None,
+            self.action.DESTINATION_TYPE: 'type-1',
+        }
         self.action_swap.input_parameters = params
-        self.assertRaises(jsonschema.ValidationError,
-                          self.action_swap.validate_parameters)
+        self.assertRaises(
+            jsonschema.ValidationError, self.action_swap.validate_parameters
+        )
 
     def test_migrate_success(self):
         volume = self.fake_volume()
@@ -168,8 +178,7 @@ class TestMigration(base.TestCase):
         result = self.action_migrate.execute()
         self.assertTrue(result)
         self.m_c_helper.migrate.assert_called_once_with(
-            volume,
-            "storage1-poolname"
+            volume, "storage1-poolname"
         )
 
     def test_retype_success(self):
@@ -179,14 +188,14 @@ class TestMigration(base.TestCase):
         result = self.action_retype.execute()
         self.assertTrue(result)
         self.m_c_helper.retype.assert_called_once_with(
-            volume,
-            "storage1-typename",
+            volume, "storage1-typename"
         )
 
     def test_can_swap_success(self):
         volume = self.fake_volume(
-            status='in-use', attachments=[
-                {'server_id': TestMigration.INSTANCE_UUID}])
+            status='in-use',
+            attachments=[{'server_id': TestMigration.INSTANCE_UUID}],
+        )
 
         instance = self.fake_instance()
         self.m_n_helper.find_instance.return_value = instance
@@ -200,10 +209,10 @@ class TestMigration(base.TestCase):
         self.assertTrue(result)
 
     def test_can_swap_fail(self):
-
         volume = self.fake_volume(
-            status='in-use', attachments=[
-                {'server_id': TestMigration.INSTANCE_UUID}])
+            status='in-use',
+            attachments=[{'server_id': TestMigration.INSTANCE_UUID}],
+        )
         instance = self.fake_instance(status='STOPPED')
         self.m_n_helper.find_instance.return_value = instance
         result = self.action_swap._can_swap(volume)
@@ -216,17 +225,20 @@ class TestMigration(base.TestCase):
 
     def test_can_swap_instance_not_found(self):
         volume = self.fake_volume(
-            status='in-use', attachments=[
-                {'server_id': TestMigration.INSTANCE_UUID}])
+            status='in-use',
+            attachments=[{'server_id': TestMigration.INSTANCE_UUID}],
+        )
         self.m_n_helper.find_instance.side_effect = (
-            exception.ComputeResourceNotFound(TestMigration.INSTANCE_UUID))
+            exception.ComputeResourceNotFound(TestMigration.INSTANCE_UUID)
+        )
         result = self.action_swap._can_swap(volume)
         self.assertFalse(result)
 
     def test_swap_success(self):
         volume = self.fake_volume(
-            status='in-use', attachments=[
-                {'server_id': TestMigration.INSTANCE_UUID}])
+            status='in-use',
+            attachments=[{'server_id': TestMigration.INSTANCE_UUID}],
+        )
         self.m_c_helper.get_volume.return_value = volume
 
         instance = self.fake_instance()
@@ -235,19 +247,20 @@ class TestMigration(base.TestCase):
         result = self.action_swap.execute()
         self.assertTrue(result)
         self.m_c_helper.migrate.assert_called_once_with(
-            volume,
-            "storage1-poolname"
+            volume, "storage1-poolname"
         )
 
     def test_pre_condition_volume_not_found(self):
-        self.m_c_helper.get_volume.side_effect = (
-            cinder_exception.NotFound('404'))
+        self.m_c_helper.get_volume.side_effect = cinder_exception.NotFound(
+            '404'
+        )
 
         # ActionSkipped is expected because the volume is not found
         self.assertRaisesRegex(
             exception.ActionSkipped,
             f"Volume {self.VOLUME_UUID} not found",
-            self.action_migrate.pre_condition)
+            self.action_migrate.pre_condition,
+        )
 
     def test_pre_condition_destination_type_not_found(self):
         volume = self.fake_volume()
@@ -259,14 +272,17 @@ class TestMigration(base.TestCase):
         fake_type_2 = mock.MagicMock()
         fake_type_2.name = "type-2"
         self.m_c_helper.get_volume_type_list.return_value = [
-            fake_type_1, fake_type_2]
+            fake_type_1,
+            fake_type_2,
+        ]
 
         # ActionExecutionFailure is expected because the destination type
         # is not found
         self.assertRaisesRegex(
             exception.ActionExecutionFailure,
             "Volume type storage1-typename not found",
-            self.action_retype.pre_condition)
+            self.action_retype.pre_condition,
+        )
 
     def test_pre_condition_destination_pool_not_found(self):
         volume = self.fake_volume()
@@ -274,14 +290,16 @@ class TestMigration(base.TestCase):
 
         # Mock get_storage_pool_by_name to raise PoolNotFound
         self.m_c_helper.get_storage_pool_by_name.side_effect = (
-            exception.PoolNotFound(name="storage1-poolname"))
+            exception.PoolNotFound(name="storage1-poolname")
+        )
 
         # ActionExecutionFailure is expected because the destination pool
         # is not found
         self.assertRaisesRegex(
             exception.ActionExecutionFailure,
             "Pool storage1-poolname not found",
-            self.action_migrate.pre_condition)
+            self.action_migrate.pre_condition,
+        )
 
     def test_pre_condition_success_with_type(self):
         volume = self.fake_volume()
@@ -293,7 +311,9 @@ class TestMigration(base.TestCase):
         fake_type_2 = mock.MagicMock()
         fake_type_2.name = "type-2"
         self.m_c_helper.get_volume_type_list.return_value = [
-            fake_type_1, fake_type_2]
+            fake_type_1,
+            fake_type_2,
+        ]
 
         # Should not raise any exception
         self.action_retype.pre_condition()
@@ -313,7 +333,8 @@ class TestMigration(base.TestCase):
         self.action_migrate.pre_condition()
         self.m_c_helper.get_volume.assert_called_once_with(self.VOLUME_UUID)
         self.m_c_helper.get_storage_pool_by_name.assert_called_once_with(
-            "storage1-poolname")
+            "storage1-poolname"
+        )
 
     def test_pre_condition_retype_same_type(self):
         # Create volume with the same type as destination
@@ -329,7 +350,8 @@ class TestMigration(base.TestCase):
         self.assertRaisesRegex(
             exception.ActionSkipped,
             "Volume type is already storage1-typename",
-            self.action_retype.pre_condition)
+            self.action_retype.pre_condition,
+        )
 
     def test_pre_condition_migrate_same_node(self):
         # Create volume on the same node as destination
@@ -345,4 +367,5 @@ class TestMigration(base.TestCase):
         self.assertRaisesRegex(
             exception.ActionSkipped,
             "Volume is already on node storage1-poolname",
-            self.action_migrate.pre_condition)
+            self.action_migrate.pre_condition,
+        )
diff --git a/watcher/tests/unit/applier/messaging/test_trigger_action_plan_endpoint.py b/watcher/tests/unit/applier/messaging/test_trigger_action_plan_endpoint.py
index d9ca81f4a..33020df5e 100644
--- a/watcher/tests/unit/applier/messaging/test_trigger_action_plan_endpoint.py
+++ b/watcher/tests/unit/applier/messaging/test_trigger_action_plan_endpoint.py
@@ -44,12 +44,14 @@ class TestTriggerActionPlan(base.TestCase):
             context=self.context,
             uuid=action_plan_uuid,
             hostname=None,
-            state=objects.action_plan.State.PENDING)
+            state=objects.action_plan.State.PENDING,
+        )
         mock_get_by_uuid.return_value = action_plan
         CONF.set_default('host', 'applier1.example.com')
 
-        expected_uuid = self.endpoint.launch_action_plan(self.context,
-                                                         action_plan_uuid)
+        expected_uuid = self.endpoint.launch_action_plan(
+            self.context, action_plan_uuid
+        )
         self.assertEqual(expected_uuid, action_plan_uuid)
         self.assertEqual(action_plan.hostname, "applier1.example.com")
         mock_save.assert_called_once_with(action_plan)
diff --git a/watcher/tests/unit/applier/test_applier_manager.py b/watcher/tests/unit/applier/test_applier_manager.py
index 0ac3a8947..1bb45a60f 100644
--- a/watcher/tests/unit/applier/test_applier_manager.py
+++ b/watcher/tests/unit/applier/test_applier_manager.py
@@ -28,8 +28,7 @@ from watcher.tests.unit import base
 class TestApplierManager(base.TestCase):
     def setUp(self):
         super().setUp()
-        p_heartbeat = mock.patch.object(
-            service.ServiceHeartbeat, "send_beat")
+        p_heartbeat = mock.patch.object(service.ServiceHeartbeat, "send_beat")
         self.m_heartbeat = p_heartbeat.start()
         self.addCleanup(p_heartbeat.stop)
         self.applier = service.Service(applier_manager.ApplierManager)
diff --git a/watcher/tests/unit/applier/test_rpcapi.py b/watcher/tests/unit/applier/test_rpcapi.py
index 010638f22..a5741a9c2 100644
--- a/watcher/tests/unit/applier/test_rpcapi.py
+++ b/watcher/tests/unit/applier/test_rpcapi.py
@@ -27,7 +27,6 @@ from watcher.tests.unit import base
 
 
 class TestApplierAPI(base.TestCase):
-
     api = rpcapi.ApplierAPI()
 
     def test_get_api_version(self):
@@ -37,7 +36,8 @@ class TestApplierAPI(base.TestCase):
             mock_call.assert_called_once_with(
                 expected_context,
                 'check_api_version',
-                api_version=rpcapi.ApplierAPI().API_VERSION)
+                api_version=rpcapi.ApplierAPI().API_VERSION,
+            )
 
     def test_execute_action_plan_without_error(self):
         with mock.patch.object(om.RPCClient, 'cast') as mock_cast:
@@ -46,10 +46,13 @@ class TestApplierAPI(base.TestCase):
             mock_cast.assert_called_once_with(
                 self.context,
                 'launch_action_plan',
-                action_plan_uuid=action_plan_uuid)
+                action_plan_uuid=action_plan_uuid,
+            )
 
     def test_execute_action_plan_throw_exception(self):
         action_plan_uuid = "uuid"
-        self.assertRaises(exception.InvalidUuidOrName,
-                          self.api.launch_action_plan,
-                          action_plan_uuid)
+        self.assertRaises(
+            exception.InvalidUuidOrName,
+            self.api.launch_action_plan,
+            action_plan_uuid,
+        )
diff --git a/watcher/tests/unit/applier/test_service.py b/watcher/tests/unit/applier/test_service.py
index 0db539288..d28aded4c 100644
--- a/watcher/tests/unit/applier/test_service.py
+++ b/watcher/tests/unit/applier/test_service.py
@@ -20,29 +20,32 @@ from watcher.common import service as watcher_service
 from watcher.tests.unit import base
 
 
-@mock.patch.object(service_monitor.ApplierMonitor, '__init__',
-                   return_value=None)
+@mock.patch.object(
+    service_monitor.ApplierMonitor, '__init__', return_value=None
+)
 @mock.patch.object(watcher_service.Service, '__init__', return_value=None)
 class TestApplierService(base.TestCase):
-
     @mock.patch.object(service_monitor.ApplierMonitor, 'start')
     @mock.patch.object(watcher_service.Service, 'start')
-    def test_applier_service_start(self, svc_start, svc_mon_start,
-                                   svc_init, svc_mon_init):
+    def test_applier_service_start(
+        self, svc_start, svc_mon_start, svc_init, svc_mon_init
+    ):
         ap_service = service.ApplierService()
         ap_service.start()
 
         # Creates a DecisionEngineMonitor instance
-        self.assertIsInstance(ap_service.service_monitor,
-                              service_monitor.ApplierMonitor)
+        self.assertIsInstance(
+            ap_service.service_monitor, service_monitor.ApplierMonitor
+        )
 
         svc_start.assert_called()
         svc_mon_start.assert_called()
 
     @mock.patch.object(service_monitor.ApplierMonitor, 'stop')
     @mock.patch.object(watcher_service.Service, 'stop')
-    def test_applier_service_stop(self, svc_stop, svc_mon_stop,
-                                  svc_init, svc_mon_init):
+    def test_applier_service_stop(
+        self, svc_stop, svc_mon_stop, svc_init, svc_mon_init
+    ):
         ap_service = service.ApplierService()
         ap_service.stop()
 
@@ -51,8 +54,9 @@ class TestApplierService(base.TestCase):
 
     @mock.patch.object(service_monitor.ApplierMonitor, 'wait')
     @mock.patch.object(watcher_service.Service, 'wait')
-    def test_applier_service_wait(self, svc_wait, svc_mon_wait,
-                                  svc_init, svc_mon_init):
+    def test_applier_service_wait(
+        self, svc_wait, svc_mon_wait, svc_init, svc_mon_init
+    ):
         ap_service = service.ApplierService()
         ap_service.wait()
 
@@ -61,8 +65,9 @@ class TestApplierService(base.TestCase):
 
     @mock.patch.object(service_monitor.ApplierMonitor, 'reset')
     @mock.patch.object(watcher_service.Service, 'reset')
-    def test_applier_service_reset(self, svc_reset, svc_mon_reset,
-                                   svc_init, svc_mon_init):
+    def test_applier_service_reset(
+        self, svc_reset, svc_mon_reset, svc_init, svc_mon_init
+    ):
         ap_service = service.ApplierService()
         ap_service.reset()
 
diff --git a/watcher/tests/unit/applier/test_service_monitor.py b/watcher/tests/unit/applier/test_service_monitor.py
index a3584516a..73c87e7f8 100644
--- a/watcher/tests/unit/applier/test_service_monitor.py
+++ b/watcher/tests/unit/applier/test_service_monitor.py
@@ -34,7 +34,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestApplierMonitor(base.TestCase):
-
     @mock.patch.object(background.BackgroundScheduler, 'start', autospec=True)
     def test_start_service_monitoring_service(self, m_start):
         monitor = service_monitor.ApplierMonitor()
@@ -43,8 +42,9 @@ class TestApplierMonitor(base.TestCase):
         jobs = monitor.get_jobs()
         self.assertEqual(1, len(jobs))
 
-    @mock.patch.object(background.BackgroundScheduler, 'shutdown',
-                       autospec=True)
+    @mock.patch.object(
+        background.BackgroundScheduler, 'shutdown', autospec=True
+    )
     def test_stop_service_monitoring_service(self, m_shutdown):
         monitor = service_monitor.ApplierMonitor()
         monitor.stop()
@@ -62,39 +62,45 @@ class TestApplierMonitor(base.TestCase):
 
 
 class TestApplierMonitorFunctions(db_base.DbTestCase):
-
     def setUp(self):
         super().setUp()
-        fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow())
+        fake_service = utils.get_test_service(created_at=timeutils.utcnow())
         self.fake_service = objects.Service(**fake_service)
 
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       'get_service_status', autospec=True)
+    @mock.patch.object(
+        service_monitor.ApplierMonitor, 'get_service_status', autospec=True
+    )
     @mock.patch.object(objects.Service, 'list', autospec=True)
     @mock.patch.object(service, 'send_service_update')
     @mock.patch.object(objects.ActionPlan, 'list', autospec=True)
-    def test_monitor_not_send_notification_on_active(self, m_actionplan_list,
-                                                     m_send_notif,
-                                                     m_service_list,
-                                                     m_get_service_status):
+    def test_monitor_not_send_notification_on_active(
+        self,
+        m_actionplan_list,
+        m_send_notif,
+        m_service_list,
+        m_get_service_status,
+    ):
         # Create two applier services
         fake_ap_service1 = utils.get_test_service(
-            id=1, name='watcher-applier', host='host1')
+            id=1, name='watcher-applier', host='host1'
+        )
         fake_ap_service2 = utils.get_test_service(
-            id=2, name='watcher-applier', host='host2')
+            id=2, name='watcher-applier', host='host2'
+        )
         fake_ap_service_obj1 = objects.Service(**fake_ap_service1)
         fake_ap_service_obj2 = objects.Service(**fake_ap_service2)
 
         m_service_list.return_value = [
-            fake_ap_service_obj1, fake_ap_service_obj2]
+            fake_ap_service_obj1,
+            fake_ap_service_obj2,
+        ]
 
         # First call: both ACTIVE in first and second call
         m_get_service_status.side_effect = [
             objects.service.ServiceStatus.ACTIVE,  # service1 first call
             objects.service.ServiceStatus.ACTIVE,  # service2 first call
             objects.service.ServiceStatus.ACTIVE,  # service1 second call
-            objects.service.ServiceStatus.ACTIVE   # service2 second call
+            objects.service.ServiceStatus.ACTIVE,  # service2 second call
         ]
 
         monitor = service_monitor.ApplierMonitor()
@@ -103,44 +109,61 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         self.flags(host='host1')
         # First call: both ACTIVE
         monitor.monitor_services_status(self.context)
-        self.assertEqual(monitor.services_status, {
-            fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-            fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-        })
+        self.assertEqual(
+            monitor.services_status,
+            {
+                fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
+                fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
+            },
+        )
         # Second call: both ACTIVE
         monitor.monitor_services_status(self.context)
-        self.assertEqual(monitor.services_status, {
-            fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-            fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-        })
+        self.assertEqual(
+            monitor.services_status,
+            {
+                fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
+                fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
+            },
+        )
 
         m_send_notif.assert_not_called()
         m_actionplan_list.assert_not_called()
 
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       'get_service_status', autospec=True)
+    @mock.patch.object(
+        service_monitor.ApplierMonitor, 'get_service_status', autospec=True
+    )
     @mock.patch.object(objects.Service, 'list', autospec=True)
     @mock.patch.object(service, 'send_service_update', autospec=True)
     @mock.patch.object(
-        sync.Syncer,
-        '_cancel_ongoing_actionplans', autospec=True)
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       '_retrigger_pending_actionplans', autospec=True)
-    def test_monitor_failover_on_failure(self, m_retrigger,
-                                         m_sync_cancel,
-                                         m_send_notif,
-                                         m_service_list,
-                                         m_get_service_status):
+        sync.Syncer, '_cancel_ongoing_actionplans', autospec=True
+    )
+    @mock.patch.object(
+        service_monitor.ApplierMonitor,
+        '_retrigger_pending_actionplans',
+        autospec=True,
+    )
+    def test_monitor_failover_on_failure(
+        self,
+        m_retrigger,
+        m_sync_cancel,
+        m_send_notif,
+        m_service_list,
+        m_get_service_status,
+    ):
         # Create two applier services
         fake_ap_service1 = utils.get_test_service(
-            id=1, name='watcher-applier', host='host1')
+            id=1, name='watcher-applier', host='host1'
+        )
         fake_ap_service2 = utils.get_test_service(
-            id=2, name='watcher-applier', host='host2')
+            id=2, name='watcher-applier', host='host2'
+        )
         fake_ap_service_obj1 = objects.Service(**fake_ap_service1)
         fake_ap_service_obj2 = objects.Service(**fake_ap_service2)
 
         m_service_list.return_value = [
-            fake_ap_service_obj1, fake_ap_service_obj2]
+            fake_ap_service_obj1,
+            fake_ap_service_obj2,
+        ]
 
         # First call: both ACTIVE
         # Second call: service1 FAILED, service2 ACTIVE
@@ -148,7 +171,7 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
             objects.service.ServiceStatus.ACTIVE,  # service1 first call
             objects.service.ServiceStatus.ACTIVE,  # service2 first call
             objects.service.ServiceStatus.FAILED,  # service1 second call
-            objects.service.ServiceStatus.ACTIVE   # service2 second call
+            objects.service.ServiceStatus.ACTIVE,  # service2 second call
         ]
 
         monitor = service_monitor.ApplierMonitor()
@@ -158,20 +181,28 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         self.flags(host='host2')
         # First call: both ACTIVE
         monitor.monitor_services_status(self.context)
-        self.assertEqual(monitor.services_status, {
-            fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-            fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-        })
+        self.assertEqual(
+            monitor.services_status,
+            {
+                fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
+                fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
+            },
+        )
         # Second call: service1 FAILED, service2 ACTIVE
         monitor.monitor_services_status(self.context)
-        self.assertEqual(monitor.services_status, {
-            fake_ap_service_obj1.id: objects.service.ServiceStatus.FAILED,
-            fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-        })
+        self.assertEqual(
+            monitor.services_status,
+            {
+                fake_ap_service_obj1.id: objects.service.ServiceStatus.FAILED,
+                fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
+            },
+        )
 
         m_send_notif.assert_called_once_with(
-            self.context, fake_ap_service_obj1,
-            state=objects.service.ServiceStatus.FAILED)
+            self.context,
+            fake_ap_service_obj1,
+            state=objects.service.ServiceStatus.FAILED,
+        )
         # Verify ongoing action plan cancel is triggered for the failed
         # service
         m_sync_cancel.assert_called_once_with(mock.ANY, self.context, 'host1')
@@ -179,33 +210,46 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         # service
         m_retrigger.assert_called_once_with(monitor, self.context, 'host1')
 
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       'get_service_status', autospec=True)
+    @mock.patch.object(
+        service_monitor.ApplierMonitor, 'get_service_status', autospec=True
+    )
     @mock.patch.object(objects.Service, 'list', autospec=True)
     @mock.patch.object(service, 'send_service_update', autospec=True)
     @mock.patch.object(
-        sync.Syncer,
-        '_cancel_ongoing_actionplans', autospec=True)
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       '_retrigger_pending_actionplans', autospec=True)
-    def test_nonleader_monitor_skips_on_failure(self, m_retrigger,
-                                                m_sync_cancel,
-                                                m_send_notif,
-                                                m_service_list,
-                                                m_get_service_status):
+        sync.Syncer, '_cancel_ongoing_actionplans', autospec=True
+    )
+    @mock.patch.object(
+        service_monitor.ApplierMonitor,
+        '_retrigger_pending_actionplans',
+        autospec=True,
+    )
+    def test_nonleader_monitor_skips_on_failure(
+        self,
+        m_retrigger,
+        m_sync_cancel,
+        m_send_notif,
+        m_service_list,
+        m_get_service_status,
+    ):
         # Create two applier services
         fake_ap_service1 = utils.get_test_service(
-            id=1, name='watcher-applier', host='host1')
+            id=1, name='watcher-applier', host='host1'
+        )
         fake_ap_service2 = utils.get_test_service(
-            id=2, name='watcher-applier', host='host2')
+            id=2, name='watcher-applier', host='host2'
+        )
         fake_ap_service3 = utils.get_test_service(
-            id=3, name='watcher-applier', host='host3')
+            id=3, name='watcher-applier', host='host3'
+        )
         fake_ap_service_obj1 = objects.Service(**fake_ap_service1)
         fake_ap_service_obj2 = objects.Service(**fake_ap_service2)
         fake_ap_service_obj3 = objects.Service(**fake_ap_service3)
 
         m_service_list.return_value = [
-            fake_ap_service_obj1, fake_ap_service_obj2, fake_ap_service_obj3]
+            fake_ap_service_obj1,
+            fake_ap_service_obj2,
+            fake_ap_service_obj3,
+        ]
 
         # First call: both ACTIVE
         # Second call: service1 FAILED, service2 ACTIVE
@@ -225,18 +269,24 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         self.flags(host='host3')
         # First call: both ACTIVE
         monitor.monitor_services_status(self.context)
-        self.assertEqual(monitor.services_status, {
-            fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-            fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
-            fake_ap_service_obj3.id: objects.service.ServiceStatus.ACTIVE
-        })
+        self.assertEqual(
+            monitor.services_status,
+            {
+                fake_ap_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
+                fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
+                fake_ap_service_obj3.id: objects.service.ServiceStatus.ACTIVE,
+            },
+        )
         # Second call: service1 FAILED, service2 ACTIVE
         monitor.monitor_services_status(self.context)
-        self.assertEqual(monitor.services_status, {
-            fake_ap_service_obj1.id: objects.service.ServiceStatus.FAILED,
-            fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
-            fake_ap_service_obj3.id: objects.service.ServiceStatus.ACTIVE
-        })
+        self.assertEqual(
+            monitor.services_status,
+            {
+                fake_ap_service_obj1.id: objects.service.ServiceStatus.FAILED,
+                fake_ap_service_obj2.id: objects.service.ServiceStatus.ACTIVE,
+                fake_ap_service_obj3.id: objects.service.ServiceStatus.ACTIVE,
+            },
+        )
 
         # Only the leader should send notifications
         m_send_notif.assert_not_called()
@@ -248,14 +298,13 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
     @freezegun.freeze_time("2016-10-18T09:52:05.219414")
     def test_get_service_status_up(self):
         fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow(),
-            last_seen_up=timeutils.utcnow())
+            created_at=timeutils.utcnow(), last_seen_up=timeutils.utcnow()
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.ApplierMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.ACTIVE, status)
 
@@ -263,14 +312,13 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
     def test_get_service_status_down(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            last_seen_up=past)
+            created_at=past, last_seen_up=past
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.ApplierMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -278,15 +326,13 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
     def test_get_service_status_down_last_seen_up_none(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            updated_at=past,
-            last_seen_up=None)
+            created_at=past, updated_at=past, last_seen_up=None
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.ApplierMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -294,15 +340,13 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
     def test_get_service_status_down_updated_at_none(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            updated_at=None,
-            last_seen_up=None)
+            created_at=past, updated_at=None, last_seen_up=None
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.ApplierMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -311,13 +355,13 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         """Test that string timestamps are properly converted."""
         fake_service = utils.get_test_service(
             created_at=timeutils.utcnow(),
-            last_seen_up="2016-10-18T09:52:05.219414")
+            last_seen_up="2016-10-18T09:52:05.219414",
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.ApplierMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.ACTIVE, status)
 
@@ -331,48 +375,51 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         # Add a service status
         monitor.services_status[1] = objects.service.ServiceStatus.ACTIVE
         self.assertEqual(
-            {1: objects.service.ServiceStatus.ACTIVE},
-            monitor.services_status
+            {1: objects.service.ServiceStatus.ACTIVE}, monitor.services_status
         )
 
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       'get_service_status')
+    @mock.patch.object(service_monitor.ApplierMonitor, 'get_service_status')
     @mock.patch.object(objects.Service, 'list')
     def test_get_services_status_without_services_in_list(
-            self, mock_get_list, mock_service_status):
+        self, mock_get_list, mock_service_status
+    ):
         scheduler = service_monitor.ApplierMonitor()
         mock_get_list.return_value = []
         services_status = scheduler.get_services_status(mock.ANY)
         self.assertEqual([], services_status)
         mock_service_status.assert_not_called()
 
-    @mock.patch.object(service_monitor.ApplierMonitor,
-                       'get_service_status')
+    @mock.patch.object(service_monitor.ApplierMonitor, 'get_service_status')
     @mock.patch.object(objects.Service, 'list')
     def test_get_services_status_with_services_in_list(
-            self, m_service_list, m_get_service_status):
+        self, m_service_list, m_get_service_status
+    ):
         """Test that get_services_status returns only the applier services."""
         # Create various services
         de_service1 = utils.get_test_service(
-            id=1, name='watcher-applier', host='host1')
+            id=1, name='watcher-applier', host='host1'
+        )
         de_service2 = utils.get_test_service(
-            id=2, name='watcher-applier', host='host2')
+            id=2, name='watcher-applier', host='host2'
+        )
         api_service = utils.get_test_service(
-            id=3, name='watcher-api', host='host3')
+            id=3, name='watcher-api', host='host3'
+        )
         applier_service = utils.get_test_service(
-            id=4, name='watcher-decision-engine', host='host4')
+            id=4, name='watcher-decision-engine', host='host4'
+        )
 
         m_service_list.return_value = [
             objects.Service(**de_service1),
             objects.Service(**de_service2),
             objects.Service(**api_service),
-            objects.Service(**applier_service)
+            objects.Service(**applier_service),
         ]
         m_get_service_status.side_effect = [
             objects.service.ServiceStatus.ACTIVE,
             objects.service.ServiceStatus.FAILED,
             objects.service.ServiceStatus.ACTIVE,
-            objects.service.ServiceStatus.ACTIVE
+            objects.service.ServiceStatus.ACTIVE,
         ]
 
         monitor = service_monitor.ApplierMonitor()
@@ -385,19 +432,20 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
                 case 'host1':
                     self.assertEqual('watcher-applier', wservice.name)
                     self.assertEqual(
-                        objects.service.ServiceStatus.ACTIVE, wservice.state)
+                        objects.service.ServiceStatus.ACTIVE, wservice.state
+                    )
                 case 'host2':
                     self.assertEqual('watcher-applier', wservice.name)
                     self.assertEqual(
-                        objects.service.ServiceStatus.FAILED, wservice.state)
+                        objects.service.ServiceStatus.FAILED, wservice.state
+                    )
                 case _:
                     self.fail(f'Unexpected host: {wservice.host}')
 
     def test_am_i_leader_with_single_active_service(self):
         """Test leader election with single active service."""
         # Create service objects with state attribute
-        service1 = objects.Service(
-            id=1, name='watcher-applier', host='host1')
+        service1 = objects.Service(id=1, name='watcher-applier', host='host1')
         service1.state = objects.service.ServiceStatus.ACTIVE
 
         monitor = service_monitor.ApplierMonitor()
@@ -416,14 +464,11 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
         """Test leader election with multiple active services."""
         # Create service objects with state attribute
         # sorted order: host1, host2, host3
-        service1 = objects.Service(
-            id=1, name='watcher-applier', host='host2')
+        service1 = objects.Service(id=1, name='watcher-applier', host='host2')
         service1.state = objects.service.ServiceStatus.ACTIVE
-        service2 = objects.Service(
-            id=2, name='watcher-applier', host='host1')
+        service2 = objects.Service(id=2, name='watcher-applier', host='host1')
         service2.state = objects.service.ServiceStatus.ACTIVE
-        service3 = objects.Service(
-            id=3, name='watcher-applier', host='host3')
+        service3 = objects.Service(id=3, name='watcher-applier', host='host3')
         service3.state = objects.service.ServiceStatus.ACTIVE
 
         monitor = service_monitor.ApplierMonitor()
@@ -444,11 +489,9 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
     def test_am_i_leader_with_failed_services(self):
         """Test leader election ignores failed services."""
         # Create service objects with mixed states
-        service1 = objects.Service(
-            id=1, name='watcher-applier', host='host1')
+        service1 = objects.Service(id=1, name='watcher-applier', host='host1')
         service1.state = objects.service.ServiceStatus.FAILED
-        service2 = objects.Service(
-            id=2, name='watcher-applier', host='host2')
+        service2 = objects.Service(id=2, name='watcher-applier', host='host2')
         service2.state = objects.service.ServiceStatus.ACTIVE
 
         monitor = service_monitor.ApplierMonitor()
@@ -465,11 +508,9 @@ class TestApplierMonitorFunctions(db_base.DbTestCase):
     def test_am_i_leader_with_no_active_services(self):
         """Test leader election when no services are active."""
         # Create service objects with all failed states
-        service1 = objects.Service(
-            id=1, name='watcher-applier', host='host1')
+        service1 = objects.Service(id=1, name='watcher-applier', host='host1')
         service1.state = objects.service.ServiceStatus.FAILED
-        service2 = objects.Service(
-            id=2, name='watcher-applier', host='host2')
+        service2 = objects.Service(id=2, name='watcher-applier', host='host2')
         service2.state = objects.service.ServiceStatus.FAILED
 
         monitor = service_monitor.ApplierMonitor()
diff --git a/watcher/tests/unit/applier/test_sync.py b/watcher/tests/unit/applier/test_sync.py
index fc5a89e1d..6a58c9b87 100644
--- a/watcher/tests/unit/applier/test_sync.py
+++ b/watcher/tests/unit/applier/test_sync.py
@@ -29,21 +29,25 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestCancelOngoingActionPlans(db_base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_audit_notifications = mock.patch.object(
-            notifications, 'audit', autospec=True)
+            notifications, 'audit', autospec=True
+        )
         self.m_audit_notifications = p_audit_notifications.start()
         self.addCleanup(p_audit_notifications.stop)
 
         self.goal = obj_utils.create_test_goal(
-            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name())
+            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name()
+        )
         self.strategy = obj_utils.create_test_strategy(
-            self.context, name=dummy_strategy.DummyStrategy.get_name(),
-            goal_id=self.goal.id)
+            self.context,
+            name=dummy_strategy.DummyStrategy.get_name(),
+            goal_id=self.goal.id,
+        )
         audit_template = obj_utils.create_test_audit_template(
-            self.context, strategy_id=self.strategy.id)
+            self.context, strategy_id=self.strategy.id
+        )
         self.audit = obj_utils.create_test_audit(
             self.context,
             id=999,
@@ -54,24 +58,26 @@ class TestCancelOngoingActionPlans(db_base.DbTestCase):
             audit_type=objects.audit.AuditType.ONESHOT.value,
             goal=self.goal,
             hostname='hostname1',
-            state=objects.audit.State.ONGOING)
+            state=objects.audit.State.ONGOING,
+        )
         self.actionplan = obj_utils.create_test_action_plan(
             self.context,
             state=objects.action_plan.State.ONGOING,
             audit_id=999,
-            hostname='hostname1')
+            hostname='hostname1',
+        )
         self.action = obj_utils.create_test_action(
-            self.context,
-            action_plan_id=1,
-            state=objects.action.State.PENDING)
+            self.context, action_plan_id=1, state=objects.action.State.PENDING
+        )
         cfg.CONF.set_override("host", "hostname1")
 
     @mock.patch.object(objects.action.Action, 'save')
     @mock.patch.object(objects.action_plan.ActionPlan, 'save')
     @mock.patch.object(objects.action.Action, 'list')
     @mock.patch.object(objects.action_plan.ActionPlan, 'list')
-    def test_cancel_ongoing_actionplans(self, m_plan_list, m_action_list,
-                                        m_plan_save, m_action_save):
+    def test_cancel_ongoing_actionplans(
+        self, m_plan_list, m_action_list, m_plan_save, m_action_save
+    ):
         m_plan_list.return_value = [self.actionplan]
         m_action_list.return_value = [self.action]
         cfg.CONF.set_override("host", "hostname1")
@@ -83,13 +89,16 @@ class TestCancelOngoingActionPlans(db_base.DbTestCase):
         m_plan_save.assert_called()
         m_action_save.assert_called()
         self.assertEqual(
-            self.actionplan.state, objects.action_plan.State.CANCELLED)
+            self.actionplan.state, objects.action_plan.State.CANCELLED
+        )
         self.assertEqual(
             self.actionplan.status_message,
             "Action plan was cancelled because Applier hostname1 was stopped "
-            "while the action plan was ongoing.")
+            "while the action plan was ongoing.",
+        )
         self.assertEqual(self.action.state, objects.action.State.CANCELLED)
         self.assertEqual(
             self.action.status_message,
             "Action was cancelled because Applier hostname1 was stopped "
-            "while the action plan was ongoing.")
+            "while the action plan was ongoing.",
+        )
diff --git a/watcher/tests/unit/applier/workflow_engine/test_default_workflow_engine.py b/watcher/tests/unit/applier/workflow_engine/test_default_workflow_engine.py
index 7d1191d47..3d6f029f1 100644
--- a/watcher/tests/unit/applier/workflow_engine/test_default_workflow_engine.py
+++ b/watcher/tests/unit/applier/workflow_engine/test_default_workflow_engine.py
@@ -61,7 +61,8 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         self.engine = tflow.DefaultWorkFlowEngine(
             config=mock.Mock(),
             context=self.context,
-            applier_manager=mock.MagicMock())
+            applier_manager=mock.MagicMock(),
+        )
         self.engine.config.max_workers = 2
 
     @mock.patch.object(objects.Strategy, "get_by_id")
@@ -76,8 +77,9 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         except Exception as exc:
             self.fail(exc)
 
-    def create_action(self, action_type, parameters, parents=None, uuid=None,
-                      state=None):
+    def create_action(
+        self, action_type, parameters, parents=None, uuid=None, state=None
+    ):
         action = {
             'uuid': uuid or utils.generate_uuid(),
             'action_plan_id': 0,
@@ -85,7 +87,6 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
             'input_parameters': parameters,
             'state': objects.action.State.PENDING,
             'parents': parents or [],
-
         }
         new_action = objects.Action(self.context, **action)
         with mock.patch.object(notifications.action, 'send_create'):
@@ -100,8 +101,9 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         for a in actions:
             self.check_action_state(a, expected_state)
 
-    def check_notifications_contains(self, notification_calls, action_state,
-                                     old_state=None):
+    def check_notifications_contains(
+        self, notification_calls, action_state, old_state=None
+    ):
         """Check that an action notification contains the expected info.
 
         notification_calls: list of notification calls arguments
@@ -136,13 +138,19 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(objects.ActionPlan, "get_by_id")
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
-    def test_execute_with_one_action(self, mock_send_update,
-                                     mock_execution_notification,
-                                     m_get_actionplan, m_get_strategy):
+    def test_execute_with_one_action(
+        self,
+        mock_send_update,
+        mock_execution_notification,
+        m_get_actionplan,
+        m_get_strategy,
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = [self.create_action("nop", {'message': 'test'})]
         try:
             self.engine.execute(actions)
@@ -155,18 +163,27 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(objects.ActionPlan, "get_by_id")
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
-    def test_execute_nop_sleep(self, mock_send_update,
-                               mock_execution_notification,
-                               m_get_actionplan, m_get_strategy):
+    def test_execute_nop_sleep(
+        self,
+        mock_send_update,
+        mock_execution_notification,
+        m_get_actionplan,
+        m_get_strategy,
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = []
         first_nop = self.create_action("nop", {'message': 'test'})
         second_nop = self.create_action("nop", {'message': 'second test'})
-        sleep = self.create_action("sleep", {'duration': 0.0},
-                                   parents=[first_nop.uuid, second_nop.uuid])
+        sleep = self.create_action(
+            "sleep",
+            {'duration': 0.0},
+            parents=[first_nop.uuid, second_nop.uuid],
+        )
         actions.extend([first_nop, second_nop, sleep])
 
         try:
@@ -180,68 +197,113 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(objects.ActionPlan, "get_by_id")
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
-    def test_execute_with_parents(self, mock_send_update,
-                                  mock_execution_notification,
-                                  m_get_actionplan, m_get_strategy):
+    def test_execute_with_parents(
+        self,
+        mock_send_update,
+        mock_execution_notification,
+        m_get_actionplan,
+        m_get_strategy,
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = []
         first_nop = self.create_action(
-            "nop", {'message': 'test'},
-            uuid='bc7eee5c-4fbe-4def-9744-b539be55aa19')
+            "nop",
+            {'message': 'test'},
+            uuid='bc7eee5c-4fbe-4def-9744-b539be55aa19',
+        )
         second_nop = self.create_action(
-            "nop", {'message': 'second test'},
-            uuid='0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23')
+            "nop",
+            {'message': 'second test'},
+            uuid='0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23',
+        )
         first_sleep = self.create_action(
-            "sleep", {'duration': 0.0}, parents=[first_nop.uuid,
-                                                 second_nop.uuid],
-            uuid='be436531-0da3-4dad-a9c0-ea1d2aff6496')
+            "sleep",
+            {'duration': 0.0},
+            parents=[first_nop.uuid, second_nop.uuid],
+            uuid='be436531-0da3-4dad-a9c0-ea1d2aff6496',
+        )
         second_sleep = self.create_action(
-            "sleep", {'duration': 0.0}, parents=[first_sleep.uuid],
-            uuid='9eb51e14-936d-4d12-a500-6ba0f5e0bb1c')
+            "sleep",
+            {'duration': 0.0},
+            parents=[first_sleep.uuid],
+            uuid='9eb51e14-936d-4d12-a500-6ba0f5e0bb1c',
+        )
         actions.extend([first_nop, second_nop, first_sleep, second_sleep])
 
         expected_nodes = [
-            {'uuid': 'bc7eee5c-4fbe-4def-9744-b539be55aa19',
-             'input_parameters': {'message': 'test'},
-             'action_plan_id': 0, 'state': 'PENDING', 'parents': [],
-             'action_type': 'nop', 'id': 1},
-            {'uuid': '0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23',
-             'input_parameters': {'message': 'second test'},
-             'action_plan_id': 0, 'state': 'PENDING', 'parents': [],
-             'action_type': 'nop', 'id': 2},
-            {'uuid': 'be436531-0da3-4dad-a9c0-ea1d2aff6496',
-             'input_parameters': {'duration': 0.0},
-             'action_plan_id': 0, 'state': 'PENDING',
-             'parents': ['bc7eee5c-4fbe-4def-9744-b539be55aa19',
-                         '0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23'],
-             'action_type': 'sleep', 'id': 3},
-            {'uuid': '9eb51e14-936d-4d12-a500-6ba0f5e0bb1c',
-             'input_parameters': {'duration': 0.0},
-             'action_plan_id': 0, 'state': 'PENDING',
-             'parents': ['be436531-0da3-4dad-a9c0-ea1d2aff6496'],
-             'action_type': 'sleep', 'id': 4}]
+            {
+                'uuid': 'bc7eee5c-4fbe-4def-9744-b539be55aa19',
+                'input_parameters': {'message': 'test'},
+                'action_plan_id': 0,
+                'state': 'PENDING',
+                'parents': [],
+                'action_type': 'nop',
+                'id': 1,
+            },
+            {
+                'uuid': '0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23',
+                'input_parameters': {'message': 'second test'},
+                'action_plan_id': 0,
+                'state': 'PENDING',
+                'parents': [],
+                'action_type': 'nop',
+                'id': 2,
+            },
+            {
+                'uuid': 'be436531-0da3-4dad-a9c0-ea1d2aff6496',
+                'input_parameters': {'duration': 0.0},
+                'action_plan_id': 0,
+                'state': 'PENDING',
+                'parents': [
+                    'bc7eee5c-4fbe-4def-9744-b539be55aa19',
+                    '0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23',
+                ],
+                'action_type': 'sleep',
+                'id': 3,
+            },
+            {
+                'uuid': '9eb51e14-936d-4d12-a500-6ba0f5e0bb1c',
+                'input_parameters': {'duration': 0.0},
+                'action_plan_id': 0,
+                'state': 'PENDING',
+                'parents': ['be436531-0da3-4dad-a9c0-ea1d2aff6496'],
+                'action_type': 'sleep',
+                'id': 4,
+            },
+        ]
 
         expected_edges = [
-            ('action_type:nop uuid:0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23',
-             'action_type:sleep uuid:be436531-0da3-4dad-a9c0-ea1d2aff6496'),
-            ('action_type:nop uuid:bc7eee5c-4fbe-4def-9744-b539be55aa19',
-             'action_type:sleep uuid:be436531-0da3-4dad-a9c0-ea1d2aff6496'),
-            ('action_type:sleep uuid:be436531-0da3-4dad-a9c0-ea1d2aff6496',
-             'action_type:sleep uuid:9eb51e14-936d-4d12-a500-6ba0f5e0bb1c')]
+            (
+                'action_type:nop uuid:0565bd5c-aa00-46e5-8d81-2cb5cc1ffa23',
+                'action_type:sleep uuid:be436531-0da3-4dad-a9c0-ea1d2aff6496',
+            ),
+            (
+                'action_type:nop uuid:bc7eee5c-4fbe-4def-9744-b539be55aa19',
+                'action_type:sleep uuid:be436531-0da3-4dad-a9c0-ea1d2aff6496',
+            ),
+            (
+                'action_type:sleep uuid:be436531-0da3-4dad-a9c0-ea1d2aff6496',
+                'action_type:sleep uuid:9eb51e14-936d-4d12-a500-6ba0f5e0bb1c',
+            ),
+        ]
 
         try:
             flow = self.engine.execute(actions)
-            actual_nodes = sorted([x[0]._db_action.as_dict()
-                                   for x in flow.iter_nodes()],
-                                  key=lambda x: x['id'])
+            actual_nodes = sorted(
+                [x[0]._db_action.as_dict() for x in flow.iter_nodes()],
+                key=lambda x: x['id'],
+            )
             for expected, actual in zip(expected_nodes, actual_nodes):
                 for key in expected.keys():
                     self.assertIn(expected[key], actual.values())
-            actual_edges = [(u.name, v.name)
-                            for (u, v, _) in flow.iter_links()]
+            actual_edges = [
+                (u.name, v.name) for (u, v, _) in flow.iter_links()
+            ]
 
             for edge in expected_edges:
                 self.assertIn(edge, actual_edges)
@@ -255,12 +317,15 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(objects.ActionPlan, "get_by_id")
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
-    def test_execute_with_two_actions(self, m_send_update, m_execution,
-                                      m_get_actionplan, m_get_strategy):
+    def test_execute_with_two_actions(
+        self, m_send_update, m_execution, m_get_actionplan, m_get_strategy
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = []
         second = self.create_action("sleep", {'duration': 0.0})
         first = self.create_action("nop", {'message': 'test'})
@@ -279,12 +344,15 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(objects.ActionPlan, "get_by_id")
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
-    def test_execute_with_three_actions(self, m_send_update, m_execution,
-                                        m_get_actionplan, m_get_strategy):
+    def test_execute_with_three_actions(
+        self, m_send_update, m_execution, m_get_actionplan, m_get_strategy
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = []
         third = self.create_action("nop", {'message': 'next'})
         second = self.create_action("sleep", {'duration': 0.0})
@@ -309,12 +377,15 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(objects.ActionPlan, "get_by_id")
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
-    def test_execute_with_exception(self, m_send_update, m_execution,
-                                    m_get_actionplan, m_get_strategy):
+    def test_execute_with_exception(
+        self, m_send_update, m_execution, m_get_actionplan, m_get_strategy
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = []
 
         third = self.create_action("no_exist", {'message': 'next'})
@@ -340,60 +411,84 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
     @mock.patch.object(factory.ActionFactory, "make_action")
-    def test_execute_with_action_failed(self, m_make_action, m_send_update,
-                                        m_send_execution, m_get_actionplan,
-                                        m_get_strategy):
+    def test_execute_with_action_failed(
+        self,
+        m_make_action,
+        m_send_update,
+        m_send_execution,
+        m_get_actionplan,
+        m_get_strategy,
+    ):
         m_get_actionplan.return_value = obj_utils.get_test_action_plan(
-            self.context, id=0)
+            self.context, id=0
+        )
         m_get_strategy.return_value = obj_utils.get_test_strategy(
-            self.context, id=1)
+            self.context, id=1
+        )
         actions = [self.create_action("fake_action", {})]
         m_make_action.return_value = FakeAction(mock.Mock())
 
         self.engine.execute(actions)
         self.check_action_state(actions[0], objects.action.State.FAILED)
-        self.assertTrue(self.check_notifications_contains(
-            m_send_update.call_args_list,
-            {
-                'state': objects.action.State.FAILED,
-                'uuid': actions[0].uuid,
-                'action_type': 'fake_action',
-                'status_message': (f"Action failed in execute: The action "
-                                   f"{actions[0].uuid} execution failed."),
-            },
-        ))
+        self.assertTrue(
+            self.check_notifications_contains(
+                m_send_update.call_args_list,
+                {
+                    'state': objects.action.State.FAILED,
+                    'uuid': actions[0].uuid,
+                    'action_type': 'fake_action',
+                    'status_message': (
+                        f"Action failed in execute: The action "
+                        f"{actions[0].uuid} execution failed."
+                    ),
+                },
+            )
+        )
 
     @mock.patch.object(objects.ActionPlan, "get_by_uuid")
     def test_execute_with_action_plan_cancel(self, m_get_actionplan):
         obj_utils.create_test_goal(self.context)
         strategy = obj_utils.create_test_strategy(self.context)
         audit = obj_utils.create_test_audit(
-            self.context, strategy_id=strategy.id)
+            self.context, strategy_id=strategy.id
+        )
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=audit.id,
+            self.context,
+            audit_id=audit.id,
             strategy_id=strategy.id,
-            state=objects.action_plan.State.CANCELLING)
+            state=objects.action_plan.State.CANCELLING,
+        )
         action1 = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
-            action_type='nop', state=objects.action.State.SUCCEEDED,
-            input_parameters={'message': 'hello World'})
+            self.context,
+            action_plan_id=action_plan.id,
+            action_type='nop',
+            state=objects.action.State.SUCCEEDED,
+            input_parameters={'message': 'hello World'},
+        )
         action2 = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
-            action_type='nop', state=objects.action.State.ONGOING,
+            self.context,
+            action_plan_id=action_plan.id,
+            action_type='nop',
+            state=objects.action.State.ONGOING,
             uuid='9eb51e14-936d-4d12-a500-6ba0f5e0bb1c',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         action3 = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
-            action_type='nop', state=objects.action.State.PENDING,
+            self.context,
+            action_plan_id=action_plan.id,
+            action_type='nop',
+            state=objects.action.State.PENDING,
             uuid='bc7eee5c-4fbe-4def-9744-b539be55aa19',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         m_get_actionplan.return_value = action_plan
         actions = []
         actions.append(action1)
         actions.append(action2)
         actions.append(action3)
-        self.assertRaises(exception.ActionPlanCancelled,
-                          self.engine.execute, actions)
+        self.assertRaises(
+            exception.ActionPlanCancelled, self.engine.execute, actions
+        )
         try:
             self.check_action_state(action1, objects.action.State.SUCCEEDED)
             self.check_action_state(action2, objects.action.State.CANCELLED)
@@ -406,24 +501,27 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
     @mock.patch.object(nop.Nop, 'debug_message')
-    def test_execute_with_automatic_skipped(self, m_nop_message,
-                                            m_send_update, m_execution,
-                                            m_get_actionplan):
-
+    def test_execute_with_automatic_skipped(
+        self, m_nop_message, m_send_update, m_execution, m_get_actionplan
+    ):
         obj_utils.create_test_goal(self.context)
         strategy = obj_utils.create_test_strategy(self.context)
         audit = obj_utils.create_test_audit(
-            self.context, strategy_id=strategy.id)
+            self.context, strategy_id=strategy.id
+        )
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=audit.id,
+            self.context,
+            audit_id=audit.id,
             strategy_id=strategy.id,
             state=objects.action_plan.State.ONGOING,
-            id=0)
+            id=0,
+        )
         m_get_actionplan.return_value = action_plan
         actions = []
 
-        action = self.create_action("nop", {'message': 'action2',
-                                            'skip_pre_condition': True})
+        action = self.create_action(
+            "nop", {'message': 'action2', 'skip_pre_condition': True}
+        )
 
         self.check_action_state(action, objects.action.State.PENDING)
 
@@ -435,8 +533,10 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         self.check_action_state(action, objects.action.State.SKIPPED)
         self.assertEqual(
             objects.Action.get_by_uuid(
-                self.context, action.uuid).status_message,
-            "Action was skipped automatically: Skipped in pre_condition")
+                self.context, action.uuid
+            ).status_message,
+            "Action was skipped automatically: Skipped in pre_condition",
+        )
         action_state_dict = {
             'state': objects.action.State.SKIPPED,
             'status_message': "Action was skipped automatically: "
@@ -444,11 +544,18 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
             'uuid': action.uuid,
             'action_type': 'nop',
         }
-        self.assertTrue(self.check_notifications_contains(
-            m_send_update.call_args_list, action_state_dict))
-        self.assertTrue(self.check_notifications_contains(
-            m_send_update.call_args_list, action_state_dict,
-            old_state=objects.action.State.PENDING))
+        self.assertTrue(
+            self.check_notifications_contains(
+                m_send_update.call_args_list, action_state_dict
+            )
+        )
+        self.assertTrue(
+            self.check_notifications_contains(
+                m_send_update.call_args_list,
+                action_state_dict,
+                old_state=objects.action.State.PENDING,
+            )
+        )
 
         m_nop_message.assert_not_called()
 
@@ -457,32 +564,41 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(notifications.action, 'send_update')
     @mock.patch.object(nop.Nop, 'debug_message')
     @mock.patch.object(nop.Nop, 'pre_condition')
-    def test_execute_with_manually_skipped(self, m_nop_pre_condition,
-                                           m_nop_message,
-                                           m_send_update, m_execution,
-                                           m_get_actionplan):
+    def test_execute_with_manually_skipped(
+        self,
+        m_nop_pre_condition,
+        m_nop_message,
+        m_send_update,
+        m_execution,
+        m_get_actionplan,
+    ):
         obj_utils.create_test_goal(self.context)
         strategy = obj_utils.create_test_strategy(self.context)
         audit = obj_utils.create_test_audit(
-            self.context, strategy_id=strategy.id)
+            self.context, strategy_id=strategy.id
+        )
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=audit.id,
+            self.context,
+            audit_id=audit.id,
             strategy_id=strategy.id,
             state=objects.action_plan.State.ONGOING,
-            id=0)
+            id=0,
+        )
         m_get_actionplan.return_value = action_plan
         actions = []
         action1 = obj_utils.create_test_action(
             self.context,
             action_type='nop',
             state=objects.action.State.PENDING,
-            input_parameters={'message': 'action1'})
+            input_parameters={'message': 'action1'},
+        )
         action2 = obj_utils.create_test_action(
             self.context,
             action_type='nop',
             state=objects.action.State.SKIPPED,
             uuid='bc7eee5c-4fbe-4def-9744-b539be55aa19',
-            input_parameters={'message': 'action2'})
+            input_parameters={'message': 'action2'},
+        )
         self.check_action_state(action1, objects.action.State.PENDING)
         self.check_action_state(action2, objects.action.State.SKIPPED)
         actions.append(action1)
@@ -499,31 +615,37 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
     @mock.patch.object(notifications.action, 'send_execution_notification')
     @mock.patch.object(notifications.action, 'send_update')
     @mock.patch.object(nop.Nop, 'debug_message')
-    def test_execute_different_action_results(self, m_nop_message,
-                                              m_send_update, m_execution,
-                                              m_get_actionplan):
-
+    def test_execute_different_action_results(
+        self, m_nop_message, m_send_update, m_execution, m_get_actionplan
+    ):
         obj_utils.create_test_goal(self.context)
         strategy = obj_utils.create_test_strategy(self.context)
         audit = obj_utils.create_test_audit(
-            self.context, strategy_id=strategy.id)
+            self.context, strategy_id=strategy.id
+        )
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=audit.id,
+            self.context,
+            audit_id=audit.id,
             strategy_id=strategy.id,
             state=objects.action_plan.State.ONGOING,
-            id=0)
+            id=0,
+        )
         m_get_actionplan.return_value = action_plan
         actions = []
 
         action1 = self.create_action("nop", {'message': 'action1'})
-        action2 = self.create_action("nop", {'message': 'action2',
-                                             'skip_pre_condition': True})
-        action3 = self.create_action("nop", {'message': 'action3',
-                                             'fail_pre_condition': True})
-        action4 = self.create_action("nop", {'message': 'action4',
-                                             'fail_execute': True})
-        action5 = self.create_action("nop", {'message': 'action5',
-                                             'fail_post_condition': True})
+        action2 = self.create_action(
+            "nop", {'message': 'action2', 'skip_pre_condition': True}
+        )
+        action3 = self.create_action(
+            "nop", {'message': 'action3', 'fail_pre_condition': True}
+        )
+        action4 = self.create_action(
+            "nop", {'message': 'action4', 'fail_execute': True}
+        )
+        action5 = self.create_action(
+            "nop", {'message': 'action5', 'fail_post_condition': True}
+        )
         action6 = self.create_action("sleep", {'duration': 1.0})
 
         self.check_action_state(action1, objects.action.State.PENDING)
@@ -545,41 +667,53 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         # successful nop action
         self.check_action_state(action1, objects.action.State.SUCCEEDED)
         self.assertIsNone(
-            objects.Action.get_by_uuid(self.context, action1.uuid)
-            .status_message)
+            objects.Action.get_by_uuid(
+                self.context, action1.uuid
+            ).status_message
+        )
         # action skipped automatically in the pre_condition phase
         self.check_action_state(action2, objects.action.State.SKIPPED)
         self.assertEqual(
             objects.Action.get_by_uuid(
-                self.context, action2.uuid).status_message,
-            "Action was skipped automatically: Skipped in pre_condition")
+                self.context, action2.uuid
+            ).status_message,
+            "Action was skipped automatically: Skipped in pre_condition",
+        )
         # action failed in the pre_condition phase
         self.check_action_state(action3, objects.action.State.FAILED)
         self.assertEqual(
             objects.Action.get_by_uuid(
-                self.context, action3.uuid).status_message,
-            "Action failed in pre_condition: Failed in pre_condition")
+                self.context, action3.uuid
+            ).status_message,
+            "Action failed in pre_condition: Failed in pre_condition",
+        )
         # action failed in the execute phase
         self.check_action_state(action4, objects.action.State.FAILED)
         self.assertEqual(
             objects.Action.get_by_uuid(
-                self.context, action4.uuid).status_message,
+                self.context, action4.uuid
+            ).status_message,
             f"Action failed in execute: The action {action4.uuid} "
-            "execution failed.")
+            "execution failed.",
+        )
         # action failed in the post_condition phase
         self.check_action_state(action5, objects.action.State.FAILED)
         self.assertEqual(
             objects.Action.get_by_uuid(
-                self.context, action5.uuid).status_message,
-            "Action failed in post_condition: Failed in post_condition")
+                self.context, action5.uuid
+            ).status_message,
+            "Action failed in post_condition: Failed in post_condition",
+        )
         # successful sleep action
         self.check_action_state(action6, objects.action.State.SUCCEEDED)
 
         # execute method should not be called for actions that are skipped of
         # failed in the pre_condition phase
-        expected_execute_calls = [mock.call('action1'),
-                                  mock.call('action4'),
-                                  mock.call('action5')]
+        expected_execute_calls = [
+            mock.call('action1'),
+            mock.call('action4'),
+            mock.call('action5'),
+        ]
         m_nop_message.assert_has_calls(expected_execute_calls, any_order=True)
         self.assertEqual(m_nop_message.call_count, 3)
 
@@ -606,23 +740,32 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         obj_utils.create_test_goal(self.context)
         strategy = obj_utils.create_test_strategy(self.context)
         audit = obj_utils.create_test_audit(
-            self.context, strategy_id=strategy.id)
+            self.context, strategy_id=strategy.id
+        )
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=audit.id,
+            self.context,
+            audit_id=audit.id,
             strategy_id=strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action1 = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
-            action_type='nop', state=objects.action.State.ONGOING,
-            input_parameters={'message': 'hello World'})
+            self.context,
+            action_plan_id=action_plan.id,
+            action_type='nop',
+            state=objects.action.State.ONGOING,
+            input_parameters={'message': 'hello World'},
+        )
         m_get_actionplan.return_value = action_plan
         actions = []
         actions.append(action1)
 
         # Test notify with status_message provided
         test_status_message = "Action completed successfully"
-        result = self.engine.notify(action1, objects.action.State.FAILED,
-                                    status_message=test_status_message)
+        result = self.engine.notify(
+            action1,
+            objects.action.State.FAILED,
+            status_message=test_status_message,
+        )
 
         # Verify the action state was updated
         self.assertEqual(result.state, objects.action.State.FAILED)
@@ -632,7 +775,8 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
 
         # Verify the changes were persisted to the database
         persisted_action = objects.Action.get_by_uuid(
-            self.context, action1.uuid)
+            self.context, action1.uuid
+        )
         self.assertEqual(persisted_action.state, objects.action.State.FAILED)
         self.assertEqual(persisted_action.status_message, test_status_message)
 
@@ -642,15 +786,21 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         obj_utils.create_test_goal(self.context)
         strategy = obj_utils.create_test_strategy(self.context)
         audit = obj_utils.create_test_audit(
-            self.context, strategy_id=strategy.id)
+            self.context, strategy_id=strategy.id
+        )
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=audit.id,
+            self.context,
+            audit_id=audit.id,
             strategy_id=strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action1 = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
-            action_type='nop', state=objects.action.State.ONGOING,
-            input_parameters={'message': 'hello World'})
+            self.context,
+            action_plan_id=action_plan.id,
+            action_type='nop',
+            state=objects.action.State.ONGOING,
+            input_parameters={'message': 'hello World'},
+        )
         m_get_actionplan.return_value = action_plan
         actions = []
         actions.append(action1)
@@ -664,7 +814,9 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
         self.assertIsNone(result.status_message)
         # Verify the changes were persisted to the database
         persisted_action = objects.Action.get_by_uuid(
-            self.context, action1.uuid)
-        self.assertEqual(persisted_action.state,
-                         objects.action.State.SUCCEEDED)
+            self.context, action1.uuid
+        )
+        self.assertEqual(
+            persisted_action.state, objects.action.State.SUCCEEDED
+        )
         self.assertIsNone(persisted_action.status_message)
diff --git a/watcher/tests/unit/applier/workflow_engine/test_taskflow_action_container.py b/watcher/tests/unit/applier/workflow_engine/test_taskflow_action_container.py
index ae5f8627e..07bf4edea 100644
--- a/watcher/tests/unit/applier/workflow_engine/test_taskflow_action_container.py
+++ b/watcher/tests/unit/applier/workflow_engine/test_taskflow_action_container.py
@@ -31,120 +31,149 @@ from watcher.tests.unit.db import base
 from watcher.tests.unit.objects import utils as obj_utils
 
 
-class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
-                                  base.DbTestCase):
+class TestTaskFlowActionContainer(
+    test_utils.NovaResourcesMixin, base.DbTestCase
+):
     def setUp(self):
         super().setUp()
         self.engine = tflow.DefaultWorkFlowEngine(
             config=mock.Mock(),
             context=self.context,
-            applier_manager=mock.MagicMock())
+            applier_manager=mock.MagicMock(),
+        )
         obj_utils.create_test_goal(self.context)
         self.strategy = obj_utils.create_test_strategy(self.context)
         self.audit = obj_utils.create_test_audit(
-            self.context, strategy_id=self.strategy.id)
+            self.context, strategy_id=self.strategy.id
+        )
 
     def test_execute(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.ONGOING,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         action_container.execute()
 
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.SUCCEEDED)
 
     def test_execute_with_failed_execute(self):
-
         mock_connection = self.useFixture(
             fixtures.MockPatch("watcher.common.clients.get_sdk_connection")
         ).mock.return_value
         instance = "31b9dd5c-b1fd-4f61-9b68-a47096326dac"
         mock_connection.compute.get_server.side_effect = [
             self.create_openstacksdk_server(id=instance),
-            sdk_exc.NotFoundException()
+            sdk_exc.NotFoundException(),
         ]
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.ONGOING,
             action_type='migrate',
-            input_parameters={"resource_id":
-                              instance,
-                              "migration_type": "live",
-                              "destination_node": "host2",
-                              "source_node": "host1"})
+            input_parameters={
+                "resource_id": instance,
+                "migration_type": "live",
+                "destination_node": "host2",
+                "source_node": "host1",
+            },
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         result = action_container.execute()
         self.assertFalse(result)
 
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.FAILED)
-        self.assertEqual(obj_action.status_message, "Action failed in execute:"
-                         " The action 10a47dd1-4874-4298-91cf-eff046dbdb8d "
-                         "execution failed.")
+        self.assertEqual(
+            obj_action.status_message,
+            "Action failed in execute:"
+            " The action 10a47dd1-4874-4298-91cf-eff046dbdb8d "
+            "execution failed.",
+        )
 
     def test_pre_execute(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.PENDING,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         action_container.pre_execute()
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.PENDING)
         self.assertIsNone(obj_action.status_message)
 
     def test_pre_execute_with_failed_pre_condition(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.PENDING,
             action_type='nop',
-            input_parameters={'message': 'hello World',
-                              'fail_pre_condition': True})
+            input_parameters={
+                'message': 'hello World',
+                'fail_pre_condition': True,
+            },
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         action_container.pre_execute()
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.FAILED)
         self.assertEqual(
             obj_action.status_message,
-            "Action failed in pre_condition: Failed in pre_condition")
+            "Action failed in pre_condition: Failed in pre_condition",
+        )
 
     @mock.patch.object(nop.Nop, "pre_condition")
     def test_pre_execute_with_failed_exception(self, m_pre_condition):
@@ -152,72 +181,96 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
         # should only include the type of the exception.
         m_pre_condition.side_effect = Exception("Third party exception")
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.PENDING,
             action_type='nop',
-            input_parameters={'message': 'hello World',
-                              'fail_pre_condition': True})
+            input_parameters={
+                'message': 'hello World',
+                'fail_pre_condition': True,
+            },
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         action_container.pre_execute()
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.FAILED)
         self.assertEqual(
             obj_action.status_message,
-            "Action failed in pre_condition: Exception")
+            "Action failed in pre_condition: Exception",
+        )
 
     def test_pre_execute_with_skipped(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.PENDING,
             action_type='nop',
-            input_parameters={'message': 'hello World',
-                              'skip_pre_condition': True})
+            input_parameters={
+                'message': 'hello World',
+                'skip_pre_condition': True,
+            },
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         action_container.pre_execute()
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.SKIPPED)
-        self.assertEqual(obj_action.status_message,
-                         "Action was skipped automatically: "
-                         "Skipped in pre_condition")
+        self.assertEqual(
+            obj_action.status_message,
+            "Action was skipped automatically: Skipped in pre_condition",
+        )
 
     def test_post_execute_with_failed_post_condition(self):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.ONGOING,
             action_type='nop',
-            input_parameters={'message': 'hello World',
-                              'fail_post_condition': True})
+            input_parameters={
+                'message': 'hello World',
+                'fail_post_condition': True,
+            },
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         action_container.post_execute()
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.FAILED)
         self.assertEqual(
             obj_action.status_message,
-            "Action failed in post_condition: Failed in post_condition")
+            "Action failed in post_condition: Failed in post_condition",
+        )
 
     def test_pre_execute_with_cancel_action_plan(self):
         """Test that actions are cancelled in the pre_execute method.
@@ -227,21 +280,26 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
         """
 
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.CANCELLING)
+            state=objects.action_plan.State.CANCELLING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.PENDING,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
 
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
-        self.assertRaises(exception.ActionPlanCancelled,
-                          action_container.pre_execute)
+        self.assertRaises(
+            exception.ActionPlanCancelled, action_container.pre_execute
+        )
 
     def test_execute_with_cancel_action_plan(self):
         """Test that actions are not cancelled in the execute method.
@@ -252,68 +310,85 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
         """
 
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.CANCELLING)
+            state=objects.action_plan.State.CANCELLING,
+        )
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.PENDING,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
 
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         result = action_container.execute()
         self.assertTrue(result)
 
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.SUCCEEDED)
 
     @mock.patch('watcher.applier.workflow_engine.default.LOG')
     def test_execute_without_rollback(self, mock_log):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.FAILED,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
-        cfg.CONF.set_override("rollback_when_actionplan_failed", False,
-                              group="watcher_applier")
+        cfg.CONF.set_override(
+            "rollback_when_actionplan_failed", False, group="watcher_applier"
+        )
         action_name = f"action_type:{action.action_type} uuid:{action.uuid}"
-        expected_log = ('Failed actionplan rollback option is turned off, '
-                        'and the following action will be skipped: %s')
+        expected_log = (
+            'Failed actionplan rollback option is turned off, '
+            'and the following action will be skipped: %s'
+        )
         action_container.revert()
         mock_log.info.assert_called_once_with(expected_log, action_name)
 
     @mock.patch('watcher.applier.workflow_engine.default.LOG')
     def test_execute_with_rollback(self, mock_log):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.FAILED,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
-        cfg.CONF.set_override("rollback_when_actionplan_failed", True,
-                              group="watcher_applier")
+        cfg.CONF.set_override(
+            "rollback_when_actionplan_failed", True, group="watcher_applier"
+        )
         action_name = f"action_type:{action.action_type} uuid:{action.uuid}"
         expected_log = 'Revert action: %s'
         action_container.revert()
@@ -322,22 +397,27 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
     @mock.patch.object(tflow.TaskFlowActionContainer, 'do_revert')
     def test_execute_with_rollback_skipped_action(self, mock_do_revert):
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.SKIPPED,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
 
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
-        cfg.CONF.set_override("rollback_when_actionplan_failed", True,
-                              group="watcher_applier")
+        cfg.CONF.set_override(
+            "rollback_when_actionplan_failed", True, group="watcher_applier"
+        )
 
         action_container.revert()
 
@@ -348,19 +428,23 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
     def test_fail_action_with_reason(self, mock_notification, mock_log):
         """Test _fail_action method with phase and reason."""
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.ONGOING,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
 
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         # Call _fail_action with a phase and reason
         phase = "execute"
@@ -369,7 +453,8 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
 
         # Verify the action state is set to FAILED
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.FAILED)
 
         # Verify status_message is set correctly
@@ -379,7 +464,8 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
         # Verify LOG.error was called
         mock_log.error.assert_called_once_with(
             'The workflow engine has failed to execute the action: %s',
-            action.uuid)
+            action.uuid,
+        )
 
         # Verify notification was sent with correct parameters
         mock_notification.assert_called_once_with(
@@ -387,7 +473,7 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
             mock.ANY,  # action object - checked separately below
             objects.fields.NotificationAction.EXECUTION,
             objects.fields.NotificationPhase.ERROR,
-            priority=objects.fields.NotificationPriority.ERROR
+            priority=objects.fields.NotificationPriority.ERROR,
         )
         call_args = mock_notification.call_args
         self.assertEqual(call_args[0][1].uuid, action.uuid)
@@ -398,19 +484,23 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
     def test_fail_action_without_reason(self, mock_notification, mock_log):
         """Test _fail_action method without a reason."""
         action_plan = obj_utils.create_test_action_plan(
-            self.context, audit_id=self.audit.id,
+            self.context,
+            audit_id=self.audit.id,
             strategy_id=self.strategy.id,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         action = obj_utils.create_test_action(
-            self.context, action_plan_id=action_plan.id,
+            self.context,
+            action_plan_id=action_plan.id,
             state=objects.action.State.ONGOING,
             action_type='nop',
-            input_parameters={'message': 'hello World'})
+            input_parameters={'message': 'hello World'},
+        )
 
         action_container = tflow.TaskFlowActionContainer(
-            db_action=action,
-            engine=self.engine)
+            db_action=action, engine=self.engine
+        )
 
         # Call _fail_action with only phase, no reason
         phase = "pre_condition"
@@ -418,7 +508,8 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
 
         # Verify the action state is set to FAILED
         obj_action = objects.Action.get_by_uuid(
-            self.engine.context, action.uuid)
+            self.engine.context, action.uuid
+        )
         self.assertEqual(obj_action.state, objects.action.State.FAILED)
 
         # Verify status_message is not set when no reason is provided
@@ -427,4 +518,5 @@ class TestTaskFlowActionContainer(test_utils.NovaResourcesMixin,
         # Verify LOG.error was called
         mock_log.error.assert_called_once_with(
             'The workflow engine has failed to execute the action: %s',
-            action.uuid)
+            action.uuid,
+        )
diff --git a/watcher/tests/unit/base.py b/watcher/tests/unit/base.py
index 97bf7209c..d2187d583 100644
--- a/watcher/tests/unit/base.py
+++ b/watcher/tests/unit/base.py
@@ -66,19 +66,16 @@ class TestCase(BaseTestCase):
         self.messaging_conf = self.useFixture(conffixture.ConfFixture(CONF))
         self.messaging_conf.transport_url = 'fake:/'
 
-        cfg.CONF.set_override("auth_type", "admin_token",
-                              group='keystone_authtoken')
+        cfg.CONF.set_override(
+            "auth_type", "admin_token", group='keystone_authtoken'
+        )
 
         app_config_path = os.path.join(os.path.dirname(__file__), 'config.py')
         self.app = testing.load_test_app(app_config_path)
         self.token_info = {
             'token': {
-                'project': {
-                    'id': 'fake_project'
-                },
-                'user': {
-                    'id': 'fake_user'
-                }
+                'project': {'id': 'fake_project'},
+                'user': {'id': 'fake_user'},
             }
         }
 
@@ -87,7 +84,8 @@ class TestCase(BaseTestCase):
         self.context = watcher_context.RequestContext(
             auth_token_info=self.token_info,
             project_id='fake_project',
-            user_id='fake_user')
+            user_id='fake_user',
+        )
 
         self.policy = self.useFixture(policy_fixture.PolicyFixture())
 
@@ -103,8 +101,9 @@ class TestCase(BaseTestCase):
             context = watcher_context.RequestContext(*args, **kwargs)
             return watcher_context.RequestContext.from_dict(context.to_dict())
 
-        p = mock.patch.object(watcher_context, 'make_context',
-                              side_effect=make_context)
+        p = mock.patch.object(
+            watcher_context, 'make_context', side_effect=make_context
+        )
         self.mock_make_context = p.start()
         self.addCleanup(p.stop)
 
@@ -112,7 +111,8 @@ class TestCase(BaseTestCase):
         self._reset_singletons()
 
         self._base_test_obj_backup = copy.copy(
-            objects_base.WatcherObjectRegistry._registry._obj_classes)
+            objects_base.WatcherObjectRegistry._registry._obj_classes
+        )
         self.addCleanup(self._restore_obj_registry)
         self.addCleanup(self._reset_singletons)
 
@@ -126,7 +126,8 @@ class TestCase(BaseTestCase):
 
     def _restore_obj_registry(self):
         objects_base.WatcherObjectRegistry._registry._obj_classes = (
-            self._base_test_obj_backup)
+            self._base_test_obj_backup
+        )
 
     def config(self, **kw):
         """Override config options for a test."""
@@ -141,7 +142,8 @@ class TestCase(BaseTestCase):
         :returns: path to the specified file, or path to project root.
         """
         root = os.path.abspath(
-            os.path.join(os.path.dirname(__file__), '..', '..'))
+            os.path.join(os.path.dirname(__file__), '..', '..')
+        )
         if project_file:
             return os.path.join(root, project_file)
         else:
diff --git a/watcher/tests/unit/cmd/test_api.py b/watcher/tests/unit/cmd/test_api.py
index baddc153c..dc55a605b 100644
--- a/watcher/tests/unit/cmd/test_api.py
+++ b/watcher/tests/unit/cmd/test_api.py
@@ -28,7 +28,6 @@ from watcher.tests.unit import base
 
 
 class TestApi(base.BaseTestCase):
-
     def setUp(self):
         super().setUp()
 
diff --git a/watcher/tests/unit/cmd/test_applier.py b/watcher/tests/unit/cmd/test_applier.py
index bc67a384b..c9fa45e92 100644
--- a/watcher/tests/unit/cmd/test_applier.py
+++ b/watcher/tests/unit/cmd/test_applier.py
@@ -39,7 +39,8 @@ class TestApplier(base.BaseTestCase):
         _fake_parse_method = types.MethodType(_fake_parse, self.conf)
         self.conf._parse_cli_opts = _fake_parse_method
         p_heartbeat = mock.patch.object(
-            watcher_service.ServiceHeartbeat, "send_beat")
+            watcher_service.ServiceHeartbeat, "send_beat"
+        )
         self.m_heartbeat = p_heartbeat.start()
         self.addCleanup(p_heartbeat.stop)
 
diff --git a/watcher/tests/unit/cmd/test_db_manage.py b/watcher/tests/unit/cmd/test_db_manage.py
index 6ce518687..6521a7755 100644
--- a/watcher/tests/unit/cmd/test_db_manage.py
+++ b/watcher/tests/unit/cmd/test_db_manage.py
@@ -26,15 +26,16 @@ from watcher.tests.unit import base
 
 
 class TestDBManageRunApp(base.TestCase):
-
     scenarios = (
         ("upgrade", {"command": "upgrade", "expected": "upgrade"}),
         ("downgrade", {"command": "downgrade", "expected": "downgrade"}),
         ("revision", {"command": "revision", "expected": "revision"}),
         ("stamp", {"command": "stamp", "expected": "stamp"}),
         ("version", {"command": "version", "expected": "version"}),
-        ("create_schema", {"command": "create_schema",
-                           "expected": "create_schema"}),
+        (
+            "create_schema",
+            {"command": "create_schema", "expected": "create_schema"},
+        ),
         ("purge", {"command": "purge", "expected": "purge"}),
         ("no_param", {"command": None, "expected": "upgrade"}),
     )
@@ -54,11 +55,11 @@ class TestDBManageRunApp(base.TestCase):
         dbmanage.main()
         self.assertEqual(1, m_func.call_count)
         m_prepare_service.assert_called_once_with(
-            ["watcher-db-manage", self.expected], cfg.CONF)
+            ["watcher-db-manage", self.expected], cfg.CONF
+        )
 
 
 class TestDBManageRunCommand(base.TestCase):
-
     @mock.patch.object(migration, "upgrade")
     def test_run_db_upgrade(self, m_upgrade):
         cfg.CONF.register_opt(cfg.StrOpt("revision"), group="command")
@@ -79,9 +80,7 @@ class TestDBManageRunCommand(base.TestCase):
     def test_run_db_revision(self, m_revision):
         cfg.CONF.register_opt(cfg.StrOpt("message"), group="command")
         cfg.CONF.register_opt(cfg.StrOpt("autogenerate"), group="command")
-        cfg.CONF.set_default(
-            "message", "dummy_message", group="command"
-        )
+        cfg.CONF.set_default("message", "dummy_message", group="command")
         cfg.CONF.set_default(
             "autogenerate", "dummy_autogenerate", group="command"
         )
@@ -122,7 +121,8 @@ class TestDBManageRunCommand(base.TestCase):
         dbmanage.DBCommand.purge()
 
         m_purge_cls.assert_called_once_with(
-            None, None, 'Some UUID', True, False)
+            None, None, 'Some UUID', True, False
+        )
         m_purge.execute.assert_called_once_with()
 
     @mock.patch.object(sys, "exit")
@@ -169,7 +169,8 @@ class TestDBManageRunCommand(base.TestCase):
         dbmanage.DBCommand.purge()
 
         m_purge_cls.assert_called_once_with(
-            None, None, 'Some UUID', True, True)
+            None, None, 'Some UUID', True, True
+        )
         self.assertEqual(1, m_purge.execute.call_count)
         self.assertEqual(0, m_purge.do_delete.call_count)
         self.assertEqual(0, m_exit.call_count)
diff --git a/watcher/tests/unit/cmd/test_decision_engine.py b/watcher/tests/unit/cmd/test_decision_engine.py
index f2bbc6ae1..c10941605 100644
--- a/watcher/tests/unit/cmd/test_decision_engine.py
+++ b/watcher/tests/unit/cmd/test_decision_engine.py
@@ -29,7 +29,6 @@ from watcher.tests.unit import base
 
 
 class TestDecisionEngine(base.BaseTestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -43,11 +42,13 @@ class TestDecisionEngine(base.BaseTestCase):
         self.conf._parse_cli_opts = _fake_parse_method
 
         p_heartbeat = mock.patch.object(
-            watcher_service.ServiceHeartbeat, "send_beat")
+            watcher_service.ServiceHeartbeat, "send_beat"
+        )
         self.m_heartbeat = p_heartbeat.start()
         self.addCleanup(p_heartbeat.stop)
         p_continuoushandler = mock.patch.object(
-            continuous.ContinuousAuditHandler, "start")
+            continuous.ContinuousAuditHandler, "start"
+        )
         self.m_continuoushandler = p_continuoushandler.start()
         self.addCleanup(p_continuoushandler.stop)
         self.fake_keystone = self.useFixture(watcher_fixtures.KeystoneClient())
@@ -59,6 +60,5 @@ class TestDecisionEngine(base.BaseTestCase):
     @mock.patch.object(sync.Syncer, "sync", mock.Mock())
     @mock.patch.object(service, "launch")
     def test_run_de_app(self, m_launch):
-
         decisionengine.main()
         self.assertEqual(1, m_launch.call_count)
diff --git a/watcher/tests/unit/cmd/test_status.py b/watcher/tests/unit/cmd/test_status.py
index 26f3ff474..7f8b912b6 100644
--- a/watcher/tests/unit/cmd/test_status.py
+++ b/watcher/tests/unit/cmd/test_status.py
@@ -23,7 +23,6 @@ CONF = conf.CONF
 
 
 class TestUpgradeChecks(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.cmd = status.Checks()
diff --git a/watcher/tests/unit/common/loader/test_loader.py b/watcher/tests/unit/common/loader/test_loader.py
index 935f4e523..71f9cd10f 100644
--- a/watcher/tests/unit/common/loader/test_loader.py
+++ b/watcher/tests/unit/common/loader/test_loader.py
@@ -26,23 +26,18 @@ from watcher.tests.unit import base
 
 
 class FakeLoadable(loadable.Loadable):
-
     @classmethod
     def get_config_opts(cls):
         return []
 
 
 class FakeLoadableWithOpts(loadable.Loadable):
-
     @classmethod
     def get_config_opts(cls):
-        return [
-            cfg.StrOpt("test_opt", default="fake_with_opts"),
-        ]
+        return [cfg.StrOpt("test_opt", default="fake_with_opts")]
 
 
 class TestLoader(base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -55,15 +50,19 @@ class TestLoader(base.TestCase):
         fake_driver = drivermanager.DriverManager.make_test_instance(
             extension=stevedore_extension.Extension(
                 name="fake",
-                entry_point=(f"{FakeLoadable.__module__}:"
-                             f"{FakeLoadable.__name__}"),
+                entry_point=(
+                    f"{FakeLoadable.__module__}:{FakeLoadable.__name__}"
+                ),
                 plugin=FakeLoadable,
-                obj=None),
-            namespace="TESTING")
+                obj=None,
+            ),
+            namespace="TESTING",
+        )
 
         loader_manager = default.DefaultLoader(namespace='TESTING')
-        with mock.patch.object(drivermanager,
-                               "DriverManager") as m_driver_manager:
+        with mock.patch.object(
+            drivermanager, "DriverManager"
+        ) as m_driver_manager:
             m_driver_manager.return_value = fake_driver
             loaded_driver = loader_manager.load(name='fake')
 
@@ -74,29 +73,35 @@ class TestLoader(base.TestCase):
         m_driver_manager.side_effect = Exception()
 
         loader_manager = default.DefaultLoader(namespace='TESTING')
-        self.assertRaises(exception.LoadingError, loader_manager.load,
-                          name='bad_driver')
+        self.assertRaises(
+            exception.LoadingError, loader_manager.load, name='bad_driver'
+        )
 
     def test_load_loadable_with_opts(self):
         fake_driver = drivermanager.DriverManager.make_test_instance(
             extension=stevedore_extension.Extension(
                 name="fake",
-                entry_point=(f"{FakeLoadableWithOpts.__module__}:"
-                             f"{FakeLoadableWithOpts.__name__}"),
+                entry_point=(
+                    f"{FakeLoadableWithOpts.__module__}:"
+                    f"{FakeLoadableWithOpts.__name__}"
+                ),
                 plugin=FakeLoadableWithOpts,
-                obj=None),
-            namespace="TESTING")
+                obj=None,
+            ),
+            namespace="TESTING",
+        )
 
         loader_manager = default.DefaultLoader(namespace='TESTING')
-        with mock.patch.object(drivermanager,
-                               "DriverManager") as m_driver_manager:
+        with mock.patch.object(
+            drivermanager, "DriverManager"
+        ) as m_driver_manager:
             m_driver_manager.return_value = fake_driver
             loaded_driver = loader_manager.load(name='fake')
 
         self.assertIsInstance(loaded_driver, FakeLoadableWithOpts)
 
         self.assertEqual(
-            "fake_with_opts", loaded_driver.config.get("test_opt"))
+            "fake_with_opts", loaded_driver.config.get("test_opt")
+        )
 
-        self.assertEqual(
-            "fake_with_opts", loaded_driver.config.test_opt)
+        self.assertEqual("fake_with_opts", loaded_driver.config.test_opt)
diff --git a/watcher/tests/unit/common/metal_helper/test_base.py b/watcher/tests/unit/common/metal_helper/test_base.py
index 6c4b910e7..2360c40a4 100644
--- a/watcher/tests/unit/common/metal_helper/test_base.py
+++ b/watcher/tests/unit/common/metal_helper/test_base.py
@@ -54,25 +54,21 @@ class TestBaseMetalNode(base.TestCase):
         self._node = MockMetalNode(self._nova_node)
 
     def test_get_hypervisor_node(self):
-        self.assertEqual(
-            self._nova_node,
-            self._node.get_hypervisor_node())
+        self.assertEqual(self._nova_node, self._node.get_hypervisor_node())
 
     def test_get_hypervisor_node_missing(self):
         node = MockMetalNode()
-        self.assertRaises(
-            exception.Invalid,
-            node.get_hypervisor_node)
+        self.assertRaises(exception.Invalid, node.get_hypervisor_node)
 
     def test_get_hypervisor_hostname(self):
         self.assertEqual(
             self._nova_node.hypervisor_hostname,
-            self._node.get_hypervisor_hostname())
+            self._node.get_hypervisor_hostname(),
+        )
 
     @mock.patch.object(MockMetalNode, 'power_on')
     @mock.patch.object(MockMetalNode, 'power_off')
-    def test_set_power_state(self,
-                             mock_power_off, mock_power_on):
+    def test_set_power_state(self, mock_power_off, mock_power_on):
         self._node.set_power_state(m_constants.PowerState.ON)
         mock_power_on.assert_called_once_with()
 
@@ -82,7 +78,8 @@ class TestBaseMetalNode(base.TestCase):
         self.assertRaises(
             exception.UnsupportedActionType,
             self._node.set_power_state,
-            m_constants.PowerState.UNKNOWN)
+            m_constants.PowerState.UNKNOWN,
+        )
 
 
 class TestBaseMetalHelper(base.TestCase):
diff --git a/watcher/tests/unit/common/metal_helper/test_factory.py b/watcher/tests/unit/common/metal_helper/test_factory.py
index ba918d07a..ccfee15e9 100644
--- a/watcher/tests/unit/common/metal_helper/test_factory.py
+++ b/watcher/tests/unit/common/metal_helper/test_factory.py
@@ -23,16 +23,11 @@ from watcher.tests.unit import base
 
 
 class TestMetalHelperFactory(base.TestCase):
-
     @mock.patch.object(clients, 'OpenStackClients')
     @mock.patch.object(maas, 'MaasHelper')
     @mock.patch.object(ironic, 'IronicHelper')
     def test_factory(self, mock_ironic, mock_maas, mock_osc):
-        self.assertEqual(
-            mock_ironic.return_value,
-            factory.get_helper())
+        self.assertEqual(mock_ironic.return_value, factory.get_helper())
 
         self.config(url="fake_maas_url", group="maas_client")
-        self.assertEqual(
-            mock_maas.return_value,
-            factory.get_helper())
+        self.assertEqual(mock_maas.return_value, factory.get_helper())
diff --git a/watcher/tests/unit/common/metal_helper/test_ironic.py b/watcher/tests/unit/common/metal_helper/test_ironic.py
index 2ffc5a55b..5b41fc36b 100644
--- a/watcher/tests/unit/common/metal_helper/test_ironic.py
+++ b/watcher/tests/unit/common/metal_helper/test_ironic.py
@@ -31,7 +31,8 @@ class TestIronicNode(base.TestCase):
         self._ironic_client = mock.Mock()
 
         self._node = ironic.IronicNode(
-            self._wrapped_node, self._nova_node, self._ironic_client)
+            self._wrapped_node, self._nova_node, self._ironic_client
+        )
 
     def test_get_power_state(self):
         states = (
@@ -40,9 +41,11 @@ class TestIronicNode(base.TestCase):
             "rebooting",
             "soft power off",
             "soft reboot",
-            'SomeOtherState')
+            'SomeOtherState',
+        )
         type(self._wrapped_node).power_state = mock.PropertyMock(
-            side_effect=states)
+            side_effect=states
+        )
 
         expected_states = (
             m_constants.PowerState.ON,
@@ -50,26 +53,27 @@ class TestIronicNode(base.TestCase):
             m_constants.PowerState.ON,
             m_constants.PowerState.OFF,
             m_constants.PowerState.ON,
-            m_constants.PowerState.UNKNOWN)
+            m_constants.PowerState.UNKNOWN,
+        )
 
         for expected_state in expected_states:
             actual_state = self._node.get_power_state()
             self.assertEqual(expected_state, actual_state)
 
     def test_get_id(self):
-        self.assertEqual(
-            self._wrapped_node.uuid,
-            self._node.get_id())
+        self.assertEqual(self._wrapped_node.uuid, self._node.get_id())
 
     def test_power_on(self):
         self._node.power_on()
         self._ironic_client.node.set_power_state.assert_called_once_with(
-            self._wrapped_node.uuid, "on")
+            self._wrapped_node.uuid, "on"
+        )
 
     def test_power_off(self):
         self._node.power_off()
         self._ironic_client.node.set_power_state.assert_called_once_with(
-            self._wrapped_node.uuid, "off")
+            self._wrapped_node.uuid, "off"
+        )
 
 
 class TestIronicHelper(base.TestCase):
@@ -86,18 +90,21 @@ class TestIronicHelper(base.TestCase):
     def test_list_compute_nodes(self):
         mock_machines = [
             mock.Mock(
-                extra=dict(compute_node_id=mock.sentinel.compute_node_id)),
+                extra=dict(compute_node_id=mock.sentinel.compute_node_id)
+            ),
             mock.Mock(
-                extra=dict(compute_node_id=mock.sentinel.compute_node_id2)),
-            mock.Mock(
-                extra=dict())
+                extra=dict(compute_node_id=mock.sentinel.compute_node_id2)
+            ),
+            mock.Mock(extra=dict()),
         ]
         mock_hypervisor = mock.Mock()
 
         self._mock_ironic_client.node.list.return_value = mock_machines
         self._mock_ironic_client.node.get.side_effect = mock_machines
         self._mock_nova_client.get_compute_node_by_uuid.side_effect = (
-            mock_hypervisor, None)
+            mock_hypervisor,
+            None,
+        )
 
         out_nodes = self._helper.list_compute_nodes()
         self.assertEqual(1, len(out_nodes))
@@ -110,16 +117,14 @@ class TestIronicHelper(base.TestCase):
 
     def test_get_node(self):
         mock_machine = mock.Mock(
-            extra=dict(compute_node_id=mock.sentinel.compute_node_id))
+            extra=dict(compute_node_id=mock.sentinel.compute_node_id)
+        )
         self._mock_ironic_client.node.get.return_value = mock_machine
 
         out_node = self._helper.get_node(mock.sentinel.id)
 
         get_compute_node = self._mock_nova_client.get_compute_node_by_uuid
-        self.assertEqual(
-            get_compute_node.return_value,
-            out_node._nova_node
-        )
+        self.assertEqual(get_compute_node.return_value, out_node._nova_node)
         get_compute_node.assert_called_once_with(mock.sentinel.compute_node_id)
         self.assertEqual(self._mock_ironic_client, out_node._ironic_client)
         self.assertEqual(mock_machine, out_node._ironic_node)
diff --git a/watcher/tests/unit/common/metal_helper/test_maas.py b/watcher/tests/unit/common/metal_helper/test_maas.py
index 883466636..cdeb5ffac 100644
--- a/watcher/tests/unit/common/metal_helper/test_maas.py
+++ b/watcher/tests/unit/common/metal_helper/test_maas.py
@@ -37,7 +37,8 @@ class TestMaasNode(base.TestCase):
         self._maas_client = mock.Mock()
 
         self._node = maas.MaasNode(
-            self._wrapped_node, self._nova_node, self._maas_client)
+            self._wrapped_node, self._nova_node, self._maas_client
+        )
 
     def test_get_power_state(self):
         if not maas_enum:
@@ -48,23 +49,23 @@ class TestMaasNode(base.TestCase):
             maas_enum.PowerState.OFF,
             maas_enum.PowerState.ERROR,
             maas_enum.PowerState.UNKNOWN,
-            'SomeOtherState')
+            'SomeOtherState',
+        )
 
         expected_states = (
             m_constants.PowerState.ON,
             m_constants.PowerState.OFF,
             m_constants.PowerState.ERROR,
             m_constants.PowerState.UNKNOWN,
-            m_constants.PowerState.UNKNOWN)
+            m_constants.PowerState.UNKNOWN,
+        )
 
         for expected_state in expected_states:
             actual_state = self._node.get_power_state()
             self.assertEqual(expected_state, actual_state)
 
     def test_get_id(self):
-        self.assertEqual(
-            self._wrapped_node.system_id,
-            self._node.get_id())
+        self.assertEqual(self._wrapped_node.system_id, self._node.get_id())
 
     def test_power_on(self):
         self._node.power_on()
@@ -92,18 +93,17 @@ class TestMaasHelper(base.TestCase):
         ctrl_fqdn = "ctrl-1"
 
         mock_machines = [
-            mock.Mock(fqdn=compute_fqdn,
-                      system_id=mock.sentinel.compute_node_id),
-            mock.Mock(fqdn=ctrl_fqdn,
-                      system_id=mock.sentinel.ctrl_node_id),
-        ]
-        mock_hypervisors = [
-            mock.Mock(hypervisor_hostname=compute_fqdn),
+            mock.Mock(
+                fqdn=compute_fqdn, system_id=mock.sentinel.compute_node_id
+            ),
+            mock.Mock(fqdn=ctrl_fqdn, system_id=mock.sentinel.ctrl_node_id),
         ]
+        mock_hypervisors = [mock.Mock(hypervisor_hostname=compute_fqdn)]
 
         self._mock_maas_client.machines.list.return_value = mock_machines
-        self._mock_nova_client.get_compute_node_list.return_value = \
+        self._mock_nova_client.get_compute_node_list.return_value = (
             mock_hypervisors
+        )
 
         out_nodes = self._helper.list_compute_nodes()
         self.assertEqual(1, len(out_nodes))
@@ -123,7 +123,8 @@ class TestMaasHelper(base.TestCase):
             mock.Mock(hypervisor_hostname="compute-01"),
         ]
         self._mock_nova_client.get_compute_node_by_hostname.return_value = (
-            mock_compute_nodes)
+            mock_compute_nodes
+        )
 
         out_node = self._helper.get_node(mock.sentinel.id)
 
diff --git a/watcher/tests/unit/common/test_cinder_helper.py b/watcher/tests/unit/common/test_cinder_helper.py
index dd794446a..b3833ff8a 100644
--- a/watcher/tests/unit/common/test_cinder_helper.py
+++ b/watcher/tests/unit/common/test_cinder_helper.py
@@ -33,7 +33,6 @@ from watcher.tests.unit import base
 
 @mock.patch.object(clients.OpenStackClients, 'cinder')
 class TestCinderHelper(base.TestCase):
-
     @staticmethod
     def fake_storage_node(**kwargs):
         node = mock.MagicMock()
@@ -48,7 +47,8 @@ class TestCinderHelper(base.TestCase):
         cinder_util.cinder.services.list.return_value = [node1]
         cinder_util.get_storage_node_list()
         cinder_util.cinder.services.list.assert_called_once_with(
-            binary='cinder-volume')
+            binary='cinder-volume'
+        )
 
     def test_get_storage_node_by_name_success(self, mock_cinder):
         node1 = self.fake_storage_node()
@@ -65,7 +65,9 @@ class TestCinderHelper(base.TestCase):
         self.assertRaisesRegex(
             exception.StorageNodeNotFound,
             "The storage node failure could not be found",
-            cinder_util.get_storage_node_by_name, 'failure')
+            cinder_util.get_storage_node_by_name,
+            'failure',
+        )
 
     @staticmethod
     def fake_pool(**kwargs):
@@ -78,10 +80,8 @@ class TestCinderHelper(base.TestCase):
         pool.capabilities = kwargs.get('capabilities', default_capabilities)
 
         def _to_dict():
-            return {
-                'name': pool.name,
-                'capabilities': pool.capabilities
-            }
+            return {'name': pool.name, 'capabilities': pool.capabilities}
+
         pool.to_dict = _to_dict
 
         return pool
@@ -108,7 +108,9 @@ class TestCinderHelper(base.TestCase):
         self.assertRaisesRegex(
             exception.PoolNotFound,
             "The pool failure could not be found",
-            cinder_util.get_storage_pool_by_name, 'failure')
+            cinder_util.get_storage_pool_by_name,
+            'failure',
+        )
 
     @staticmethod
     def fake_volume_type(**kwargs):
@@ -126,22 +128,26 @@ class TestCinderHelper(base.TestCase):
         cinder_util.cinder.volume_types.list.assert_called_once_with()
 
     def test_get_volume_type_by_backendname_with_backend_exist(
-            self, mock_cinder):
+        self, mock_cinder
+    ):
         volume_type1 = self.fake_volume_type()
         cinder_util = cinder_helper.CinderHelper()
         cinder_util.cinder.volume_types.list.return_value = [volume_type1]
         volume_type_name = cinder_util.get_volume_type_by_backendname(
-            'backend')
+            'backend'
+        )
 
         self.assertEqual(volume_type_name[0], volume_type1.name)
 
     def test_get_volume_type_by_backendname_with_no_backend_exist(
-            self, mock_cinder):
+        self, mock_cinder
+    ):
         volume_type1 = self.fake_volume_type()
         cinder_util = cinder_helper.CinderHelper()
         cinder_util.cinder.volume_types.list.return_value = [volume_type1]
         volume_type_name = cinder_util.get_volume_type_by_backendname(
-            'nobackend')
+            'nobackend'
+        )
 
         self.assertEqual([], volume_type_name)
 
@@ -157,20 +163,19 @@ class TestCinderHelper(base.TestCase):
         volume.volume_type = kwargs.get('volume_type', 'fake_type')
         volume.migration_status = kwargs.get('migration_status')
         setattr(
-            volume, 'os-vol-host-attr:host',
-            kwargs.get('os_vol_host_attr_host')
+            volume,
+            'os-vol-host-attr:host',
+            kwargs.get('os_vol_host_attr_host'),
         )
         return volume
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     @mock.patch.object(cinder_helper.CinderHelper, 'get_storage_pool_by_name')
     def test_migrate_success(self, mock_get_pool, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume(
-            os_vol_host_attr_host='source_node',
-            migration_status='success'
+            os_vol_host_attr_host='source_node', migration_status='success'
         )
         cinder_util.cinder.volumes.get.return_value = volume
 
@@ -186,7 +191,6 @@ class TestCinderHelper(base.TestCase):
     @mock.patch.object(time, 'sleep', mock.Mock())
     @mock.patch.object(cinder_helper.CinderHelper, 'get_storage_pool_by_name')
     def test_migrate_fail(self, mock_get_pool, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -196,7 +200,7 @@ class TestCinderHelper(base.TestCase):
 
         volume_type = self.fake_volume_type(
             name='notbackend',
-            extra_specs={'volume_backend_name': 'diff_backend'}
+            extra_specs={'volume_backend_name': 'diff_backend'},
         )
         cinder_util.cinder.volume_types.list.return_value = [volume_type]
 
@@ -204,11 +208,13 @@ class TestCinderHelper(base.TestCase):
             exception.Invalid,
             "Volume type 'fake_type' is not compatible with destination "
             "pool 'host@backend#pool'",
-            cinder_util.migrate, volume, 'host@backend#pool')
+            cinder_util.migrate,
+            volume,
+            'host@backend#pool',
+        )
 
         volume = self.fake_volume(
-            migration_status='error',
-            os_vol_host_attr_host='source_node'
+            migration_status='error', os_vol_host_attr_host='source_node'
         )
         cinder_util.cinder.volumes.get.return_value = volume
 
@@ -263,7 +269,10 @@ class TestCinderHelper(base.TestCase):
         self.assertRaisesRegex(
             exception.Invalid,
             "Volume type must be different for retyping",
-            cinder_util.retype, volume, 'fake_type')
+            cinder_util.retype,
+            volume,
+            'fake_type',
+        )
 
         # type is not the expected one
         volume = self.fake_volume()
@@ -281,19 +290,18 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_create_volume_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
         cinder_util.cinder.volumes.get.return_value = volume
         cinder_util.cinder.volumes.create.return_value = volume
         new_vloume = cinder_util.create_volume(
-            cinder_util.cinder, volume, 'fake_type')
+            cinder_util.cinder, volume, 'fake_type'
+        )
         self.assertEqual(new_vloume, volume)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_create_volume_fail(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -304,12 +312,16 @@ class TestCinderHelper(base.TestCase):
         self.assertRaisesRegex(
             Exception,
             "Failed to create volume",
-            cinder_util.create_volume, cinder_util.cinder, volume,
-            'fake_type', retry=2, retry_interval=1)
+            cinder_util.create_volume,
+            cinder_util.cinder,
+            volume,
+            'fake_type',
+            retry=2,
+            retry_interval=1,
+        )
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_delete_volume_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -321,7 +333,6 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_delete_volume_fail(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -334,11 +345,11 @@ class TestCinderHelper(base.TestCase):
             Exception,
             "Failed to delete volume",
             cinder_util.delete_volume,
-            volume)
+            volume,
+        )
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_can_get_volume_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -348,25 +359,21 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_can_get_volume_fail(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
         cinder_util.get_volume = mock.MagicMock()
-        cinder_util.get_volume.side_effect =\
-            cinder_exception.NotFound(HTTPStatus.NOT_FOUND)
+        cinder_util.get_volume.side_effect = cinder_exception.NotFound(
+            HTTPStatus.NOT_FOUND
+        )
         result = cinder_util._can_get_volume(volume.id)
         self.assertFalse(result)
 
         cinder_util.get_volume = mock.MagicMock(return_value=None)
-        self.assertRaises(
-            Exception,
-            cinder_util._can_get_volume,
-            volume.id)
+        self.assertRaises(Exception, cinder_util._can_get_volume, volume.id)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_has_snapshot_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -377,7 +384,6 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_has_snapshot_fail(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -388,7 +394,6 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_get_volume_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -398,7 +403,6 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_get_volume_fail(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -410,31 +414,30 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_check_volume_deleted_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
         cinder_util.cinder.volumes.get.return_value = volume
         cinder_util._can_get_volume = mock.MagicMock(return_value=None)
         result = cinder_util.check_volume_deleted(
-            volume, retry=2, retry_interval=1)
+            volume, retry=2, retry_interval=1
+        )
         self.assertTrue(result)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_check_volume_deleted_fail(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
         cinder_util.cinder.volumes.get.return_value = volume
         cinder_util._can_get_volume = mock.MagicMock(return_value=volume)
         result = cinder_util.check_volume_deleted(
-            volume, retry=2, retry_interval=1)
+            volume, retry=2, retry_interval=1
+        )
         self.assertFalse(result)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_check_migrated_success(self, mock_cinder):
-
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume()
@@ -447,7 +450,6 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     def test_check_migrated_fail(self, mock_cinder):
-
         def side_effect(volume):
             if isinstance(volume, str):
                 volume = self.fake_volume()
@@ -492,28 +494,32 @@ class TestCinderHelper(base.TestCase):
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     @mock.patch.object(cinder_helper.LOG, 'debug')
-    def test_check_retyped_success_immediate(self, mock_log_debug,
-                                             mock_cinder):
-
+    def test_check_retyped_success_immediate(
+        self, mock_log_debug, mock_cinder
+    ):
         cinder_util = cinder_helper.CinderHelper()
 
         volume = self.fake_volume(status='in-use', volume_type='dest_type')
         cinder_util.cinder.volumes.get.return_value = volume
         cinder_util.check_volume_deleted = mock.MagicMock(return_value=True)
         result = cinder_util.check_retyped(volume, 'dest_type')
-        self.assertNotIn(mock.call('Waiting the retype of %s',
-                         volume), mock_log_debug.mock_calls)
+        self.assertNotIn(
+            mock.call('Waiting the retype of %s', volume),
+            mock_log_debug.mock_calls,
+        )
         mock_log_debug.assert_called_with(
             "Volume retype succeeded : volume %(volume)s has now type "
-            "'%(type)s'.", {'volume': volume.id, 'type': 'dest_type'})
+            "'%(type)s'.",
+            {'volume': volume.id, 'type': 'dest_type'},
+        )
         self.assertTrue(result)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     @mock.patch.object(cinder_helper.CinderHelper, 'get_volume')
     @mock.patch.object(cinder_helper.LOG, 'debug')
-    def test_check_retyped_success_retries(self, mock_log_debug,
-                                           mock_get_volume, mock_cinder):
-
+    def test_check_retyped_success_retries(
+        self, mock_log_debug, mock_get_volume, mock_cinder
+    ):
         cinder_util = cinder_helper.CinderHelper()
         volume = self.fake_volume(status='in-use')
 
@@ -536,18 +542,23 @@ class TestCinderHelper(base.TestCase):
         mock_log_debug.assert_any_call('Waiting the retype of %s', volume)
         mock_log_debug.assert_called_with(
             "Volume retype succeeded : volume %(volume)s has now type "
-            "'%(type)s'.", {'volume': volume.id, 'type': 'dest_type'})
+            "'%(type)s'.",
+            {'volume': volume.id, 'type': 'dest_type'},
+        )
         self.assertTrue(result)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     @mock.patch.object(cinder_helper.CinderHelper, 'get_volume')
     @mock.patch.object(cinder_helper.LOG, 'debug')
     def test_check_retyped_success_retries_migration(
-            self, mock_log_debug, mock_get_volume, mock_cinder):
-
+        self, mock_log_debug, mock_get_volume, mock_cinder
+    ):
         cinder_util = cinder_helper.CinderHelper()
-        volume = self.fake_volume(status='in-use', migration_status='success',
-                                  os_vol_host_attr_host='source_node')
+        volume = self.fake_volume(
+            status='in-use',
+            migration_status='success',
+            os_vol_host_attr_host='source_node',
+        )
 
         def side_effect(volume, status, volume_type):
             result_volume = copy.deepcopy(volume)
@@ -569,7 +580,9 @@ class TestCinderHelper(base.TestCase):
         mock_log_debug.assert_any_call('Waiting the retype of %s', volume)
         mock_log_debug.assert_called_with(
             "Volume retype succeeded : volume %(volume)s has now type "
-            "'%(type)s'.", {'volume': volume.id, 'type': 'dest_type'})
+            "'%(type)s'.",
+            {'volume': volume.id, 'type': 'dest_type'},
+        )
         self.assertTrue(result)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
@@ -577,9 +590,8 @@ class TestCinderHelper(base.TestCase):
     @mock.patch.object(cinder_helper.LOG, 'debug')
     @mock.patch.object(cinder_helper.LOG, 'error')
     def test_check_retyped_failed_available(
-            self, mock_log_error, mock_log_debug, mock_get_volume,
-            mock_cinder):
-
+        self, mock_log_error, mock_log_debug, mock_get_volume, mock_cinder
+    ):
         cinder_util = cinder_helper.CinderHelper()
         volume = self.fake_volume(status='available')
 
@@ -597,22 +609,24 @@ class TestCinderHelper(base.TestCase):
 
         cinder_util.cinder.volumes.get.return_value = volume
         result = cinder_util.check_retyped(
-            volume, 'dest_type', retry_interval=1)
+            volume, 'dest_type', retry_interval=1
+        )
         self.assertEqual(mock_get_volume.call_count, 3)
         mock_log_debug.assert_any_call('Waiting the retype of %s', volume)
         mock_log_error.assert_called_with(
             "Volume retype failed : volume %(volume)s has now type "
             "'%(type)s' and status %(status)s",
-            {'volume': volume.id, 'type': 'fake_type', 'status': 'available'})
+            {'volume': volume.id, 'type': 'fake_type', 'status': 'available'},
+        )
         self.assertFalse(result)
 
     @mock.patch.object(time, 'sleep', mock.Mock())
     @mock.patch.object(cinder_helper.CinderHelper, 'get_volume')
     @mock.patch.object(cinder_helper.LOG, 'debug')
     @mock.patch.object(cinder_helper.LOG, 'error')
-    def test_check_retyped_failed_inuse(self, mock_log_error, mock_log_debug,
-                                        mock_get_volume, mock_cinder):
-
+    def test_check_retyped_failed_inuse(
+        self, mock_log_error, mock_log_debug, mock_get_volume, mock_cinder
+    ):
         cinder_util = cinder_helper.CinderHelper()
         volume = self.fake_volume(status='in-use', migration_status='error')
 
@@ -631,148 +645,132 @@ class TestCinderHelper(base.TestCase):
 
         cinder_util.cinder.volumes.get.return_value = volume
         result = cinder_util.check_retyped(
-            volume, 'dest_type', retry_interval=1)
+            volume, 'dest_type', retry_interval=1
+        )
         self.assertEqual(mock_get_volume.call_count, 4)
         mock_log_debug.assert_any_call('Waiting the retype of %s', volume)
         mock_log_error.assert_any_call(
             "Volume retype failed : volume %(volume)s has now type "
             "'%(type)s' and status %(status)s",
-            {'volume': volume.id, 'type': 'fake_type', 'status': 'in-use'})
+            {'volume': volume.id, 'type': 'fake_type', 'status': 'in-use'},
+        )
         mock_log_error.assert_called_with(
             "Volume migration error on volume %(volume)s.",
-            {'volume': volume.id})
+            {'volume': volume.id},
+        )
         self.assertFalse(result)
 
-    def test_get_volume_types_for_pool_matching_backend(
-            self, mock_cinder):
+    def test_get_volume_types_for_pool_matching_backend(self, mock_cinder):
         """Test matching backend and no extra_specs are selected."""
         cinder_util = cinder_helper.CinderHelper()
         pool = self.fake_pool(
             name='host@backend#pool',
-            capabilities={'volume_backend_name': 'backend'}
+            capabilities={'volume_backend_name': 'backend'},
         )
         volume_type1 = self.fake_volume_type(
             name='type_matching',
-            extra_specs={'volume_backend_name': 'backend'}
+            extra_specs={'volume_backend_name': 'backend'},
         )
         volume_type2 = self.fake_volume_type(
-            name='type_no_specs',
-            extra_specs={}
+            name='type_no_specs', extra_specs={}
         )
         cinder_util.cinder.volume_types.list.return_value = [
-            volume_type1, volume_type2
+            volume_type1,
+            volume_type2,
         ]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
-        self.assertEqual(
-            sorted(result),
-            ['type_matching', 'type_no_specs'])
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
+        self.assertEqual(sorted(result), ['type_matching', 'type_no_specs'])
 
-    def test_get_volume_types_for_pool_different_backend(
-            self, mock_cinder):
+    def test_get_volume_types_for_pool_different_backend(self, mock_cinder):
         """Test different backend is excluded, no specs is included."""
         cinder_util = cinder_helper.CinderHelper()
         pool = self.fake_pool(
             name='host@backend#pool',
-            capabilities={'volume_backend_name': 'backend'}
+            capabilities={'volume_backend_name': 'backend'},
         )
         volume_type1 = self.fake_volume_type(
-            name='type_no_specs',
-            extra_specs={}
+            name='type_no_specs', extra_specs={}
         )
         volume_type2 = self.fake_volume_type(
             name='type_different_backend',
-            extra_specs={'volume_backend_name': 'different_backend'}
+            extra_specs={'volume_backend_name': 'different_backend'},
         )
         cinder_util.cinder.volume_types.list.return_value = [
-            volume_type1, volume_type2
+            volume_type1,
+            volume_type2,
         ]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
         self.assertEqual(result, ['type_no_specs'])
 
-    def test_get_volume_types_for_pool_matching_capability(
-            self, mock_cinder):
+    def test_get_volume_types_for_pool_matching_capability(self, mock_cinder):
         """Test volume type with matching capability is selected."""
         cinder_util = cinder_helper.CinderHelper()
         pool = self.fake_pool(
-            name='host@backend#pool',
-            capabilities={'disk_speed': 'fast'}
+            name='host@backend#pool', capabilities={'disk_speed': 'fast'}
         )
         volume_type = self.fake_volume_type(
-            name='type_fast_disk',
-            extra_specs={'disk_speed': 'fast'}
+            name='type_fast_disk', extra_specs={'disk_speed': 'fast'}
         )
-        cinder_util.cinder.volume_types.list.return_value = [
-            volume_type]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
+        cinder_util.cinder.volume_types.list.return_value = [volume_type]
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
         self.assertEqual(result, ['type_fast_disk'])
 
     def test_get_volume_types_for_pool_mismatched_capability(
-            self, mock_cinder):
+        self, mock_cinder
+    ):
         """Test volume type with different capability value excluded."""
         cinder_util = cinder_helper.CinderHelper()
         pool = self.fake_pool(
-            name='host@backend#pool',
-            capabilities={'disk_speed': 'fast'}
+            name='host@backend#pool', capabilities={'disk_speed': 'fast'}
         )
         volume_type = self.fake_volume_type(
-            name='type_slow_disk',
-            extra_specs={'disk_speed': 'slow'}
+            name='type_slow_disk', extra_specs={'disk_speed': 'slow'}
         )
-        cinder_util.cinder.volume_types.list.return_value = [
-            volume_type]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
+        cinder_util.cinder.volume_types.list.return_value = [volume_type]
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
         self.assertEqual([], result)
 
-    def test_get_volume_types_for_pool_no_capabilities(
-            self, mock_cinder):
+    def test_get_volume_types_for_pool_no_capabilities(self, mock_cinder):
         """Test pool with no capabilities selects no-specs types."""
         cinder_util = cinder_helper.CinderHelper()
-        pool = self.fake_pool(
-            name='host@backend#pool',
-            capabilities={}
-        )
+        pool = self.fake_pool(name='host@backend#pool', capabilities={})
         volume_type1 = self.fake_volume_type(
-            name='type_no_specs',
-            extra_specs={}
+            name='type_no_specs', extra_specs={}
         )
         volume_type2 = self.fake_volume_type(
             name='type_with_specs',
-            extra_specs={'volume_backend_name': 'backend'}
+            extra_specs={'volume_backend_name': 'backend'},
         )
         cinder_util.cinder.volume_types.list.return_value = [
-            volume_type1, volume_type2
+            volume_type1,
+            volume_type2,
         ]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
         self.assertEqual(result, ['type_no_specs', 'type_with_specs'])
 
     def test_get_volume_types_for_pool_requirements_not_in_caps(
-            self, mock_cinder):
+        self, mock_cinder
+    ):
         """Test volume type with requirements not in pool capabilities."""
         cinder_util = cinder_helper.CinderHelper()
         pool = self.fake_pool(
             name='host@backend#pool',
-            capabilities={'volume_backend_name': 'backend'}
+            capabilities={'volume_backend_name': 'backend'},
         )
         volume_type = self.fake_volume_type(
             name='type_extra_reqs',
             extra_specs={
                 'volume_backend_name': 'backend',
                 'disk_speed': 'fast',
-            }
+            },
         )
-        cinder_util.cinder.volume_types.list.return_value = [
-            volume_type]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
+        cinder_util.cinder.volume_types.list.return_value = [volume_type]
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
         self.assertEqual(result, ['type_extra_reqs'])
 
     def test_get_volume_types_for_pool_multiple_specs_partial_match(
-            self, mock_cinder):
+        self, mock_cinder
+    ):
         """Test volume type with multiple extra_specs partial match."""
         cinder_util = cinder_helper.CinderHelper()
         pool = self.fake_pool(
@@ -781,7 +779,7 @@ class TestCinderHelper(base.TestCase):
                 'volume_backend_name': 'backend',
                 'disk_speed': 'fast',
                 'compression': 'enabled',
-            }
+            },
         )
         volume_type = self.fake_volume_type(
             name='type_partial',
@@ -789,10 +787,8 @@ class TestCinderHelper(base.TestCase):
                 'volume_backend_name': 'backend',
                 'disk_speed': 'slow',
                 'compression': 'enabled',
-            }
+            },
         )
-        cinder_util.cinder.volume_types.list.return_value = [
-            volume_type]
-        result = cinder_util.get_volume_types_for_pool(
-            pool.to_dict())
+        cinder_util.cinder.volume_types.list.return_value = [volume_type]
+        result = cinder_util.get_volume_types_for_pool(pool.to_dict())
         self.assertEqual([], result)
diff --git a/watcher/tests/unit/common/test_clients.py b/watcher/tests/unit/common/test_clients.py
index 71b1811af..a3926d06b 100644
--- a/watcher/tests/unit/common/test_clients.py
+++ b/watcher/tests/unit/common/test_clients.py
@@ -32,7 +32,6 @@ CONF = conf.CONF
 
 
 class TestBaseClients(base.TestCase):
-
     def _register_watcher_clients_auth_opts(self):
         _AUTH_CONF_GROUP = 'watcher_clients_auth'
         ka_loading.register_auth_conf_options(CONF, _AUTH_CONF_GROUP)
@@ -62,15 +61,15 @@ class TestBaseClients(base.TestCase):
             conf_obj.register_opts = original_method
 
         original_register_opts = CONF.register_opts
-        self.addCleanup(reset_register_opts_mock,
-                        CONF,
-                        original_register_opts)
+        self.addCleanup(reset_register_opts_mock, CONF, original_register_opts)
 
-        expected = {'username': 'foousername',
-                    'password': 'foopassword',
-                    'auth_url': 'http://server.ip:5000',
-                    'user_domain_id': 'foouserdomainid',
-                    'project_domain_id': 'fooprojdomainid'}
+        expected = {
+            'username': 'foousername',
+            'password': 'foopassword',
+            'auth_url': 'http://server.ip:5000',
+            'user_domain_id': 'foouserdomainid',
+            'project_domain_id': 'fooprojdomainid',
+        }
 
         # Because some of the conf options for auth plugins are not registered
         # until right before they are loaded, and because the method that does
@@ -90,25 +89,27 @@ class TestBaseClients(base.TestCase):
 
 
 class TestClients(TestBaseClients):
-
     def test_get_keystone_session(self):
         self._register_watcher_clients_auth_opts()
 
         osc = clients.OpenStackClients()
 
-        expected = {'username': 'foousername',
-                    'password': 'foopassword',
-                    'auth_url': 'http://server.ip:5000',
-                    'user_domain_id': 'foouserdomainid',
-                    'project_domain_id': 'fooprojdomainid'}
+        expected = {
+            'username': 'foousername',
+            'password': 'foopassword',
+            'auth_url': 'http://server.ip:5000',
+            'user_domain_id': 'foouserdomainid',
+            'project_domain_id': 'fooprojdomainid',
+        }
 
         sess = osc.session
         self.assertEqual(expected['auth_url'], sess.auth.auth_url)
         self.assertEqual(expected['username'], sess.auth._username)
         self.assertEqual(expected['password'], sess.auth._password)
         self.assertEqual(expected['user_domain_id'], sess.auth._user_domain_id)
-        self.assertEqual(expected['project_domain_id'],
-                         sess.auth._project_domain_id)
+        self.assertEqual(
+            expected['project_domain_id'], sess.auth._project_domain_id
+        )
 
     @mock.patch.object(gnclient, 'Client')
     @mock.patch.object(clients.OpenStackClients, 'session')
@@ -120,8 +121,10 @@ class TestClients(TestBaseClients):
             CONF.gnocchi_client.api_version,
             adapter_options={
                 "interface": CONF.gnocchi_client.endpoint_type,
-                "region_name": CONF.gnocchi_client.region_name},
-            session=mock_session)
+                "region_name": CONF.gnocchi_client.region_name,
+            },
+            session=mock_session,
+        )
 
     @mock.patch.object(clients.OpenStackClients, 'session')
     def test_clients_gnocchi_diff_vers(self, mock_session):
@@ -159,7 +162,8 @@ class TestClients(TestBaseClients):
             CONF.cinder_client.api_version,
             endpoint_type=CONF.cinder_client.endpoint_type,
             region_name=CONF.cinder_client.region_name,
-            session=mock_session)
+            session=mock_session,
+        )
 
     @mock.patch.object(clients.OpenStackClients, 'session')
     def test_clients_cinder_diff_vers(self, mock_session):
@@ -171,8 +175,9 @@ class TestClients(TestBaseClients):
 
     @mock.patch.object(clients.OpenStackClients, 'session')
     def test_clients_cinder_diff_endpoint(self, mock_session):
-        CONF.set_override('endpoint_type',
-                          'internalURL', group='cinder_client')
+        CONF.set_override(
+            'endpoint_type', 'internalURL', group='cinder_client'
+        )
         osc = clients.OpenStackClients()
         osc._cinder = None
         osc.cinder()
@@ -214,18 +219,17 @@ class TestClients(TestBaseClients):
         osc._ironic = None
         osc.ironic()
         mock_session.get_endpoint.assert_called_with(
-            interface='publicURL',
-            region_name=None,
-            service_type='baremetal')
+            interface='publicURL', region_name=None, service_type='baremetal'
+        )
 
-        CONF.set_override('endpoint_type', 'internalURL',
-                          group='ironic_client')
+        CONF.set_override(
+            'endpoint_type', 'internalURL', group='ironic_client'
+        )
         osc._ironic = None
         osc.ironic()
         mock_session.get_endpoint.assert_called_with(
-            interface='internalURL',
-            region_name=None,
-            service_type='baremetal')
+            interface='internalURL', region_name=None, service_type='baremetal'
+        )
 
     @mock.patch.object(clients.OpenStackClients, 'session')
     def test_clients_ironic_cached(self, mock_session):
@@ -249,7 +253,8 @@ class TestClients(TestBaseClients):
             default_microversion=CONF.placement_client.api_version,
             interface=CONF.placement_client.interface,
             region_name=CONF.placement_client.region_name,
-            additional_headers=headers)
+            additional_headers=headers,
+        )
 
 
 class TestGetSDKConnection(TestBaseClients):
@@ -260,13 +265,13 @@ class TestGetSDKConnection(TestBaseClients):
         return super().setUp()
 
     @mock.patch('openstack.connection.Connection', autospec=True)
-    def test_get_sdk_connection_with_context(
-            self, mock_connect):
+    def test_get_sdk_connection_with_context(self, mock_connect):
         """Test SDK connection creation with context."""
 
         context_obj = context.RequestContext(
-            auth_token='test_token', project_id='test_project_id',
-            project_domain='test_project_domain_id'
+            auth_token='test_token',
+            project_id='test_project_id',
+            project_domain='test_project_domain_id',
         )
         mock_connection = mock.Mock()
         mock_connect.return_value = mock_connection
@@ -282,15 +287,17 @@ class TestGetSDKConnection(TestBaseClients):
             project_domain_id='test_project_domain_id',
             auth_url='http://server.ip:5000',
             interface=None,
-            region_name=None
+            region_name=None,
         )
         self.assertEqual(mock_connection, result)
 
-    @mock.patch.object(ka_loading, 'load_auth_from_conf_options',
-                       autospec=True)
+    @mock.patch.object(
+        ka_loading, 'load_auth_from_conf_options', autospec=True
+    )
     @mock.patch('openstack.connection.Connection', autospec=True)
     def test_get_sdk_connection_with_session(
-            self, mock_connect, mock_load_auth):
+        self, mock_connect, mock_load_auth
+    ):
         """Test SDK connection creation with provided session."""
         mock_session = mock.Mock()
         mock_connection = mock.Mock()
@@ -301,21 +308,21 @@ class TestGetSDKConnection(TestBaseClients):
         )
 
         mock_connect.assert_called_once_with(
-            session=mock_session,
-            oslo_conf=CONF
-        )
-        mock_load_auth.assert_called_once_with(
-            CONF, 'watcher_clients_auth'
+            session=mock_session, oslo_conf=CONF
         )
+        mock_load_auth.assert_called_once_with(CONF, 'watcher_clients_auth')
         self.assertEqual(mock_connection, result)
 
-    @mock.patch.object(ka_loading, 'load_session_from_conf_options',
-                       autospec=True)
-    @mock.patch.object(ka_loading, 'load_auth_from_conf_options',
-                       autospec=True)
+    @mock.patch.object(
+        ka_loading, 'load_session_from_conf_options', autospec=True
+    )
+    @mock.patch.object(
+        ka_loading, 'load_auth_from_conf_options', autospec=True
+    )
     @mock.patch('openstack.connection.Connection', autospec=True)
     def test_get_sdk_connection_no_session_no_context(
-            self, mock_connect, mock_load_auth, mock_load_session):
+        self, mock_connect, mock_load_auth, mock_load_session
+    ):
         """Test SDK connection creation without session or context."""
         mock_auth = mock.Mock()
         mock_session = mock.Mock()
@@ -326,15 +333,11 @@ class TestGetSDKConnection(TestBaseClients):
 
         result = clients.get_sdk_connection('watcher_clients_auth')
 
-        mock_load_auth.assert_called_once_with(
-            CONF, 'watcher_clients_auth'
-        )
+        mock_load_auth.assert_called_once_with(CONF, 'watcher_clients_auth')
         mock_load_session.assert_called_once_with(
-            CONF,
-            'watcher_clients_auth',
-            auth=mock_auth)
+            CONF, 'watcher_clients_auth', auth=mock_auth
+        )
         mock_connect.assert_called_once_with(
-            session=mock_session,
-            oslo_conf=CONF
+            session=mock_session, oslo_conf=CONF
         )
         self.assertEqual(mock_connection, result)
diff --git a/watcher/tests/unit/common/test_executor.py b/watcher/tests/unit/common/test_executor.py
index 5ac754379..a817119dc 100644
--- a/watcher/tests/unit/common/test_executor.py
+++ b/watcher/tests/unit/common/test_executor.py
@@ -23,7 +23,6 @@ from watcher.tests.unit import base
 
 @mock.patch.object(eventlet_helper, 'is_patched')
 class TestFuturistPoolExecutor(base.TestCase):
-
     def test_get_futurist_pool_executor_eventlet(self, eventlet_patched_mock):
         eventlet_patched_mock.return_value = True
 
@@ -41,14 +40,14 @@ class TestFuturistPoolExecutor(base.TestCase):
 
 @mock.patch.object(executor.CONF, 'print_thread_pool_stats', True)
 class TestLogExecutorStats(base.TestCase):
-
     @mock.patch.object(executor.LOG, 'debug')
     def test_log_executor_stats_eventlet(self, m_log_debug):
         workers = 2
         pool_executor = futurist.GreenThreadPoolExecutor(workers)
 
-        executor.log_executor_stats(pool_executor,
-                                    name="test-threadpool-eventlet")
+        executor.log_executor_stats(
+            pool_executor, name="test-threadpool-eventlet"
+        )
 
         m_log_debug.assert_called_once_with(
             "State of %s GreenThreadPoolExecutor when submitting a "
@@ -58,15 +57,17 @@ class TestLogExecutorStats(base.TestCase):
             len(pool_executor._pool.coroutines_running),
             workers,
             pool_executor._delayed_work.unfinished_tasks,
-            pool_executor.statistics)
+            pool_executor.statistics,
+        )
 
     @mock.patch.object(executor.LOG, 'debug')
     def test_log_executor_stats_threading(self, m_log_debug):
         workers = 3
         pool_executor = futurist.ThreadPoolExecutor(workers)
 
-        executor.log_executor_stats(pool_executor,
-                                    name="test-threadpool-threading")
+        executor.log_executor_stats(
+            pool_executor, name="test-threadpool-threading"
+        )
 
         m_log_debug.assert_called_once_with(
             "State of %s ThreadPoolExecutor when submitting a new "
@@ -77,4 +78,5 @@ class TestLogExecutorStats(base.TestCase):
             len(pool_executor._workers),
             len([w for w in pool_executor._workers if w.idle]),
             pool_executor._work_queue.qsize(),
-            pool_executor.statistics)
+            pool_executor.statistics,
+        )
diff --git a/watcher/tests/unit/common/test_ironic_helper.py b/watcher/tests/unit/common/test_ironic_helper.py
index b47604294..aecb738ae 100644
--- a/watcher/tests/unit/common/test_ironic_helper.py
+++ b/watcher/tests/unit/common/test_ironic_helper.py
@@ -26,7 +26,6 @@ from watcher.tests.unit import base
 
 
 class TestIronicHelper(base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -59,4 +58,6 @@ class TestIronicHelper(base.TestCase):
         self.assertRaisesRegex(
             exception.IronicNodeNotFound,
             "The ironic node node1 could not be found",
-            self.ironic_util.get_ironic_node_by_uuid, 'node1')
+            self.ironic_util.get_ironic_node_by_uuid,
+            'node1',
+        )
diff --git a/watcher/tests/unit/common/test_keystone_helper.py b/watcher/tests/unit/common/test_keystone_helper.py
index 0f91a5b04..8bf5e44e2 100644
--- a/watcher/tests/unit/common/test_keystone_helper.py
+++ b/watcher/tests/unit/common/test_keystone_helper.py
@@ -31,30 +31,37 @@ class TestKeystoneHelper(test.TestCase):
         self.keystone_helper = keystone_helper.KeystoneHelper()
 
     def test_is_service_enabled(self):
-        self.keystone_svs.list.return_value = [mock.MagicMock(
-            spec=ks_service.Service, enabled=True)]
+        self.keystone_svs.list.return_value = [
+            mock.MagicMock(spec=ks_service.Service, enabled=True)
+        ]
         self.assertTrue(
-            self.keystone_helper.is_service_enabled_by_type('block-storage'))
+            self.keystone_helper.is_service_enabled_by_type('block-storage')
+        )
         self.keystone_svs.list.assert_called_once_with(type='block-storage')
 
     def test_is_service_enabled_not_found(self):
         self.keystone_svs.list.return_value = []
         self.assertFalse(
-            self.keystone_helper.is_service_enabled_by_type('block-storage'))
+            self.keystone_helper.is_service_enabled_by_type('block-storage')
+        )
         self.keystone_svs.list.assert_called_once_with(type='block-storage')
 
     def test_is_service_enabled_with_multiple_services_one_enabled(self):
         self.keystone_svs.list.return_value = [
             mock.MagicMock(spec=ks_service.Service, enabled=True),
-            mock.MagicMock(spec=ks_service.Service, enabled=False)]
+            mock.MagicMock(spec=ks_service.Service, enabled=False),
+        ]
         self.assertTrue(
-            self.keystone_helper.is_service_enabled_by_type('block-storage'))
+            self.keystone_helper.is_service_enabled_by_type('block-storage')
+        )
         self.keystone_svs.list.assert_called_once_with(type='block-storage')
 
     def test_is_service_enabled_multiple_services_two_enabled(self):
         self.keystone_svs.list.return_value = [
             mock.MagicMock(spec=ks_service.Service, enabled=True),
-            mock.MagicMock(spec=ks_service.Service, enabled=True)]
+            mock.MagicMock(spec=ks_service.Service, enabled=True),
+        ]
         self.assertFalse(
-            self.keystone_helper.is_service_enabled_by_type('block-storage'))
+            self.keystone_helper.is_service_enabled_by_type('block-storage')
+        )
         self.keystone_svs.list.assert_called_once_with(type='block-storage')
diff --git a/watcher/tests/unit/common/test_nova_helper.py b/watcher/tests/unit/common/test_nova_helper.py
index 7d52cdfb6..4b83336d5 100644
--- a/watcher/tests/unit/common/test_nova_helper.py
+++ b/watcher/tests/unit/common/test_nova_helper.py
@@ -39,7 +39,6 @@ CONF = conf.CONF
 
 @mock.patch.object(clients.OpenStackClients, 'cinder')
 class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.instance_uuid = "fb5311b7-37f3-457e-9cde-6494a3c59bfe"
@@ -47,7 +46,8 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         self.destination_node = "ldev-indeedsrv006"
         self.flavor_name = "x1"
         self.mock_sleep = self.useFixture(
-            fixtures.MockPatchObject(time, 'sleep')).mock
+            fixtures.MockPatchObject(time, 'sleep')
+        ).mock
         self.mock_connection = self.useFixture(
             fixtures.MockPatch("watcher.common.clients.get_sdk_connection")
         ).mock.return_value
@@ -77,27 +77,27 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
                 fake_list
             ]
 
-    def test_get_compute_node_by_hostname(
-            self, mock_cinder):
+    def test_get_compute_node_by_hostname(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
         hypervisor_id = utils.generate_uuid()
         hypervisor_name = "fake_hypervisor_1"
         hypervisor = self.create_openstacksdk_hypervisor(
-            id=hypervisor_id,
-            name=hypervisor_name
+            id=hypervisor_id, name=hypervisor_name
         )
         self.mock_connection.compute.hypervisors.return_value = [hypervisor]
         # verify that the compute node can be obtained normally by name
         compute_node = nova_util.get_compute_node_by_hostname(hypervisor_name)
         self.assertEqual(
-            compute_node, nova_helper.Hypervisor.from_openstacksdk(hypervisor))
+            compute_node, nova_helper.Hypervisor.from_openstacksdk(hypervisor)
+        )
 
         # verify that getting the compute node with the wrong name
         # will throw an exception.
         self.assertRaises(
             exception.ComputeNodeNotFound,
             nova_util.get_compute_node_by_hostname,
-            "exception_hypervisor_1")
+            "exception_hypervisor_1",
+        )
 
         # verify that when the result of getting the compute node is empty
         # will throw an exception.
@@ -105,7 +105,8 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertRaises(
             exception.ComputeNodeNotFound,
             nova_util.get_compute_node_by_hostname,
-            hypervisor_name)
+            hypervisor_name,
+        )
 
     def test_get_compute_node_by_hostname_multiple_matches(self, mocks_cinder):
         # Tests a scenario where get_compute_node_by_name returns multiple
@@ -118,7 +119,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             node = self.create_openstacksdk_hypervisor(
                 id=utils.generate_uuid(),
                 name=hostname,
-                service_details={'host': hostname}
+                service_details={'host': hostname},
             )
             nodes.append(node)
         # We should get back exact matches based on the service host.
@@ -126,16 +127,15 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         for index, name in enumerate(['compute1', 'compute10']):
             result = nova_util.get_compute_node_by_hostname(name)
             self.assertEqual(
-                nova_helper.Hypervisor.from_openstacksdk(nodes[index]), result)
+                nova_helper.Hypervisor.from_openstacksdk(nodes[index]), result
+            )
 
-    def test_get_compute_node_by_uuid(
-            self, mock_cinder):
+    def test_get_compute_node_by_uuid(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
         hypervisor_id = utils.generate_uuid()
         hypervisor_name = "fake_hypervisor_1"
         hypervisor = self.create_openstacksdk_hypervisor(
-            id=hypervisor_id,
-            name=hypervisor_name
+            id=hypervisor_id, name=hypervisor_name
         )
         self.mock_connection.compute.get_hypervisor.return_value = hypervisor
         # verify that the compute node can be obtained normally by id
@@ -158,8 +158,11 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             filters={'host': 'fake-host'}, limit=2
         )
         self.mock_connection.compute.servers.assert_called_once_with(
-            details=True, all_projects=True, compute_host='fake-host',
-            limit=2, marker=None
+            details=True,
+            all_projects=True,
+            compute_host='fake-host',
+            limit=2,
+            marker=None,
         )
         self.assertEqual([], result)
 
@@ -167,24 +170,17 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_util = nova_helper.NovaHelper()
         instance_id = utils.generate_uuid()
         # verify that the method will return True when stopped
-        kwargs = {
-            "id": instance_id,
-            "vm_state": "stopped"
-        }
+        kwargs = {"id": instance_id, "vm_state": "stopped"}
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
-            self.mock_connection,
-            fake_find=server,
-            fake_list=server)
+            self.mock_connection, fake_find=server, fake_list=server
+        )
 
         result = nova_util.stop_instance(instance_id)
         self.assertTrue(result)
 
         # verify that the method will return False when active
-        kwargs = {
-            "id": instance_id,
-            "vm_state": "active"
-        }
+        kwargs = {"id": instance_id, "vm_state": "active"}
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=None
@@ -196,17 +192,13 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         # verify that the method will return True when the state of instance
         # is in the expected state.
         with mock.patch.object(
-            nova_util,
-            'wait_for_instance_state',
-            return_value=True
+            nova_util, 'wait_for_instance_state', return_value=True
         ) as mock_instance_state:
             result = nova_util.stop_instance(instance_id)
             self.assertTrue(result)
             mock_instance_state.assert_called_once_with(
-                mock.ANY,
-                "stopped",
-                8,
-                10)
+                mock.ANY, "stopped", 8, 10
+            )
 
         # verify that the method stop_instance will return False when the
         # server is not available.
@@ -219,24 +211,17 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_util = nova_helper.NovaHelper()
         instance_id = utils.generate_uuid()
         # verify that the method will return True when active
-        kwargs = {
-            "id": instance_id,
-            "vm_state": "active"
-        }
+        kwargs = {"id": instance_id, "vm_state": "active"}
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
-            self.mock_connection,
-            fake_find=server,
-            fake_list=server)
+            self.mock_connection, fake_find=server, fake_list=server
+        )
 
         result = nova_util.start_instance(instance_id)
         self.assertTrue(result)
 
         # verify that the method will return False when stopped
-        kwargs = {
-            "id": instance_id,
-            "vm_state": "stopped"
-        }
+        kwargs = {"id": instance_id, "vm_state": "stopped"}
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=None
@@ -248,17 +233,13 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         # verify that the method will return True when the state of instance
         # is in the expected state.
         with mock.patch.object(
-            nova_util,
-            'wait_for_instance_state',
-            return_value=True
+            nova_util, 'wait_for_instance_state', return_value=True
         ) as mock_instance_state:
             result = nova_util.start_instance(instance_id)
             self.assertTrue(result)
             mock_instance_state.assert_called_once_with(
-                mock.ANY,
-                "active",
-                8,
-                10)
+                mock.ANY, "active", 8, 10
+            )
 
         # verify that the method start_instance will return False when the
         # server is not available.
@@ -273,25 +254,26 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
     @mock.patch.object(
         nova_helper.NovaHelper, '_instance_confirm_resize', autospec=True
     )
-    def test_resize_instance(self, mock_confirm_resize, mock_resize,
-                             mock_cinder):
+    def test_resize_instance(
+        self, mock_confirm_resize, mock_resize, mock_cinder
+    ):
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "status": "VERIFY_RESIZE",
-            "vm_state": "resized"
+            "vm_state": "resized",
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
-            self.mock_connection,
-            fake_find=server,
-            fake_list=server)
+            self.mock_connection, fake_find=server, fake_list=server
+        )
         flavor = self.create_openstacksdk_flavor(
             id=self.flavor_name, name=self.flavor_name
         )
         self.mock_connection.compute.get_flavor.return_value = flavor
-        is_success = nova_util.resize_instance(self.instance_uuid,
-                                               self.flavor_name)
+        is_success = nova_util.resize_instance(
+            self.instance_uuid, self.flavor_name
+        )
         self.assertTrue(is_success)
         mock_resize.assert_called_once_with(
             nova_util, self.instance_uuid, self.flavor_name
@@ -306,19 +288,19 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "status": "SOMETHING_ELSE",
-            "vm_state": "resizing"
+            "vm_state": "resizing",
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
-            self.mock_connection,
-            fake_find=server,
-            fake_list=server)
+            self.mock_connection, fake_find=server, fake_list=server
+        )
         flavor = self.create_openstacksdk_flavor(
             id=self.flavor_name, name=self.flavor_name
         )
         self.mock_connection.compute.get_flavor.return_value = flavor
-        is_success = nova_util.resize_instance(self.instance_uuid,
-                                               self.flavor_name)
+        is_success = nova_util.resize_instance(
+            self.instance_uuid, self.flavor_name
+        )
         self.assertFalse(is_success)
         mock_resize.assert_called_once_with(
             nova_util, self.instance_uuid, self.flavor_name
@@ -330,25 +312,29 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "status": "RESIZING",
-            "vm_state": "resizing"
+            "vm_state": "resizing",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         kwargs = {
             "id": self.instance_uuid,
             "status": "VERIFY_RESIZE",
-            "vm_state": "resized"
+            "vm_state": "resized",
         }
         resized_server = self.create_openstacksdk_server(**kwargs)
 
         # This means instance will be found as VERIFY_RESIZE in second retry
-        self.mock_connection.compute.get_server.side_effect = (server, server,
-                                                               resized_server)
+        self.mock_connection.compute.get_server.side_effect = (
+            server,
+            server,
+            resized_server,
+        )
 
         self.mock_connection.compute.confirm_resize.return_value = True
 
-        self.flags(migration_max_retries=20, migration_interval=4,
-                   group='nova')
+        self.flags(
+            migration_max_retries=20, migration_interval=4, group='nova'
+        )
         # Resize will succeed because status changes to VERIFY_RESIZE
         is_success = nova_util.resize_instance(
             self.instance_uuid, self.flavor_name
@@ -369,7 +355,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "status": "RESIZING",
-            "vm_state": "resizing"
+            "vm_state": "resizing",
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(self.mock_connection, fake_find=server)
@@ -394,14 +380,15 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "status": "RESIZING",
-            "vm_state": "resizing"
+            "vm_state": "resizing",
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(self.mock_connection, fake_find=server)
 
         # Set config to a custom values to ensure custom values are used
-        self.flags(migration_max_retries=10,
-                   migration_interval=3, group='nova')
+        self.flags(
+            migration_max_retries=10, migration_interval=3, group='nova'
+        )
 
         is_success = nova_util.resize_instance(
             self.instance_uuid, self.flavor_name
@@ -420,13 +407,12 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
-            "compute_host": self.destination_node
+            "compute_host": self.destination_node,
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
-            self.mock_connection,
-            fake_find=server,
-            fake_list=server)
+            self.mock_connection, fake_find=server, fake_list=server
+        )
         is_success = nova_util.live_migrate_instance(
             self.instance_uuid, self.destination_node
         )
@@ -435,7 +421,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "task_state": "migrating"
+            "task_state": "migrating",
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
@@ -462,9 +448,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=None
         )
-        is_success = nova_util.live_migrate_instance(
-            self.instance_uuid, None
-        )
+        is_success = nova_util.live_migrate_instance(self.instance_uuid, None)
         self.assertFalse(is_success)
 
     @mock.patch.object(
@@ -477,7 +461,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "task_state": ""
+            "task_state": "",
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
@@ -505,31 +489,31 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_live_migrate', autospec=True
     )
     def test_live_migrate_instance_no_destination_node(
-            self, mock_migrate, mock_cinder
+        self, mock_migrate, mock_cinder
     ):
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "status": "MIGRATING"
+            "status": "MIGRATING",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.destination_node,
-            "status": "ACTIVE"
+            "status": "ACTIVE",
         }
         migrated_server = self.create_openstacksdk_server(**kwargs)
 
         self.mock_connection.compute.get_server.side_effect = (
-            server, server, migrated_server
+            server,
+            server,
+            migrated_server,
         )
 
         # Migration will success as will transition from migrating to ACTIVE
-        is_success = nova_util.live_migrate_instance(
-            self.instance_uuid, None
-        )
+        is_success = nova_util.live_migrate_instance(self.instance_uuid, None)
 
         # Should call once to migrate the instance
         mock_migrate.assert_called_once_with(
@@ -538,15 +522,14 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         # Should succeed
         self.assertTrue(is_success)
 
-    def test_watcher_non_live_migrate_instance_not_found(
-            self, mock_cinder):
+    def test_watcher_non_live_migrate_instance_not_found(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
         err = sdk_exc.NotFoundException()
         self.mock_connection.compute.get_server.side_effect = err
 
         is_success = nova_util.watcher_non_live_migrate_instance(
-            self.instance_uuid,
-            self.destination_node)
+            self.instance_uuid, self.destination_node
+        )
 
         self.assertFalse(is_success)
 
@@ -555,7 +538,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "task_state": None
+            "task_state": None,
         }
         server = self.create_openstacksdk_server(**kwargs)
         migration = self.create_openstacksdk_migration(id=2)
@@ -567,13 +550,16 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             self.mock_connection, fake_find=server, fake_list=server
         )
 
-        self.assertTrue(nova_util.abort_live_migrate(
-            self.instance_uuid, self.source_node, self.destination_node))
+        self.assertTrue(
+            nova_util.abort_live_migrate(
+                self.instance_uuid, self.source_node, self.destination_node
+            )
+        )
 
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.destination_node,
-            "task_state": None
+            "task_state": None,
         }
         server = self.create_openstacksdk_server(**kwargs)
 
@@ -581,8 +567,11 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             self.mock_connection, fake_find=server, fake_list=server
         )
 
-        self.assertFalse(nova_util.abort_live_migrate(
-            self.instance_uuid, self.source_node, self.destination_node))
+        self.assertFalse(
+            nova_util.abort_live_migrate(
+                self.instance_uuid, self.source_node, self.destination_node
+            )
+        )
 
         server.status = 'ERROR'
         self.assertRaises(
@@ -590,45 +579,53 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             nova_util.abort_live_migrate,
             self.instance_uuid,
             self.source_node,
-            self.destination_node)
+            self.destination_node,
+        )
 
         kwargs = {
             "id": self.instance_uuid,
             "task_state": "fake_task_state",
-            "compute_host": self.destination_node
+            "compute_host": self.destination_node,
         }
         server = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=None
         )
         self.fake_nova_migration_list(self.mock_connection, fake_list=None)
-        self.assertFalse(nova_util.abort_live_migrate(
-            self.instance_uuid, self.source_node, self.destination_node))
+        self.assertFalse(
+            nova_util.abort_live_migrate(
+                self.instance_uuid, self.source_node, self.destination_node
+            )
+        )
 
     @mock.patch.object(
         nova_helper.NovaHelper, '_instance_migrate', autospec=True
     )
     @mock.patch.object(nova_helper.NovaHelper, 'confirm_resize', autospec=True)
     def test_non_live_migrate_instance_no_destination_node(
-            self, mock_confirm_resize, mock_migrate, mock_cinder
+        self, mock_confirm_resize, mock_migrate, mock_cinder
     ):
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "status": "MIGRATING"
+            "status": "MIGRATING",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.destination_node,
-            "status": "VERIFY_RESIZE"
+            "status": "VERIFY_RESIZE",
         }
         migrated_server = self.create_openstacksdk_server(**kwargs)
 
         self.mock_connection.compute.get_server.side_effect = (
-            server, server, server, migrated_server)
+            server,
+            server,
+            server,
+            migrated_server,
+        )
 
         self.destination_node = None
         self.fake_nova_find_list(
@@ -648,32 +645,37 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_migrate', autospec=True
     )
     def test_watcher_non_live_migrate_instance_retry_success(
-            self, mock_migrate, mock_confirm_resize, mock_cinder):
+        self, mock_migrate, mock_confirm_resize, mock_cinder
+    ):
         """Test that watcher_non_live_migrate uses config timeout by default"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "status": 'MIGRATING',  # Never reaches ACTIVE
-            "compute_host": self.source_node
+            "compute_host": self.source_node,
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         kwargs = {
             "id": self.instance_uuid,
             "status": 'VERIFY_RESIZE',
-            "compute_host": self.destination_node
+            "compute_host": self.destination_node,
         }
         verify_server = self.create_openstacksdk_server(**kwargs)
 
         # This means instance will be found as VERIFY_RESIZE in second retry
         self.mock_connection.compute.get_server.side_effect = (
-            server, server, server, verify_server
+            server,
+            server,
+            server,
+            verify_server,
         )
 
         mock_confirm_resize.return_value = True
 
-        self.flags(migration_max_retries=20, migration_interval=4,
-                   group='nova')
+        self.flags(
+            migration_max_retries=20, migration_interval=4, group='nova'
+        )
         # Migration will success as will transition from MIGRATING to
         # VERIFY_RESIZE
         is_success = nova_util.watcher_non_live_migrate_instance(
@@ -682,7 +684,8 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
         # Should call once to migrate the instance
         mock_migrate.assert_called_once_with(
-            nova_util, self.instance_uuid, self.destination_node)
+            nova_util, self.instance_uuid, self.destination_node
+        )
         # Should succeed
         self.assertTrue(is_success)
         # It will sleep 2 times because it will be found as VERIFY_RESIZE in
@@ -696,13 +699,14 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_migrate', autospec=True
     )
     def test_watcher_non_live_migrate_instance_retry_default(
-            self, mock_migrate, mock_cinder):
+        self, mock_migrate, mock_cinder
+    ):
         """Test that watcher_non_live_migrate uses config timeout by default"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "status": "MIGRATING"
+            "status": "MIGRATING",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
@@ -717,7 +721,8 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
         # Should call once to migrate the instance
         mock_migrate.assert_called_once_with(
-            nova_util, self.instance_uuid, self.destination_node)
+            nova_util, self.instance_uuid, self.destination_node
+        )
         # Should fail due to timeout
         self.assertFalse(is_success)
         # With default migration_max_retries and migration_interval, should
@@ -731,19 +736,21 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_migrate', autospec=True
     )
     def test_watcher_non_live_migrate_instance_retry_custom(
-            self, mock_migrate, mock_cinder):
+        self, mock_migrate, mock_cinder
+    ):
         """Test that watcher_non_live_migrate respects explicit retry value"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "status": 'MIGRATING'  # Never reaches ACTIVE
+            "status": 'MIGRATING',  # Never reaches ACTIVE
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         # Set config to a custom values to ensure custom values are used
-        self.flags(migration_max_retries=10, migration_interval=3,
-                   group='nova')
+        self.flags(
+            migration_max_retries=10, migration_interval=3, group='nova'
+        )
 
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=server
@@ -755,7 +762,8 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
         # Should call once to migrate the instance
         mock_migrate.assert_called_once_with(
-            nova_util, self.instance_uuid, self.destination_node)
+            nova_util, self.instance_uuid, self.destination_node
+        )
         # Should fail due to timeout
         self.assertFalse(is_success)
         # It should sleep migration_max_retries times with migration_interval
@@ -769,14 +777,14 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_live_migrate', autospec=True
     )
     def test_live_migrate_instance_retry_default_success(
-            self, mock_migrate, mock_cinder
+        self, mock_migrate, mock_cinder
     ):
         """Test that live_migrate_instance uses config timeout by default"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "task_state": "migrating"
+            "task_state": "migrating",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
@@ -784,7 +792,11 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         migrated_server = self.create_openstacksdk_server(**kwargs)
 
         self.mock_connection.compute.get_server.side_effect = (
-            server, server, server, migrated_server)
+            server,
+            server,
+            server,
+            migrated_server,
+        )
 
         # Migration will success as will transition from migrating to ACTIVE
         is_success = nova_util.live_migrate_instance(
@@ -808,13 +820,14 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_live_migrate', autospec=True
     )
     def test_live_migrate_instance_retry_default(
-            self, mock_migrate, mock_cinder):
+        self, mock_migrate, mock_cinder
+    ):
         """Test that live_migrate_instance uses config timeout by default"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "task_state": "migrating"
+            "task_state": "migrating",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
@@ -844,20 +857,21 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_live_migrate', autospec=True
     )
     def test_live_migrate_instance_retry_custom(
-            self, mock_migrate, mock_cinder
+        self, mock_migrate, mock_cinder
     ):
         """Test that live_migrate_instance uses config timeout by default"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "task_state": "migrating"
+            "task_state": "migrating",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         # Set config value
-        self.flags(migration_max_retries=20, migration_interval=1.5,
-                   group='nova')
+        self.flags(
+            migration_max_retries=20, migration_interval=1.5, group='nova'
+        )
 
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=server
@@ -893,7 +907,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "status": "MIGRATING"
+            "status": "MIGRATING",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
@@ -902,9 +916,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         )
 
         # Migration with no destination will timeout
-        is_success = nova_util.live_migrate_instance(
-            self.instance_uuid, None
-        )
+        is_success = nova_util.live_migrate_instance(self.instance_uuid, None)
 
         # Should call once to migrate the instance
         mock_migrate.assert_called_once_with(
@@ -924,28 +936,28 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         nova_helper.NovaHelper, '_instance_live_migrate', autospec=True
     )
     def test_live_migrate_instance_no_dest_retry_custom(
-            self, mock_migrate, mock_cinder):
+        self, mock_migrate, mock_cinder
+    ):
         """Test live_migrate with no destination uses config timeout"""
         nova_util = nova_helper.NovaHelper()
         kwargs = {
             "id": self.instance_uuid,
             "compute_host": self.source_node,
-            "status": "MIGRATING"
+            "status": "MIGRATING",
         }
         server = self.create_openstacksdk_server(**kwargs)
 
         # Set config value
-        self.flags(migration_max_retries=10, migration_interval=3,
-                   group='nova')
+        self.flags(
+            migration_max_retries=10, migration_interval=3, group='nova'
+        )
 
         self.fake_nova_find_list(
             self.mock_connection, fake_find=server, fake_list=server
         )
 
         # Migration with no destination will timeout
-        is_success = nova_util.live_migrate_instance(
-            self.instance_uuid, None
-        )
+        is_success = nova_util.live_migrate_instance(self.instance_uuid, None)
 
         # Should call once to migrate the instance
         mock_migrate.assert_called_once_with(
@@ -1025,9 +1037,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
     )
     def test_confirm_resize(self, mock_confirm_resize, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=instance, fake_list=None
@@ -1052,46 +1062,45 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         hypervisor1_id = utils.generate_uuid()
         hypervisor1_name = "fake_hypervisor_1"
         hypervisor1 = self.create_openstacksdk_hypervisor(
-            id=hypervisor1_id, name=hypervisor1_name,
-            hypervisor_type="QEMU"
+            id=hypervisor1_id, name=hypervisor1_name, hypervisor_type="QEMU"
         )
 
         hypervisor2_id = utils.generate_uuid()
         hypervisor2_name = "fake_ironic"
         hypervisor2 = self.create_openstacksdk_hypervisor(
-            id=hypervisor2_id, name=hypervisor2_name,
-            hypervisor_type="ironic"
+            id=hypervisor2_id, name=hypervisor2_name, hypervisor_type="ironic"
         )
 
         self.mock_connection.compute.hypervisors.return_value = [
-            hypervisor1, hypervisor2
+            hypervisor1,
+            hypervisor2,
         ]
 
         compute_nodes = nova_util.get_compute_node_list()
 
         # baremetal node should be removed
         self.assertEqual(1, len(compute_nodes))
-        self.assertEqual(hypervisor1_name,
-                         compute_nodes[0].hypervisor_hostname)
+        self.assertEqual(
+            hypervisor1_name, compute_nodes[0].hypervisor_hostname
+        )
 
     def test_get_compute_node_list_with_ironic(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
         hypervisor1_id = utils.generate_uuid()
         hypervisor1_name = "fake_hypervisor_1"
         hypervisor1 = self.create_openstacksdk_hypervisor(
-            id=hypervisor1_id, name=hypervisor1_name,
-            hypervisor_type="QEMU"
+            id=hypervisor1_id, name=hypervisor1_name, hypervisor_type="QEMU"
         )
 
         hypervisor2_id = utils.generate_uuid()
         hypervisor2_name = "fake_ironic"
         hypervisor2 = self.create_openstacksdk_hypervisor(
-            id=hypervisor2_id, name=hypervisor2_name,
-            hypervisor_type="ironic"
+            id=hypervisor2_id, name=hypervisor2_name, hypervisor_type="ironic"
         )
 
         self.mock_connection.compute.hypervisors.return_value = [
-            hypervisor1, hypervisor2
+            hypervisor1,
+            hypervisor2,
         ]
 
         compute_nodes = nova_util.get_compute_node_list(
@@ -1100,16 +1109,16 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
         # baremetal node should be included
         self.assertEqual(2, len(compute_nodes))
-        self.assertEqual(hypervisor1_name,
-                         compute_nodes[0].hypervisor_hostname)
-        self.assertEqual(hypervisor2_name,
-                         compute_nodes[1].hypervisor_hostname)
+        self.assertEqual(
+            hypervisor1_name, compute_nodes[0].hypervisor_hostname
+        )
+        self.assertEqual(
+            hypervisor2_name, compute_nodes[1].hypervisor_hostname
+        )
 
     def test_find_instance(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=instance, fake_list=None
@@ -1119,20 +1128,19 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         self.assertEqual(1, self.mock_connection.compute.get_server.call_count)
         self.mock_sleep.assert_not_called()
         self.assertEqual(
-            nova_helper.Server.from_openstacksdk(instance), result)
+            nova_helper.Server.from_openstacksdk(instance), result
+        )
 
     def test_find_instance_retries(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=instance, fake_list=None
         )
         self.mock_connection.compute.get_server.side_effect = [
             ksa_exc.ConnectionError("Connection failed"),
-            instance
+            instance,
         ]
 
         result = nova_util.find_instance(self.instance_uuid)
@@ -1144,9 +1152,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
     def test_find_instance_retries_exhausts_retries(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         self.fake_nova_find_list(
             self.mock_connection, fake_find=instance, fake_list=None
@@ -1154,16 +1160,17 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         err = ksa_exc.ConnectionError("Connection failed")
         self.mock_connection.compute.get_server.side_effect = err
 
-        self.assertRaises(ksa_exc.ConnectionError,
-                          nova_util.find_instance, self.instance_uuid)
+        self.assertRaises(
+            ksa_exc.ConnectionError,
+            nova_util.find_instance,
+            self.instance_uuid,
+        )
         self.assertEqual(4, self.mock_connection.compute.get_server.call_count)
         self.assertEqual(3, self.mock_sleep.call_count)
 
     def test_nova_start_instance(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         nova_util._nova_start_instance(instance.id)
         self.mock_connection.compute.start_server.assert_called_once_with(
@@ -1172,19 +1179,16 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
     def test_nova_stop_instance(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         nova_util._nova_stop_instance(instance.id)
         self.mock_connection.compute.stop_server.assert_called_once_with(
-            instance.id)
+            instance.id
+        )
 
     def test_instance_resize(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         flavor_name = "m1.small"
 
@@ -1196,18 +1200,14 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
     def test_instance_confirm_resize(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         nova_util._instance_confirm_resize(instance)
         self.mock_connection.compute.confirm_server_resize(instance)
 
     def test_instance_live_migrate(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         dest_hostname = "dest_hostname"
         nova_util._instance_live_migrate(instance, dest_hostname)
@@ -1218,9 +1218,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
     def test_instance_migrate(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         dest_hostname = "dest_hostname"
         nova_util._instance_migrate(instance, dest_hostname)
@@ -1230,13 +1228,12 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
 
     def test_live_migration_abort(self, mock_cinder):
         nova_util = nova_helper.NovaHelper()
-        kwargs = {
-            "id": self.instance_uuid
-        }
+        kwargs = {"id": self.instance_uuid}
         instance = self.create_openstacksdk_server(**kwargs)
         nova_util._live_migration_abort(instance.id, 1)
-        self.mock_connection.compute.abort_server_migration.\
-            assert_called_once_with(1, instance.id)
+        self.mock_connection.compute.abort_server_migration.assert_called_once_with(
+            1, instance.id
+        )
 
     def test_is_pinned_az_available_version_supported(self, mock_cinder):
         """Test is_pinned_az_available returns True for version >= 2.96."""
@@ -1290,9 +1287,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         """Test get_flavor_id returns id when flavor is found by ID."""
         nova_util = nova_helper.NovaHelper()
         flavor_id = 'flavor-123'
-        flavor = self.create_openstacksdk_flavor(
-            id=flavor_id, name='m1.small'
-        )
+        flavor = self.create_openstacksdk_flavor(id=flavor_id, name='m1.small')
         self.mock_connection.compute.get_flavor.return_value = flavor
 
         result = nova_util.get_flavor_id(flavor_id)
@@ -1344,7 +1339,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             exception.ComputeResourceNotFound,
             f"{flavor_name} of type Flavor",
             nova_util.get_flavor_id,
-            flavor_name
+            flavor_name,
         )
 
     def test_get_flavor_id_not_found_in_list(self, mock_cinder):
@@ -1366,7 +1361,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
             exception.ComputeResourceNotFound,
             f"{flavor_name} of type Flavor",
             nova_util.get_flavor_id,
-            flavor_name
+            flavor_name,
         )
 
     def test_get_flavor_id_sdk_exception(self, mock_cinder):
@@ -1380,9 +1375,7 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         )
 
         self.assertRaises(
-            exception.NovaClientError,
-            nova_util.get_flavor_id,
-            flavor_id
+            exception.NovaClientError, nova_util.get_flavor_id, flavor_id
         )
 
     def test_get_flavor_id_by_name_multiple_flavors(self, mock_cinder):
@@ -1408,7 +1401,9 @@ class TestNovaHelper(test_utils.NovaResourcesMixin, base.TestCase):
         )
         # get_flavor_list returns multiple flavors
         self.mock_connection.compute.flavors.return_value = [
-            flavor1, flavor2, flavor3
+            flavor1,
+            flavor2,
+            flavor3,
         ]
 
         result = nova_util.get_flavor_id(flavor_name)
@@ -1422,10 +1417,12 @@ class TestNovaRetries(base.TestCase):
     def setUp(self):
         super().setUp()
         self.mock_sleep = self.useFixture(
-            fixtures.MockPatchObject(time, 'sleep')).mock
+            fixtures.MockPatchObject(time, 'sleep')
+        ).mock
 
     def test_nova_retries_success_on_first_attempt(self):
         """Test that decorator returns result when function succeeds."""
+
         @nova_helper.nova_retries
         def mock_function():
             return "success"
@@ -1498,6 +1495,7 @@ class TestNovaRetries(base.TestCase):
 
     def test_nova_retries_with_function_args(self):
         """Test that decorator preserves function arguments and return."""
+
         @nova_helper.nova_retries
         def mock_function(arg1, arg2, kwarg1=None):
             return f"{arg1}-{arg2}-{kwarg1}"
@@ -1508,6 +1506,7 @@ class TestNovaRetries(base.TestCase):
 
     def test_nova_retries_propagates_other_exceptions(self):
         """Test that decorator doesn't catch non-ConnectionError exception."""
+
         @nova_helper.nova_retries
         def mock_function():
             raise ValueError("Some other error")
@@ -1534,8 +1533,11 @@ class TestNovaRetries(base.TestCase):
         # Should have logged warning about connection error
         self.assertTrue(mock_log.warning.called)
         # Check that retry message was logged
-        warning_calls = [call for call in mock_log.warning.call_args_list
-                         if 'Retrying connection' in str(call)]
+        warning_calls = [
+            call
+            for call in mock_log.warning.call_args_list
+            if 'Retrying connection' in str(call)
+        ]
         self.assertEqual(1, len(warning_calls))
 
     @mock.patch.object(nova_helper, 'LOG')
@@ -1551,8 +1553,11 @@ class TestNovaRetries(base.TestCase):
 
         # Should have logged error about final failure
         self.assertTrue(mock_log.error.called)
-        error_calls = [call for call in mock_log.error.call_args_list
-                       if 'Failed to connect' in str(call)]
+        error_calls = [
+            call
+            for call in mock_log.error.call_args_list
+            if 'Failed to connect' in str(call)
+        ]
         self.assertEqual(1, len(error_calls))
 
     def test_nova_retries_single_retry_config(self):
@@ -1593,7 +1598,7 @@ class TestServerWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             locked=False,
             metadata={},
             availability_zone='nova',
-            pinned_availability_zone=None
+            pinned_availability_zone=None,
         )
         self.assertEqual(valid_uuid, server.uuid)
 
@@ -1615,7 +1620,7 @@ class TestServerWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             locked=False,
             metadata={},
             availability_zone='nova',
-            pinned_availability_zone=None
+            pinned_availability_zone=None,
         )
 
     def test_server_from_openstacksdk_basic_properties(self):
@@ -1629,7 +1634,7 @@ class TestServerWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             project_id='tenant-123',
             is_locked=True,
             metadata={'key': 'value'},
-            pinned_availability_zone='az1'
+            pinned_availability_zone='az1',
         )
 
         wrapped = nova_helper.Server.from_openstacksdk(sdk_server)
@@ -1652,7 +1657,7 @@ class TestServerWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             vm_state='active',
             task_state=None,
             power_state=1,
-            availability_zone='nova'
+            availability_zone='nova',
         )
 
         wrapped = nova_helper.Server.from_openstacksdk(sdk_server)
@@ -1667,8 +1672,7 @@ class TestServerWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         """Test Server.from_openstacksdk flavor property."""
         server_id = utils.generate_uuid()
         sdk_server = self.create_openstacksdk_server(
-            id=server_id,
-            flavor={'id': 'flavor-123', 'name': 'm1.small'}
+            id=server_id, flavor={'id': 'flavor-123', 'name': 'm1.small'}
         )
 
         wrapped = nova_helper.Server.from_openstacksdk(sdk_server)
@@ -1698,7 +1702,7 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             service_host='compute-1',
             service_id='svc-123',
             service_disabled_reason=None,
-            servers=[]
+            servers=[],
         )
         self.assertEqual(valid_uuid, hypervisor.uuid)
 
@@ -1721,7 +1725,7 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             service_host='compute-1',
             service_id='svc-123',
             service_disabled_reason=None,
-            servers=[]
+            servers=[],
         )
 
     def test_hypervisor_servers_property(self):
@@ -1732,19 +1736,11 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         # Create fake server objects with required attributes
         server1_id = utils.generate_uuid()
         server2_id = utils.generate_uuid()
-        server1 = {
-            'uuid': server1_id,
-            'name': 'server1',
-        }
-        server2 = {
-            'uuid': server2_id,
-            'name': 'server2'
-        }
+        server1 = {'uuid': server1_id, 'name': 'server1'}
+        server2 = {'uuid': server2_id, 'name': 'server2'}
 
         nova_hypervisor = self.create_openstacksdk_hypervisor(
-            id=hypervisor_id,
-            name=hostname,
-            servers=[server1, server2]
+            id=hypervisor_id, name=hostname, servers=[server1, server2]
         )
 
         wrapped = nova_helper.Hypervisor.from_openstacksdk(nova_hypervisor)
@@ -1770,7 +1766,7 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             memory_size=65536,
             memory_used=16384,
             local_disk_size=1000,
-            local_disk_used=250
+            local_disk_used=250,
         )
 
         wrapped = nova_helper.Hypervisor.from_openstacksdk(sdk_hypervisor)
@@ -1796,8 +1792,8 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             service_details={
                 'host': hostname,
                 'id': 42,
-                'disabled_reason': 'maintenance'
-            }
+                'disabled_reason': 'maintenance',
+            },
         )
 
         wrapped = nova_helper.Hypervisor.from_openstacksdk(sdk_hypervisor)
@@ -1811,7 +1807,7 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         sdk_hypervisor = self.create_openstacksdk_hypervisor(
             id=utils.generate_uuid(),
             name='compute-node-1',
-            service_details='not-a-dict'
+            service_details='not-a-dict',
         )
 
         wrapped = nova_helper.Hypervisor.from_openstacksdk(sdk_hypervisor)
@@ -1827,19 +1823,11 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
 
         server1_id = utils.generate_uuid()
         server2_id = utils.generate_uuid()
-        server1 = {
-            'uuid': server1_id,
-            'name': 'server1',
-        }
-        server2 = {
-            'uuid': server2_id,
-            'name': 'server2'
-        }
+        server1 = {'uuid': server1_id, 'name': 'server1'}
+        server2 = {'uuid': server2_id, 'name': 'server2'}
 
         sdk_hypervisor = self.create_openstacksdk_hypervisor(
-            id=hypervisor_id,
-            name=hostname,
-            servers=[server1, server2]
+            id=hypervisor_id, name=hostname, servers=[server1, server2]
         )
 
         wrapped = nova_helper.Hypervisor.from_openstacksdk(sdk_hypervisor)
@@ -1852,9 +1840,7 @@ class TestHypervisorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
     def test_hypervisor_from_openstacksdk_servers_none(self):
         """Test Hypervisor.from_openstacksdk when servers is None."""
         sdk_hypervisor = self.create_openstacksdk_hypervisor(
-            id=utils.generate_uuid(),
-            name='compute-node-1',
-            servers=None
+            id=utils.generate_uuid(), name='compute-node-1', servers=None
         )
 
         wrapped = nova_helper.Hypervisor.from_openstacksdk(sdk_hypervisor)
@@ -1875,7 +1861,7 @@ class TestFlavorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             disk=20,
             ephemeral=10,
             swap=512,
-            is_public=True
+            is_public=True,
         )
 
         wrapped = nova_helper.Flavor.from_openstacksdk(sdk_flavor)
@@ -1893,9 +1879,7 @@ class TestFlavorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         """Test Flavor.from_openstacksdk with zero swap."""
         flavor_id = utils.generate_uuid()
         sdk_flavor = self.create_openstacksdk_flavor(
-            id=flavor_id,
-            name='m1.noswap',
-            swap=0
+            id=flavor_id, name='m1.noswap', swap=0
         )
 
         wrapped = nova_helper.Flavor.from_openstacksdk(sdk_flavor)
@@ -1905,9 +1889,7 @@ class TestFlavorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         """Test Flavor.from_openstacksdk with private flavor."""
         flavor_id = utils.generate_uuid()
         sdk_flavor = self.create_openstacksdk_flavor(
-            id=flavor_id,
-            name='m1.private',
-            is_public=False
+            id=flavor_id, name='m1.private', is_public=False
         )
 
         wrapped = nova_helper.Flavor.from_openstacksdk(sdk_flavor)
@@ -1919,22 +1901,21 @@ class TestFlavorWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         sdk_flavor = self.create_openstacksdk_flavor(
             id=flavor_id,
             name='m1.compute',
-            extra_specs={'hw:cpu_policy': 'dedicated', 'hw:numa_nodes': '2'}
+            extra_specs={'hw:cpu_policy': 'dedicated', 'hw:numa_nodes': '2'},
         )
 
         wrapped = nova_helper.Flavor.from_openstacksdk(sdk_flavor)
 
         self.assertEqual(
             {'hw:cpu_policy': 'dedicated', 'hw:numa_nodes': '2'},
-            wrapped.extra_specs
+            wrapped.extra_specs,
         )
 
     def test_flavor_from_openstacksdk_without_extra_specs(self):
         """Test Flavor.from_openstacksdk without extra_specs."""
         flavor_id = utils.generate_uuid()
         sdk_flavor = self.create_openstacksdk_flavor(
-            id=flavor_id,
-            name='m1.basic'
+            id=flavor_id, name='m1.basic'
         )
 
         wrapped = nova_helper.Flavor.from_openstacksdk(sdk_flavor)
@@ -1952,7 +1933,7 @@ class TestAggregateWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             name='test-aggregate',
             availability_zone='az1',
             hosts=['host1', 'host2', 'host3'],
-            metadata={'ssd': 'true', 'gpu': 'nvidia'}
+            metadata={'ssd': 'true', 'gpu': 'nvidia'},
         )
 
         wrapped = nova_helper.Aggregate.from_openstacksdk(sdk_aggregate)
@@ -1967,9 +1948,7 @@ class TestAggregateWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         """Test Aggregate.from_openstacksdk without availability zone."""
         aggregate_id = utils.generate_uuid()
         sdk_aggregate = self.create_openstacksdk_aggregate(
-            id=aggregate_id,
-            name='test-aggregate',
-            availability_zone=None
+            id=aggregate_id, name='test-aggregate', availability_zone=None
         )
 
         wrapped = nova_helper.Aggregate.from_openstacksdk(sdk_aggregate)
@@ -1990,7 +1969,7 @@ class TestServiceWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             status='enabled',
             state='up',
             updated_at='2026-01-01T00:00:00Z',
-            disabled_reason=None
+            disabled_reason=None,
         )
         self.assertEqual(valid_uuid, service.uuid)
 
@@ -2006,7 +1985,7 @@ class TestServiceWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             status='enabled',
             state='up',
             updated_at='2026-01-01T00:00:00Z',
-            disabled_reason=None
+            disabled_reason=None,
         )
 
     def test_service_from_openstacksdk_basic_properties(self):
@@ -2020,7 +1999,7 @@ class TestServiceWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             status='enabled',
             state='up',
             updated_at='2026-01-09T12:00:00Z',
-            disabled_reason=None
+            disabled_reason=None,
         )
 
         wrapped = nova_helper.Service.from_openstacksdk(sdk_service)
@@ -2041,7 +2020,7 @@ class TestServiceWrapper(test_utils.NovaResourcesMixin, base.TestCase):
             id=service_id,
             status='disabled',
             state='down',
-            disabled_reason='maintenance'
+            disabled_reason='maintenance',
         )
 
         wrapped = nova_helper.Service.from_openstacksdk(sdk_service)
@@ -2056,6 +2035,7 @@ class TestHandleNovaError(base.TestCase):
 
     def test_handle_nova_error_returns_result_on_success(self):
         """Test that decorator returns result when function succeeds."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, instance_id):
             return "success"
@@ -2065,6 +2045,7 @@ class TestHandleNovaError(base.TestCase):
 
     def test_handle_nova_error_returns_none_on_not_found(self):
         """Test that decorator raises when NotFound is raised."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, instance_id):
             raise sdk_exc.NotFoundException()
@@ -2072,12 +2053,15 @@ class TestHandleNovaError(base.TestCase):
         self.assertRaisesRegex(
             exception.ComputeResourceNotFound,
             "instance-123 of type Instance",
-            mock_function, None, "instance-123"
+            mock_function,
+            None,
+            "instance-123",
         )
 
     @mock.patch.object(nova_helper, 'LOG', autospec=True)
     def test_handle_nova_error_logs_debug_message(self, mock_log):
         """Test that decorator logs debug message on NotFound."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, instance_id):
             raise sdk_exc.NotFoundException()
@@ -2085,14 +2069,18 @@ class TestHandleNovaError(base.TestCase):
         self.assertRaisesRegex(
             exception.ComputeResourceNotFound,
             "instance-123 of type Instance",
-            mock_function, None, "instance-123"
+            mock_function,
+            None,
+            "instance-123",
         )
 
         mock_log.debug.assert_called_once_with(
-            "%s %s was not found", "Instance", "instance-123")
+            "%s %s was not found", "Instance", "instance-123"
+        )
 
     def test_handle_nova_error_with_custom_resource_type(self):
         """Test that decorator uses custom resource type in log message."""
+
         @nova_helper.handle_nova_error("Flavor")
         def mock_function(self, flavor_id):
             raise sdk_exc.NotFoundException()
@@ -2101,13 +2089,17 @@ class TestHandleNovaError(base.TestCase):
             self.assertRaisesRegex(
                 exception.ComputeResourceNotFound,
                 "flavor-abc of type Flavor",
-                mock_function, None, "flavor-abc"
+                mock_function,
+                None,
+                "flavor-abc",
             )
             mock_log.debug.assert_called_once_with(
-                "%s %s was not found", "Flavor", "flavor-abc")
+                "%s %s was not found", "Flavor", "flavor-abc"
+            )
 
     def test_handle_nova_error_with_custom_id_arg_index(self):
         """Test that decorator uses custom id_arg_index."""
+
         @nova_helper.handle_nova_error("Aggregate", id_arg_index=2)
         def mock_function(self, other_arg, aggregate_id):
             raise sdk_exc.NotFoundException()
@@ -2116,13 +2108,18 @@ class TestHandleNovaError(base.TestCase):
             self.assertRaisesRegex(
                 exception.ComputeResourceNotFound,
                 "agg-123 of type Aggregate",
-                mock_function, None, "other", "agg-123"
+                mock_function,
+                None,
+                "other",
+                "agg-123",
             )
             mock_log.debug.assert_called_once_with(
-                "%s %s was not found", "Aggregate", "agg-123")
+                "%s %s was not found", "Aggregate", "agg-123"
+            )
 
     def test_handle_nova_error_logs_unknown_when_no_id_arg(self):
         """Test that decorator logs 'unknown' when id arg is missing."""
+
         @nova_helper.handle_nova_error("Instance", id_arg_index=5)
         def mock_function(self, instance_id):
             raise sdk_exc.NotFoundException()
@@ -2131,13 +2128,17 @@ class TestHandleNovaError(base.TestCase):
             self.assertRaisesRegex(
                 exception.ComputeResourceNotFound,
                 "unknown of type Instance",
-                mock_function, None, "instance-123"
+                mock_function,
+                None,
+                "instance-123",
             )
             mock_log.debug.assert_called_once_with(
-                "%s %s was not found", "Instance", "unknown")
+                "%s %s was not found", "Instance", "unknown"
+            )
 
     def test_handle_nova_error_propagates_non_nova_exceptions(self):
         """Test that decorator doesn't catch non-novaclient exceptions."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, instance_id):
             raise ValueError("Some other error")
@@ -2146,24 +2147,29 @@ class TestHandleNovaError(base.TestCase):
 
     def test_handle_nova_error_reraises_client_exception(self):
         """Test that ClientException is re-raised as NovaClientError."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, instance_id):
             raise sdk_exc.SDKException("Nova error")
 
         self.assertRaises(
-            exception.NovaClientError, mock_function, None, "instance-123")
+            exception.NovaClientError, mock_function, None, "instance-123"
+        )
 
     def test_handle_nova_error_logs_client_exception(self):
         """Test that ClientException is logged before re-raising."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, instance_id):
             raise sdk_exc.SDKException("Nova error")
 
         self.assertRaises(
-            exception.NovaClientError, mock_function, None, "instance-123")
+            exception.NovaClientError, mock_function, None, "instance-123"
+        )
 
     def test_handle_nova_error_preserves_function_args(self):
         """Test that decorator preserves function arguments and return."""
+
         @nova_helper.handle_nova_error("Instance")
         def mock_function(self, arg1, kwarg1=None):
             return f"{arg1}-{kwarg1}"
@@ -2173,6 +2179,7 @@ class TestHandleNovaError(base.TestCase):
 
     def test_handle_nova_error_preserves_function_name(self):
         """Test that decorator preserves function metadata."""
+
         @nova_helper.handle_nova_error("Instance")
         def my_function(self, instance_id):
             return "result"
@@ -2186,9 +2193,7 @@ class TestServerMigrationWrapper(test_utils.NovaResourcesMixin, base.TestCase):
     def test_migration_from_openstacksdk_basic_properties(self):
         """Test ServerMigration.from_openstacksdk with basic properties."""
         migration_id = utils.generate_uuid()
-        sdk_migration = self.create_openstacksdk_migration(
-            id=migration_id
-        )
+        sdk_migration = self.create_openstacksdk_migration(id=migration_id)
 
         wrapped = nova_helper.ServerMigration.from_openstacksdk(sdk_migration)
         self.assertEqual(migration_id, wrapped.id)
@@ -2199,11 +2204,14 @@ class TestServerMigrationWrapper(test_utils.NovaResourcesMixin, base.TestCase):
         migration_id2 = utils.generate_uuid()
 
         mig1a = nova_helper.ServerMigration.from_openstacksdk(
-            self.create_openstacksdk_migration(id=migration_id1))
+            self.create_openstacksdk_migration(id=migration_id1)
+        )
         mig1b = nova_helper.ServerMigration.from_openstacksdk(
-            self.create_openstacksdk_migration(id=migration_id1))
+            self.create_openstacksdk_migration(id=migration_id1)
+        )
         mig2 = nova_helper.ServerMigration.from_openstacksdk(
-            self.create_openstacksdk_migration(id=migration_id2))
+            self.create_openstacksdk_migration(id=migration_id2)
+        )
 
         # Same ID and attributes should be equal
         self.assertEqual(mig1a, mig1b)
diff --git a/watcher/tests/unit/common/test_oslo_service_helper.py b/watcher/tests/unit/common/test_oslo_service_helper.py
index 154ed2d4c..b6d538c8c 100644
--- a/watcher/tests/unit/common/test_oslo_service_helper.py
+++ b/watcher/tests/unit/common/test_oslo_service_helper.py
@@ -22,25 +22,22 @@ from watcher.tests.unit import base
 
 
 class TestOsloServiceHelper(base.TestCase):
-
     @mock.patch.object(eventlet_helper, 'is_patched')
     @mock.patch.object(backend, 'init_backend')
-    def test_init_oslo_backend_eventlet(self, mock_init_backend,
-                                        mock_is_patched):
-
+    def test_init_oslo_backend_eventlet(
+        self, mock_init_backend, mock_is_patched
+    ):
         mock_is_patched.return_value = True
 
         oslo_service_helper.init_oslo_service_backend()
 
-        mock_init_backend.assert_called_once_with(
-            backend.BackendType.EVENTLET
-        )
+        mock_init_backend.assert_called_once_with(backend.BackendType.EVENTLET)
 
     @mock.patch.object(eventlet_helper, 'is_patched')
     @mock.patch.object(backend, 'init_backend')
-    def test_init_oslo_backend_threading(self, mock_init_backend,
-                                         mock_is_patched):
-
+    def test_init_oslo_backend_threading(
+        self, mock_init_backend, mock_is_patched
+    ):
         mock_is_patched.return_value = False
 
         oslo_service_helper.init_oslo_service_backend()
diff --git a/watcher/tests/unit/common/test_placement_helper.py b/watcher/tests/unit/common/test_placement_helper.py
index ceeeb94aa..775cd9074 100644
--- a/watcher/tests/unit/common/test_placement_helper.py
+++ b/watcher/tests/unit/common/test_placement_helper.py
@@ -36,15 +36,14 @@ class TestPlacementHelper(base.TestCase):
         ka_loading.register_session_conf_options(CONF, _AUTH_CONF_GROUP)
         self.client = placement_helper.PlacementHelper()
         self.fake_err_msg = {
-            'errors': [{
-                'detail': 'The resource could not be found.',
-            }]
+            'errors': [{'detail': 'The resource could not be found.'}]
         }
 
     def _add_default_kwargs(self, kwargs):
         kwargs['endpoint_filter'] = {
             'service_type': 'placement',
-            'interface': CONF.placement_client.interface}
+            'interface': CONF.placement_client.interface,
+        }
         kwargs['headers'] = {'accept': 'application/json'}
         kwargs['microversion'] = CONF.placement_client.api_version
         kwargs['raise_exc'] = False
@@ -68,17 +67,20 @@ class TestPlacementHelper(base.TestCase):
         rp_uuid = uuidutils.generate_uuid()
         parent_uuid = uuidutils.generate_uuid()
 
-        fake_rp = [{'uuid': rp_uuid,
-                    'name': rp_name,
-                    'generation': 0,
-                    'parent_provider_uuid': parent_uuid}]
+        fake_rp = [
+            {
+                'uuid': rp_uuid,
+                'name': rp_name,
+                'generation': 0,
+                'parent_provider_uuid': parent_uuid,
+            }
+        ]
 
-        mock_json_data = {
-            'resource_providers': fake_rp
-        }
+        mock_json_data = {'resource_providers': fake_rp}
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_resource_providers(rp_name)
 
@@ -91,17 +93,20 @@ class TestPlacementHelper(base.TestCase):
         rp_uuid = uuidutils.generate_uuid()
         parent_uuid = uuidutils.generate_uuid()
 
-        fake_rp = [{'uuid': rp_uuid,
-                    'name': 'compute',
-                    'generation': 0,
-                    'parent_provider_uuid': parent_uuid}]
+        fake_rp = [
+            {
+                'uuid': rp_uuid,
+                'name': 'compute',
+                'generation': 0,
+                'parent_provider_uuid': parent_uuid,
+            }
+        ]
 
-        mock_json_data = {
-            'resource_providers': fake_rp
-        }
+        mock_json_data = {'resource_providers': fake_rp}
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_resource_providers(rp_name)
 
@@ -113,7 +118,8 @@ class TestPlacementHelper(base.TestCase):
         rp_name = 'compute'
         kss_req.return_value = fake_requests.FakeResponse(
             HTTPStatus.BAD_REQUEST,
-            content=jsonutils.dump_as_bytes(self.fake_err_msg))
+            content=jsonutils.dump_as_bytes(self.fake_err_msg),
+        )
         result = self.client.get_resource_providers(rp_name)
         self.assertIsNone(result)
 
@@ -127,7 +133,7 @@ class TestPlacementHelper(base.TestCase):
                 "min_unit": 1,
                 "reserved": 0,
                 "step_size": 1,
-                "total": 35
+                "total": 35,
             },
             "MEMORY_MB": {
                 "allocation_ratio": 1.5,
@@ -135,7 +141,7 @@ class TestPlacementHelper(base.TestCase):
                 "min_unit": 1,
                 "reserved": 512,
                 "step_size": 1,
-                "total": 5825
+                "total": 5825,
             },
             "VCPU": {
                 "allocation_ratio": 16.0,
@@ -143,16 +149,17 @@ class TestPlacementHelper(base.TestCase):
                 "min_unit": 1,
                 "reserved": 0,
                 "step_size": 1,
-                "total": 4
+                "total": 4,
             },
         }
         mock_json_data = {
             'inventories': fake_inventories,
-            "resource_provider_generation": 7
+            "resource_provider_generation": 7,
         }
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_inventories(rp_uuid)
 
@@ -164,22 +171,23 @@ class TestPlacementHelper(base.TestCase):
         rp_uuid = uuidutils.generate_uuid()
         kss_req.return_value = fake_requests.FakeResponse(
             HTTPStatus.NOT_FOUND,
-            content=jsonutils.dump_as_bytes(self.fake_err_msg))
+            content=jsonutils.dump_as_bytes(self.fake_err_msg),
+        )
         result = self.client.get_inventories(rp_uuid)
         self.assertIsNone(result)
 
     def test_get_provider_traits_OK(self, kss_req):
         rp_uuid = uuidutils.generate_uuid()
 
-        fake_traits = ["CUSTOM_HW_FPGA_CLASS1",
-                       "CUSTOM_HW_FPGA_CLASS3"]
+        fake_traits = ["CUSTOM_HW_FPGA_CLASS1", "CUSTOM_HW_FPGA_CLASS3"]
         mock_json_data = {
             'traits': fake_traits,
-            "resource_provider_generation": 7
+            "resource_provider_generation": 7,
         }
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_provider_traits(rp_uuid)
 
@@ -191,7 +199,8 @@ class TestPlacementHelper(base.TestCase):
         rp_uuid = uuidutils.generate_uuid()
         kss_req.return_value = fake_requests.FakeResponse(
             HTTPStatus.NOT_FOUND,
-            content=jsonutils.dump_as_bytes(self.fake_err_msg))
+            content=jsonutils.dump_as_bytes(self.fake_err_msg),
+        )
         result = self.client.get_provider_traits(rp_uuid)
         self.assertIsNone(result)
 
@@ -201,27 +210,23 @@ class TestPlacementHelper(base.TestCase):
         fake_allocations = {
             "92637880-2d79-43c6-afab-d860886c6391": {
                 "generation": 2,
-                "resources": {
-                    "DISK_GB": 5
-                }
+                "resources": {"DISK_GB": 5},
             },
             "ba8e1ef8-7fa3-41a4-9bb4-d7cb2019899b": {
                 "generation": 8,
-                "resources": {
-                    "MEMORY_MB": 512,
-                    "VCPU": 2
-                }
-            }
+                "resources": {"MEMORY_MB": 512, "VCPU": 2},
+            },
         }
         mock_json_data = {
             'allocations': fake_allocations,
             "consumer_generation": 1,
             "project_id": "7e67cbf7-7c38-4a32-b85b-0739c690991a",
-            "user_id": "067f691e-725a-451a-83e2-5c3d13e1dffc"
+            "user_id": "067f691e-725a-451a-83e2-5c3d13e1dffc",
         }
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_allocations_for_consumer(c_uuid)
 
@@ -233,25 +238,23 @@ class TestPlacementHelper(base.TestCase):
         c_uuid = uuidutils.generate_uuid()
         kss_req.return_value = fake_requests.FakeResponse(
             HTTPStatus.NOT_FOUND,
-            content=jsonutils.dump_as_bytes(self.fake_err_msg))
+            content=jsonutils.dump_as_bytes(self.fake_err_msg),
+        )
         result = self.client.get_allocations_for_consumer(c_uuid)
         self.assertIsNone(result)
 
     def test_get_usages_for_resource_provider_OK(self, kss_req):
         rp_uuid = uuidutils.generate_uuid()
 
-        fake_usages = {
-            "DISK_GB": 1,
-            "MEMORY_MB": 512,
-            "VCPU": 1
-        }
+        fake_usages = {"DISK_GB": 1, "MEMORY_MB": 512, "VCPU": 1}
         mock_json_data = {
             'usages': fake_usages,
-            "resource_provider_generation": 7
+            "resource_provider_generation": 7,
         }
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_usages_for_resource_provider(rp_uuid)
 
@@ -263,7 +266,8 @@ class TestPlacementHelper(base.TestCase):
         rp_uuid = uuidutils.generate_uuid()
         kss_req.return_value = fake_requests.FakeResponse(
             HTTPStatus.NOT_FOUND,
-            content=jsonutils.dump_as_bytes(self.fake_err_msg))
+            content=jsonutils.dump_as_bytes(self.fake_err_msg),
+        )
         result = self.client.get_usages_for_resource_provider(rp_uuid)
         self.assertIsNone(result)
 
@@ -272,38 +276,26 @@ class TestPlacementHelper(base.TestCase):
 
         fake_provider_summaries = {
             "a99bad54-a275-4c4f-a8a3-ac00d57e5c64": {
-                "resources": {
-                    "DISK_GB": {
-                        "used": 0,
-                        "capacity": 1900
-                    },
-                },
+                "resources": {"DISK_GB": {"used": 0, "capacity": 1900}},
                 "traits": ["MISC_SHARES_VIA_AGGREGATE"],
                 "parent_provider_uuid": None,
-                "root_provider_uuid": "a99bad54-a275-4c4f-a8a3-ac00d57e5c64"
+                "root_provider_uuid": "a99bad54-a275-4c4f-a8a3-ac00d57e5c64",
             },
             "35791f28-fb45-4717-9ea9-435b3ef7c3b3": {
                 "resources": {
-                    "VCPU": {
-                        "used": 0,
-                        "capacity": 384
-                    },
-                    "MEMORY_MB": {
-                        "used": 0,
-                        "capacity": 196608
-                    },
+                    "VCPU": {"used": 0, "capacity": 384},
+                    "MEMORY_MB": {"used": 0, "capacity": 196608},
                 },
                 "traits": ["HW_CPU_X86_SSE2", "HW_CPU_X86_AVX2"],
                 "parent_provider_uuid": None,
-                "root_provider_uuid": "35791f28-fb45-4717-9ea9-435b3ef7c3b3"
+                "root_provider_uuid": "35791f28-fb45-4717-9ea9-435b3ef7c3b3",
             },
         }
-        mock_json_data = {
-            'provider_summaries': fake_provider_summaries,
-        }
+        mock_json_data = {'provider_summaries': fake_provider_summaries}
 
         kss_req.return_value = fake_requests.FakeResponse(
-            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data))
+            HTTPStatus.OK, content=jsonutils.dump_as_bytes(mock_json_data)
+        )
 
         result = self.client.get_candidate_providers(resources)
 
@@ -315,6 +307,7 @@ class TestPlacementHelper(base.TestCase):
         rp_uuid = uuidutils.generate_uuid()
         kss_req.return_value = fake_requests.FakeResponse(
             HTTPStatus.NOT_FOUND,
-            content=jsonutils.dump_as_bytes(self.fake_err_msg))
+            content=jsonutils.dump_as_bytes(self.fake_err_msg),
+        )
         result = self.client.get_candidate_providers(rp_uuid)
         self.assertIsNone(result)
diff --git a/watcher/tests/unit/common/test_scheduling.py b/watcher/tests/unit/common/test_scheduling.py
index 31b690ca5..f62702d4b 100644
--- a/watcher/tests/unit/common/test_scheduling.py
+++ b/watcher/tests/unit/common/test_scheduling.py
@@ -19,7 +19,6 @@ from watcher.tests.unit import base
 
 
 class TestSchedulerMonkeyPatching(base.BaseTestCase):
-
     def setUp(self):
         super().setUp()
         self.started = False
@@ -54,7 +53,8 @@ class TestSchedulerMonkeyPatching(base.BaseTestCase):
     @mock.patch.object(background.BackgroundScheduler, '_main_loop')
     @mock.patch.object(eventlet_helper, 'patch')
     def test_main_loop_is_monkey_patched(
-            self, mock_eventlet_patch, mock_main_loop):
+        self, mock_eventlet_patch, mock_main_loop
+    ):
         self.test_scheduler._main_loop()
         mock_eventlet_patch.assert_called_once_with()
         mock_main_loop.assert_called_once_with()
diff --git a/watcher/tests/unit/common/test_service.py b/watcher/tests/unit/common/test_service.py
index d24546ab8..d2b95f61f 100644
--- a/watcher/tests/unit/common/test_service.py
+++ b/watcher/tests/unit/common/test_service.py
@@ -34,13 +34,11 @@ CONF = cfg.CONF
 
 
 class DummyEndpoint:
-
     def __init__(self, messaging):
         self._messaging = messaging
 
 
 class DummyManager:
-
     API_VERSION = '1.0'
 
     conductor_endpoints = [DummyEndpoint]
@@ -55,33 +53,31 @@ class DummyManager:
 
 
 class TestServiceHeartbeat(base.TestCase):
-
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(objects.Service, 'create')
-    def test_send_beat_with_creating_service(self, mock_create,
-                                             mock_list):
+    def test_send_beat_with_creating_service(self, mock_create, mock_list):
         CONF.set_default('host', 'fake-fqdn')
 
         mock_list.return_value = []
         service.ServiceHeartbeat(service_name='watcher-service')
-        mock_list.assert_called_once_with(mock.ANY,
-                                          filters={'name': 'watcher-service',
-                                                   'host': 'fake-fqdn'})
+        mock_list.assert_called_once_with(
+            mock.ANY, filters={'name': 'watcher-service', 'host': 'fake-fqdn'}
+        )
         self.assertEqual(1, mock_create.call_count)
 
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(objects.Service, 'save')
     def test_send_beat_without_creating_service(self, mock_save, mock_list):
-
-        mock_list.return_value = [objects.Service(mock.Mock(),
-                                                  name='watcher-service',
-                                                  host='controller')]
+        mock_list.return_value = [
+            objects.Service(
+                mock.Mock(), name='watcher-service', host='controller'
+            )
+        ]
         service.ServiceHeartbeat(service_name='watcher-service')
         self.assertEqual(1, mock_save.call_count)
 
 
 class TestService(base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -108,16 +104,14 @@ class TestService(base.TestCase):
     def test_init_service(self):
         dummy_service = service.Service(DummyManager)
         self.assertIsInstance(
-            dummy_service.conductor_topic_handler,
-            om.rpc.server.RPCServer)
+            dummy_service.conductor_topic_handler, om.rpc.server.RPCServer
+        )
 
 
 class TestServiceMonitoringBase(db_base.DbTestCase):
-
     def setUp(self):
         super().setUp()
-        fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow())
+        fake_service = utils.get_test_service(created_at=timeutils.utcnow())
         self.fake_service = objects.Service(**fake_service)
 
         class DummyServiceMonitoringBase(service.ServiceMonitoringBase):
@@ -125,18 +119,18 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
                 pass
 
         self.monitor = DummyServiceMonitoringBase(
-            service_name='watcher-monitored-service')
+            service_name='watcher-monitored-service'
+        )
 
     @freezegun.freeze_time("2016-10-18T09:52:05.219414")
     def test_get_service_status_up(self):
         fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow(),
-            last_seen_up=timeutils.utcnow())
+            created_at=timeutils.utcnow(), last_seen_up=timeutils.utcnow()
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
-        status = self.monitor.get_service_status(self.context,
-                                                 test_service.id)
+        status = self.monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.ACTIVE, status)
 
@@ -144,13 +138,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
     def test_get_service_status_down(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            last_seen_up=past)
+            created_at=past, last_seen_up=past
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
-        status = self.monitor.get_service_status(self.context,
-                                                 test_service.id)
+        status = self.monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -158,14 +151,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
     def test_get_service_status_down_last_seen_up_none(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            updated_at=past,
-            last_seen_up=None)
+            created_at=past, updated_at=past, last_seen_up=None
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
-        status = self.monitor.get_service_status(self.context,
-                                                 test_service.id)
+        status = self.monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -173,14 +164,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
     def test_get_service_status_down_updated_at_none(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            updated_at=None,
-            last_seen_up=None)
+            created_at=past, updated_at=None, last_seen_up=None
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
-        status = self.monitor.get_service_status(self.context,
-                                                 test_service.id)
+        status = self.monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -189,12 +178,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         """Test that string timestamps are properly converted."""
         fake_service = utils.get_test_service(
             created_at=timeutils.utcnow(),
-            last_seen_up="2016-10-18T09:52:05.219414")
+            last_seen_up="2016-10-18T09:52:05.219414",
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
-        status = self.monitor.get_service_status(self.context,
-                                                 test_service.id)
+        status = self.monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.ACTIVE, status)
 
@@ -207,46 +196,50 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         self.monitor.services_status[1] = objects.service.ServiceStatus.ACTIVE
         self.assertEqual(
             {1: objects.service.ServiceStatus.ACTIVE},
-            self.monitor.services_status
+            self.monitor.services_status,
         )
 
-    @mock.patch.object(service.ServiceMonitoringBase,
-                       'get_service_status')
+    @mock.patch.object(service.ServiceMonitoringBase, 'get_service_status')
     @mock.patch.object(objects.Service, 'list')
     def test_get_services_status_without_services_in_list(
-            self, mock_get_list, mock_service_status):
+        self, mock_get_list, mock_service_status
+    ):
         mock_get_list.return_value = []
         services_status = self.monitor.get_services_status(mock.ANY)
         self.assertEqual([], services_status)
         mock_service_status.assert_not_called()
 
-    @mock.patch.object(service.ServiceMonitoringBase,
-                       'get_service_status')
+    @mock.patch.object(service.ServiceMonitoringBase, 'get_service_status')
     @mock.patch.object(objects.Service, 'list')
     def test_get_services_status_with_services_in_list(
-            self, m_service_list, m_get_service_status):
+        self, m_service_list, m_get_service_status
+    ):
         """get_services_status returns only the services with service name."""
         # Create various services
         de_service1 = utils.get_test_service(
-            id=1, name='watcher-monitored-service', host='host1')
+            id=1, name='watcher-monitored-service', host='host1'
+        )
         de_service2 = utils.get_test_service(
-            id=2, name='watcher-monitored-service', host='host2')
+            id=2, name='watcher-monitored-service', host='host2'
+        )
         api_service = utils.get_test_service(
-            id=3, name='watcher-api', host='host3')
+            id=3, name='watcher-api', host='host3'
+        )
         applier_service = utils.get_test_service(
-            id=4, name='watcher-applier', host='host4')
+            id=4, name='watcher-applier', host='host4'
+        )
 
         m_service_list.return_value = [
             objects.Service(**de_service1),
             objects.Service(**de_service2),
             objects.Service(**api_service),
-            objects.Service(**applier_service)
+            objects.Service(**applier_service),
         ]
         m_get_service_status.side_effect = [
             objects.service.ServiceStatus.ACTIVE,
             objects.service.ServiceStatus.FAILED,
             objects.service.ServiceStatus.ACTIVE,
-            objects.service.ServiceStatus.ACTIVE
+            objects.service.ServiceStatus.ACTIVE,
         ]
 
         result = self.monitor.get_services_status(self.context)
@@ -257,14 +250,18 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
             match wservice.host:
                 case 'host1':
                     self.assertEqual(
-                        'watcher-monitored-service', wservice.name)
+                        'watcher-monitored-service', wservice.name
+                    )
                     self.assertEqual(
-                        objects.service.ServiceStatus.ACTIVE, wservice.state)
+                        objects.service.ServiceStatus.ACTIVE, wservice.state
+                    )
                 case 'host2':
                     self.assertEqual(
-                        'watcher-monitored-service', wservice.name)
+                        'watcher-monitored-service', wservice.name
+                    )
                     self.assertEqual(
-                        objects.service.ServiceStatus.FAILED, wservice.state)
+                        objects.service.ServiceStatus.FAILED, wservice.state
+                    )
                 case _:
                     self.fail(f'Unexpected host: {wservice.host}')
 
@@ -272,7 +269,8 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         """Test leader election with single active service."""
         # Create service objects with state attribute
         service1 = objects.Service(
-            id=1, name='watcher-monitored-service', host='host1')
+            id=1, name='watcher-monitored-service', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.ACTIVE
 
         # Test when current host is the leader
@@ -290,13 +288,16 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         # Create service objects with state attribute
         # sorted order: host1, host2, host3
         service1 = objects.Service(
-            id=1, name='watcher-monitored-service', host='host2')
+            id=1, name='watcher-monitored-service', host='host2'
+        )
         service1.state = objects.service.ServiceStatus.ACTIVE
         service2 = objects.Service(
-            id=2, name='watcher-monitored-service', host='host1')
+            id=2, name='watcher-monitored-service', host='host1'
+        )
         service2.state = objects.service.ServiceStatus.ACTIVE
         service3 = objects.Service(
-            id=3, name='watcher-monitored-service', host='host3')
+            id=3, name='watcher-monitored-service', host='host3'
+        )
         service3.state = objects.service.ServiceStatus.ACTIVE
 
         # Leader should be host1 (alphabetically first)
@@ -316,10 +317,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         """Test leader election ignores failed services."""
         # Create service objects with mixed states
         service1 = objects.Service(
-            id=1, name='watcher-monitored-service', host='host1')
+            id=1, name='watcher-monitored-service', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.FAILED
         service2 = objects.Service(
-            id=2, name='watcher-monitored-service', host='host2')
+            id=2, name='watcher-monitored-service', host='host2'
+        )
         service2.state = objects.service.ServiceStatus.ACTIVE
 
         # Leader should be host2 (only active service)
@@ -335,10 +338,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         """Test leader election ignores failed services."""
         # Create service objects with mixed states
         service1 = objects.Service(
-            id=1, name='watcher-monitored-service', host='host1')
+            id=1, name='watcher-monitored-service', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.FAILED
         service2 = objects.Service(
-            id=2, name='watcher-monitored-service', host='host2')
+            id=2, name='watcher-monitored-service', host='host2'
+        )
         service2.state = objects.service.ServiceStatus.ACTIVE
 
         # Leader should be host2 (only active service)
@@ -365,10 +370,12 @@ class TestServiceMonitoringBase(db_base.DbTestCase):
         """Test leader election when no services are active."""
         # Create service objects with all failed states
         service1 = objects.Service(
-            id=1, name='watcher-monitored-service', host='host1')
+            id=1, name='watcher-monitored-service', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.FAILED
         service2 = objects.Service(
-            id=2, name='watcher-monitored-service', host='host2')
+            id=2, name='watcher-monitored-service', host='host2'
+        )
         service2.state = objects.service.ServiceStatus.FAILED
 
         # Should return False when no services are active
diff --git a/watcher/tests/unit/common/test_utils.py b/watcher/tests/unit/common/test_utils.py
index ebaebf75d..b6c37e824 100644
--- a/watcher/tests/unit/common/test_utils.py
+++ b/watcher/tests/unit/common/test_utils.py
@@ -38,7 +38,8 @@ class TestCommonUtils(base.TestCase):
             IOError,
             utils.async_compat_call,
             self.test_coro,
-            raise_exc=OSError('fake error'))
+            raise_exc=OSError('fake error'),
+        )
 
     def test_async_compat_timeout(self):
         # Timeout not reached.
@@ -50,4 +51,6 @@ class TestCommonUtils(base.TestCase):
             asyncio.TimeoutError,
             utils.async_compat_call,
             self.test_coro,
-            sleep=0.5, timeout=0.1)
+            sleep=0.5,
+            timeout=0.1,
+        )
diff --git a/watcher/tests/unit/common/utils.py b/watcher/tests/unit/common/utils.py
index e046772cf..969ce72e3 100644
--- a/watcher/tests/unit/common/utils.py
+++ b/watcher/tests/unit/common/utils.py
@@ -45,7 +45,8 @@ class NovaResourcesMixin:
             'metadata': kwargs.pop('metadata', {}),
             'availability_zone': kwargs.pop('availability_zone', None),
             'pinned_availability_zone': kwargs.pop(
-                'pinned_availability_zone', None),
+                'pinned_availability_zone', None
+            ),
         }
         server_info.update(kwargs)
         return server.Server(**server_info)
@@ -140,8 +141,6 @@ class NovaResourcesMixin:
         :param kwargs: migration attributes
         :returns: openstack.compute.v2.server_migration.ServerMigration object
         """
-        migration_info = {
-            'id': kwargs.pop('id', 'migration-id'),
-        }
+        migration_info = {'id': kwargs.pop('id', 'migration-id')}
         migration_info.update(kwargs)
         return server_migration.ServerMigration(**migration_info)
diff --git a/watcher/tests/unit/conf/test_list_opts.py b/watcher/tests/unit/conf/test_list_opts.py
index 057b52405..acefdfd98 100644
--- a/watcher/tests/unit/conf/test_list_opts.py
+++ b/watcher/tests/unit/conf/test_list_opts.py
@@ -30,17 +30,32 @@ class TestListOpts(base.TestCase):
         super().setUp()
         # These option groups will be registered using strings instead of
         # OptGroup objects this should be avoided if possible.
-        self.none_objects = ['DEFAULT', 'watcher_clients_auth',
-                             'watcher_strategies.strategy_1']
+        self.none_objects = [
+            'DEFAULT',
+            'watcher_clients_auth',
+            'watcher_strategies.strategy_1',
+        ]
 
         self.base_sections = [
-            'DEFAULT', 'api', 'database', 'watcher_decision_engine',
-            'watcher_applier', 'watcher_datasources', 'watcher_planner',
-            'nova_client', 'gnocchi_client', 'grafana_client',
-            'grafana_translators', 'cinder_client',
-            'ironic_client', 'keystone_client',
-            'neutron_client', 'watcher_clients_auth', 'collector',
-            'placement_client']
+            'DEFAULT',
+            'api',
+            'database',
+            'watcher_decision_engine',
+            'watcher_applier',
+            'watcher_datasources',
+            'watcher_planner',
+            'nova_client',
+            'gnocchi_client',
+            'grafana_client',
+            'grafana_translators',
+            'cinder_client',
+            'ironic_client',
+            'keystone_client',
+            'neutron_client',
+            'watcher_clients_auth',
+            'collector',
+            'placement_client',
+        ]
         self.opt_sections = list(dict(opts.list_opts()).keys())
 
     def _assert_name_or_group(self, actual_sections, expected_sections):
@@ -56,7 +71,8 @@ class TestListOpts(base.TestCase):
                 # new groups should use OptGroup
                 raise Exception(
                     f"Invalid option group: {section_name} should be of "
-                    "type OptGroup not string.")
+                    "type OptGroup not string."
+                )
 
         self.assertIn(section_name, expected_sections)
         self.assertTrue(len(options))
@@ -75,14 +91,17 @@ class TestListOpts(base.TestCase):
         expected_sections = self.base_sections
         # Set up the fake Stevedore extensions
         fake_extmanager_call = extension.ExtensionManager.make_test_instance(
-            extensions=[extension.Extension(
-                name=fake_strategies.FakeDummy1Strategy2.get_name(),
-                entry_point=(
-                    f"{fake_strategies.FakeDummy1Strategy2.__module__}:"
-                    f"{fake_strategies.FakeDummy1Strategy2.__name__}"),
-                plugin=fake_strategies.FakeDummy1Strategy2,
-                obj=None,
-            )],
+            extensions=[
+                extension.Extension(
+                    name=fake_strategies.FakeDummy1Strategy2.get_name(),
+                    entry_point=(
+                        f"{fake_strategies.FakeDummy1Strategy2.__module__}:"
+                        f"{fake_strategies.FakeDummy1Strategy2.__name__}"
+                    ),
+                    plugin=fake_strategies.FakeDummy1Strategy2,
+                    obj=None,
+                )
+            ],
             namespace="watcher_strategies",
         )
 
@@ -91,7 +110,8 @@ class TestListOpts(base.TestCase):
                 return fake_extmanager_call
             else:
                 return extension.ExtensionManager.make_test_instance(
-                    extensions=[], namespace=namespace)
+                    extensions=[], namespace=namespace
+                )
 
         with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
             m_ext_manager.side_effect = m_list_available
@@ -102,17 +122,21 @@ class TestListOpts(base.TestCase):
 
     def test_list_opts_with_opts(self):
         expected_sections = self.base_sections + [
-            'watcher_strategies.strategy_1']
+            'watcher_strategies.strategy_1'
+        ]
         # Set up the fake Stevedore extensions
         fake_extmanager_call = extension.ExtensionManager.make_test_instance(
-            extensions=[extension.Extension(
-                name=fake_strategies.FakeDummy1Strategy1.get_name(),
-                entry_point=(
-                    f"{fake_strategies.FakeDummy1Strategy1.__module__}:"
-                    f"{fake_strategies.FakeDummy1Strategy1.__name__}"),
-                plugin=fake_strategies.FakeDummy1Strategy1,
-                obj=None,
-            )],
+            extensions=[
+                extension.Extension(
+                    name=fake_strategies.FakeDummy1Strategy1.get_name(),
+                    entry_point=(
+                        f"{fake_strategies.FakeDummy1Strategy1.__module__}:"
+                        f"{fake_strategies.FakeDummy1Strategy1.__name__}"
+                    ),
+                    plugin=fake_strategies.FakeDummy1Strategy1,
+                    obj=None,
+                )
+            ],
             namespace="watcher_strategies",
         )
 
@@ -121,7 +145,8 @@ class TestListOpts(base.TestCase):
                 return fake_extmanager_call
             else:
                 return extension.ExtensionManager.make_test_instance(
-                    extensions=[], namespace=namespace)
+                    extensions=[], namespace=namespace
+                )
 
         with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
             m_ext_manager.side_effect = m_list_available
@@ -136,18 +161,20 @@ class TestListOpts(base.TestCase):
 
 
 class TestPlugins(base.TestCase):
-
     def test_show_plugins(self):
         # Set up the fake Stevedore extensions
         fake_extmanager_call = extension.ExtensionManager.make_test_instance(
-            extensions=[extension.Extension(
-                name=fake_strategies.FakeDummy1Strategy1.get_name(),
-                entry_point=(
-                    f"{fake_strategies.FakeDummy1Strategy1.__module__}:"
-                    f"{fake_strategies.FakeDummy1Strategy1.__name__}"),
-                plugin=fake_strategies.FakeDummy1Strategy1,
-                obj=None,
-            )],
+            extensions=[
+                extension.Extension(
+                    name=fake_strategies.FakeDummy1Strategy1.get_name(),
+                    entry_point=(
+                        f"{fake_strategies.FakeDummy1Strategy1.__module__}:"
+                        f"{fake_strategies.FakeDummy1Strategy1.__name__}"
+                    ),
+                    plugin=fake_strategies.FakeDummy1Strategy1,
+                    obj=None,
+                )
+            ],
             namespace="watcher_strategies",
         )
 
@@ -156,7 +183,8 @@ class TestPlugins(base.TestCase):
                 return fake_extmanager_call
             else:
                 return extension.ExtensionManager.make_test_instance(
-                    extensions=[], namespace=namespace)
+                    extensions=[], namespace=namespace
+                )
 
         with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
             with mock.patch.object(
@@ -165,6 +193,12 @@ class TestPlugins(base.TestCase):
                 m_ext_manager.side_effect = m_list_available
                 plugins.show_plugins()
                 m_show.assert_called_once_with(
-                    [('watcher_strategies.strategy_1', 'strategy_1',
-                      'watcher.tests.unit.decision_engine.'
-                      'fake_strategies.FakeDummy1Strategy1')])
+                    [
+                        (
+                            'watcher_strategies.strategy_1',
+                            'strategy_1',
+                            'watcher.tests.unit.decision_engine.'
+                            'fake_strategies.FakeDummy1Strategy1',
+                        )
+                    ]
+                )
diff --git a/watcher/tests/unit/config.py b/watcher/tests/unit/config.py
index a214a0231..d71ac7a92 100644
--- a/watcher/tests/unit/config.py
+++ b/watcher/tests/unit/config.py
@@ -14,21 +14,14 @@ from watcher.api import hooks
 
 
 # Server Specific Configurations
-server = {
-    'port': '9322',
-    'host': '0.0.0.0'
-}
+server = {'port': '9322', 'host': '0.0.0.0'}
 
 # Pecan Application Configurations
 app = {
     'root': 'watcher.api.controllers.root.RootController',
     'modules': ['watcher.api'],
-    'hooks': [
-        hooks.ContextHook(),
-    ],
-    'acl_public_routes': [
-        '/'
-    ],
+    'hooks': [hooks.ContextHook()],
+    'acl_public_routes': ['/'],
 }
 
 # Custom Configurations must be in Python dictionary format::
diff --git a/watcher/tests/unit/db/base.py b/watcher/tests/unit/db/base.py
index 096b7cc9a..0b0e8e722 100644
--- a/watcher/tests/unit/db/base.py
+++ b/watcher/tests/unit/db/base.py
@@ -14,6 +14,7 @@
 #    under the License.
 
 """Watcher DB test base class."""
+
 import os
 import sqlite3
 import tempfile
@@ -36,8 +37,9 @@ CONF = cfg.CONF
 CONF.import_opt('enable_authentication', 'watcher.api.acl')
 
 
-class SqliteDatabaseFixture(test_fixtures.GeneratesSchema,
-                            test_fixtures.AdHocDbFixture):
+class SqliteDatabaseFixture(
+    test_fixtures.GeneratesSchema, test_fixtures.AdHocDbFixture
+):
     """oslo_db-based fixture for SQLite-backed tests.
 
     This uses oslo_db's AdHocDbFixture to provision a per-test (or per-run)
@@ -56,7 +58,6 @@ class SqliteDatabaseFixture(test_fixtures.GeneratesSchema,
 
 
 class DbTestCase(base.TestCase):
-
     def get_next_id(self):
         return next(self._id_gen)
 
@@ -70,12 +71,14 @@ class DbTestCase(base.TestCase):
         # native thread, since each one can have its own connection to
         # the database. Files created by SQLite will be cleaned up
         # by the NestedTempfile fixture.
-        fd, dbfile_path = tempfile.mkstemp(prefix="watcher_test_",
-                                           suffix=".db")
+        fd, dbfile_path = tempfile.mkstemp(
+            prefix="watcher_test_", suffix=".db"
+        )
         # close the file descriptor before SQLite connects
         os.close(fd)
         CONF.set_override(
-            "connection", f"sqlite:///{dbfile_path}", group="database")
+            "connection", f"sqlite:///{dbfile_path}", group="database"
+        )
 
         # Enable WAL journaling mode: "WAL provides more concurrency as
         # readers do not block writers and a writer does not block readers."
@@ -95,11 +98,14 @@ class DbTestCase(base.TestCase):
         local_enginefacade = enginefacade.transaction_context()
         local_enginefacade.configure(
             connection=CONF.database.connection,
-            sqlite_synchronous=CONF.database.sqlite_synchronous)
+            sqlite_synchronous=CONF.database.sqlite_synchronous,
+        )
 
         self.useFixture(
             test_fixtures.ReplaceEngineFacadeFixture(
-                enginefacade._context_manager, local_enginefacade))
+                enginefacade._context_manager, local_enginefacade
+            )
+        )
 
         # Provision and configure a SQLite database for this test using
         # oslo_db's fixtures.
@@ -113,14 +119,12 @@ class DbTestCase(base.TestCase):
 
 
 class MySQLDbTestCase(test_fixtures.OpportunisticDBTestMixin, base.TestCase):
-
     FIXTURE = test_fixtures.MySQLOpportunisticFixture
 
     def setUp(self):
         conn_str = "mysql+pymysql://root:insecure_slave@127.0.0.1"
         # to use mysql db
-        cfg.CONF.set_override("connection", conn_str,
-                              group="database")
+        cfg.CONF.set_override("connection", conn_str, group="database")
         super().setUp()
         self.engine = enginefacade.writer.get_engine()
         self.dbapi = dbapi.get_instance()
diff --git a/watcher/tests/unit/db/test_action.py b/watcher/tests/unit/db/test_action.py
index 8e40e5c4f..6c3e08573 100644
--- a/watcher/tests/unit/db/test_action.py
+++ b/watcher/tests/unit/db/test_action.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbActionFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -39,21 +38,27 @@ class TestDbActionFilters(base.DbTestCase):
         self.audit_template_name = "Audit Template"
 
         self.audit_template = utils.create_test_audit_template(
-            name=self.audit_template_name, id=1, uuid=None)
+            name=self.audit_template_name, id=1, uuid=None
+        )
         self.audit = utils.create_test_audit(
-            audit_template_id=self.audit_template.id, id=1, uuid=None)
+            audit_template_id=self.audit_template.id, id=1, uuid=None
+        )
         self.action_plan = utils.create_test_action_plan(
-            audit_id=self.audit.id, id=1, uuid=None)
+            audit_id=self.audit.id, id=1, uuid=None
+        )
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.action1 = utils.create_test_action(
-                action_plan_id=self.action_plan.id, id=1, uuid=None)
+                action_plan_id=self.action_plan.id, id=1, uuid=None
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.action2 = utils.create_test_action(
-                action_plan_id=self.action_plan.id, id=2, uuid=None)
+                action_plan_id=self.action_plan.id, id=2, uuid=None
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.action3 = utils.create_test_action(
-                action_plan_id=self.action_plan.id, id=3, uuid=None)
+                action_plan_id=self.action_plan.id, id=3, uuid=None
+            )
 
     def _soft_delete_actions(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -67,22 +72,26 @@ class TestDbActionFilters(base.DbTestCase):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_action(
                 self.action1.uuid,
-                values={"state": objects.action_plan.State.SUCCEEDED})
+                values={"state": objects.action_plan.State.SUCCEEDED},
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_action(
                 self.action2.uuid,
-                values={"state": objects.action_plan.State.SUCCEEDED})
+                values={"state": objects.action_plan.State.SUCCEEDED},
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_action(
                 self.action3.uuid,
-                values={"state": objects.action_plan.State.SUCCEEDED})
+                values={"state": objects.action_plan.State.SUCCEEDED},
+            )
 
     def test_get_action_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_action(self.action1.uuid)
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
@@ -91,16 +100,19 @@ class TestDbActionFilters(base.DbTestCase):
             self.dbapi.soft_delete_action(self.action1.uuid)
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
-        self.assertEqual([self.action2['id'], self.action3['id']],
-                         [r.id for r in res])
+        self.assertEqual(
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_deleted_at_eq(self):
         self._soft_delete_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
@@ -108,27 +120,30 @@ class TestDbActionFilters(base.DbTestCase):
         self._soft_delete_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            [self.action2['id'], self.action3['id']],
-            [r.id for r in res])
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_deleted_at_lte(self):
         self._soft_delete_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.action2['id'], self.action3['id']],
-            [r.id for r in res])
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_deleted_at_gt(self):
         self._soft_delete_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
@@ -136,50 +151,56 @@ class TestDbActionFilters(base.DbTestCase):
         self._soft_delete_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.action1['id'], self.action2['id']],
-            [r.id for r in res])
+            [self.action1['id'], self.action2['id']], [r.id for r in res]
+        )
 
     # created_at #
 
     def test_get_action_filter_created_at_eq(self):
         res = self.dbapi.get_action_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
     def test_get_action_filter_created_at_lt(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             res = self.dbapi.get_action_list(
-                self.context, filters={'created_at__lt': self.FAKE_TODAY})
+                self.context, filters={'created_at__lt': self.FAKE_TODAY}
+            )
 
         self.assertEqual(
-            [self.action2['id'], self.action3['id']],
-            [r.id for r in res])
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_created_at_lte(self):
         res = self.dbapi.get_action_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.action2['id'], self.action3['id']],
-            [r.id for r in res])
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_created_at_gt(self):
         res = self.dbapi.get_action_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
     def test_get_action_filter_created_at_gte(self):
         res = self.dbapi.get_action_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.action1['id'], self.action2['id']],
-            [r.id for r in res])
+            [self.action1['id'], self.action2['id']], [r.id for r in res]
+        )
 
     # updated_at #
 
@@ -187,7 +208,8 @@ class TestDbActionFilters(base.DbTestCase):
         self._update_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
@@ -195,27 +217,30 @@ class TestDbActionFilters(base.DbTestCase):
         self._update_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            [self.action2['id'], self.action3['id']],
-            [r.id for r in res])
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_updated_at_lte(self):
         self._update_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.action2['id'], self.action3['id']],
-            [r.id for r in res])
+            [self.action2['id'], self.action3['id']], [r.id for r in res]
+        )
 
     def test_get_action_filter_updated_at_gt(self):
         self._update_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action1['id']], [r.id for r in res])
 
@@ -223,15 +248,15 @@ class TestDbActionFilters(base.DbTestCase):
         self._update_actions()
 
         res = self.dbapi.get_action_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.action1['id'], self.action2['id']],
-            [r.id for r in res])
+            [self.action1['id'], self.action2['id']], [r.id for r in res]
+        )
 
 
 class DbActionTestCase(base.DbTestCase):
-
     def test_get_action_list(self):
         uuids = []
         for _ in range(1, 4):
@@ -251,15 +276,18 @@ class DbActionTestCase(base.DbTestCase):
         uuids = []
         for i in range(1, 4):
             action = utils.create_test_action(
-                id=i, uuid=w_utils.generate_uuid(),
-                action_plan_id=action_plan.id)
+                id=i,
+                uuid=w_utils.generate_uuid(),
+                action_plan_id=action_plan.id,
+            )
             uuids.append(str(action['uuid']))
         actions = self.dbapi.get_action_list(self.context, eager=True)
         action_map = {a.uuid: a for a in actions}
         self.assertEqual(sorted(uuids), sorted(action_map.keys()))
         eager_action = action_map[action.uuid]
         self.assertEqual(
-            action_plan.as_dict(), eager_action.action_plan.as_dict())
+            action_plan.as_dict(), eager_action.action_plan.as_dict()
+        )
 
     def test_get_action_list_with_filters(self):
         audit = utils.create_test_audit(uuid=w_utils.generate_uuid())
@@ -268,7 +296,8 @@ class DbActionTestCase(base.DbTestCase):
             uuid=w_utils.generate_uuid(),
             audit_id=audit.id,
             parents=None,
-            state=objects.action_plan.State.RECOMMENDED)
+            state=objects.action_plan.State.RECOMMENDED,
+        )
 
         action1 = utils.create_test_action(
             id=1,
@@ -276,71 +305,78 @@ class DbActionTestCase(base.DbTestCase):
             description='description action 1',
             uuid=w_utils.generate_uuid(),
             parents=None,
-            state=objects.action_plan.State.PENDING)
+            state=objects.action_plan.State.PENDING,
+        )
         action2 = utils.create_test_action(
             id=2,
             action_plan_id=2,
             description='description action 2',
             uuid=w_utils.generate_uuid(),
             parents=[action1['uuid']],
-            state=objects.action_plan.State.PENDING)
+            state=objects.action_plan.State.PENDING,
+        )
         action3 = utils.create_test_action(
             id=3,
             action_plan_id=action_plan['id'],
             description='description action 3',
             uuid=w_utils.generate_uuid(),
             parents=[action2['uuid']],
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
         action4 = utils.create_test_action(
             id=4,
             action_plan_id=action_plan['id'],
             description='description action 4',
             uuid=w_utils.generate_uuid(),
             parents=None,
-            state=objects.action_plan.State.ONGOING)
+            state=objects.action_plan.State.ONGOING,
+        )
 
         self.dbapi.soft_delete_action(action4['uuid'])
 
         res = self.dbapi.get_action_list(
-            self.context,
-            filters={'state': objects.action_plan.State.ONGOING})
+            self.context, filters={'state': objects.action_plan.State.ONGOING}
+        )
         self.assertEqual([action3['id']], [r.id for r in res])
 
-        res = self.dbapi.get_action_list(self.context,
-                                         filters={'state': 'bad-state'})
+        res = self.dbapi.get_action_list(
+            self.context, filters={'state': 'bad-state'}
+        )
         self.assertEqual([], [r.id for r in res])
 
         res = self.dbapi.get_action_list(
-            self.context,
-            filters={'action_plan_id': 2})
+            self.context, filters={'action_plan_id': 2}
+        )
         self.assertEqual([action2['id']], [r.id for r in res])
 
         res = self.dbapi.get_action_list(
-            self.context,
-            filters={'action_plan_uuid': action_plan['uuid']})
+            self.context, filters={'action_plan_uuid': action_plan['uuid']}
+        )
         self.assertEqual(
-            sorted([action1['id'], action3['id']]),
-            sorted([r.id for r in res]))
+            sorted([action1['id'], action3['id']]), sorted([r.id for r in res])
+        )
 
         temp_context = self.context
         temp_context.show_deleted = True
         res = self.dbapi.get_action_list(
-            temp_context,
-            filters={'action_plan_uuid': action_plan['uuid']})
+            temp_context, filters={'action_plan_uuid': action_plan['uuid']}
+        )
         self.assertEqual(
             sorted([action1['id'], action3['id'], action4['id']]),
-            sorted([r.id for r in res]))
+            sorted([r.id for r in res]),
+        )
 
         res = self.dbapi.get_action_list(
-            self.context,
-            filters={'audit_uuid': audit.uuid})
+            self.context, filters={'audit_uuid': audit.uuid}
+        )
         for action in res:
             self.assertEqual(action_plan['id'], action.action_plan_id)
 
     def test_get_action_list_with_filter_by_uuid(self):
         action = utils.create_test_action()
         res = self.dbapi.get_action_list(
-            self.context, filters={'uuid': action["uuid"]})
+            self.context, filters={'uuid': action["uuid"]}
+        )
 
         self.assertEqual(len(res), 1)
         self.assertEqual(action['uuid'], res[0].uuid)
@@ -356,56 +392,77 @@ class DbActionTestCase(base.DbTestCase):
         self.assertEqual(action['id'], action.id)
 
     def test_get_action_that_does_not_exist(self):
-        self.assertRaises(exception.ActionNotFound,
-                          self.dbapi.get_action_by_id, self.context, 1234)
+        self.assertRaises(
+            exception.ActionNotFound,
+            self.dbapi.get_action_by_id,
+            self.context,
+            1234,
+        )
 
     def test_update_action(self):
         action = utils.create_test_action()
         res = self.dbapi.update_action(
-            action['id'], {'state': objects.action_plan.State.CANCELLED})
+            action['id'], {'state': objects.action_plan.State.CANCELLED}
+        )
         self.assertEqual(objects.action_plan.State.CANCELLED, res.state)
 
     def test_update_action_that_does_not_exist(self):
-        self.assertRaises(exception.ActionNotFound,
-                          self.dbapi.update_action, 1234, {'state': ''})
+        self.assertRaises(
+            exception.ActionNotFound,
+            self.dbapi.update_action,
+            1234,
+            {'state': ''},
+        )
 
     def test_update_action_uuid(self):
         action = utils.create_test_action()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_action, action['id'],
-                          {'uuid': 'hello'})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_action,
+            action['id'],
+            {'uuid': 'hello'},
+        )
 
     def test_destroy_action(self):
         action = utils.create_test_action()
         self.dbapi.destroy_action(action['id'])
-        self.assertRaises(exception.ActionNotFound,
-                          self.dbapi.get_action_by_id,
-                          self.context, action['id'])
+        self.assertRaises(
+            exception.ActionNotFound,
+            self.dbapi.get_action_by_id,
+            self.context,
+            action['id'],
+        )
 
     def test_destroy_action_by_uuid(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_action(uuid=uuid)
-        self.assertIsNotNone(self.dbapi.get_action_by_uuid(self.context,
-                                                           uuid))
+        self.assertIsNotNone(self.dbapi.get_action_by_uuid(self.context, uuid))
         self.dbapi.destroy_action(uuid)
-        self.assertRaises(exception.ActionNotFound,
-                          self.dbapi.get_action_by_uuid, self.context, uuid)
+        self.assertRaises(
+            exception.ActionNotFound,
+            self.dbapi.get_action_by_uuid,
+            self.context,
+            uuid,
+        )
 
     def test_destroy_action_that_does_not_exist(self):
-        self.assertRaises(exception.ActionNotFound,
-                          self.dbapi.destroy_action, 1234)
+        self.assertRaises(
+            exception.ActionNotFound, self.dbapi.destroy_action, 1234
+        )
 
     def test_create_action_already_exists(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_action(id=1, uuid=uuid)
-        self.assertRaises(exception.ActionAlreadyExists,
-                          utils.create_test_action,
-                          id=2, uuid=uuid)
+        self.assertRaises(
+            exception.ActionAlreadyExists,
+            utils.create_test_action,
+            id=2,
+            uuid=uuid,
+        )
 
     def test_action_status_message(self):
         action = utils.create_test_action()
         self.assertIsNone(action.status_message)
-        self.dbapi.update_action(action['id'],
-                                 {'status_message': 'test'})
+        self.dbapi.update_action(action['id'], {'status_message': 'test'})
         action = self.dbapi.get_action_by_id(self.context, action['id'])
         self.assertEqual(action.status_message, 'test')
diff --git a/watcher/tests/unit/db/test_action_description.py b/watcher/tests/unit/db/test_action_description.py
index 058c7f2ca..8b593f896 100644
--- a/watcher/tests/unit/db/test_action_description.py
+++ b/watcher/tests/unit/db/test_action_description.py
@@ -24,7 +24,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbActionDescriptionFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2015-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2016-01-01T09:52:05.219414'
     FAKE_TODAY = '2017-02-24T09:52:05.219414'
@@ -41,16 +40,16 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.action_desc1 = utils.create_test_action_desc(
-                id=1, action_type=action_desc1_type,
-                description="description")
+                id=1, action_type=action_desc1_type, description="description"
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.action_desc2 = utils.create_test_action_desc(
-                id=2, action_type=action_desc2_type,
-                description="description")
+                id=2, action_type=action_desc2_type, description="description"
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.action_desc3 = utils.create_test_action_desc(
-                id=3, action_type=action_desc3_type,
-                description="description")
+                id=3, action_type=action_desc3_type, description="description"
+            )
 
     def _soft_delete_action_descs(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -63,44 +62,53 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
     def _update_action_descs(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_action_description(
-                self.action_desc1.id, values={"description":
-                                              "nop description"})
+                self.action_desc1.id, values={"description": "nop description"}
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_action_description(
-                self.action_desc2.id, values={"description":
-                                              "sleep description"})
+                self.action_desc2.id,
+                values={"description": "sleep description"},
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_action_description(
-                self.action_desc3.id, values={"description":
-                                              "resize description"})
+                self.action_desc3.id,
+                values={"description": "resize description"},
+            )
 
     def test_get_action_desc_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_action_description(self.action_desc1.id)
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
-        self.assertEqual([self.action_desc1['action_type']],
-                         [r.action_type for r in res])
+        self.assertEqual(
+            [self.action_desc1['action_type']], [r.action_type for r in res]
+        )
 
     def test_get_action_desc_list_filter_deleted_false(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_action_description(self.action_desc1.id)
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
-            {self.action_desc2['action_type'],
-                self.action_desc3['action_type']},
-            {r.action_type for r in res})
+            {
+                self.action_desc2['action_type'],
+                self.action_desc3['action_type'],
+            },
+            {r.action_type for r in res},
+        )
 
     def test_get_action_desc_list_filter_deleted_at_eq(self):
         self._soft_delete_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action_desc1['id']], [r.id for r in res])
 
@@ -108,27 +116,32 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
         self._soft_delete_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.action_desc2['id'], self.action_desc3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_action_desc_list_filter_deleted_at_lte(self):
         self._soft_delete_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.action_desc2['id'], self.action_desc3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_action_desc_list_filter_deleted_at_gt(self):
         self._soft_delete_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action_desc1['id']], [r.id for r in res])
 
@@ -136,49 +149,59 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
         self._soft_delete_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.action_desc1['id'], self.action_desc2['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     # created_at #
 
     def test_get_action_desc_list_filter_created_at_eq(self):
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action_desc1['id']], [r.id for r in res])
 
     def test_get_action_desc_list_filter_created_at_lt(self):
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.action_desc2['id'], self.action_desc3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_action_desc_list_filter_created_at_lte(self):
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.action_desc2['id'], self.action_desc3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_action_desc_list_filter_created_at_gt(self):
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action_desc1['id']], [r.id for r in res])
 
     def test_get_action_desc_list_filter_created_at_gte(self):
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.action_desc1['id'], self.action_desc2['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     # updated_at #
 
@@ -186,7 +209,8 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
         self._update_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action_desc1['id']], [r.id for r in res])
 
@@ -194,27 +218,32 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
         self._update_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.action_desc2['id'], self.action_desc3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_action_desc_list_filter_updated_at_lte(self):
         self._update_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.action_desc2['id'], self.action_desc3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_action_desc_list_filter_updated_at_gt(self):
         self._update_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action_desc1['id']], [r.id for r in res])
 
@@ -222,22 +251,22 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
         self._update_action_descs()
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.action_desc1['id'], self.action_desc2['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
 
 class DbActionDescriptionTestCase(base.DbTestCase):
-
     def test_get_action_desc_list(self):
         ids = []
         for i in range(1, 4):
             action_desc = utils.create_test_action_desc(
-                id=i,
-                action_type=f"action_{i}",
-                description=f"description_{i}")
+                id=i, action_type=f"action_{i}", description=f"description_{i}"
+            )
             ids.append(action_desc['id'])
         action_descs = self.dbapi.get_action_description_list(self.context)
         action_desc_ids = [s.id for s in action_descs]
@@ -245,43 +274,47 @@ class DbActionDescriptionTestCase(base.DbTestCase):
 
     def test_get_action_desc_list_with_filters(self):
         action_desc1 = utils.create_test_action_desc(
-            id=1,
-            action_type="action_1",
-            description="description_1",
+            id=1, action_type="action_1", description="description_1"
         )
         action_desc2 = utils.create_test_action_desc(
-            id=2,
-            action_type="action_2",
-            description="description_2",
+            id=2, action_type="action_2", description="description_2"
         )
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'action_type': 'action_1'})
+            self.context, filters={'action_type': 'action_1'}
+        )
         self.assertEqual([action_desc1['id']], [r.id for r in res])
 
         res = self.dbapi.get_action_description_list(
-            self.context, filters={'action_type': 'action_3'})
+            self.context, filters={'action_type': 'action_3'}
+        )
         self.assertEqual([], [r.id for r in res])
 
         res = self.dbapi.get_action_description_list(
-            self.context,
-            filters={'action_type': 'action_2'})
+            self.context, filters={'action_type': 'action_2'}
+        )
         self.assertEqual([action_desc2['id']], [r.id for r in res])
 
     def test_get_action_desc_by_type(self):
         created_action_desc = utils.create_test_action_desc()
         action_desc = self.dbapi.get_action_description_by_type(
-            self.context, created_action_desc['action_type'])
-        self.assertEqual(action_desc.action_type,
-                         created_action_desc['action_type'])
+            self.context, created_action_desc['action_type']
+        )
+        self.assertEqual(
+            action_desc.action_type, created_action_desc['action_type']
+        )
 
     def test_get_action_desc_that_does_not_exist(self):
-        self.assertRaises(exception.ActionDescriptionNotFound,
-                          self.dbapi.get_action_description_by_id,
-                          self.context, 404)
+        self.assertRaises(
+            exception.ActionDescriptionNotFound,
+            self.dbapi.get_action_description_by_id,
+            self.context,
+            404,
+        )
 
     def test_update_action_desc(self):
         action_desc = utils.create_test_action_desc()
         res = self.dbapi.update_action_description(
-            action_desc['id'], {'description': 'description_test'})
+            action_desc['id'], {'description': 'description_test'}
+        )
         self.assertEqual('description_test', res.description)
diff --git a/watcher/tests/unit/db/test_action_plan.py b/watcher/tests/unit/db/test_action_plan.py
index 381498036..c6fdfa79f 100644
--- a/watcher/tests/unit/db/test_action_plan.py
+++ b/watcher/tests/unit/db/test_action_plan.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbActionPlanFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -39,20 +38,27 @@ class TestDbActionPlanFilters(base.DbTestCase):
         self.audit_template_name = "Audit Template"
 
         self.audit_template = utils.create_test_audit_template(
-            name=self.audit_template_name, id=1, uuid=None)
+            name=self.audit_template_name, id=1, uuid=None
+        )
         self.audit = utils.create_test_audit(
-            audit_template_id=self.audit_template.id, id=1, uuid=None)
+            audit_template_id=self.audit_template.id, id=1, uuid=None
+        )
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.action_plan1 = utils.create_test_action_plan(
-                audit_id=self.audit.id, id=1, uuid=None)
+                audit_id=self.audit.id, id=1, uuid=None
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.action_plan2 = utils.create_test_action_plan(
-                audit_id=self.audit.id, id=2, uuid=None)
+                audit_id=self.audit.id, id=2, uuid=None
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.action_plan3 = utils.create_test_action_plan(
-                audit_id=self.audit.id, id=3, uuid=None,
-                hostname='test-hostname')
+                audit_id=self.audit.id,
+                id=3,
+                uuid=None,
+                hostname='test-hostname',
+            )
 
     def _soft_delete_action_plans(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -66,22 +72,26 @@ class TestDbActionPlanFilters(base.DbTestCase):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_action_plan(
                 self.action_plan1.uuid,
-                values={"state": ap_objects.State.SUCCEEDED})
+                values={"state": ap_objects.State.SUCCEEDED},
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_action_plan(
                 self.action_plan2.uuid,
-                values={"state": ap_objects.State.SUCCEEDED})
+                values={"state": ap_objects.State.SUCCEEDED},
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_action_plan(
                 self.action_plan3.uuid,
-                values={"state": ap_objects.State.SUCCEEDED})
+                values={"state": ap_objects.State.SUCCEEDED},
+            )
 
     def test_get_action_plan_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_action_plan(self.action_plan1.uuid)
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
@@ -90,16 +100,20 @@ class TestDbActionPlanFilters(base.DbTestCase):
             self.dbapi.soft_delete_action_plan(self.action_plan1.uuid)
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
-        self.assertEqual([self.action_plan2['id'], self.action_plan3['id']],
-                         [r.id for r in res])
+        self.assertEqual(
+            [self.action_plan2['id'], self.action_plan3['id']],
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_deleted_at_eq(self):
         self._soft_delete_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
@@ -107,27 +121,32 @@ class TestDbActionPlanFilters(base.DbTestCase):
         self._soft_delete_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.action_plan2['id'], self.action_plan3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_deleted_at_lte(self):
         self._soft_delete_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.action_plan2['id'], self.action_plan3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_deleted_at_gt(self):
         self._soft_delete_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
@@ -135,49 +154,59 @@ class TestDbActionPlanFilters(base.DbTestCase):
         self._soft_delete_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.action_plan1['id'], self.action_plan2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # created_at #
 
     def test_get_action_plan_list_filter_created_at_eq(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
     def test_get_action_plan_list_filter_created_at_lt(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.action_plan2['id'], self.action_plan3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_created_at_lte(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.action_plan2['id'], self.action_plan3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_created_at_gt(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
     def test_get_action_plan_list_filter_created_at_gte(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.action_plan1['id'], self.action_plan2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # updated_at #
 
@@ -185,7 +214,8 @@ class TestDbActionPlanFilters(base.DbTestCase):
         self._update_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
@@ -193,27 +223,32 @@ class TestDbActionPlanFilters(base.DbTestCase):
         self._update_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.action_plan2['id'], self.action_plan3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_updated_at_lte(self):
         self._update_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.action_plan2['id'], self.action_plan3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_action_plan_list_filter_updated_at_gt(self):
         self._update_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.action_plan1['id']], [r.id for r in res])
 
@@ -221,37 +256,46 @@ class TestDbActionPlanFilters(base.DbTestCase):
         self._update_action_plans()
 
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.action_plan1['id'], self.action_plan2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # hostname #
 
     def test_get_action_plan_list_filter_hostname(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'hostname': 'test-hostname'})
+            self.context, filters={'hostname': 'test-hostname'}
+        )
 
         self.assertEqual([self.action_plan3['id']], [r.id for r in res])
 
     def test_get_action_plan_list_filter_wrong_hostname(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'hostname': 'wrong-hostname'})
+            self.context, filters={'hostname': 'wrong-hostname'}
+        )
 
         self.assertEqual([], [r.id for r in res])
 
     def test_get_action_plan_list_filter_hostname_and_audit(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'hostname': 'test-hostname',
-                                   'audit_id': self.audit.id})
+            self.context,
+            filters={'hostname': 'test-hostname', 'audit_id': self.audit.id},
+        )
 
         self.assertEqual([self.action_plan3['id']], [r.id for r in res])
 
     def test_get_action_plan_list_filter_hostname_and_wrong_audit(self):
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'hostname': 'test-hostname',
-                                   'audit_id': self.audit.id + 1})
+            self.context,
+            filters={
+                'hostname': 'test-hostname',
+                'audit_id': self.audit.id + 1,
+            },
+        )
 
         self.assertEqual([], [r.id for r in res])
 
@@ -259,17 +303,23 @@ class TestDbActionPlanFilters(base.DbTestCase):
 
     def test_get_action_plan_list_no_filter(self):
         res = self.dbapi.get_action_plan_list(self.context)
-        self.assertEqual([self.action_plan1['id'], self.action_plan2['id'],
-                          self.action_plan3['id']], [r.id for r in res])
+        self.assertEqual(
+            [
+                self.action_plan1['id'],
+                self.action_plan2['id'],
+                self.action_plan3['id'],
+            ],
+            [r.id for r in res],
+        )
 
 
 class DbActionPlanTestCase(base.DbTestCase):
-
     def test_get_action_plan_list(self):
         uuids = []
         for _ in range(1, 4):
             action_plan = utils.create_test_action_plan(
-                uuid=w_utils.generate_uuid())
+                uuid=w_utils.generate_uuid()
+            )
             uuids.append(str(action_plan['uuid']))
         action_plans = self.dbapi.get_action_plan_list(self.context)
         action_plan_uuids = [ap.uuid for ap in action_plans]
@@ -287,15 +337,18 @@ class DbActionPlanTestCase(base.DbTestCase):
         uuids = []
         for _ in range(1, 4):
             action_plan = utils.create_test_action_plan(
-                uuid=w_utils.generate_uuid())
+                uuid=w_utils.generate_uuid()
+            )
             uuids.append(str(action_plan['uuid']))
         action_plans = self.dbapi.get_action_plan_list(
-            self.context, eager=True)
+            self.context, eager=True
+        )
         action_plan_map = {a.uuid: a for a in action_plans}
         self.assertEqual(sorted(uuids), sorted(action_plan_map.keys()))
         eager_action_plan = action_plan_map[action_plan.uuid]
         self.assertEqual(
-            strategy.as_dict(), eager_action_plan.strategy.as_dict())
+            strategy.as_dict(), eager_action_plan.strategy.as_dict()
+        )
         self.assertEqual(audit.as_dict(), eager_action_plan.audit.as_dict())
 
     def test_get_action_plan_list_with_filters(self):
@@ -303,50 +356,55 @@ class DbActionPlanTestCase(base.DbTestCase):
             id=2,
             audit_type='ONESHOT',
             uuid=w_utils.generate_uuid(),
-            state=ap_objects.State.ONGOING)
+            state=ap_objects.State.ONGOING,
+        )
 
         action_plan1 = utils.create_test_action_plan(
             id=1,
             uuid=w_utils.generate_uuid(),
             audit_id=audit['id'],
-            state=ap_objects.State.RECOMMENDED)
+            state=ap_objects.State.RECOMMENDED,
+        )
         action_plan2 = utils.create_test_action_plan(
             id=2,
             uuid=w_utils.generate_uuid(),
             audit_id=audit['id'],
-            state=ap_objects.State.ONGOING)
+            state=ap_objects.State.ONGOING,
+        )
         action_plan3 = utils.create_test_action_plan(
             id=3,
             uuid=w_utils.generate_uuid(),
             audit_id=audit['id'],
-            state=ap_objects.State.RECOMMENDED)
+            state=ap_objects.State.RECOMMENDED,
+        )
 
         # check on bug 1761956
         self.dbapi.soft_delete_action_plan(action_plan3['uuid'])
 
         res = self.dbapi.get_action_plan_list(
-            self.context,
-            filters={'state': ap_objects.State.RECOMMENDED})
+            self.context, filters={'state': ap_objects.State.RECOMMENDED}
+        )
         self.assertEqual([action_plan1['id']], [r.id for r in res])
 
         res = self.dbapi.get_action_plan_list(
-            self.context,
-            filters={'state': ap_objects.State.ONGOING})
+            self.context, filters={'state': ap_objects.State.ONGOING}
+        )
         self.assertEqual([action_plan2['id']], [r.id for r in res])
 
         res = self.dbapi.get_action_plan_list(
-            self.context,
-            filters={'audit_uuid': audit['uuid']})
+            self.context, filters={'audit_uuid': audit['uuid']}
+        )
         self.assertEqual(
             sorted([action_plan1['id'], action_plan2['id']]),
-            sorted([r.id for r in res]))
+            sorted([r.id for r in res]),
+        )
         for r in res:
             self.assertEqual(audit['id'], r.audit_id)
 
         self.dbapi.soft_delete_action_plan(action_plan1['uuid'])
         res = self.dbapi.get_action_plan_list(
-            self.context,
-            filters={'audit_uuid': audit['uuid']})
+            self.context, filters={'audit_uuid': audit['uuid']}
+        )
 
         self.assertEqual([action_plan2['id']], [r.id for r in res])
         self.assertNotEqual([action_plan1['id']], [r.id for r in res])
@@ -354,7 +412,8 @@ class DbActionPlanTestCase(base.DbTestCase):
     def test_get_action_plan_list_with_filter_by_uuid(self):
         action_plan = utils.create_test_action_plan()
         res = self.dbapi.get_action_plan_list(
-            self.context, filters={'uuid': action_plan["uuid"]})
+            self.context, filters={'uuid': action_plan["uuid"]}
+        )
 
         self.assertEqual(len(res), 1)
         self.assertEqual(action_plan['uuid'], res[0].uuid)
@@ -362,75 +421,105 @@ class DbActionPlanTestCase(base.DbTestCase):
     def test_get_action_plan_by_id(self):
         action_plan = utils.create_test_action_plan()
         action_plan = self.dbapi.get_action_plan_by_id(
-            self.context, action_plan['id'])
+            self.context, action_plan['id']
+        )
         self.assertEqual(action_plan['uuid'], action_plan.uuid)
 
     def test_get_action_plan_by_uuid(self):
         action_plan = utils.create_test_action_plan()
         action_plan = self.dbapi.get_action_plan_by_uuid(
-            self.context, action_plan['uuid'])
+            self.context, action_plan['uuid']
+        )
         self.assertEqual(action_plan['id'], action_plan.id)
 
     def test_get_action_plan_that_does_not_exist(self):
-        self.assertRaises(exception.ActionPlanNotFound,
-                          self.dbapi.get_action_plan_by_id, self.context, 1234)
+        self.assertRaises(
+            exception.ActionPlanNotFound,
+            self.dbapi.get_action_plan_by_id,
+            self.context,
+            1234,
+        )
 
     def test_update_action_plan(self):
         action_plan = utils.create_test_action_plan()
         res = self.dbapi.update_action_plan(
-            action_plan['id'], {'name': 'updated-model'})
+            action_plan['id'], {'name': 'updated-model'}
+        )
         self.assertEqual('updated-model', res.name)
 
     def test_update_action_plan_that_does_not_exist(self):
-        self.assertRaises(exception.ActionPlanNotFound,
-                          self.dbapi.update_action_plan, 1234, {'name': ''})
+        self.assertRaises(
+            exception.ActionPlanNotFound,
+            self.dbapi.update_action_plan,
+            1234,
+            {'name': ''},
+        )
 
     def test_update_action_plan_uuid(self):
         action_plan = utils.create_test_action_plan()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_action_plan, action_plan['id'],
-                          {'uuid': 'hello'})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_action_plan,
+            action_plan['id'],
+            {'uuid': 'hello'},
+        )
 
     def test_destroy_action_plan(self):
         action_plan = utils.create_test_action_plan()
         self.dbapi.destroy_action_plan(action_plan['id'])
-        self.assertRaises(exception.ActionPlanNotFound,
-                          self.dbapi.get_action_plan_by_id,
-                          self.context, action_plan['id'])
+        self.assertRaises(
+            exception.ActionPlanNotFound,
+            self.dbapi.get_action_plan_by_id,
+            self.context,
+            action_plan['id'],
+        )
 
     def test_destroy_action_plan_by_uuid(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_action_plan(uuid=uuid)
-        self.assertIsNotNone(self.dbapi.get_action_plan_by_uuid(
-            self.context, uuid))
+        self.assertIsNotNone(
+            self.dbapi.get_action_plan_by_uuid(self.context, uuid)
+        )
         self.dbapi.destroy_action_plan(uuid)
-        self.assertRaises(exception.ActionPlanNotFound,
-                          self.dbapi.get_action_plan_by_uuid,
-                          self.context, uuid)
+        self.assertRaises(
+            exception.ActionPlanNotFound,
+            self.dbapi.get_action_plan_by_uuid,
+            self.context,
+            uuid,
+        )
 
     def test_destroy_action_plan_that_does_not_exist(self):
-        self.assertRaises(exception.ActionPlanNotFound,
-                          self.dbapi.destroy_action_plan, 1234)
+        self.assertRaises(
+            exception.ActionPlanNotFound, self.dbapi.destroy_action_plan, 1234
+        )
 
     def test_destroy_action_plan_that_referenced_by_actions(self):
         action_plan = utils.create_test_action_plan()
         action = utils.create_test_action(action_plan_id=action_plan['id'])
         self.assertEqual(action_plan['id'], action.action_plan_id)
-        self.assertRaises(exception.ActionPlanReferenced,
-                          self.dbapi.destroy_action_plan, action_plan['id'])
+        self.assertRaises(
+            exception.ActionPlanReferenced,
+            self.dbapi.destroy_action_plan,
+            action_plan['id'],
+        )
 
     def test_create_action_plan_already_exists(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_action_plan(id=1, uuid=uuid)
-        self.assertRaises(exception.ActionPlanAlreadyExists,
-                          utils.create_test_action_plan,
-                          id=2, uuid=uuid)
+        self.assertRaises(
+            exception.ActionPlanAlreadyExists,
+            utils.create_test_action_plan,
+            id=2,
+            uuid=uuid,
+        )
 
     def test_action_plan_status_message(self):
         action_plan = utils.create_test_action_plan()
         self.assertIsNone(action_plan.status_message)
-        self.dbapi.update_action_plan(action_plan['id'],
-                                      {'status_message': 'test'})
+        self.dbapi.update_action_plan(
+            action_plan['id'], {'status_message': 'test'}
+        )
         action_plan = self.dbapi.get_action_plan_by_id(
-            self.context, action_plan['id'])
+            self.context, action_plan['id']
+        )
         self.assertEqual(action_plan.status_message, 'test')
diff --git a/watcher/tests/unit/db/test_audit.py b/watcher/tests/unit/db/test_audit.py
index c38dcb2bc..e88a5a173 100644
--- a/watcher/tests/unit/db/test_audit.py
+++ b/watcher/tests/unit/db/test_audit.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbAuditFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -47,24 +46,40 @@ class TestDbAuditFilters(base.DbTestCase):
         self.audit4_name = gen_name()
 
         self.audit_template = utils.create_test_audit_template(
-            name=self.audit_template_name, id=1, uuid=None)
+            name=self.audit_template_name, id=1, uuid=None
+        )
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.audit1 = utils.create_test_audit(
-                audit_template_id=self.audit_template.id, id=1, uuid=None,
-                name=self.audit1_name)
+                audit_template_id=self.audit_template.id,
+                id=1,
+                uuid=None,
+                name=self.audit1_name,
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.audit2 = utils.create_test_audit(
-                audit_template_id=self.audit_template.id, id=2, uuid=None,
-                name=self.audit2_name, state=objects.audit.State.FAILED)
+                audit_template_id=self.audit_template.id,
+                id=2,
+                uuid=None,
+                name=self.audit2_name,
+                state=objects.audit.State.FAILED,
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.audit3 = utils.create_test_audit(
-                audit_template_id=self.audit_template.id, id=3, uuid=None,
-                name=self.audit3_name, state=objects.audit.State.CANCELLED)
+                audit_template_id=self.audit_template.id,
+                id=3,
+                uuid=None,
+                name=self.audit3_name,
+                state=objects.audit.State.CANCELLED,
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.audit4 = utils.create_test_audit(
-                audit_template_id=self.audit_template.id, id=4, uuid=None,
-                name=self.audit4_name, state=objects.audit.State.SUSPENDED)
+                audit_template_id=self.audit_template.id,
+                id=4,
+                uuid=None,
+                name=self.audit4_name,
+                state=objects.audit.State.SUSPENDED,
+            )
 
     def _soft_delete_audits(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -78,22 +93,26 @@ class TestDbAuditFilters(base.DbTestCase):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_audit(
                 self.audit1.uuid,
-                values={"state": objects.audit.State.SUCCEEDED})
+                values={"state": objects.audit.State.SUCCEEDED},
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_audit(
                 self.audit2.uuid,
-                values={"state": objects.audit.State.SUCCEEDED})
+                values={"state": objects.audit.State.SUCCEEDED},
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_audit(
                 self.audit3.uuid,
-                values={"state": objects.audit.State.SUCCEEDED})
+                values={"state": objects.audit.State.SUCCEEDED},
+            )
 
     def test_get_audit_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_audit(self.audit1.uuid)
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
@@ -102,17 +121,20 @@ class TestDbAuditFilters(base.DbTestCase):
             self.dbapi.soft_delete_audit(self.audit1.uuid)
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
             [self.audit2['id'], self.audit3['id'], self.audit4['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_list_filter_deleted_at_eq(self):
         self._soft_delete_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
@@ -120,27 +142,30 @@ class TestDbAuditFilters(base.DbTestCase):
         self._soft_delete_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            [self.audit2['id'], self.audit3['id']],
-            [r.id for r in res])
+            [self.audit2['id'], self.audit3['id']], [r.id for r in res]
+        )
 
     def test_get_audit_list_filter_deleted_at_lte(self):
         self._soft_delete_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.audit2['id'], self.audit3['id']],
-            [r.id for r in res])
+            [self.audit2['id'], self.audit3['id']], [r.id for r in res]
+        )
 
     def test_get_audit_list_filter_deleted_at_gt(self):
         self._soft_delete_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
@@ -148,49 +173,57 @@ class TestDbAuditFilters(base.DbTestCase):
         self._soft_delete_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.audit1['id'], self.audit2['id']],
-            [r.id for r in res])
+            [self.audit1['id'], self.audit2['id']], [r.id for r in res]
+        )
 
     # created_at #
 
     def test_get_audit_list_filter_created_at_eq(self):
         res = self.dbapi.get_audit_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
     def test_get_audit_list_filter_created_at_lt(self):
         res = self.dbapi.get_audit_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.audit2['id'], self.audit3['id'], self.audit4['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_list_filter_created_at_lte(self):
         res = self.dbapi.get_audit_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit2['id'], self.audit3['id'], self.audit4['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_list_filter_created_at_gt(self):
         res = self.dbapi.get_audit_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
     def test_get_audit_list_filter_created_at_gte(self):
         res = self.dbapi.get_audit_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.audit1['id'], self.audit2['id']],
-            [r.id for r in res])
+            [self.audit1['id'], self.audit2['id']], [r.id for r in res]
+        )
 
     # updated_at #
 
@@ -198,7 +231,8 @@ class TestDbAuditFilters(base.DbTestCase):
         self._update_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
@@ -206,27 +240,30 @@ class TestDbAuditFilters(base.DbTestCase):
         self._update_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            [self.audit2['id'], self.audit3['id']],
-            [r.id for r in res])
+            [self.audit2['id'], self.audit3['id']], [r.id for r in res]
+        )
 
     def test_get_audit_list_filter_updated_at_lte(self):
         self._update_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.audit2['id'], self.audit3['id']],
-            [r.id for r in res])
+            [self.audit2['id'], self.audit3['id']], [r.id for r in res]
+        )
 
     def test_get_audit_list_filter_updated_at_gt(self):
         self._update_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.audit1['id']], [r.id for r in res])
 
@@ -234,44 +271,48 @@ class TestDbAuditFilters(base.DbTestCase):
         self._update_audits()
 
         res = self.dbapi.get_audit_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            [self.audit1['id'], self.audit2['id']],
-            [r.id for r in res])
+            [self.audit1['id'], self.audit2['id']], [r.id for r in res]
+        )
 
     def test_get_audit_list_filter_state_in(self):
         res = self.dbapi.get_audit_list(
             self.context,
             filters={
-                'state__in':
+                'state__in': (
                     objects.audit.AuditStateTransitionManager.INACTIVE_STATES
-            })
+                )
+            },
+        )
 
         self.assertEqual(
             [self.audit2['id'], self.audit3['id'], self.audit4['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_list_filter_state_notin(self):
         res = self.dbapi.get_audit_list(
             self.context,
             filters={
-                'state__notin':
+                'state__notin': (
                     objects.audit.AuditStateTransitionManager.INACTIVE_STATES
-            })
+                )
+            },
+        )
 
-        self.assertEqual(
-            [self.audit1['id']],
-            [r.id for r in res])
+        self.assertEqual([self.audit1['id']], [r.id for r in res])
 
 
 class DbAuditTestCase(base.DbTestCase):
-
     def test_get_audit_list(self):
         uuids = []
         for id_ in range(1, 4):
-            audit = utils.create_test_audit(uuid=w_utils.generate_uuid(),
-                                            name=f'My Audit {id_}')
+            audit = utils.create_test_audit(
+                uuid=w_utils.generate_uuid(), name=f'My Audit {id_}'
+            )
             uuids.append(str(audit['uuid']))
         audits = self.dbapi.get_audit_list(self.context)
         audit_uuids = [a.uuid for a in audits]
@@ -289,9 +330,12 @@ class DbAuditTestCase(base.DbTestCase):
         uuids = []
         for i in range(1, 4):
             audit = utils.create_test_audit(
-                id=i, uuid=w_utils.generate_uuid(),
+                id=i,
+                uuid=w_utils.generate_uuid(),
                 name=f'My Audit {i}',
-                goal_id=goal.id, strategy_id=strategy.id)
+                goal_id=goal.id,
+                strategy_id=strategy.id,
+            )
             uuids.append(str(audit['uuid']))
         audits = self.dbapi.get_audit_list(self.context, eager=True)
         audit_map = {a.uuid: a for a in audits}
@@ -309,62 +353,70 @@ class DbAuditTestCase(base.DbTestCase):
             uuid=w_utils.generate_uuid(),
             name=f'My Audit {1}',
             state=objects.audit.State.ONGOING,
-            goal_id=goal['id'])
+            goal_id=goal['id'],
+        )
         audit2 = utils.create_test_audit(
             id=2,
             audit_type=objects.audit.AuditType.CONTINUOUS.value,
             uuid=w_utils.generate_uuid(),
             name=f'My Audit {2}',
             state=objects.audit.State.PENDING,
-            goal_id=goal['id'])
+            goal_id=goal['id'],
+        )
         audit3 = utils.create_test_audit(
             id=3,
             audit_type=objects.audit.AuditType.CONTINUOUS.value,
             uuid=w_utils.generate_uuid(),
             name=f'My Audit {3}',
             state=objects.audit.State.ONGOING,
-            goal_id=goal['id'])
+            goal_id=goal['id'],
+        )
 
         self.dbapi.soft_delete_audit(audit3['uuid'])
 
         res = self.dbapi.get_audit_list(
             self.context,
-            filters={'audit_type': objects.audit.AuditType.ONESHOT.value})
+            filters={'audit_type': objects.audit.AuditType.ONESHOT.value},
+        )
         self.assertEqual([audit1['id']], [r.id for r in res])
 
         res = self.dbapi.get_audit_list(
-            self.context,
-            filters={'audit_type': 'bad-type'})
+            self.context, filters={'audit_type': 'bad-type'}
+        )
         self.assertEqual([], [r.id for r in res])
 
         res = self.dbapi.get_audit_list(
-            self.context,
-            filters={'state': objects.audit.State.ONGOING})
+            self.context, filters={'state': objects.audit.State.ONGOING}
+        )
         self.assertEqual([audit1['id']], [r.id for r in res])
 
         res = self.dbapi.get_audit_list(
-            self.context,
-            filters={'state': objects.audit.State.PENDING})
+            self.context, filters={'state': objects.audit.State.PENDING}
+        )
         self.assertEqual([audit2['id']], [r.id for r in res])
 
         res = self.dbapi.get_audit_list(
-            self.context,
-            filters={'goal_name': 'DUMMY'})
-        self.assertEqual(sorted([audit1['id'], audit2['id']]),
-                         sorted([r.id for r in res]))
+            self.context, filters={'goal_name': 'DUMMY'}
+        )
+        self.assertEqual(
+            sorted([audit1['id'], audit2['id']]), sorted([r.id for r in res])
+        )
 
         temp_context = self.context
         temp_context.show_deleted = True
         res = self.dbapi.get_audit_list(
-            temp_context,
-            filters={'goal_name': 'DUMMY'})
-        self.assertEqual(sorted([audit1['id'], audit2['id'], audit3['id']]),
-                         sorted([r.id for r in res]))
+            temp_context, filters={'goal_name': 'DUMMY'}
+        )
+        self.assertEqual(
+            sorted([audit1['id'], audit2['id'], audit3['id']]),
+            sorted([r.id for r in res]),
+        )
 
     def test_get_audit_list_with_filter_by_uuid(self):
         audit = utils.create_test_audit()
         res = self.dbapi.get_audit_list(
-            self.context, filters={'uuid': audit["uuid"]})
+            self.context, filters={'uuid': audit["uuid"]}
+        )
 
         self.assertEqual(len(res), 1)
         self.assertEqual(audit['uuid'], res[0].uuid)
@@ -380,8 +432,12 @@ class DbAuditTestCase(base.DbTestCase):
         self.assertEqual(audit['id'], audit.id)
 
     def test_get_audit_that_does_not_exist(self):
-        self.assertRaises(exception.AuditNotFound,
-                          self.dbapi.get_audit_by_id, self.context, 1234)
+        self.assertRaises(
+            exception.AuditNotFound,
+            self.dbapi.get_audit_by_id,
+            self.context,
+            1234,
+        )
 
     def test_update_audit(self):
         audit = utils.create_test_audit()
@@ -389,64 +445,83 @@ class DbAuditTestCase(base.DbTestCase):
         self.assertEqual('updated-model', res.name)
 
     def test_update_audit_that_does_not_exist(self):
-        self.assertRaises(exception.AuditNotFound,
-                          self.dbapi.update_audit, 1234, {'name': ''})
+        self.assertRaises(
+            exception.AuditNotFound,
+            self.dbapi.update_audit,
+            1234,
+            {'name': ''},
+        )
 
     def test_update_audit_uuid(self):
         audit = utils.create_test_audit()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_audit, audit['id'],
-                          {'uuid': 'hello'})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_audit,
+            audit['id'],
+            {'uuid': 'hello'},
+        )
 
     def test_destroy_audit(self):
         audit = utils.create_test_audit()
         self.dbapi.destroy_audit(audit['id'])
-        self.assertRaises(exception.AuditNotFound,
-                          self.dbapi.get_audit_by_id,
-                          self.context, audit['id'])
+        self.assertRaises(
+            exception.AuditNotFound,
+            self.dbapi.get_audit_by_id,
+            self.context,
+            audit['id'],
+        )
 
     def test_destroy_audit_by_uuid(self):
         audit = utils.create_test_audit()
-        self.assertIsNotNone(self.dbapi.get_audit_by_uuid(self.context,
-                                                          audit['uuid']))
+        self.assertIsNotNone(
+            self.dbapi.get_audit_by_uuid(self.context, audit['uuid'])
+        )
         self.dbapi.destroy_audit(audit['uuid'])
-        self.assertRaises(exception.AuditNotFound,
-                          self.dbapi.get_audit_by_uuid, self.context,
-                          audit['uuid'])
+        self.assertRaises(
+            exception.AuditNotFound,
+            self.dbapi.get_audit_by_uuid,
+            self.context,
+            audit['uuid'],
+        )
 
     def test_destroy_audit_that_does_not_exist(self):
-        self.assertRaises(exception.AuditNotFound,
-                          self.dbapi.destroy_audit, 1234)
+        self.assertRaises(
+            exception.AuditNotFound, self.dbapi.destroy_audit, 1234
+        )
 
     def test_destroy_audit_that_referenced_by_action_plans(self):
         audit = utils.create_test_audit()
         action_plan = utils.create_test_action_plan(audit_id=audit['id'])
         self.assertEqual(audit['id'], action_plan.audit_id)
-        self.assertRaises(exception.AuditReferenced,
-                          self.dbapi.destroy_audit, audit['id'])
+        self.assertRaises(
+            exception.AuditReferenced, self.dbapi.destroy_audit, audit['id']
+        )
 
     def test_create_audit_already_exists(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_audit(id=1, uuid=uuid)
-        self.assertRaises(exception.AuditAlreadyExists,
-                          utils.create_test_audit,
-                          id=2, uuid=uuid)
+        self.assertRaises(
+            exception.AuditAlreadyExists,
+            utils.create_test_audit,
+            id=2,
+            uuid=uuid,
+        )
 
     def test_create_same_name_audit(self):
         audit = utils.create_test_audit(
-            uuid=w_utils.generate_uuid(),
-            name='my_audit')
+            uuid=w_utils.generate_uuid(), name='my_audit'
+        )
         self.assertEqual(audit['uuid'], audit.uuid)
         self.assertRaises(
             exception.AuditAlreadyExists,
             utils.create_test_audit,
             uuid=w_utils.generate_uuid(),
-            name='my_audit')
+            name='my_audit',
+        )
 
     def test_audit_status_message(self):
         audit = utils.create_test_audit()
         self.assertIsNone(audit.status_message)
-        self.dbapi.update_audit(audit['id'],
-                                {'status_message': 'test'})
+        self.dbapi.update_audit(audit['id'], {'status_message': 'test'})
         audit = self.dbapi.get_audit_by_id(self.context, audit['id'])
         self.assertEqual(audit.status_message, 'test')
diff --git a/watcher/tests/unit/db/test_audit_template.py b/watcher/tests/unit/db/test_audit_template.py
index 6ba88d0b2..85d030e3f 100644
--- a/watcher/tests/unit/db/test_audit_template.py
+++ b/watcher/tests/unit/db/test_audit_template.py
@@ -24,7 +24,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbAuditTemplateFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -35,7 +34,6 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
         self._data_setup()
 
     def _data_setup(self):
-
         def gen_name():
             return f"Audit Template {w_utils.generate_uuid()}"
 
@@ -45,13 +43,16 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.audit_template1 = utils.create_test_audit_template(
-                name=self.audit_template1_name, id=1, uuid=None)
+                name=self.audit_template1_name, id=1, uuid=None
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.audit_template2 = utils.create_test_audit_template(
-                name=self.audit_template2_name, id=2, uuid=None)
+                name=self.audit_template2_name, id=2, uuid=None
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.audit_template3 = utils.create_test_audit_template(
-                name=self.audit_template3_name, id=3, uuid=None)
+                name=self.audit_template3_name, id=3, uuid=None
+            )
 
     def _soft_delete_audit_templates(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -64,20 +65,24 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
     def _update_audit_templates(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_audit_template(
-                self.audit_template1.uuid, values={"name": "audit_template1"})
+                self.audit_template1.uuid, values={"name": "audit_template1"}
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_audit_template(
-                self.audit_template2.uuid, values={"name": "audit_template2"})
+                self.audit_template2.uuid, values={"name": "audit_template2"}
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_audit_template(
-                self.audit_template3.uuid, values={"name": "audit_template3"})
+                self.audit_template3.uuid, values={"name": "audit_template3"}
+            )
 
     def test_get_audit_template_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_audit_template(self.audit_template1.uuid)
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
@@ -86,17 +91,20 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
             self.dbapi.soft_delete_audit_template(self.audit_template1.uuid)
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_deleted_at_eq(self):
         self._soft_delete_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
@@ -104,27 +112,32 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
         self._soft_delete_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_deleted_at_lte(self):
         self._soft_delete_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_deleted_at_gt(self):
         self._soft_delete_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
@@ -132,49 +145,59 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
         self._soft_delete_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit_template1['id'], self.audit_template2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # created_at #
 
     def test_get_audit_template_list_filter_created_at_eq(self):
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
     def test_get_audit_template_list_filter_created_at_lt(self):
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_created_at_lte(self):
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_created_at_gt(self):
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
     def test_get_audit_template_list_filter_created_at_gte(self):
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit_template1['id'], self.audit_template2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # updated_at #
 
@@ -182,7 +205,8 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
         self._update_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
@@ -190,27 +214,32 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
         self._update_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_updated_at_lte(self):
         self._update_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit_template2['id'], self.audit_template3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_audit_template_list_filter_updated_at_gt(self):
         self._update_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.audit_template1['id']], [r.id for r in res])
 
@@ -218,22 +247,24 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
         self._update_audit_templates()
 
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.audit_template1['id'], self.audit_template2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
 
 class DbAuditTemplateTestCase(base.DbTestCase):
-
     def test_get_audit_template_list(self):
         uuids = []
         for i in range(1, 4):
             audit_template = utils.create_test_audit_template(
                 id=i,
                 uuid=w_utils.generate_uuid(),
-                name=f'My Audit Template {i}')
+                name=f'My Audit Template {i}',
+            )
             uuids.append(str(audit_template['uuid']))
         audit_templates = self.dbapi.get_audit_template_list(self.context)
         audit_template_uuids = [at.uuid for at in audit_templates]
@@ -251,18 +282,23 @@ class DbAuditTemplateTestCase(base.DbTestCase):
         uuids = []
         for i in range(1, 4):
             audit_template = utils.create_test_audit_template(
-                id=i, uuid=w_utils.generate_uuid(),
+                id=i,
+                uuid=w_utils.generate_uuid(),
                 name=f'My Audit Template {i}',
-                goal_id=goal.id, strategy_id=strategy.id)
+                goal_id=goal.id,
+                strategy_id=strategy.id,
+            )
             uuids.append(str(audit_template['uuid']))
         audit_templates = self.dbapi.get_audit_template_list(
-            self.context, eager=True)
+            self.context, eager=True
+        )
         audit_template_map = {a.uuid: a for a in audit_templates}
         self.assertEqual(sorted(uuids), sorted(audit_template_map.keys()))
         eager_audit_template = audit_template_map[audit_template.uuid]
         self.assertEqual(goal.as_dict(), eager_audit_template.goal.as_dict())
         self.assertEqual(
-            strategy.as_dict(), eager_audit_template.strategy.as_dict())
+            strategy.as_dict(), eager_audit_template.strategy.as_dict()
+        )
 
     def test_get_audit_template_list_with_filters(self):
         goal = utils.create_test_goal(name='DUMMY')
@@ -272,58 +308,69 @@ class DbAuditTemplateTestCase(base.DbTestCase):
             uuid=w_utils.generate_uuid(),
             name='My Audit Template 1',
             description='Description of my audit template 1',
-            goal_id=goal['id'])
+            goal_id=goal['id'],
+        )
         audit_template2 = utils.create_test_audit_template(
             id=2,
             uuid=w_utils.generate_uuid(),
             name='My Audit Template 2',
             description='Description of my audit template 2',
-            goal_id=goal['id'])
+            goal_id=goal['id'],
+        )
         audit_template3 = utils.create_test_audit_template(
             id=3,
             uuid=w_utils.generate_uuid(),
             name='My Audit Template 3',
             description='Description of my audit template 3',
-            goal_id=goal['id'])
+            goal_id=goal['id'],
+        )
 
         self.dbapi.soft_delete_audit_template(audit_template3['uuid'])
 
         res = self.dbapi.get_audit_template_list(
-            self.context,
-            filters={'name': 'My Audit Template 1'})
+            self.context, filters={'name': 'My Audit Template 1'}
+        )
         self.assertEqual([audit_template1['id']], [r.id for r in res])
 
         res = self.dbapi.get_audit_template_list(
-            self.context,
-            filters={'name': 'Does not exist'})
+            self.context, filters={'name': 'Does not exist'}
+        )
         self.assertEqual([], [r.id for r in res])
 
         res = self.dbapi.get_audit_template_list(
-            self.context,
-            filters={'goal_name': 'DUMMY'})
+            self.context, filters={'goal_name': 'DUMMY'}
+        )
         self.assertEqual(
             sorted([audit_template1['id'], audit_template2['id']]),
-            sorted([r.id for r in res]))
+            sorted([r.id for r in res]),
+        )
 
         temp_context = self.context
         temp_context.show_deleted = True
         res = self.dbapi.get_audit_template_list(
-            temp_context,
-            filters={'goal_name': 'DUMMY'})
+            temp_context, filters={'goal_name': 'DUMMY'}
+        )
         self.assertEqual(
-            sorted([audit_template1['id'], audit_template2['id'],
-                    audit_template3['id']]),
-            sorted([r.id for r in res]))
+            sorted(
+                [
+                    audit_template1['id'],
+                    audit_template2['id'],
+                    audit_template3['id'],
+                ]
+            ),
+            sorted([r.id for r in res]),
+        )
 
         res = self.dbapi.get_audit_template_list(
-            self.context,
-            filters={'name': 'My Audit Template 2'})
+            self.context, filters={'name': 'My Audit Template 2'}
+        )
         self.assertEqual([audit_template2['id']], [r.id for r in res])
 
     def test_get_audit_template_list_with_filter_by_uuid(self):
         audit_template = utils.create_test_audit_template()
         res = self.dbapi.get_audit_template_list(
-            self.context, filters={'uuid': audit_template["uuid"]})
+            self.context, filters={'uuid': audit_template["uuid"]}
+        )
 
         self.assertEqual(len(res), 1)
         self.assertEqual(audit_template['uuid'], res[0].uuid)
@@ -331,72 +378,98 @@ class DbAuditTemplateTestCase(base.DbTestCase):
     def test_get_audit_template_by_id(self):
         audit_template = utils.create_test_audit_template()
         audit_template = self.dbapi.get_audit_template_by_id(
-            self.context, audit_template['id'])
+            self.context, audit_template['id']
+        )
         self.assertEqual(audit_template['uuid'], audit_template.uuid)
 
     def test_get_audit_template_by_uuid(self):
         audit_template = utils.create_test_audit_template()
         audit_template = self.dbapi.get_audit_template_by_uuid(
-            self.context, audit_template['uuid'])
+            self.context, audit_template['uuid']
+        )
         self.assertEqual(audit_template['id'], audit_template.id)
 
     def test_get_audit_template_that_does_not_exist(self):
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          self.dbapi.get_audit_template_by_id,
-                          self.context, 1234)
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            self.dbapi.get_audit_template_by_id,
+            self.context,
+            1234,
+        )
 
     def test_update_audit_template(self):
         audit_template = utils.create_test_audit_template()
-        res = self.dbapi.update_audit_template(audit_template['id'],
-                                               {'name': 'updated-model'})
+        res = self.dbapi.update_audit_template(
+            audit_template['id'], {'name': 'updated-model'}
+        )
         self.assertEqual('updated-model', res.name)
 
     def test_update_audit_template_that_does_not_exist(self):
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          self.dbapi.update_audit_template, 1234, {'name': ''})
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            self.dbapi.update_audit_template,
+            1234,
+            {'name': ''},
+        )
 
     def test_update_audit_template_uuid(self):
         audit_template = utils.create_test_audit_template()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_audit_template,
-                          audit_template['id'],
-                          {'uuid': 'hello'})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_audit_template,
+            audit_template['id'],
+            {'uuid': 'hello'},
+        )
 
     def test_destroy_audit_template(self):
         audit_template = utils.create_test_audit_template()
         self.dbapi.destroy_audit_template(audit_template['id'])
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          self.dbapi.get_audit_template_by_id,
-                          self.context, audit_template['id'])
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            self.dbapi.get_audit_template_by_id,
+            self.context,
+            audit_template['id'],
+        )
 
     def test_destroy_audit_template_by_uuid(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_audit_template(uuid=uuid)
-        self.assertIsNotNone(self.dbapi.get_audit_template_by_uuid(
-            self.context, uuid))
+        self.assertIsNotNone(
+            self.dbapi.get_audit_template_by_uuid(self.context, uuid)
+        )
         self.dbapi.destroy_audit_template(uuid)
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          self.dbapi.get_audit_template_by_uuid,
-                          self.context, uuid)
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            self.dbapi.get_audit_template_by_uuid,
+            self.context,
+            uuid,
+        )
 
     def test_destroy_audit_template_that_does_not_exist(self):
-        self.assertRaises(exception.AuditTemplateNotFound,
-                          self.dbapi.destroy_audit_template, 1234)
+        self.assertRaises(
+            exception.AuditTemplateNotFound,
+            self.dbapi.destroy_audit_template,
+            1234,
+        )
 
     def test_create_audit_template_already_exists(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_audit_template(id=1, uuid=uuid)
-        self.assertRaises(exception.AuditTemplateAlreadyExists,
-                          utils.create_test_audit_template,
-                          id=2, uuid=uuid)
+        self.assertRaises(
+            exception.AuditTemplateAlreadyExists,
+            utils.create_test_audit_template,
+            id=2,
+            uuid=uuid,
+        )
 
     def test_audit_template_create_same_name(self):
         audit_template1 = utils.create_test_audit_template(
-            uuid=w_utils.generate_uuid(),
-            name='audit_template_name')
+            uuid=w_utils.generate_uuid(), name='audit_template_name'
+        )
         self.assertEqual(audit_template1['uuid'], audit_template1.uuid)
         self.assertRaises(
             exception.AuditTemplateAlreadyExists,
             utils.create_test_audit_template,
             uuid=w_utils.generate_uuid(),
-            name='audit_template_name')
+            name='audit_template_name',
+        )
diff --git a/watcher/tests/unit/db/test_deadlock_decorator_validation.py b/watcher/tests/unit/db/test_deadlock_decorator_validation.py
index ce49679a8..935d9caf7 100644
--- a/watcher/tests/unit/db/test_deadlock_decorator_validation.py
+++ b/watcher/tests/unit/db/test_deadlock_decorator_validation.py
@@ -48,9 +48,11 @@ class ASTMethodAnalyzer:
         for dec in method_node.decorator_list:
             # @oslo_db_api.retry_on_deadlock
             if isinstance(dec, ast.Attribute):
-                if (isinstance(dec.value, ast.Name) and
-                        dec.value.id == 'oslo_db_api' and
-                        dec.attr == 'retry_on_deadlock'):
+                if (
+                    isinstance(dec.value, ast.Name)
+                    and dec.value.id == 'oslo_db_api'
+                    and dec.attr == 'retry_on_deadlock'
+                ):
                     return True
             # @retry_on_deadlock (if imported directly)
             elif isinstance(dec, ast.Name):
@@ -74,8 +76,10 @@ class ASTMethodAnalyzer:
             if isinstance(node, ast.Call):
                 # self.method_name()
                 if isinstance(node.func, ast.Attribute):
-                    if (isinstance(node.func.value, ast.Name) and
-                            node.func.value.id == 'self'):
+                    if (
+                        isinstance(node.func.value, ast.Name)
+                        and node.func.value.id == 'self'
+                    ):
                         called.add(node.func.attr)
         return called
 
@@ -93,7 +97,7 @@ class ASTMethodAnalyzer:
                     'has_decorator': self._has_retry_decorator(item),
                     'uses_write': self._uses_session_for_write(item),
                     'calls': self._get_called_methods(item),
-                    'is_public': not item.name.startswith('_')
+                    'is_public': not item.name.startswith('_'),
                 }
 
         return methods
@@ -120,7 +124,7 @@ class ASTMethodAnalyzer:
                     'direct': True,
                     'indirect': False,
                     'call_chain': [name, '_session_for_write()'],
-                    'protected': info['has_decorator']
+                    'protected': info['has_decorator'],
                 }
 
         # Iterative fixed-point: propagate to callers
@@ -147,9 +151,10 @@ class ASTMethodAnalyzer:
                             result[name] = {
                                 'direct': False,
                                 'indirect': True,
-                                'call_chain': ([name] +
-                                               result[called]['call_chain']),
-                                'protected': info['has_decorator']
+                                'call_chain': (
+                                    [name] + result[called]['call_chain']
+                                ),
+                                'protected': info['has_decorator'],
                             }
                             changed = True
                             break
@@ -199,7 +204,7 @@ class TestRetryOnDeadlockDecorator(base.TestCase):
                 violation = {
                     'method': method_name,
                     'direct': usage_info['direct'],
-                    'call_chain': call_chain
+                    'call_chain': call_chain,
                 }
                 violations.append(violation)
 
@@ -215,7 +220,8 @@ class TestRetryOnDeadlockDecorator(base.TestCase):
                 usage_type = "directly" if v['direct'] else "indirectly via"
                 msg_parts.append(
                     "  - {}() - uses {}: {}".format(
-                        v['method'], usage_type, v['call_chain'])
+                        v['method'], usage_type, v['call_chain']
+                    )
                 )
             msg_parts.append(
                 "\nNote: Methods calling decorated helpers (_create, "
@@ -248,11 +254,12 @@ class TestRetryOnDeadlockDecorator(base.TestCase):
         for method_name in known_decorated:
             method_info = self.analyzer.methods.get(method_name)
             self.assertIsNotNone(
-                method_info,
-                f"AST analyzer should find {method_name}()")
+                method_info, f"AST analyzer should find {method_name}()"
+            )
             self.assertTrue(
                 method_info['has_decorator'],
-                f"{method_name}() should have @retry_on_deadlock decorator")
+                f"{method_name}() should have @retry_on_deadlock decorator",
+            )
 
     def test_ast_analyzer_detects_write_session_usage(self):
         """Verify AST analyzer detects _session_for_write() usage."""
@@ -274,8 +281,10 @@ class TestRetryOnDeadlockDecorator(base.TestCase):
                 method_name,
                 write_users,
                 f"AST analyzer should detect {method_name}() uses "
-                "_session_for_write()")
+                "_session_for_write()",
+            )
             # Verify it's marked as direct usage
             self.assertTrue(
                 write_users[method_name]['direct'],
-                f"{method_name}() should be marked as direct user")
+                f"{method_name}() should be marked as direct user",
+            )
diff --git a/watcher/tests/unit/db/test_efficacy_indicator.py b/watcher/tests/unit/db/test_efficacy_indicator.py
index 25be4aa09..cb9eeb46c 100644
--- a/watcher/tests/unit/db/test_efficacy_indicator.py
+++ b/watcher/tests/unit/db/test_efficacy_indicator.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbEfficacyIndicatorFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -39,77 +38,104 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
         self.audit_template_name = "Audit Template"
 
         self.audit_template = utils.create_test_audit_template(
-            name=self.audit_template_name, id=1, uuid=None)
+            name=self.audit_template_name, id=1, uuid=None
+        )
         self.audit = utils.create_test_audit(
-            audit_template_id=self.audit_template.id, id=1, uuid=None)
+            audit_template_id=self.audit_template.id, id=1, uuid=None
+        )
         self.action_plan = utils.create_test_action_plan(
-            audit_id=self.audit.id, id=1, uuid=None)
+            audit_id=self.audit.id, id=1, uuid=None
+        )
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.efficacy_indicator1 = utils.create_test_efficacy_indicator(
-                action_plan_id=self.action_plan.id, id=1, uuid=None,
-                name="efficacy_indicator1", description="Test Indicator 1")
+                action_plan_id=self.action_plan.id,
+                id=1,
+                uuid=None,
+                name="efficacy_indicator1",
+                description="Test Indicator 1",
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.efficacy_indicator2 = utils.create_test_efficacy_indicator(
-                action_plan_id=self.action_plan.id, id=2, uuid=None,
-                name="efficacy_indicator2", description="Test Indicator 2")
+                action_plan_id=self.action_plan.id,
+                id=2,
+                uuid=None,
+                name="efficacy_indicator2",
+                description="Test Indicator 2",
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.efficacy_indicator3 = utils.create_test_efficacy_indicator(
-                action_plan_id=self.action_plan.id, id=3, uuid=None,
-                name="efficacy_indicator3", description="Test Indicator 3")
+                action_plan_id=self.action_plan.id,
+                id=3,
+                uuid=None,
+                name="efficacy_indicator3",
+                description="Test Indicator 3",
+            )
 
     def _soft_delete_efficacy_indicators(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_efficacy_indicator(
-                self.efficacy_indicator1.uuid)
+                self.efficacy_indicator1.uuid
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.soft_delete_efficacy_indicator(
-                self.efficacy_indicator2.uuid)
+                self.efficacy_indicator2.uuid
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.soft_delete_efficacy_indicator(
-                self.efficacy_indicator3.uuid)
+                self.efficacy_indicator3.uuid
+            )
 
     def _update_efficacy_indicators(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_efficacy_indicator(
                 self.efficacy_indicator1.uuid,
-                values={"description": "New description 1"})
+                values={"description": "New description 1"},
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_efficacy_indicator(
                 self.efficacy_indicator2.uuid,
-                values={"description": "New description 2"})
+                values={"description": "New description 2"},
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_efficacy_indicator(
                 self.efficacy_indicator3.uuid,
-                values={"description": "New description 3"})
+                values={"description": "New description 3"},
+            )
 
     def test_get_efficacy_indicator_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_efficacy_indicator(
-                self.efficacy_indicator1.uuid)
+                self.efficacy_indicator1.uuid
+            )
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
     def test_get_efficacy_indicator_filter_deleted_false(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_efficacy_indicator(
-                self.efficacy_indicator1.uuid)
+                self.efficacy_indicator1.uuid
+            )
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
-        self.assertEqual([self.efficacy_indicator2['id'],
-                          self.efficacy_indicator3['id']],
-                         [r.id for r in res])
+        self.assertEqual(
+            [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_deleted_at_eq(self):
         self._soft_delete_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
@@ -117,27 +143,32 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
         self._soft_delete_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_deleted_at_lte(self):
         self._soft_delete_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_deleted_at_gt(self):
         self._soft_delete_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
@@ -145,50 +176,60 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
         self._soft_delete_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator1['id'], self.efficacy_indicator2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # created_at #
 
     def test_get_efficacy_indicator_filter_created_at_eq(self):
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
     def test_get_efficacy_indicator_filter_created_at_lt(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             res = self.dbapi.get_efficacy_indicator_list(
-                self.context, filters={'created_at__lt': self.FAKE_TODAY})
+                self.context, filters={'created_at__lt': self.FAKE_TODAY}
+            )
 
         self.assertEqual(
             [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_created_at_lte(self):
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_created_at_gt(self):
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
     def test_get_efficacy_indicator_filter_created_at_gte(self):
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator1['id'], self.efficacy_indicator2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     # updated_at #
 
@@ -196,7 +237,8 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
         self._update_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
@@ -204,27 +246,32 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
         self._update_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_updated_at_lte(self):
         self._update_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator2['id'], self.efficacy_indicator3['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
     def test_get_efficacy_indicator_filter_updated_at_gt(self):
         self._update_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.efficacy_indicator1['id']], [r.id for r in res])
 
@@ -232,25 +279,31 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
         self._update_efficacy_indicators()
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             [self.efficacy_indicator1['id'], self.efficacy_indicator2['id']],
-            [r.id for r in res])
+            [r.id for r in res],
+        )
 
 
 class DbEfficacyIndicatorTestCase(base.DbTestCase):
-
     def test_get_efficacy_indicator_list(self):
         uuids = []
         action_plan = utils.create_test_action_plan()
         for id_ in range(1, 4):
             efficacy_indicator = utils.create_test_efficacy_indicator(
-                action_plan_id=action_plan.id, id=id_, uuid=None,
-                name="efficacy_indicator", description="Test Indicator ")
+                action_plan_id=action_plan.id,
+                id=id_,
+                uuid=None,
+                name="efficacy_indicator",
+                description="Test Indicator ",
+            )
             uuids.append(str(efficacy_indicator['uuid']))
         efficacy_indicators = self.dbapi.get_efficacy_indicator_list(
-            self.context)
+            self.context
+        )
         efficacy_indicator_uuids = [ei.uuid for ei in efficacy_indicators]
         self.assertEqual(sorted(uuids), sorted(efficacy_indicator_uuids))
         for efficacy_indicator in efficacy_indicators:
@@ -263,18 +316,23 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
         uuids = []
         for i in range(1, 4):
             efficacy_indicator = utils.create_test_efficacy_indicator(
-                id=i, uuid=w_utils.generate_uuid(),
-                action_plan_id=action_plan.id)
+                id=i,
+                uuid=w_utils.generate_uuid(),
+                action_plan_id=action_plan.id,
+            )
             uuids.append(str(efficacy_indicator['uuid']))
         efficacy_indicators = self.dbapi.get_efficacy_indicator_list(
-            self.context, eager=True)
+            self.context, eager=True
+        )
         efficacy_indicator_map = {a.uuid: a for a in efficacy_indicators}
         self.assertEqual(sorted(uuids), sorted(efficacy_indicator_map.keys()))
         eager_efficacy_indicator = efficacy_indicator_map[
-            efficacy_indicator.uuid]
+            efficacy_indicator.uuid
+        ]
         self.assertEqual(
             action_plan.as_dict(),
-            eager_efficacy_indicator.action_plan.as_dict())
+            eager_efficacy_indicator.action_plan.as_dict(),
+        )
 
     def test_get_efficacy_indicator_list_with_filters(self):
         audit = utils.create_test_audit(uuid=w_utils.generate_uuid())
@@ -283,7 +341,8 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
             uuid=w_utils.generate_uuid(),
             audit_id=audit.id,
             first_efficacy_indicator_id=None,
-            state=objects.action_plan.State.RECOMMENDED)
+            state=objects.action_plan.State.RECOMMENDED,
+        )
 
         efficacy_indicator1 = utils.create_test_efficacy_indicator(
             id=1,
@@ -291,57 +350,63 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
             uuid=w_utils.generate_uuid(),
             action_plan_id=action_plan['id'],
             description='Description efficacy indicator 1',
-            unit='%')
+            unit='%',
+        )
         efficacy_indicator2 = utils.create_test_efficacy_indicator(
             id=2,
             name='indicator_2',
             uuid=w_utils.generate_uuid(),
             action_plan_id=2,
             description='Description efficacy indicator 2',
-            unit='%')
+            unit='%',
+        )
         efficacy_indicator3 = utils.create_test_efficacy_indicator(
             id=3,
             name='indicator_3',
             uuid=w_utils.generate_uuid(),
             action_plan_id=action_plan['id'],
             description='Description efficacy indicator 3',
-            unit='%')
+            unit='%',
+        )
         efficacy_indicator4 = utils.create_test_efficacy_indicator(
             id=4,
             name='indicator_4',
             uuid=w_utils.generate_uuid(),
             action_plan_id=action_plan['id'],
             description='Description efficacy indicator 4',
-            unit='%')
+            unit='%',
+        )
 
         self.dbapi.soft_delete_efficacy_indicator(efficacy_indicator4['uuid'])
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context,
-            filters={'name': 'indicator_3'})
+            self.context, filters={'name': 'indicator_3'}
+        )
         self.assertEqual([efficacy_indicator3['id']], [r.id for r in res])
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context,
-            filters={'unit': 'kWh'})
+            self.context, filters={'unit': 'kWh'}
+        )
         self.assertEqual([], [r.id for r in res])
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context,
-            filters={'action_plan_id': 2})
+            self.context, filters={'action_plan_id': 2}
+        )
         self.assertEqual([efficacy_indicator2['id']], [r.id for r in res])
 
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context,
-            filters={'action_plan_uuid': action_plan['uuid']})
+            self.context, filters={'action_plan_uuid': action_plan['uuid']}
+        )
         self.assertEqual(
             sorted([efficacy_indicator1['id'], efficacy_indicator3['id']]),
-            sorted([r.id for r in res]))
+            sorted([r.id for r in res]),
+        )
 
     def test_get_efficacy_indicator_list_with_filter_by_uuid(self):
         efficacy_indicator = utils.create_test_efficacy_indicator()
         res = self.dbapi.get_efficacy_indicator_list(
-            self.context, filters={'uuid': efficacy_indicator.uuid})
+            self.context, filters={'uuid': efficacy_indicator.uuid}
+        )
 
         self.assertEqual(len(res), 1)
         self.assertEqual(efficacy_indicator.uuid, res[0].uuid)
@@ -349,70 +414,93 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
     def test_get_efficacy_indicator_by_id(self):
         efficacy_indicator = utils.create_test_efficacy_indicator()
         efficacy_indicator = self.dbapi.get_efficacy_indicator_by_id(
-            self.context, efficacy_indicator.id)
+            self.context, efficacy_indicator.id
+        )
         self.assertEqual(efficacy_indicator.uuid, efficacy_indicator.uuid)
 
     def test_get_efficacy_indicator_by_uuid(self):
         efficacy_indicator = utils.create_test_efficacy_indicator()
         efficacy_indicator = self.dbapi.get_efficacy_indicator_by_uuid(
-            self.context, efficacy_indicator.uuid)
+            self.context, efficacy_indicator.uuid
+        )
         self.assertEqual(efficacy_indicator['id'], efficacy_indicator.id)
 
     def test_get_efficacy_indicator_that_does_not_exist(self):
         self.assertRaises(
             exception.EfficacyIndicatorNotFound,
-            self.dbapi.get_efficacy_indicator_by_id, self.context, 1234)
+            self.dbapi.get_efficacy_indicator_by_id,
+            self.context,
+            1234,
+        )
 
     def test_update_efficacy_indicator(self):
         efficacy_indicator = utils.create_test_efficacy_indicator()
         res = self.dbapi.update_efficacy_indicator(
             efficacy_indicator.id,
-            {'state': objects.action_plan.State.CANCELLED})
+            {'state': objects.action_plan.State.CANCELLED},
+        )
         self.assertEqual('CANCELLED', res.state)
 
     def test_update_efficacy_indicator_that_does_not_exist(self):
         self.assertRaises(
             exception.EfficacyIndicatorNotFound,
-            self.dbapi.update_efficacy_indicator, 1234, {'state': ''})
+            self.dbapi.update_efficacy_indicator,
+            1234,
+            {'state': ''},
+        )
 
     def test_update_efficacy_indicator_uuid(self):
         efficacy_indicator = utils.create_test_efficacy_indicator()
         self.assertRaises(
             exception.Invalid,
-            self.dbapi.update_efficacy_indicator, efficacy_indicator.id,
-            {'uuid': 'hello'})
+            self.dbapi.update_efficacy_indicator,
+            efficacy_indicator.id,
+            {'uuid': 'hello'},
+        )
 
     def test_destroy_efficacy_indicator(self):
         efficacy_indicator = utils.create_test_efficacy_indicator()
         self.dbapi.destroy_efficacy_indicator(efficacy_indicator['id'])
-        self.assertRaises(exception.EfficacyIndicatorNotFound,
-                          self.dbapi.get_efficacy_indicator_by_id,
-                          self.context, efficacy_indicator['id'])
+        self.assertRaises(
+            exception.EfficacyIndicatorNotFound,
+            self.dbapi.get_efficacy_indicator_by_id,
+            self.context,
+            efficacy_indicator['id'],
+        )
 
     def test_destroy_efficacy_indicator_by_uuid(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_efficacy_indicator(uuid=uuid)
-        self.assertIsNotNone(self.dbapi.get_efficacy_indicator_by_uuid(
-            self.context, uuid))
+        self.assertIsNotNone(
+            self.dbapi.get_efficacy_indicator_by_uuid(self.context, uuid)
+        )
         self.dbapi.destroy_efficacy_indicator(uuid)
         self.assertRaises(
             exception.EfficacyIndicatorNotFound,
-            self.dbapi.get_efficacy_indicator_by_uuid, self.context, uuid)
+            self.dbapi.get_efficacy_indicator_by_uuid,
+            self.context,
+            uuid,
+        )
 
     def test_destroy_efficacy_indicator_that_does_not_exist(self):
-        self.assertRaises(exception.EfficacyIndicatorNotFound,
-                          self.dbapi.destroy_efficacy_indicator, 1234)
+        self.assertRaises(
+            exception.EfficacyIndicatorNotFound,
+            self.dbapi.destroy_efficacy_indicator,
+            1234,
+        )
 
     def test_create_efficacy_indicator_already_exists(self):
         uuid = w_utils.generate_uuid()
         utils.create_test_efficacy_indicator(id=1, uuid=uuid)
-        self.assertRaises(exception.EfficacyIndicatorAlreadyExists,
-                          utils.create_test_efficacy_indicator,
-                          id=2, uuid=uuid)
+        self.assertRaises(
+            exception.EfficacyIndicatorAlreadyExists,
+            utils.create_test_efficacy_indicator,
+            id=2,
+            uuid=uuid,
+        )
 
 
 class MySQLDbEfficacyIndicatorTestCase(base.MySQLDbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -426,34 +514,56 @@ class MySQLDbEfficacyIndicatorTestCase(base.MySQLDbTestCase):
         self.audit_template_name = "Audit Template"
 
         self.goal = utils.create_test_goal(
-            id=1, uuid=w_utils.generate_uuid(),
-            name="GOAL_1", display_name='Goal 1')
+            id=1,
+            uuid=w_utils.generate_uuid(),
+            name="GOAL_1",
+            display_name='Goal 1',
+        )
         self.strategy = utils.create_test_strategy(
-            id=1, uuid=w_utils.generate_uuid(),
-            name="STRATEGY_ID_1", display_name='My Strategy 1')
+            id=1,
+            uuid=w_utils.generate_uuid(),
+            name="STRATEGY_ID_1",
+            display_name='My Strategy 1',
+        )
         self.audit_template = utils.create_test_audit_template(
-            name=self.audit_template_name, id=1, uuid=None)
+            name=self.audit_template_name, id=1, uuid=None
+        )
         self.audit = utils.create_test_audit(
-            audit_template_id=self.audit_template.id, id=1, uuid=None)
+            audit_template_id=self.audit_template.id, id=1, uuid=None
+        )
         self.action_plan = utils.create_test_action_plan(
-            audit_id=self.audit.id, id=1, uuid=None)
+            audit_id=self.audit.id, id=1, uuid=None
+        )
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.efficacy_indicator1 = utils.create_test_efficacy_indicator(
-                action_plan_id=self.action_plan.id, id=1, uuid=None,
-                name="efficacy_indicator1", description="Test Indicator 1",
-                value=0.01234567912345678)
+                action_plan_id=self.action_plan.id,
+                id=1,
+                uuid=None,
+                name="efficacy_indicator1",
+                description="Test Indicator 1",
+                value=0.01234567912345678,
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.efficacy_indicator2 = utils.create_test_efficacy_indicator(
-                action_plan_id=self.action_plan.id, id=2, uuid=None,
-                name="efficacy_indicator2", description="Test Indicator 2")
+                action_plan_id=self.action_plan.id,
+                id=2,
+                uuid=None,
+                name="efficacy_indicator2",
+                description="Test Indicator 2",
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.efficacy_indicator3 = utils.create_test_efficacy_indicator(
-                action_plan_id=self.action_plan.id, id=3, uuid=None,
-                name="efficacy_indicator3", description="Test Indicator 3")
+                action_plan_id=self.action_plan.id,
+                id=3,
+                uuid=None,
+                name="efficacy_indicator3",
+                description="Test Indicator 3",
+            )
 
     def test_efficacy_indicator_value(self):
         db_efficacy_indicator = self.dbapi.get_efficacy_indicator_by_id(
-            self.context, 1)
+            self.context, 1
+        )
         self.assertAlmostEqual(db_efficacy_indicator.value, 0.012, places=3)
         self.assertAlmostEqual(db_efficacy_indicator.data, 0.012, places=3)
diff --git a/watcher/tests/unit/db/test_goal.py b/watcher/tests/unit/db/test_goal.py
index 24fa59fd6..39ce2626c 100644
--- a/watcher/tests/unit/db/test_goal.py
+++ b/watcher/tests/unit/db/test_goal.py
@@ -24,7 +24,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbGoalFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -37,16 +36,25 @@ class TestDbGoalFilters(base.DbTestCase):
     def _data_setup(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.goal1 = utils.create_test_goal(
-                id=1, uuid=w_utils.generate_uuid(), name="GOAL_1",
-                display_name="Goal 1")
+                id=1,
+                uuid=w_utils.generate_uuid(),
+                name="GOAL_1",
+                display_name="Goal 1",
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.goal2 = utils.create_test_goal(
-                id=2, uuid=w_utils.generate_uuid(),
-                name="GOAL_2", display_name="Goal 2")
+                id=2,
+                uuid=w_utils.generate_uuid(),
+                name="GOAL_2",
+                display_name="Goal 2",
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.goal3 = utils.create_test_goal(
-                id=3, uuid=w_utils.generate_uuid(),
-                name="GOAL_3", display_name="Goal 3")
+                id=3,
+                uuid=w_utils.generate_uuid(),
+                name="GOAL_3",
+                display_name="Goal 3",
+            )
 
     def _soft_delete_goals(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -59,20 +67,22 @@ class TestDbGoalFilters(base.DbTestCase):
     def _update_goals(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_goal(
-                self.goal1.uuid, values={"display_name": "goal1"})
+                self.goal1.uuid, values={"display_name": "goal1"}
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_goal(
-                self.goal2.uuid, values={"display_name": "goal2"})
+                self.goal2.uuid, values={"display_name": "goal2"}
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_goal(
-                self.goal3.uuid, values={"display_name": "goal3"})
+                self.goal3.uuid, values={"display_name": "goal3"}
+            )
 
     def test_get_goal_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_goal(self.goal1.id)
 
-        res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted': True})
+        res = self.dbapi.get_goal_list(self.context, filters={'deleted': True})
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
@@ -81,17 +91,19 @@ class TestDbGoalFilters(base.DbTestCase):
             self.dbapi.soft_delete_goal(self.goal1.id)
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_deleted_at_eq(self):
         self._soft_delete_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
@@ -99,27 +111,30 @@ class TestDbGoalFilters(base.DbTestCase):
         self._soft_delete_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_deleted_at_lte(self):
         self._soft_delete_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_deleted_at_gt(self):
         self._soft_delete_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
@@ -127,49 +142,55 @@ class TestDbGoalFilters(base.DbTestCase):
         self._soft_delete_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.goal1.uuid, self.goal2.uuid},
-            {r.uuid for r in res})
+            {self.goal1.uuid, self.goal2.uuid}, {r.uuid for r in res}
+        )
 
     # created_at #
 
     def test_get_goal_list_filter_created_at_eq(self):
         res = self.dbapi.get_goal_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
     def test_get_goal_list_filter_created_at_lt(self):
         res = self.dbapi.get_goal_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_created_at_lte(self):
         res = self.dbapi.get_goal_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_created_at_gt(self):
         res = self.dbapi.get_goal_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
     def test_get_goal_list_filter_created_at_gte(self):
         res = self.dbapi.get_goal_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.goal1.uuid, self.goal2.uuid},
-            {r.uuid for r in res})
+            {self.goal1.uuid, self.goal2.uuid}, {r.uuid for r in res}
+        )
 
     # updated_at #
 
@@ -177,7 +198,8 @@ class TestDbGoalFilters(base.DbTestCase):
         self._update_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
@@ -185,27 +207,30 @@ class TestDbGoalFilters(base.DbTestCase):
         self._update_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_updated_at_lte(self):
         self._update_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.goal2.uuid, self.goal3.uuid},
-            {r.uuid for r in res})
+            {self.goal2.uuid, self.goal3.uuid}, {r.uuid for r in res}
+        )
 
     def test_get_goal_list_filter_updated_at_gt(self):
         self._update_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.goal1.uuid], [r.uuid for r in res])
 
@@ -213,15 +238,15 @@ class TestDbGoalFilters(base.DbTestCase):
         self._update_goals()
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.goal1.uuid, self.goal2.uuid},
-            {r.uuid for r in res})
+            {self.goal1.uuid, self.goal2.uuid}, {r.uuid for r in res}
+        )
 
 
 class DbGoalTestCase(base.DbTestCase):
-
     def test_get_goal_list(self):
         uuids = []
         for i in range(1, 4):
@@ -229,7 +254,8 @@ class DbGoalTestCase(base.DbTestCase):
                 id=i,
                 uuid=w_utils.generate_uuid(),
                 name=f"GOAL_{i}",
-                display_name=f'My Goal {i}')
+                display_name=f'My Goal {i}',
+            )
             uuids.append(str(goal['uuid']))
         goals = self.dbapi.get_goal_list(self.context)
         goal_uuids = [g.uuid for g in goals]
@@ -258,75 +284,99 @@ class DbGoalTestCase(base.DbTestCase):
         self.dbapi.soft_delete_goal(goal3['uuid'])
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'display_name': 'Goal 1'})
+            self.context, filters={'display_name': 'Goal 1'}
+        )
         self.assertEqual([goal1['uuid']], [r.uuid for r in res])
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'display_name': 'Goal 3'})
+            self.context, filters={'display_name': 'Goal 3'}
+        )
         self.assertEqual([], [r.uuid for r in res])
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'name': 'GOAL_1'})
+            self.context, filters={'name': 'GOAL_1'}
+        )
         self.assertEqual([goal1['uuid']], [r.uuid for r in res])
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'display_name': 'Goal 2'})
+            self.context, filters={'display_name': 'Goal 2'}
+        )
         self.assertEqual([goal2['uuid']], [r.uuid for r in res])
 
         res = self.dbapi.get_goal_list(
-            self.context, filters={'uuid': goal3['uuid']})
+            self.context, filters={'uuid': goal3['uuid']}
+        )
         self.assertEqual([], [r.uuid for r in res])
 
     def test_get_goal_by_uuid(self):
-        efficacy_spec = [{"unit": "%", "name": "dummy",
-                          "schema": "Range(min=0, max=100, min_included=True, "
-                                    "max_included=True, msg=None)",
-                          "description": "Dummy indicator"}]
+        efficacy_spec = [
+            {
+                "unit": "%",
+                "name": "dummy",
+                "schema": "Range(min=0, max=100, min_included=True, "
+                "max_included=True, msg=None)",
+                "description": "Dummy indicator",
+            }
+        ]
         created_goal = utils.create_test_goal(
-            efficacy_specification=efficacy_spec)
+            efficacy_specification=efficacy_spec
+        )
         goal = self.dbapi.get_goal_by_uuid(self.context, created_goal['uuid'])
         self.assertEqual(goal.uuid, created_goal['uuid'])
 
     def test_get_goal_that_does_not_exist(self):
         random_uuid = w_utils.generate_uuid()
-        self.assertRaises(exception.GoalNotFound,
-                          self.dbapi.get_goal_by_uuid,
-                          self.context, random_uuid)
+        self.assertRaises(
+            exception.GoalNotFound,
+            self.dbapi.get_goal_by_uuid,
+            self.context,
+            random_uuid,
+        )
 
     def test_update_goal(self):
         goal = utils.create_test_goal()
-        res = self.dbapi.update_goal(goal['uuid'],
-                                     {'display_name': 'updated-model'})
+        res = self.dbapi.update_goal(
+            goal['uuid'], {'display_name': 'updated-model'}
+        )
         self.assertEqual('updated-model', res.display_name)
 
     def test_update_goal_id(self):
         goal = utils.create_test_goal()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_goal, goal['uuid'],
-                          {'uuid': 'NEW_GOAL'})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_goal,
+            goal['uuid'],
+            {'uuid': 'NEW_GOAL'},
+        )
 
     def test_update_goal_that_does_not_exist(self):
         random_uuid = w_utils.generate_uuid()
-        self.assertRaises(exception.GoalNotFound,
-                          self.dbapi.update_goal,
-                          random_uuid,
-                          {'display_name': ''})
+        self.assertRaises(
+            exception.GoalNotFound,
+            self.dbapi.update_goal,
+            random_uuid,
+            {'display_name': ''},
+        )
 
     def test_destroy_goal(self):
         goal = utils.create_test_goal()
         self.dbapi.destroy_goal(goal['uuid'])
-        self.assertRaises(exception.GoalNotFound,
-                          self.dbapi.get_goal_by_uuid,
-                          self.context, goal['uuid'])
+        self.assertRaises(
+            exception.GoalNotFound,
+            self.dbapi.get_goal_by_uuid,
+            self.context,
+            goal['uuid'],
+        )
 
     def test_destroy_goal_that_does_not_exist(self):
         random_uuid = w_utils.generate_uuid()
-        self.assertRaises(exception.GoalNotFound,
-                          self.dbapi.destroy_goal, random_uuid)
+        self.assertRaises(
+            exception.GoalNotFound, self.dbapi.destroy_goal, random_uuid
+        )
 
     def test_create_goal_already_exists(self):
         goal_uuid = w_utils.generate_uuid()
         utils.create_test_goal(uuid=goal_uuid)
-        self.assertRaises(exception.GoalAlreadyExists,
-                          utils.create_test_goal,
-                          uuid=goal_uuid)
+        self.assertRaises(
+            exception.GoalAlreadyExists, utils.create_test_goal, uuid=goal_uuid
+        )
diff --git a/watcher/tests/unit/db/test_migrations.py b/watcher/tests/unit/db/test_migrations.py
index ce08791ad..32559b441 100644
--- a/watcher/tests/unit/db/test_migrations.py
+++ b/watcher/tests/unit/db/test_migrations.py
@@ -13,7 +13,7 @@
 # under the License.
 #
 
-""""Tests for database migration for Watcher.
+""" "Tests for database migration for Watcher.
 
 These are "opportunistic" tests which allow testing against all three databases
 (sqlite in memory, mysql, pg) in a properly configured unit test environment.
@@ -44,16 +44,15 @@ from watcher.tests.unit.db import utils
 LOG = logging.getLogger(__name__)
 
 
-class MySQLDbMigrationsTestCase(test_fixtures.OpportunisticDBTestMixin,
-                                base.TestCase):
-
+class MySQLDbMigrationsTestCase(
+    test_fixtures.OpportunisticDBTestMixin, base.TestCase
+):
     FIXTURE = test_fixtures.MySQLOpportunisticFixture
 
     def setUp(self):
         conn_str = "mysql+pymysql://root:insecure_slave@127.0.0.1"
         # to use mysql db
-        cfg.CONF.set_override("connection", conn_str,
-                              group="database")
+        cfg.CONF.set_override("connection", conn_str, group="database")
         super().setUp()
         self.engine = enginefacade.writer.get_engine()
         self.dbapi = dbapi.get_instance()
@@ -156,12 +155,11 @@ class MySQLDbDataMigrationsTestCase(MySQLDbMigrationsTestCase):
         metadata.reflect(bind=self.engine)
         eff_ind_table = sqlalchemy.Table('efficacy_indicators', metadata)
         with connection.begin():
-
             return connection.execute(
                 sqlalchemy.select(eff_ind_table.c.data).where(
                     eff_ind_table.c.id == id
-                    )
-                ).one()
+                )
+            ).one()
 
     def _pre_upgrade_15f7375ca737(self, connection):
         """Add data to the database before applying the 15f7375ca737 revision.
@@ -171,42 +169,65 @@ class MySQLDbDataMigrationsTestCase(MySQLDbMigrationsTestCase):
 
         """
         self.goal = utils.create_test_goal(
-            id=1, uuid=w_utils.generate_uuid(),
-            name="GOAL_1", display_name='Goal 1')
+            id=1,
+            uuid=w_utils.generate_uuid(),
+            name="GOAL_1",
+            display_name='Goal 1',
+        )
         self.strategy = utils.create_test_strategy(
-            id=1, uuid=w_utils.generate_uuid(),
-            name="STRATEGY_ID_1", display_name='My Strategy 1')
+            id=1,
+            uuid=w_utils.generate_uuid(),
+            name="STRATEGY_ID_1",
+            display_name='My Strategy 1',
+        )
         self.audit_template = utils.create_test_audit_template(
-            name="Audit Template", id=1, uuid=None)
+            name="Audit Template", id=1, uuid=None
+        )
         self._create_manual_audit(
             connection,
-            audit_template_id=self.audit_template.id, id=1, uuid=None,
-            name="AUDIT_1")
+            audit_template_id=self.audit_template.id,
+            id=1,
+            uuid=None,
+            name="AUDIT_1",
+        )
         self._create_manual_action_plan(
-            connection,
-            audit_id=1, id=1, uuid=None)
+            connection, audit_id=1, id=1, uuid=None
+        )
 
         self._create_manual_efficacy_indicator(
             connection,
-            action_plan_id=1, id=1, uuid=None,
-            name="efficacy_indicator1", description="Test Indicator 1",
-            value=1.01234567912345678)
+            action_plan_id=1,
+            id=1,
+            uuid=None,
+            name="efficacy_indicator1",
+            description="Test Indicator 1",
+            value=1.01234567912345678,
+        )
         self._create_manual_efficacy_indicator(
             connection,
-            action_plan_id=1, id=2, uuid=None,
-            name="efficacy_indicator2", description="Test Indicator 2",
-            value=2.01234567912345678)
+            action_plan_id=1,
+            id=2,
+            uuid=None,
+            name="efficacy_indicator2",
+            description="Test Indicator 2",
+            value=2.01234567912345678,
+        )
 
     def _check_15f7375ca737(self, connection):
         """Check data integrity after the database migration."""
         # check that creating a new efficacy_indicator after the migration
         # works
         utils.create_test_efficacy_indicator(
-            action_plan_id=1, id=3, uuid=None,
-            name="efficacy_indicator3", description="Test Indicator 3",
-            value=0.01234567912345678)
+            action_plan_id=1,
+            id=3,
+            uuid=None,
+            name="efficacy_indicator3",
+            description="Test Indicator 3",
+            value=0.01234567912345678,
+        )
         db_efficacy_indicator = self.dbapi.get_efficacy_indicator_by_id(
-            self.context, 3)
+            self.context, 3
+        )
         self.assertAlmostEqual(db_efficacy_indicator.value, 0.012, places=3)
         # check that the 'data' column of the efficacy_indicator created before
         # applying the revision is null for both efficacy_indicators
@@ -215,53 +236,47 @@ class MySQLDbDataMigrationsTestCase(MySQLDbMigrationsTestCase):
 
         # check that the existing data is there after the migration
         db_efficacy_indicator_1 = self.dbapi.get_efficacy_indicator_by_id(
-            self.context, 1)
-        self.assertAlmostEqual(db_efficacy_indicator_1.data,
-                               1.00, places=2)
-        self.assertAlmostEqual(db_efficacy_indicator_1.value,
-                               1.00, places=2)
+            self.context, 1
+        )
+        self.assertAlmostEqual(db_efficacy_indicator_1.data, 1.00, places=2)
+        self.assertAlmostEqual(db_efficacy_indicator_1.value, 1.00, places=2)
         self.assertEqual(db_efficacy_indicator_1.name, "efficacy_indicator1")
         # check that the 'data' column of the efficacy_indicator1 is now the
         # same as the 'value' column, i.e the data migration on load worked
         eff_ind_1_data = self._read_efficacy_indicator(connection, 1)[0]
-        self.assertAlmostEqual(eff_ind_1_data,
-                               1.00, places=2)
+        self.assertAlmostEqual(eff_ind_1_data, 1.00, places=2)
 
         # check that getting the efficacy_indicator using the
         # get_efficacy_indicator_list method reports the correct values
         efficacy_indicators = self.dbapi.get_efficacy_indicator_list(
-            self.context)
+            self.context
+        )
         self.assertEqual(len(efficacy_indicators), 3)
         self.assertEqual(efficacy_indicators[0].id, 1)
-        self.assertAlmostEqual(efficacy_indicators[0].value,
-                               1.00, places=3)
+        self.assertAlmostEqual(efficacy_indicators[0].value, 1.00, places=3)
         self.assertEqual(efficacy_indicators[1].id, 2)
-        self.assertAlmostEqual(efficacy_indicators[1].value,
-                               2.00, places=3)
+        self.assertAlmostEqual(efficacy_indicators[1].value, 2.00, places=3)
 
         self.assertEqual(efficacy_indicators[2].id, 3)
-        self.assertAlmostEqual(efficacy_indicators[2].value,
-                               0.012, places=3)
+        self.assertAlmostEqual(efficacy_indicators[2].value, 0.012, places=3)
         # check that the 'data' column of the efficacy_indicator1 is now the
         # same as the 'value' column, i.e the data migration on load worked
         # after the call to get_efficacy_indicator_list
         eff_ind_2_data = self._read_efficacy_indicator(connection, 2)[0]
-        self.assertAlmostEqual(eff_ind_2_data,
-                               2.00, places=2)
+        self.assertAlmostEqual(eff_ind_2_data, 2.00, places=2)
 
     def _check_7150a7d8f228(self, connection):
         """Check new columen status_message have been created."""
         self.assertTrue(
             oslodbutils.column_exists(
-                connection, "action_plans", "status_message")
+                connection, "action_plans", "status_message"
+            )
         )
         self.assertTrue(
-            oslodbutils.column_exists(
-                connection, "actions", "status_message")
+            oslodbutils.column_exists(connection, "actions", "status_message")
         )
         self.assertTrue(
-            oslodbutils.column_exists(
-                connection, "audits", "status_message")
+            oslodbutils.column_exists(connection, "audits", "status_message")
         )
 
     def test_migration_revisions(self):
diff --git a/watcher/tests/unit/db/test_purge.py b/watcher/tests/unit/db/test_purge.py
index 95ed5bf1a..a01edda8d 100644
--- a/watcher/tests/unit/db/test_purge.py
+++ b/watcher/tests/unit/db/test_purge.py
@@ -28,18 +28,13 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestPurgeCommand(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.cmd = purge.PurgeCommand()
         token_info = {
             'token': {
-                'project': {
-                    'id': 'fake_project'
-                },
-                'user': {
-                    'id': 'fake_user'
-                }
+                'project': {'id': 'fake_project'},
+                'user': {'id': 'fake_user'},
             }
         }
         self.context = watcher_context.RequestContext(
@@ -94,110 +89,165 @@ class TestPurgeCommand(base.DbTestCase):
         strategy3_name = "strategy_3"
 
         self.audit_template1_name = self.generate_unique_name(
-            prefix="Audit Template 1 ")
+            prefix="Audit Template 1 "
+        )
         self.audit_template2_name = self.generate_unique_name(
-            prefix="Audit Template 2 ")
+            prefix="Audit Template 2 "
+        )
         self.audit_template3_name = self.generate_unique_name(
-            prefix="Audit Template 3 ")
+            prefix="Audit Template 3 "
+        )
 
-        self.audit1_name = self.generate_unique_name(
-            prefix="Audit 1 ")
-        self.audit2_name = self.generate_unique_name(
-            prefix="Audit 2 ")
-        self.audit3_name = self.generate_unique_name(
-            prefix="Audit 3 ")
+        self.audit1_name = self.generate_unique_name(prefix="Audit 1 ")
+        self.audit2_name = self.generate_unique_name(prefix="Audit 2 ")
+        self.audit3_name = self.generate_unique_name(prefix="Audit 3 ")
 
         with freezegun.freeze_time(self.expired_date):
             self.goal1 = obj_utils.create_test_goal(
-                self.context, id=self._generate_id(),
+                self.context,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=goal1_name, display_name=goal1_name.lower())
+                name=goal1_name,
+                display_name=goal1_name.lower(),
+            )
             self.goal2 = obj_utils.create_test_goal(
-                self.context, id=self._generate_id(),
+                self.context,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=goal2_name, display_name=goal2_name.lower())
+                name=goal2_name,
+                display_name=goal2_name.lower(),
+            )
             self.goal3 = obj_utils.create_test_goal(
-                self.context, id=self._generate_id(),
+                self.context,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=goal3_name, display_name=goal3_name.lower())
+                name=goal3_name,
+                display_name=goal3_name.lower(),
+            )
             self.goal1.soft_delete()
 
         with freezegun.freeze_time(self.expired_date):
             self.strategy1 = obj_utils.create_test_strategy(
-                self.context, id=self._generate_id(),
+                self.context,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=strategy1_name, display_name=strategy1_name.lower(),
-                goal_id=self.goal1.id)
+                name=strategy1_name,
+                display_name=strategy1_name.lower(),
+                goal_id=self.goal1.id,
+            )
             self.strategy2 = obj_utils.create_test_strategy(
-                self.context, id=self._generate_id(),
+                self.context,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=strategy2_name, display_name=strategy2_name.lower(),
-                goal_id=self.goal2.id)
+                name=strategy2_name,
+                display_name=strategy2_name.lower(),
+                goal_id=self.goal2.id,
+            )
             self.strategy3 = obj_utils.create_test_strategy(
-                self.context, id=self._generate_id(),
+                self.context,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=strategy3_name, display_name=strategy3_name.lower(),
-                goal_id=self.goal3.id)
+                name=strategy3_name,
+                display_name=strategy3_name.lower(),
+                goal_id=self.goal3.id,
+            )
             self.strategy1.soft_delete()
 
         with freezegun.freeze_time(self.expired_date):
             self.audit_template1 = obj_utils.create_test_audit_template(
-                self.context, name=self.audit_template1_name,
+                self.context,
+                name=self.audit_template1_name,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid(), goal_id=self.goal1.id,
-                strategy_id=self.strategy1.id)
+                uuid=utils.generate_uuid(),
+                goal_id=self.goal1.id,
+                strategy_id=self.strategy1.id,
+            )
             self.audit_template2 = obj_utils.create_test_audit_template(
-                self.context, name=self.audit_template2_name,
+                self.context,
+                name=self.audit_template2_name,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid(), goal_id=self.goal2.id,
-                strategy_id=self.strategy2.id)
+                uuid=utils.generate_uuid(),
+                goal_id=self.goal2.id,
+                strategy_id=self.strategy2.id,
+            )
             self.audit_template3 = obj_utils.create_test_audit_template(
-                self.context, name=self.audit_template3_name,
+                self.context,
+                name=self.audit_template3_name,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid(), goal_id=self.goal3.id,
-                strategy_id=self.strategy3.id)
+                uuid=utils.generate_uuid(),
+                goal_id=self.goal3.id,
+                strategy_id=self.strategy3.id,
+            )
             self.audit_template1.soft_delete()
 
         with freezegun.freeze_time(self.expired_date):
             self.audit1 = obj_utils.create_test_audit(
-                self.context, id=self._generate_id(),
-                uuid=utils.generate_uuid(), name=self.audit1_name,
-                goal_id=self.goal1.id, strategy_id=self.strategy1.id)
+                self.context,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                name=self.audit1_name,
+                goal_id=self.goal1.id,
+                strategy_id=self.strategy1.id,
+            )
             self.audit2 = obj_utils.create_test_audit(
-                self.context, id=self._generate_id(),
-                uuid=utils.generate_uuid(), name=self.audit2_name,
-                goal_id=self.goal2.id, strategy_id=self.strategy2.id)
+                self.context,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                name=self.audit2_name,
+                goal_id=self.goal2.id,
+                strategy_id=self.strategy2.id,
+            )
             self.audit3 = obj_utils.create_test_audit(
-                self.context, id=self._generate_id(),
-                uuid=utils.generate_uuid(), name=self.audit3_name,
-                goal_id=self.goal3.id, strategy_id=self.strategy3.id)
+                self.context,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                name=self.audit3_name,
+                goal_id=self.goal3.id,
+                strategy_id=self.strategy3.id,
+            )
             self.audit1.soft_delete()
 
         with freezegun.freeze_time(self.expired_date):
             self.action_plan1 = obj_utils.create_test_action_plan(
-                self.context, audit_id=self.audit1.id,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
-                strategy_id=self.strategy1.id)
+                self.context,
+                audit_id=self.audit1.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                strategy_id=self.strategy1.id,
+            )
             self.action_plan2 = obj_utils.create_test_action_plan(
-                self.context, audit_id=self.audit2.id,
+                self.context,
+                audit_id=self.audit2.id,
                 id=self._generate_id(),
                 strategy_id=self.strategy2.id,
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             self.action_plan3 = obj_utils.create_test_action_plan(
-                self.context, audit_id=self.audit3.id,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
-                strategy_id=self.strategy3.id)
+                self.context,
+                audit_id=self.audit3.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                strategy_id=self.strategy3.id,
+            )
 
             self.action1 = obj_utils.create_test_action(
-                self.context, action_plan_id=self.action_plan1.id,
+                self.context,
+                action_plan_id=self.action_plan1.id,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+            )
             self.action2 = obj_utils.create_test_action(
-                self.context, action_plan_id=self.action_plan2.id,
-                id=self._generate_id(), uuid=utils.generate_uuid())
+                self.context,
+                action_plan_id=self.action_plan2.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
             self.action3 = obj_utils.create_test_action(
-                self.context, action_plan_id=self.action_plan3.id,
-                id=self._generate_id(), uuid=utils.generate_uuid())
+                self.context,
+                action_plan_id=self.action_plan3.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
             self.action_plan1.soft_delete()
 
     @mock.patch.object(dbapi.Connection, "destroy_action")
@@ -206,13 +256,15 @@ class TestPurgeCommand(base.DbTestCase):
     @mock.patch.object(dbapi.Connection, "destroy_audit_template")
     @mock.patch.object(dbapi.Connection, "destroy_strategy")
     @mock.patch.object(dbapi.Connection, "destroy_goal")
-    def test_execute_max_number_exceeded(self,
-                                         m_destroy_goal,
-                                         m_destroy_strategy,
-                                         m_destroy_audit_template,
-                                         m_destroy_audit,
-                                         m_destroy_action_plan,
-                                         m_destroy_action):
+    def test_execute_max_number_exceeded(
+        self,
+        m_destroy_goal,
+        m_destroy_strategy,
+        m_destroy_audit_template,
+        m_destroy_audit,
+        m_destroy_action_plan,
+        m_destroy_action,
+    ):
         self.cmd.age_in_days = None
         self.cmd.max_number = 10
 
@@ -272,42 +324,64 @@ class TestPurgeCommand(base.DbTestCase):
         with freezegun.freeze_time(self.fake_today):
             # orphan audit template
             audit_template4 = obj_utils.create_test_audit_template(
-                self.context, goal_id=self.goal2.id,
+                self.context,
+                goal_id=self.goal2.id,
                 name=self.generate_unique_name(prefix="Audit Template 4 "),
-                strategy_id=self.strategy1.id, id=self._generate_id(),
-                uuid=utils.generate_uuid())
-            audit4 = obj_utils.create_test_audit(
-                self.context, audit_template_id=audit_template4.id,
-                strategy_id=self.strategy1.id, id=self._generate_id(),
+                strategy_id=self.strategy1.id,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=self.generate_unique_name(prefix="Audit 4 "))
+            )
+            audit4 = obj_utils.create_test_audit(
+                self.context,
+                audit_template_id=audit_template4.id,
+                strategy_id=self.strategy1.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                name=self.generate_unique_name(prefix="Audit 4 "),
+            )
             action_plan4 = obj_utils.create_test_action_plan(
                 self.context,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
-                audit_id=audit4.id, strategy_id=self.strategy1.id)
-            action4 = obj_utils.create_test_action(
-                self.context, action_plan_id=action_plan4.id,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+                audit_id=audit4.id,
+                strategy_id=self.strategy1.id,
+            )
+            action4 = obj_utils.create_test_action(
+                self.context,
+                action_plan_id=action_plan4.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
 
             audit_template5 = obj_utils.create_test_audit_template(
-                self.context, goal_id=self.goal1.id,
+                self.context,
+                goal_id=self.goal1.id,
                 name=self.generate_unique_name(prefix="Audit Template 5 "),
-                strategy_id=None, id=self._generate_id(),
-                uuid=utils.generate_uuid())
-            audit5 = obj_utils.create_test_audit(
-                self.context, audit_template_id=audit_template5.id,
-                strategy_id=self.strategy1.id, id=self._generate_id(),
+                strategy_id=None,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=self.generate_unique_name(prefix="Audit 5 "))
+            )
+            audit5 = obj_utils.create_test_audit(
+                self.context,
+                audit_template_id=audit_template5.id,
+                strategy_id=self.strategy1.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                name=self.generate_unique_name(prefix="Audit 5 "),
+            )
             action_plan5 = obj_utils.create_test_action_plan(
                 self.context,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
-                audit_id=audit5.id, strategy_id=self.strategy1.id)
-            action5 = obj_utils.create_test_action(
-                self.context, action_plan_id=action_plan5.id,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+                audit_id=audit5.id,
+                strategy_id=self.strategy1.id,
+            )
+            action5 = obj_utils.create_test_action(
+                self.context,
+                action_plan_id=action_plan5.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
 
             self.goal2.soft_delete()
             self.strategy2.soft_delete()
@@ -335,7 +409,8 @@ class TestPurgeCommand(base.DbTestCase):
         self.assertEqual(len(objects_map.actions), 3)
         self.assertEqual(
             {self.action1.id, action4.id, action5.id},
-            {entry.id for entry in objects_map.actions})
+            {entry.id for entry in objects_map.actions},
+        )
 
     @mock.patch.object(dbapi.Connection, "destroy_action")
     @mock.patch.object(dbapi.Connection, "destroy_action_plan")
@@ -343,20 +418,24 @@ class TestPurgeCommand(base.DbTestCase):
     @mock.patch.object(dbapi.Connection, "destroy_audit_template")
     @mock.patch.object(dbapi.Connection, "destroy_strategy")
     @mock.patch.object(dbapi.Connection, "destroy_goal")
-    def test_purge_command(self, m_destroy_goal, m_destroy_strategy,
-                           m_destroy_audit_template, m_destroy_audit,
-                           m_destroy_action_plan, m_destroy_action):
+    def test_purge_command(
+        self,
+        m_destroy_goal,
+        m_destroy_strategy,
+        m_destroy_audit_template,
+        m_destroy_audit,
+        m_destroy_action_plan,
+        m_destroy_action,
+    ):
         with freezegun.freeze_time(self.fake_today):
             self.cmd.execute()
 
         m_destroy_audit_template.assert_called_once_with(
-            self.audit_template1.uuid)
-        m_destroy_audit.assert_called_with(
-            self.audit1.uuid)
-        m_destroy_action_plan.assert_called_with(
-            self.action_plan1.uuid)
-        m_destroy_action.assert_called_with(
-            self.action1.uuid)
+            self.audit_template1.uuid
+        )
+        m_destroy_audit.assert_called_with(self.audit1.uuid)
+        m_destroy_action_plan.assert_called_with(self.action_plan1.uuid)
+        m_destroy_action.assert_called_with(self.action1.uuid)
 
     @mock.patch.object(dbapi.Connection, "destroy_action")
     @mock.patch.object(dbapi.Connection, "destroy_action_plan")
@@ -365,48 +444,74 @@ class TestPurgeCommand(base.DbTestCase):
     @mock.patch.object(dbapi.Connection, "destroy_strategy")
     @mock.patch.object(dbapi.Connection, "destroy_goal")
     def test_purge_command_with_nonexpired_related_entries(
-            self, m_destroy_goal, m_destroy_strategy,
-            m_destroy_audit_template, m_destroy_audit,
-            m_destroy_action_plan, m_destroy_action):
+        self,
+        m_destroy_goal,
+        m_destroy_strategy,
+        m_destroy_audit_template,
+        m_destroy_audit,
+        m_destroy_action_plan,
+        m_destroy_action,
+    ):
         with freezegun.freeze_time(self.fake_today):
             # orphan audit template
             audit_template4 = obj_utils.create_test_audit_template(
-                self.context, goal_id=self.goal2.id,
+                self.context,
+                goal_id=self.goal2.id,
                 name=self.generate_unique_name(prefix="Audit Template 4 "),
-                strategy_id=None, id=self._generate_id(),
-                uuid=utils.generate_uuid())
+                strategy_id=None,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
             audit4 = obj_utils.create_test_audit(
                 self.context,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
                 audit_template_id=audit_template4.id,
-                name=self.generate_unique_name(prefix="Audit 4 "))
+                name=self.generate_unique_name(prefix="Audit 4 "),
+            )
             action_plan4 = obj_utils.create_test_action_plan(
                 self.context,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
-                audit_id=audit4.id, strategy_id=self.strategy1.id)
-            action4 = obj_utils.create_test_action(
-                self.context, action_plan_id=action_plan4.id,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+                audit_id=audit4.id,
+                strategy_id=self.strategy1.id,
+            )
+            action4 = obj_utils.create_test_action(
+                self.context,
+                action_plan_id=action_plan4.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
 
             audit_template5 = obj_utils.create_test_audit_template(
-                self.context, goal_id=self.goal1.id,
+                self.context,
+                goal_id=self.goal1.id,
                 name=self.generate_unique_name(prefix="Audit Template 5 "),
-                strategy_id=None, id=self._generate_id(),
-                uuid=utils.generate_uuid())
-            audit5 = obj_utils.create_test_audit(
-                self.context, audit_template_id=audit_template5.id,
-                strategy_id=self.strategy1.id, id=self._generate_id(),
+                strategy_id=None,
+                id=self._generate_id(),
                 uuid=utils.generate_uuid(),
-                name=self.generate_unique_name(prefix="Audit 5 "))
+            )
+            audit5 = obj_utils.create_test_audit(
+                self.context,
+                audit_template_id=audit_template5.id,
+                strategy_id=self.strategy1.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+                name=self.generate_unique_name(prefix="Audit 5 "),
+            )
             action_plan5 = obj_utils.create_test_action_plan(
                 self.context,
-                id=self._generate_id(), uuid=utils.generate_uuid(),
-                audit_id=audit5.id, strategy_id=self.strategy1.id)
-            action5 = obj_utils.create_test_action(
-                self.context, action_plan_id=action_plan5.id,
                 id=self._generate_id(),
-                uuid=utils.generate_uuid())
+                uuid=utils.generate_uuid(),
+                audit_id=audit5.id,
+                strategy_id=self.strategy1.id,
+            )
+            action5 = obj_utils.create_test_action(
+                self.context,
+                action_plan_id=action_plan5.id,
+                id=self._generate_id(),
+                uuid=utils.generate_uuid(),
+            )
 
             self.goal2.soft_delete()
             self.strategy2.soft_delete()
@@ -450,9 +555,14 @@ class TestPurgeCommand(base.DbTestCase):
     @mock.patch.object(dbapi.Connection, "destroy_strategy")
     @mock.patch.object(dbapi.Connection, "destroy_goal")
     def test_purge_command_with_strategy_uuid(
-            self, m_destroy_goal, m_destroy_strategy,
-            m_destroy_audit_template, m_destroy_audit,
-            m_destroy_action_plan, m_destroy_action):
+        self,
+        m_destroy_goal,
+        m_destroy_strategy,
+        m_destroy_audit_template,
+        m_destroy_audit,
+        m_destroy_action_plan,
+        m_destroy_action,
+    ):
         self.cmd.exclude_orphans = False
         self.cmd.uuid = self.strategy1.uuid
 
@@ -473,9 +583,14 @@ class TestPurgeCommand(base.DbTestCase):
     @mock.patch.object(dbapi.Connection, "destroy_strategy")
     @mock.patch.object(dbapi.Connection, "destroy_goal")
     def test_purge_command_with_audit_template_not_expired(
-            self, m_destroy_goal, m_destroy_strategy,
-            m_destroy_audit_template, m_destroy_audit,
-            m_destroy_action_plan, m_destroy_action):
+        self,
+        m_destroy_goal,
+        m_destroy_strategy,
+        m_destroy_audit_template,
+        m_destroy_audit,
+        m_destroy_action_plan,
+        m_destroy_action,
+    ):
         self.cmd.exclude_orphans = True
         self.cmd.uuid = self.audit_template2.uuid
 
@@ -496,9 +611,14 @@ class TestPurgeCommand(base.DbTestCase):
     @mock.patch.object(dbapi.Connection, "destroy_strategy")
     @mock.patch.object(dbapi.Connection, "destroy_goal")
     def test_purge_command_with_audit_template_not_soft_deleted(
-            self, m_destroy_goal, m_destroy_strategy,
-            m_destroy_audit_template, m_destroy_audit,
-            m_destroy_action_plan, m_destroy_action):
+        self,
+        m_destroy_goal,
+        m_destroy_strategy,
+        m_destroy_audit_template,
+        m_destroy_audit,
+        m_destroy_action_plan,
+        m_destroy_action,
+    ):
         self.cmd.exclude_orphans = False
         self.cmd.uuid = self.audit_template3.uuid
 
diff --git a/watcher/tests/unit/db/test_scoring_engine.py b/watcher/tests/unit/db/test_scoring_engine.py
index eb8cc8202..76663a64e 100644
--- a/watcher/tests/unit/db/test_scoring_engine.py
+++ b/watcher/tests/unit/db/test_scoring_engine.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbScoringEngineFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -38,16 +37,28 @@ class TestDbScoringEngineFilters(base.DbTestCase):
     def _data_setup(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.scoring_engine1 = utils.create_test_scoring_engine(
-                id=1, uuid='e8370ede-4f39-11e6-9ffa-08002722cb22',
-                name="se-1", description="Scoring Engine 1", metainfo="a1=b1")
+                id=1,
+                uuid='e8370ede-4f39-11e6-9ffa-08002722cb22',
+                name="se-1",
+                description="Scoring Engine 1",
+                metainfo="a1=b1",
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.scoring_engine2 = utils.create_test_scoring_engine(
-                id=2, uuid='e8370ede-4f39-11e6-9ffa-08002722cb23',
-                name="se-2", description="Scoring Engine 2", metainfo="a2=b2")
+                id=2,
+                uuid='e8370ede-4f39-11e6-9ffa-08002722cb23',
+                name="se-2",
+                description="Scoring Engine 2",
+                metainfo="a2=b2",
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.scoring_engine3 = utils.create_test_scoring_engine(
-                id=3, uuid='e8370ede-4f39-11e6-9ffa-08002722cb24',
-                name="se-3", description="Scoring Engine 3", metainfo="a3=b3")
+                id=3,
+                uuid='e8370ede-4f39-11e6-9ffa-08002722cb24',
+                name="se-3",
+                description="Scoring Engine 3",
+                metainfo="a3=b3",
+            )
 
     def _soft_delete_scoring_engines(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -61,22 +72,26 @@ class TestDbScoringEngineFilters(base.DbTestCase):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_scoring_engine(
                 self.scoring_engine1.id,
-                values={"description": "scoring_engine1"})
+                values={"description": "scoring_engine1"},
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_scoring_engine(
                 self.scoring_engine2.id,
-                values={"description": "scoring_engine2"})
+                values={"description": "scoring_engine2"},
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_scoring_engine(
                 self.scoring_engine3.id,
-                values={"description": "scoring_engine3"})
+                values={"description": "scoring_engine3"},
+            )
 
     def test_get_scoring_engine_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_scoring_engine(self.scoring_engine1.id)
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
@@ -85,17 +100,20 @@ class TestDbScoringEngineFilters(base.DbTestCase):
             self.dbapi.soft_delete_scoring_engine(self.scoring_engine1.id)
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_deleted_at_eq(self):
         self._soft_delete_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
@@ -103,27 +121,32 @@ class TestDbScoringEngineFilters(base.DbTestCase):
         self._soft_delete_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_deleted_at_lte(self):
         self._soft_delete_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_deleted_at_gt(self):
         self._soft_delete_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
@@ -131,49 +154,59 @@ class TestDbScoringEngineFilters(base.DbTestCase):
         self._soft_delete_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.scoring_engine1['id'], self.scoring_engine2['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     # created_at #
 
     def test_get_scoring_engine_list_filter_created_at_eq(self):
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
     def test_get_scoring_engine_list_filter_created_at_lt(self):
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_created_at_lte(self):
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_created_at_gt(self):
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
     def test_get_scoring_engine_list_filter_created_at_gte(self):
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.scoring_engine1['id'], self.scoring_engine2['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     # updated_at #
 
@@ -181,7 +214,8 @@ class TestDbScoringEngineFilters(base.DbTestCase):
         self._update_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
@@ -189,27 +223,32 @@ class TestDbScoringEngineFilters(base.DbTestCase):
         self._update_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_updated_at_lte(self):
         self._update_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.scoring_engine2['id'], self.scoring_engine3['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
     def test_get_scoring_engine_list_filter_updated_at_gt(self):
         self._update_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.scoring_engine1['id']], [r.id for r in res])
 
@@ -217,15 +256,16 @@ class TestDbScoringEngineFilters(base.DbTestCase):
         self._update_scoring_engines()
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.scoring_engine1['id'], self.scoring_engine2['id']},
-            {r.id for r in res})
+            {r.id for r in res},
+        )
 
 
 class DbScoringEngineTestCase(base.DbTestCase):
-
     def test_get_scoring_engine_list(self):
         names = []
         for i in range(1, 4):
@@ -234,7 +274,8 @@ class DbScoringEngineTestCase(base.DbTestCase):
                 uuid=w_utils.generate_uuid(),
                 name=f"SE_ID_{i}",
                 description=f'My ScoringEngine {i}',
-                metainfo=f'a{i}=b{i}')
+                metainfo=f'a{i}=b{i}',
+            )
             names.append(str(scoring_engine['name']))
         scoring_engines = self.dbapi.get_scoring_engine_list(self.context)
         scoring_engines_names = [se.name for se in scoring_engines]
@@ -266,73 +307,95 @@ class DbScoringEngineTestCase(base.DbTestCase):
         self.dbapi.soft_delete_scoring_engine(scoring_engine3['uuid'])
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'description': 'ScoringEngine 1'})
+            self.context, filters={'description': 'ScoringEngine 1'}
+        )
         self.assertEqual([scoring_engine1['name']], [r.name for r in res])
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'description': 'ScoringEngine 3'})
+            self.context, filters={'description': 'ScoringEngine 3'}
+        )
         self.assertEqual([], [r.name for r in res])
 
         res = self.dbapi.get_scoring_engine_list(
-            self.context, filters={'description': 'ScoringEngine 2'})
+            self.context, filters={'description': 'ScoringEngine 2'}
+        )
         self.assertEqual([scoring_engine2['name']], [r.name for r in res])
 
     def test_get_scoring_engine_by_id(self):
         created_scoring_engine = utils.create_test_scoring_engine()
         scoring_engine = self.dbapi.get_scoring_engine_by_id(
-            self.context, created_scoring_engine['id'])
+            self.context, created_scoring_engine['id']
+        )
         self.assertEqual(scoring_engine.id, created_scoring_engine['id'])
 
     def test_get_scoring_engine_by_uuid(self):
         created_scoring_engine = utils.create_test_scoring_engine()
         scoring_engine = self.dbapi.get_scoring_engine_by_uuid(
-            self.context, created_scoring_engine['uuid'])
+            self.context, created_scoring_engine['uuid']
+        )
         self.assertEqual(scoring_engine.uuid, created_scoring_engine['uuid'])
 
     def test_get_scoring_engine_by_name(self):
         created_scoring_engine = utils.create_test_scoring_engine()
         scoring_engine = self.dbapi.get_scoring_engine_by_name(
-            self.context, created_scoring_engine['name'])
+            self.context, created_scoring_engine['name']
+        )
         self.assertEqual(scoring_engine.name, created_scoring_engine['name'])
 
     def test_get_scoring_engine_that_does_not_exist(self):
-        self.assertRaises(exception.ScoringEngineNotFound,
-                          self.dbapi.get_scoring_engine_by_id,
-                          self.context, 404)
+        self.assertRaises(
+            exception.ScoringEngineNotFound,
+            self.dbapi.get_scoring_engine_by_id,
+            self.context,
+            404,
+        )
 
     def test_update_scoring_engine(self):
         scoring_engine = utils.create_test_scoring_engine()
         res = self.dbapi.update_scoring_engine(
-            scoring_engine['id'], {'description': 'updated-model'})
+            scoring_engine['id'], {'description': 'updated-model'}
+        )
         self.assertEqual('updated-model', res.description)
 
     def test_update_scoring_engine_id(self):
         scoring_engine = utils.create_test_scoring_engine()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_scoring_engine,
-                          scoring_engine['id'],
-                          {'uuid': w_utils.generate_uuid()})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_scoring_engine,
+            scoring_engine['id'],
+            {'uuid': w_utils.generate_uuid()},
+        )
 
     def test_update_scoring_engine_that_does_not_exist(self):
-        self.assertRaises(exception.ScoringEngineNotFound,
-                          self.dbapi.update_scoring_engine,
-                          404,
-                          {'description': ''})
+        self.assertRaises(
+            exception.ScoringEngineNotFound,
+            self.dbapi.update_scoring_engine,
+            404,
+            {'description': ''},
+        )
 
     def test_destroy_scoring_engine(self):
         scoring_engine = utils.create_test_scoring_engine()
         self.dbapi.destroy_scoring_engine(scoring_engine['id'])
-        self.assertRaises(exception.ScoringEngineNotFound,
-                          self.dbapi.get_scoring_engine_by_id,
-                          self.context, scoring_engine['id'])
+        self.assertRaises(
+            exception.ScoringEngineNotFound,
+            self.dbapi.get_scoring_engine_by_id,
+            self.context,
+            scoring_engine['id'],
+        )
 
     def test_destroy_scoring_engine_that_does_not_exist(self):
-        self.assertRaises(exception.ScoringEngineNotFound,
-                          self.dbapi.destroy_scoring_engine, 404)
+        self.assertRaises(
+            exception.ScoringEngineNotFound,
+            self.dbapi.destroy_scoring_engine,
+            404,
+        )
 
     def test_create_scoring_engine_already_exists(self):
         scoring_engine_id = "SE_ID"
         utils.create_test_scoring_engine(name=scoring_engine_id)
-        self.assertRaises(exception.ScoringEngineAlreadyExists,
-                          utils.create_test_scoring_engine,
-                          name=scoring_engine_id)
+        self.assertRaises(
+            exception.ScoringEngineAlreadyExists,
+            utils.create_test_scoring_engine,
+            name=scoring_engine_id,
+        )
diff --git a/watcher/tests/unit/db/test_service.py b/watcher/tests/unit/db/test_service.py
index 27ccd5118..ec52ff6ab 100644
--- a/watcher/tests/unit/db/test_service.py
+++ b/watcher/tests/unit/db/test_service.py
@@ -26,7 +26,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbServiceFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -43,16 +42,25 @@ class TestDbServiceFilters(base.DbTestCase):
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.service1 = utils.create_test_service(
-                id=1, name=service1_name, host="controller",
-                last_seen_up=timeutils.parse_isotime("2016-09-22T08:32:05"))
+                id=1,
+                name=service1_name,
+                host="controller",
+                last_seen_up=timeutils.parse_isotime("2016-09-22T08:32:05"),
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.service2 = utils.create_test_service(
-                id=2, name=service2_name, host="controller",
-                last_seen_up=timeutils.parse_isotime("2016-09-22T08:32:05"))
+                id=2,
+                name=service2_name,
+                host="controller",
+                last_seen_up=timeutils.parse_isotime("2016-09-22T08:32:05"),
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.service3 = utils.create_test_service(
-                id=3, name=service3_name, host="controller",
-                last_seen_up=timeutils.parse_isotime("2016-09-22T08:32:05"))
+                id=3,
+                name=service3_name,
+                host="controller",
+                last_seen_up=timeutils.parse_isotime("2016-09-22T08:32:05"),
+            )
 
     def _soft_delete_services(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -65,20 +73,24 @@ class TestDbServiceFilters(base.DbTestCase):
     def _update_services(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_service(
-                self.service1.id, values={"host": "controller1"})
+                self.service1.id, values={"host": "controller1"}
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_service(
-                self.service2.id, values={"host": "controller2"})
+                self.service2.id, values={"host": "controller2"}
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_service(
-                self.service3.id, values={"host": "controller3"})
+                self.service3.id, values={"host": "controller3"}
+            )
 
     def test_get_service_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_service(self.service1.id)
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.service1['name']], [r.name for r in res])
 
@@ -87,17 +99,20 @@ class TestDbServiceFilters(base.DbTestCase):
             self.dbapi.soft_delete_service(self.service1.id)
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
             {self.service2['name'], self.service3['name']},
-            {r.name for r in res})
+            {r.name for r in res},
+        )
 
     def test_get_service_list_filter_deleted_at_eq(self):
         self._soft_delete_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.service1['id']], [r.id for r in res])
 
@@ -105,27 +120,30 @@ class TestDbServiceFilters(base.DbTestCase):
         self._soft_delete_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            {self.service2['id'], self.service3['id']},
-            {r.id for r in res})
+            {self.service2['id'], self.service3['id']}, {r.id for r in res}
+        )
 
     def test_get_service_list_filter_deleted_at_lte(self):
         self._soft_delete_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.service2['id'], self.service3['id']},
-            {r.id for r in res})
+            {self.service2['id'], self.service3['id']}, {r.id for r in res}
+        )
 
     def test_get_service_list_filter_deleted_at_gt(self):
         self._soft_delete_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.service1['id']], [r.id for r in res])
 
@@ -133,49 +151,55 @@ class TestDbServiceFilters(base.DbTestCase):
         self._soft_delete_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.service1['id'], self.service2['id']},
-            {r.id for r in res})
+            {self.service1['id'], self.service2['id']}, {r.id for r in res}
+        )
 
     # created_at #
 
     def test_get_service_list_filter_created_at_eq(self):
         res = self.dbapi.get_service_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.service1['id']], [r.id for r in res])
 
     def test_get_service_list_filter_created_at_lt(self):
         res = self.dbapi.get_service_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            {self.service2['id'], self.service3['id']},
-            {r.id for r in res})
+            {self.service2['id'], self.service3['id']}, {r.id for r in res}
+        )
 
     def test_get_service_list_filter_created_at_lte(self):
         res = self.dbapi.get_service_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.service2['id'], self.service3['id']},
-            {r.id for r in res})
+            {self.service2['id'], self.service3['id']}, {r.id for r in res}
+        )
 
     def test_get_service_list_filter_created_at_gt(self):
         res = self.dbapi.get_service_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.service1['id']], [r.id for r in res])
 
     def test_get_service_list_filter_created_at_gte(self):
         res = self.dbapi.get_service_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.service1['id'], self.service2['id']},
-            {r.id for r in res})
+            {self.service1['id'], self.service2['id']}, {r.id for r in res}
+        )
 
     # updated_at #
 
@@ -183,7 +207,8 @@ class TestDbServiceFilters(base.DbTestCase):
         self._update_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.service1['id']], [r.id for r in res])
 
@@ -191,27 +216,30 @@ class TestDbServiceFilters(base.DbTestCase):
         self._update_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
-            {self.service2['id'], self.service3['id']},
-            {r.id for r in res})
+            {self.service2['id'], self.service3['id']}, {r.id for r in res}
+        )
 
     def test_get_service_list_filter_updated_at_lte(self):
         self._update_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.service2['id'], self.service3['id']},
-            {r.id for r in res})
+            {self.service2['id'], self.service3['id']}, {r.id for r in res}
+        )
 
     def test_get_service_list_filter_updated_at_gt(self):
         self._update_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.service1['id']], [r.id for r in res])
 
@@ -219,22 +247,21 @@ class TestDbServiceFilters(base.DbTestCase):
         self._update_services()
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
-            {self.service1['id'], self.service2['id']},
-            {r.id for r in res})
+            {self.service1['id'], self.service2['id']}, {r.id for r in res}
+        )
 
 
 class DbServiceTestCase(base.DbTestCase):
-
     def test_get_service_list(self):
         ids = []
         for i in range(1, 4):
             service = utils.create_test_service(
-                id=i,
-                name=f"SERVICE_ID_{i}",
-                host=f"controller_{i}")
+                id=i, name=f"SERVICE_ID_{i}", host=f"controller_{i}"
+            )
             ids.append(service['id'])
         services = self.dbapi.get_service_list(self.context)
         service_ids = [s.id for s in services]
@@ -242,61 +269,67 @@ class DbServiceTestCase(base.DbTestCase):
 
     def test_get_service_list_with_filters(self):
         service1 = utils.create_test_service(
-            id=1,
-            name="SERVICE_ID_1",
-            host="controller_1",
+            id=1, name="SERVICE_ID_1", host="controller_1"
         )
         service2 = utils.create_test_service(
-            id=2,
-            name="SERVICE_ID_2",
-            host="controller_2",
+            id=2, name="SERVICE_ID_2", host="controller_2"
         )
         service3 = utils.create_test_service(
-            id=3,
-            name="SERVICE_ID_3",
-            host="controller_3",
+            id=3, name="SERVICE_ID_3", host="controller_3"
         )
 
         self.dbapi.soft_delete_service(service3['id'])
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'host': 'controller_1'})
+            self.context, filters={'host': 'controller_1'}
+        )
         self.assertEqual([service1['id']], [r.id for r in res])
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'host': 'controller_3'})
+            self.context, filters={'host': 'controller_3'}
+        )
         self.assertEqual([], [r.id for r in res])
 
         res = self.dbapi.get_service_list(
-            self.context, filters={'host': 'controller_2'})
+            self.context, filters={'host': 'controller_2'}
+        )
         self.assertEqual([service2['id']], [r.id for r in res])
 
     def test_get_service_by_name(self):
         created_service = utils.create_test_service()
         service = self.dbapi.get_service_by_name(
-            self.context, created_service['name'])
+            self.context, created_service['name']
+        )
         self.assertEqual(service.name, created_service['name'])
 
     def test_get_service_that_does_not_exist(self):
-        self.assertRaises(exception.ServiceNotFound,
-                          self.dbapi.get_service_by_id,
-                          self.context, 404)
+        self.assertRaises(
+            exception.ServiceNotFound,
+            self.dbapi.get_service_by_id,
+            self.context,
+            404,
+        )
 
     def test_update_service(self):
         service = utils.create_test_service()
         res = self.dbapi.update_service(
-            service['id'], {'host': 'controller_test'})
+            service['id'], {'host': 'controller_test'}
+        )
         self.assertEqual('controller_test', res.host)
 
     def test_update_service_that_does_not_exist(self):
-        self.assertRaises(exception.ServiceNotFound,
-                          self.dbapi.update_service,
-                          405,
-                          {'name': ''})
+        self.assertRaises(
+            exception.ServiceNotFound,
+            self.dbapi.update_service,
+            405,
+            {'name': ''},
+        )
 
     def test_create_service_already_exists(self):
         service_id = "STRATEGY_ID"
         utils.create_test_service(name=service_id)
-        self.assertRaises(exception.ServiceAlreadyExists,
-                          utils.create_test_service,
-                          name=service_id)
+        self.assertRaises(
+            exception.ServiceAlreadyExists,
+            utils.create_test_service,
+            name=service_id,
+        )
diff --git a/watcher/tests/unit/db/test_strategy.py b/watcher/tests/unit/db/test_strategy.py
index 1f10e8f84..333037d8c 100644
--- a/watcher/tests/unit/db/test_strategy.py
+++ b/watcher/tests/unit/db/test_strategy.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDbStrategyFilters(base.DbTestCase):
-
     FAKE_OLDER_DATE = '2014-01-01T09:52:05.219414'
     FAKE_OLD_DATE = '2015-01-01T09:52:05.219414'
     FAKE_TODAY = '2016-02-24T09:52:05.219414'
@@ -41,27 +40,42 @@ class TestDbStrategyFilters(base.DbTestCase):
         strategy3_name = "STRATEGY_ID_3"
 
         self.goal1 = utils.create_test_goal(
-            id=1, uuid=w_utils.generate_uuid(),
-            name="GOAL_ID", display_name="Goal")
+            id=1,
+            uuid=w_utils.generate_uuid(),
+            name="GOAL_ID",
+            display_name="Goal",
+        )
         self.goal2 = utils.create_test_goal(
-            id=2, uuid=w_utils.generate_uuid(),
-            name="DUMMY", display_name="Dummy")
+            id=2,
+            uuid=w_utils.generate_uuid(),
+            name="DUMMY",
+            display_name="Dummy",
+        )
 
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.strategy1 = utils.create_test_strategy(
-                id=1, uuid=w_utils.generate_uuid(),
-                name=strategy1_name, display_name="Strategy 1",
-                goal_id=self.goal1.id)
+                id=1,
+                uuid=w_utils.generate_uuid(),
+                name=strategy1_name,
+                display_name="Strategy 1",
+                goal_id=self.goal1.id,
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.strategy2 = utils.create_test_strategy(
-                id=2, uuid=w_utils.generate_uuid(),
-                name=strategy2_name, display_name="Strategy 2",
-                goal_id=self.goal1.id)
+                id=2,
+                uuid=w_utils.generate_uuid(),
+                name=strategy2_name,
+                display_name="Strategy 2",
+                goal_id=self.goal1.id,
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.strategy3 = utils.create_test_strategy(
-                id=3, uuid=w_utils.generate_uuid(),
-                name=strategy3_name, display_name="Strategy 3",
-                goal_id=self.goal2.id)
+                id=3,
+                uuid=w_utils.generate_uuid(),
+                name=strategy3_name,
+                display_name="Strategy 3",
+                goal_id=self.goal2.id,
+            )
 
     def _soft_delete_strategys(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
@@ -74,20 +88,24 @@ class TestDbStrategyFilters(base.DbTestCase):
     def _update_strategies(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.update_strategy(
-                self.strategy1.id, values={"display_name": "strategy1"})
+                self.strategy1.id, values={"display_name": "strategy1"}
+            )
         with freezegun.freeze_time(self.FAKE_OLD_DATE):
             self.dbapi.update_strategy(
-                self.strategy2.id, values={"display_name": "strategy2"})
+                self.strategy2.id, values={"display_name": "strategy2"}
+            )
         with freezegun.freeze_time(self.FAKE_OLDER_DATE):
             self.dbapi.update_strategy(
-                self.strategy3.id, values={"display_name": "strategy3"})
+                self.strategy3.id, values={"display_name": "strategy3"}
+            )
 
     def test_get_strategy_list_filter_deleted_true(self):
         with freezegun.freeze_time(self.FAKE_TODAY):
             self.dbapi.soft_delete_strategy(self.strategy1.id)
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted': True})
+            self.context, filters={'deleted': True}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
@@ -96,17 +114,20 @@ class TestDbStrategyFilters(base.DbTestCase):
             self.dbapi.soft_delete_strategy(self.strategy1.id)
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted': False})
+            self.context, filters={'deleted': False}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_deleted_at_eq(self):
         self._soft_delete_strategys()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted_at__eq': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
@@ -114,27 +135,32 @@ class TestDbStrategyFilters(base.DbTestCase):
         self._soft_delete_strategys()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted_at__lt': self.FAKE_TODAY})
+            self.context, filters={'deleted_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_deleted_at_lte(self):
         self._soft_delete_strategys()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_deleted_at_gt(self):
         self._soft_delete_strategys()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
@@ -142,49 +168,59 @@ class TestDbStrategyFilters(base.DbTestCase):
         self._soft_delete_strategys()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'deleted_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.strategy1['uuid'], self.strategy2['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     # created_at #
 
     def test_get_strategy_list_filter_created_at_eq(self):
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'created_at__eq': self.FAKE_TODAY})
+            self.context, filters={'created_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
     def test_get_strategy_list_filter_created_at_lt(self):
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'created_at__lt': self.FAKE_TODAY})
+            self.context, filters={'created_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_created_at_lte(self):
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_created_at_gt(self):
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
     def test_get_strategy_list_filter_created_at_gte(self):
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'created_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.strategy1['uuid'], self.strategy2['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     # updated_at #
 
@@ -192,7 +228,8 @@ class TestDbStrategyFilters(base.DbTestCase):
         self._update_strategies()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'updated_at__eq': self.FAKE_TODAY})
+            self.context, filters={'updated_at__eq': self.FAKE_TODAY}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
@@ -200,27 +237,32 @@ class TestDbStrategyFilters(base.DbTestCase):
         self._update_strategies()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'updated_at__lt': self.FAKE_TODAY})
+            self.context, filters={'updated_at__lt': self.FAKE_TODAY}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_updated_at_lte(self):
         self._update_strategies()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__lte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.strategy2['uuid'], self.strategy3['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
     def test_get_strategy_list_filter_updated_at_gt(self):
         self._update_strategies()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gt': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual([self.strategy1['uuid']], [r.uuid for r in res])
 
@@ -228,15 +270,16 @@ class TestDbStrategyFilters(base.DbTestCase):
         self._update_strategies()
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE})
+            self.context, filters={'updated_at__gte': self.FAKE_OLD_DATE}
+        )
 
         self.assertEqual(
             {self.strategy1['uuid'], self.strategy2['uuid']},
-            {r.uuid for r in res})
+            {r.uuid for r in res},
+        )
 
 
 class DbStrategyTestCase(base.DbTestCase):
-
     def test_get_strategy_list(self):
         uuids = []
         for i in range(1, 4):
@@ -244,7 +287,8 @@ class DbStrategyTestCase(base.DbTestCase):
                 id=i,
                 uuid=w_utils.generate_uuid(),
                 name=f"STRATEGY_ID_{i}",
-                display_name=f'My Strategy {i}')
+                display_name=f'My Strategy {i}',
+            )
             uuids.append(str(strategy['uuid']))
         strategies = self.dbapi.get_strategy_list(self.context)
         strategy_uuids = [s.uuid for s in strategies]
@@ -262,7 +306,8 @@ class DbStrategyTestCase(base.DbTestCase):
                 uuid=w_utils.generate_uuid(),
                 name=f"STRATEGY_ID_{i}",
                 display_name=f'My Strategy {i}',
-                goal_id=goal.id)
+                goal_id=goal.id,
+            )
             uuids.append(str(strategy['uuid']))
         strategys = self.dbapi.get_strategy_list(self.context, eager=True)
         strategy_map = {a.uuid: a for a in strategys}
@@ -296,71 +341,93 @@ class DbStrategyTestCase(base.DbTestCase):
         self.dbapi.soft_delete_strategy(strategy3['uuid'])
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'display_name': 'Strategy 1'})
+            self.context, filters={'display_name': 'Strategy 1'}
+        )
         self.assertEqual([strategy1['uuid']], [r.uuid for r in res])
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'display_name': 'Strategy 3'})
+            self.context, filters={'display_name': 'Strategy 3'}
+        )
         self.assertEqual([], [r.uuid for r in res])
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'goal_id': 1})
-        self.assertEqual([strategy1['uuid'], strategy2['uuid']],
-                         [r.uuid for r in res])
+            self.context, filters={'goal_id': 1}
+        )
+        self.assertEqual(
+            [strategy1['uuid'], strategy2['uuid']], [r.uuid for r in res]
+        )
 
         res = self.dbapi.get_strategy_list(
-            self.context, filters={'display_name': 'Strategy 2'})
+            self.context, filters={'display_name': 'Strategy 2'}
+        )
         self.assertEqual([strategy2['uuid']], [r.uuid for r in res])
 
     def test_get_strategy_by_uuid(self):
         created_strategy = utils.create_test_strategy()
         strategy = self.dbapi.get_strategy_by_uuid(
-            self.context, created_strategy['uuid'])
+            self.context, created_strategy['uuid']
+        )
         self.assertEqual(strategy.uuid, created_strategy['uuid'])
 
     def test_get_strategy_by_name(self):
         created_strategy = utils.create_test_strategy()
         strategy = self.dbapi.get_strategy_by_name(
-            self.context, created_strategy['name'])
+            self.context, created_strategy['name']
+        )
         self.assertEqual(strategy.name, created_strategy['name'])
 
     def test_get_strategy_that_does_not_exist(self):
-        self.assertRaises(exception.StrategyNotFound,
-                          self.dbapi.get_strategy_by_id,
-                          self.context, 404)
+        self.assertRaises(
+            exception.StrategyNotFound,
+            self.dbapi.get_strategy_by_id,
+            self.context,
+            404,
+        )
 
     def test_update_strategy(self):
         strategy = utils.create_test_strategy()
         res = self.dbapi.update_strategy(
-            strategy['uuid'], {'display_name': 'updated-model'})
+            strategy['uuid'], {'display_name': 'updated-model'}
+        )
         self.assertEqual('updated-model', res.display_name)
 
     def test_update_goal_id(self):
         strategy = utils.create_test_strategy()
-        self.assertRaises(exception.Invalid,
-                          self.dbapi.update_strategy, strategy['uuid'],
-                          {'uuid': 'new_strategy_id'})
+        self.assertRaises(
+            exception.Invalid,
+            self.dbapi.update_strategy,
+            strategy['uuid'],
+            {'uuid': 'new_strategy_id'},
+        )
 
     def test_update_strategy_that_does_not_exist(self):
-        self.assertRaises(exception.StrategyNotFound,
-                          self.dbapi.update_strategy,
-                          404,
-                          {'display_name': ''})
+        self.assertRaises(
+            exception.StrategyNotFound,
+            self.dbapi.update_strategy,
+            404,
+            {'display_name': ''},
+        )
 
     def test_destroy_strategy(self):
         strategy = utils.create_test_strategy()
         self.dbapi.destroy_strategy(strategy['uuid'])
-        self.assertRaises(exception.StrategyNotFound,
-                          self.dbapi.get_strategy_by_id,
-                          self.context, strategy['uuid'])
+        self.assertRaises(
+            exception.StrategyNotFound,
+            self.dbapi.get_strategy_by_id,
+            self.context,
+            strategy['uuid'],
+        )
 
     def test_destroy_strategy_that_does_not_exist(self):
-        self.assertRaises(exception.StrategyNotFound,
-                          self.dbapi.destroy_strategy, 404)
+        self.assertRaises(
+            exception.StrategyNotFound, self.dbapi.destroy_strategy, 404
+        )
 
     def test_create_strategy_already_exists(self):
         strategy_id = "STRATEGY_ID"
         utils.create_test_strategy(name=strategy_id)
-        self.assertRaises(exception.StrategyAlreadyExists,
-                          utils.create_test_strategy,
-                          name=strategy_id)
+        self.assertRaises(
+            exception.StrategyAlreadyExists,
+            utils.create_test_strategy,
+            name=strategy_id,
+        )
diff --git a/watcher/tests/unit/db/utils.py b/watcher/tests/unit/db/utils.py
index 685fb1670..d355272ec 100644
--- a/watcher/tests/unit/db/utils.py
+++ b/watcher/tests/unit/db/utils.py
@@ -58,7 +58,8 @@ def get_test_audit_template(**kwargs):
     # ObjectField doesn't allow None nor dict, so if we want to simulate a
     # non-eager object loading, the field should not be referenced at all.
     audit_template_data.update(
-        _load_relationships(models.AuditTemplate, kwargs))
+        _load_relationships(models.AuditTemplate, kwargs)
+    )
 
     return audit_template_data
 
@@ -130,12 +131,14 @@ def get_test_action(**kwargs):
         'uuid': kwargs.get('uuid', '10a47dd1-4874-4298-91cf-eff046dbdb8d'),
         'action_plan_id': kwargs.get('action_plan_id', 1),
         'action_type': kwargs.get('action_type', 'nop'),
-        'input_parameters':
-            kwargs.get('input_parameters',
-                       {'key1': 'val1',
-                        'key2': 'val2',
-                        'resource_id':
-                        '10a47dd1-4874-4298-91cf-eff046dbdb8d'}),
+        'input_parameters': kwargs.get(
+            'input_parameters',
+            {
+                'key1': 'val1',
+                'key2': 'val2',
+                'resource_id': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
+            },
+        ),
         'state': kwargs.get('state', objects.action_plan.State.PENDING),
         'parents': kwargs.get('parents', []),
         'created_at': kwargs.get('created_at'),
@@ -280,7 +283,9 @@ def get_test_service(**kwargs):
         'host': kwargs.get('host', 'controller'),
         'last_seen_up': kwargs.get(
             'last_seen_up',
-            timeutils.parse_isotime('2016-09-22T08:32:06').replace(tzinfo=None)
+            timeutils.parse_isotime('2016-09-22T08:32:06').replace(
+                tzinfo=None
+            ),
         ),
         'created_at': kwargs.get('created_at'),
         'updated_at': kwargs.get('updated_at'),
diff --git a/watcher/tests/unit/decision_engine/audit/test_audit_handlers.py b/watcher/tests/unit/decision_engine/audit/test_audit_handlers.py
index 991aaae49..2eaf7a855 100644
--- a/watcher/tests/unit/decision_engine/audit/test_audit_handlers.py
+++ b/watcher/tests/unit/decision_engine/audit/test_audit_handlers.py
@@ -41,54 +41,74 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestOneShotAuditHandler(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_audit_notifications = mock.patch.object(
-            notifications, 'audit', autospec=True)
+            notifications, 'audit', autospec=True
+        )
         self.m_audit_notifications = p_audit_notifications.start()
         self.addCleanup(p_audit_notifications.stop)
 
         self.goal = obj_utils.create_test_goal(
-            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name())
+            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name()
+        )
         self.strategy = obj_utils.create_test_strategy(
-            self.context, name=dummy_strategy.DummyStrategy.get_name(),
-            goal_id=self.goal.id)
+            self.context,
+            name=dummy_strategy.DummyStrategy.get_name(),
+            goal_id=self.goal.id,
+        )
         audit_template = obj_utils.create_test_audit_template(
-            self.context, strategy_id=self.strategy.id)
+            self.context, strategy_id=self.strategy.id
+        )
         self.audit = obj_utils.create_test_audit(
             self.context,
             uuid=uuidutils.generate_uuid(),
             goal_id=self.goal.id,
             strategy_id=self.strategy.id,
             audit_template_id=audit_template.id,
-            goal=self.goal)
+            goal=self.goal,
+        )
 
     @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector")
-    @mock.patch.object(base_strategy.BaseStrategy, "compute_model",
-                       mock.Mock(stale=False))
+    @mock.patch.object(
+        base_strategy.BaseStrategy, "compute_model", mock.Mock(stale=False)
+    )
     def test_trigger_audit_without_errors(self, m_collector):
         m_collector.return_value = faker.FakerModelCollector()
         audit_handler = oneshot.OneShotAuditHandler()
         audit_handler.execute(self.audit, self.context)
 
         expected_calls = [
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.END),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.END)]
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+        ]
 
         self.assertEqual(
             expected_calls,
-            self.m_audit_notifications.send_action_notification.call_args_list)
+            self.m_audit_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(base_strategy.BaseStrategy, "do_execute")
     @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector")
@@ -99,21 +119,30 @@ class TestOneShotAuditHandler(base.DbTestCase):
         audit_handler.execute(self.audit, self.context)
 
         expected_calls = [
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      priority=objects.fields.NotificationPriority.ERROR,
-                      phase=objects.fields.NotificationPhase.ERROR)]
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                priority=objects.fields.NotificationPriority.ERROR,
+                phase=objects.fields.NotificationPhase.ERROR,
+            ),
+        ]
 
         self.assertEqual(
             expected_calls,
-            self.m_audit_notifications.send_action_notification.call_args_list)
+            self.m_audit_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector")
-    @mock.patch.object(base_strategy.BaseStrategy, "compute_model",
-                       mock.Mock(stale=False))
+    @mock.patch.object(
+        base_strategy.BaseStrategy, "compute_model", mock.Mock(stale=False)
+    )
     def test_trigger_audit_state_succeeded(self, m_collector):
         m_collector.return_value = faker.FakerModelCollector()
         audit_handler = oneshot.OneShotAuditHandler()
@@ -122,66 +151,103 @@ class TestOneShotAuditHandler(base.DbTestCase):
         self.assertEqual(objects.audit.State.SUCCEEDED, audit.state)
 
         expected_calls = [
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.END),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.END)]
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+        ]
 
         self.assertEqual(
             expected_calls,
-            self.m_audit_notifications.send_action_notification.call_args_list)
+            self.m_audit_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector")
-    @mock.patch.object(base_strategy.BaseStrategy, "compute_model",
-                       mock.Mock(stale=False))
+    @mock.patch.object(
+        base_strategy.BaseStrategy, "compute_model", mock.Mock(stale=False)
+    )
     def test_trigger_audit_send_notification(self, m_collector):
         m_collector.return_value = faker.FakerModelCollector()
         audit_handler = oneshot.OneShotAuditHandler()
         audit_handler.execute(self.audit, self.context)
 
         expected_calls = [
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.END),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audit,
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.END)]
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audit,
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+        ]
 
         self.assertEqual(
             expected_calls,
-            self.m_audit_notifications.send_action_notification.call_args_list)
+            self.m_audit_notifications.send_action_notification.call_args_list,
+        )
 
-    @mock.patch.object(oneshot.OneShotAuditHandler, "update_audit_state",
-                       autospec=True)
+    @mock.patch.object(
+        oneshot.OneShotAuditHandler, "update_audit_state", autospec=True
+    )
     def test_pre_execute_audit_cancelled(self, m_update_audit_state):
         audit_handler = oneshot.OneShotAuditHandler()
         self.audit.state = objects.audit.State.CANCELLED
         self.audit.save()
-        self.assertRaises(exception.AuditCancelled,
-                          audit_handler.pre_execute, self.audit, self.context)
+        self.assertRaises(
+            exception.AuditCancelled,
+            audit_handler.pre_execute,
+            self.audit,
+            self.context,
+        )
 
         m_update_audit_state.assert_not_called()
 
-    @mock.patch.object(oneshot.OneShotAuditHandler, "do_execute",
-                       autospec=True)
-    @mock.patch.object(oneshot.OneShotAuditHandler, "post_execute",
-                       autospec=True)
-    def test_cancelled_audit_is_not_executed(self, m_post_execute,
-                                             m_do_execute):
+    @mock.patch.object(
+        oneshot.OneShotAuditHandler, "do_execute", autospec=True
+    )
+    @mock.patch.object(
+        oneshot.OneShotAuditHandler, "post_execute", autospec=True
+    )
+    def test_cancelled_audit_is_not_executed(
+        self, m_post_execute, m_do_execute
+    ):
         self.audit.state = objects.audit.State.CANCELLED
         self.audit.save()
         audit_handler = oneshot.OneShotAuditHandler()
@@ -192,16 +258,17 @@ class TestOneShotAuditHandler(base.DbTestCase):
 
 
 class TestAutoTriggerActionPlan(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.goal = obj_utils.create_test_goal(
-            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name())
+            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name()
+        )
         self.strategy = obj_utils.create_test_strategy(
-            self.context, name=dummy_strategy.DummyStrategy.get_name(),
-            goal_id=self.goal.id)
-        audit_template = obj_utils.create_test_audit_template(
-            self.context)
+            self.context,
+            name=dummy_strategy.DummyStrategy.get_name(),
+            goal_id=self.goal.id,
+        )
+        audit_template = obj_utils.create_test_audit_template(self.context)
         self.audit = obj_utils.create_test_audit(
             self.context,
             id=0,
@@ -210,7 +277,8 @@ class TestAutoTriggerActionPlan(base.DbTestCase):
             goal_id=self.goal.id,
             audit_type=objects.audit.AuditType.CONTINUOUS.value,
             goal=self.goal,
-            auto_trigger=True)
+            auto_trigger=True,
+        )
         self.ongoing_action_plan = obj_utils.create_test_action_plan(
             self.context,
             uuid=uuidutils.generate_uuid(),
@@ -231,8 +299,9 @@ class TestAutoTriggerActionPlan(base.DbTestCase):
 
     @mock.patch.object(oneshot.OneShotAuditHandler, 'do_execute')
     @mock.patch.object(objects.action_plan.ActionPlan, 'list')
-    def test_trigger_audit_with_actionplan_ongoing(self, mock_list,
-                                                   mock_do_execute):
+    def test_trigger_audit_with_actionplan_ongoing(
+        self, mock_list, mock_do_execute
+    ):
         mock_list.return_value = [self.ongoing_action_plan]
         audit_handler = oneshot.OneShotAuditHandler()
         audit_handler.execute(self.audit, self.context)
@@ -241,18 +310,22 @@ class TestAutoTriggerActionPlan(base.DbTestCase):
     @mock.patch.object(rpcapi.ApplierAPI, 'launch_action_plan')
     @mock.patch.object(objects.action_plan.ActionPlan, 'list')
     @mock.patch.object(objects.audit.Audit, 'get_by_id')
-    def test_trigger_action_plan_without_ongoing(self, mock_get_by_id,
-                                                 mock_list, mock_applier):
+    def test_trigger_action_plan_without_ongoing(
+        self, mock_get_by_id, mock_list, mock_applier
+    ):
         mock_get_by_id.return_value = self.audit
         mock_list.return_value = []
         auto_trigger_handler = oneshot.OneShotAuditHandler()
-        with mock.patch.object(auto_trigger_handler,
-                               'do_schedule') as m_schedule:
+        with mock.patch.object(
+            auto_trigger_handler, 'do_schedule'
+        ) as m_schedule:
             m_schedule().uuid = self.recommended_action_plan.uuid
-            auto_trigger_handler.post_execute(self.audit, mock.MagicMock(),
-                                              self.context)
-        mock_applier.assert_called_once_with(self.context,
-                                             self.recommended_action_plan.uuid)
+            auto_trigger_handler.post_execute(
+                self.audit, mock.MagicMock(), self.context
+            )
+        mock_applier.assert_called_once_with(
+            self.context, self.recommended_action_plan.uuid
+        )
 
     @mock.patch.object(oneshot.OneShotAuditHandler, 'do_execute')
     def test_trigger_audit_with_force(self, mock_do_execute):
@@ -263,18 +336,18 @@ class TestAutoTriggerActionPlan(base.DbTestCase):
 
 
 class TestContinuousAuditHandler(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_audit_notifications = mock.patch.object(
-            notifications, 'audit', autospec=True)
+            notifications, 'audit', autospec=True
+        )
         self.m_audit_notifications = p_audit_notifications.start()
         self.addCleanup(p_audit_notifications.stop)
 
         self.goal = obj_utils.create_test_goal(
-            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name())
-        audit_template = obj_utils.create_test_audit_template(
-            self.context)
+            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name()
+        )
+        audit_template = obj_utils.create_test_audit_template(self.context)
         self.audits = [
             obj_utils.create_test_audit(
                 self.context,
@@ -285,8 +358,10 @@ class TestContinuousAuditHandler(base.DbTestCase):
                 goal_id=self.goal.id,
                 audit_type=objects.audit.AuditType.CONTINUOUS.value,
                 goal=self.goal,
-                hostname='hostname1')
-            for id_ in range(2, 4)]
+                hostname='hostname1',
+            )
+            for id_ in range(2, 4)
+        ]
         cfg.CONF.set_override("host", "hostname1")
 
     @mock.patch.object(objects.service.Service, 'list')
@@ -295,11 +370,13 @@ class TestContinuousAuditHandler(base.DbTestCase):
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     @mock.patch.object(objects.audit.Audit, 'list')
     def test_launch_audits_periodically_with_interval(
-            self, mock_list, mock_jobs, m_add_job, m_engine, m_service):
+        self, mock_list, mock_jobs, m_add_job, m_engine, m_service
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
         mock_list.return_value = self.audits
-        self.audits[0].next_run_time = (datetime.datetime.now() -
-                                        datetime.timedelta(seconds=1800))
+        self.audits[0].next_run_time = (
+            datetime.datetime.now() - datetime.timedelta(seconds=1800)
+        )
         mock_jobs.return_value = mock.MagicMock()
         m_engine.return_value = mock.MagicMock()
         m_add_job.return_value = mock.MagicMock()
@@ -318,7 +395,8 @@ class TestContinuousAuditHandler(base.DbTestCase):
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     @mock.patch.object(objects.audit.Audit, 'list')
     def test_launch_audits_periodically_with_cron(
-            self, mock_list, mock_jobs, m_add_job, m_engine, m_service):
+        self, mock_list, mock_jobs, m_add_job, m_engine, m_service
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
         mock_list.return_value = self.audits
         self.audits[0].interval = "*/5 * * * *"
@@ -341,8 +419,8 @@ class TestContinuousAuditHandler(base.DbTestCase):
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     @mock.patch.object(objects.audit.Audit, 'list')
     def test_launch_audits_periodically_with_invalid_cron(
-            self, mock_list, mock_jobs, m_add_job, m_engine, m_service,
-            mock_cron):
+        self, mock_list, mock_jobs, m_add_job, m_engine, m_service, mock_cron
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
         mock_list.return_value = self.audits
         self.audits[0].interval = "*/5* * * *"
@@ -351,27 +429,35 @@ class TestContinuousAuditHandler(base.DbTestCase):
         m_engine.return_value = mock.MagicMock()
         m_add_job.return_value = mock.MagicMock()
 
-        self.assertRaises(exception.CronFormatIsInvalid,
-                          audit_handler.launch_audits_periodically)
+        self.assertRaises(
+            exception.CronFormatIsInvalid,
+            audit_handler.launch_audits_periodically,
+        )
 
     @mock.patch.object(objects.service.Service, 'list')
     @mock.patch.object(sq_api.enginefacade.writer, 'get_engine')
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'add_job')
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     @mock.patch.object(objects.audit.Audit, 'list')
-    def test_launch_multiply_audits_periodically(self, mock_list,
-                                                 mock_jobs, m_add_job,
-                                                 m_engine, m_service):
+    def test_launch_multiply_audits_periodically(
+        self, mock_list, mock_jobs, m_add_job, m_engine, m_service
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
         mock_list.return_value = self.audits
         mock_jobs.return_value = mock.MagicMock()
         m_engine.return_value = mock.MagicMock()
         m_service.return_value = mock.MagicMock()
-        calls = [mock.call(audit_handler.execute_audit, 'interval',
-                           args=[mock.ANY, mock.ANY],
-                           seconds=3600,
-                           name='execute_audit',
-                           next_run_time=mock.ANY) for _ in self.audits]
+        calls = [
+            mock.call(
+                audit_handler.execute_audit,
+                'interval',
+                args=[mock.ANY, mock.ANY],
+                seconds=3600,
+                name='execute_audit',
+                next_run_time=mock.ANY,
+            )
+            for _ in self.audits
+        ]
         audit_handler.launch_audits_periodically()
         m_add_job.assert_has_calls(calls)
 
@@ -380,31 +466,40 @@ class TestContinuousAuditHandler(base.DbTestCase):
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'add_job')
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     @mock.patch.object(objects.audit.Audit, 'list')
-    def test_period_audit_not_called_when_deleted(self, mock_list,
-                                                  mock_jobs, m_add_job,
-                                                  m_engine, m_service):
+    def test_period_audit_not_called_when_deleted(
+        self, mock_list, mock_jobs, m_add_job, m_engine, m_service
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
         mock_list.return_value = self.audits
         mock_jobs.return_value = mock.MagicMock()
         m_service.return_value = mock.MagicMock()
         m_engine.return_value = mock.MagicMock()
 
-        ap_jobs = [job.Job(mock.MagicMock(), name='execute_audit',
-                           func=audit_handler.execute_audit,
-                           args=(self.audits[0], mock.MagicMock()),
-                           kwargs={}),
-                   job.Job(mock.MagicMock(), name='execute_audit',
-                           func=audit_handler.execute_audit,
-                           args=(self.audits[1], mock.MagicMock()),
-                           kwargs={})
-                   ]
+        ap_jobs = [
+            job.Job(
+                mock.MagicMock(),
+                name='execute_audit',
+                func=audit_handler.execute_audit,
+                args=(self.audits[0], mock.MagicMock()),
+                kwargs={},
+            ),
+            job.Job(
+                mock.MagicMock(),
+                name='execute_audit',
+                func=audit_handler.execute_audit,
+                args=(self.audits[1], mock.MagicMock()),
+                kwargs={},
+            ),
+        ]
         mock_jobs.return_value = ap_jobs
         audit_handler.launch_audits_periodically()
 
-        audit_handler.update_audit_state(self.audits[1],
-                                         objects.audit.State.CANCELLED)
-        audit_handler.update_audit_state(self.audits[0],
-                                         objects.audit.State.SUSPENDED)
+        audit_handler.update_audit_state(
+            self.audits[1], objects.audit.State.CANCELLED
+        )
+        audit_handler.update_audit_state(
+            self.audits[0], objects.audit.State.SUSPENDED
+        )
         is_inactive = audit_handler._is_audit_inactive(self.audits[1])
         self.assertTrue(is_inactive)
         is_inactive = audit_handler._is_audit_inactive(self.audits[0])
@@ -413,19 +508,17 @@ class TestContinuousAuditHandler(base.DbTestCase):
     @mock.patch.object(objects.service.Service, 'list')
     @mock.patch.object(sq_api.enginefacade.writer, 'get_engine')
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
-    @mock.patch.object(objects.audit.AuditStateTransitionManager,
-                       'is_inactive')
+    @mock.patch.object(
+        objects.audit.AuditStateTransitionManager, 'is_inactive'
+    )
     @mock.patch.object(continuous.ContinuousAuditHandler, 'execute')
     def test_execute_audit_with_interval_no_job(
-            self,
-            m_execute,
-            m_is_inactive,
-            m_get_jobs,
-            m_get_engine,
-            m_service):
+        self, m_execute, m_is_inactive, m_get_jobs, m_get_engine, m_service
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
-        self.audits[0].next_run_time = (datetime.datetime.now() -
-                                        datetime.timedelta(seconds=1800))
+        self.audits[0].next_run_time = (
+            datetime.datetime.now() - datetime.timedelta(seconds=1800)
+        )
         m_is_inactive.return_value = True
         m_get_jobs.return_value = []
 
@@ -439,12 +532,19 @@ class TestContinuousAuditHandler(base.DbTestCase):
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     @mock.patch.object(objects.audit.Audit, 'list')
     def test_launch_audits_periodically_with_diff_interval(
-            self, mock_list, mock_jobs, m_add_job, m_remove_job,
-            m_engine, m_service):
+        self,
+        mock_list,
+        mock_jobs,
+        m_add_job,
+        m_remove_job,
+        m_engine,
+        m_service,
+    ):
         audit_handler = continuous.ContinuousAuditHandler()
         mock_list.return_value = self.audits
-        self.audits[0].next_run_time = (datetime.datetime.now() -
-                                        datetime.timedelta(seconds=1800))
+        self.audits[0].next_run_time = (
+            datetime.datetime.now() - datetime.timedelta(seconds=1800)
+        )
         m_job1 = mock.MagicMock()
         m_job1.name = 'execute_audit'
         m_audit = mock.MagicMock()
@@ -466,31 +566,47 @@ class TestContinuousAuditHandler(base.DbTestCase):
         audit_handler.launch_audits_periodically()
         m_remove_job.assert_called()
 
-    @mock.patch.object(continuous.ContinuousAuditHandler, 'get_planner',
-                       mock.Mock())
-    @mock.patch.object(base_strategy.BaseStrategy, "compute_model",
-                       mock.Mock(stale=False))
+    @mock.patch.object(
+        continuous.ContinuousAuditHandler, 'get_planner', mock.Mock()
+    )
+    @mock.patch.object(
+        base_strategy.BaseStrategy, "compute_model", mock.Mock(stale=False)
+    )
     def test_execute_audit(self):
         audit_handler = continuous.ContinuousAuditHandler()
         audit_handler.execute_audit(self.audits[0], self.context)
 
         expected_calls = [
-            mock.call(self.context, self.audits[0],
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audits[0],
-                      action=objects.fields.NotificationAction.STRATEGY,
-                      phase=objects.fields.NotificationPhase.END),
-            mock.call(self.context, self.audits[0],
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.START),
-            mock.call(self.context, self.audits[0],
-                      action=objects.fields.NotificationAction.PLANNER,
-                      phase=objects.fields.NotificationPhase.END)]
+            mock.call(
+                self.context,
+                self.audits[0],
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audits[0],
+                action=objects.fields.NotificationAction.STRATEGY,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+            mock.call(
+                self.context,
+                self.audits[0],
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.START,
+            ),
+            mock.call(
+                self.context,
+                self.audits[0],
+                action=objects.fields.NotificationAction.PLANNER,
+                phase=objects.fields.NotificationPhase.END,
+            ),
+        ]
 
         self.assertEqual(
             expected_calls,
-            self.m_audit_notifications.send_action_notification.call_args_list)
+            self.m_audit_notifications.send_action_notification.call_args_list,
+        )
 
     @mock.patch.object(scheduling.BackgroundSchedulerService, 'get_jobs')
     def test_is_audit_inactive(self, mock_jobs):
@@ -498,14 +614,19 @@ class TestContinuousAuditHandler(base.DbTestCase):
         mock_jobs.return_value = mock.MagicMock()
         audit_handler._audit_scheduler = mock.MagicMock()
 
-        ap_jobs = [job.Job(mock.MagicMock(), name='execute_audit',
-                           func=audit_handler.execute_audit,
-                           args=(self.audits[0], mock.MagicMock()),
-                           kwargs={}),
-                   ]
+        ap_jobs = [
+            job.Job(
+                mock.MagicMock(),
+                name='execute_audit',
+                func=audit_handler.execute_audit,
+                args=(self.audits[0], mock.MagicMock()),
+                kwargs={},
+            )
+        ]
 
-        audit_handler.update_audit_state(self.audits[1],
-                                         objects.audit.State.CANCELLED)
+        audit_handler.update_audit_state(
+            self.audits[1], objects.audit.State.CANCELLED
+        )
         mock_jobs.return_value = ap_jobs
         is_inactive = audit_handler._is_audit_inactive(self.audits[1])
         self.assertTrue(is_inactive)
@@ -523,19 +644,19 @@ class TestContinuousAuditHandler(base.DbTestCase):
         self.assertIsNone(self.audits[0].end_time)
 
         # current time < start_time and end_time is None
-        self.audits[0].start_time = current+datetime.timedelta(days=1)
+        self.audits[0].start_time = current + datetime.timedelta(days=1)
         result = audit_handler.check_audit_expired(self.audits[0])
         self.assertTrue(result)
         self.assertIsNone(self.audits[0].end_time)
 
         # current time is between start_time and end_time
-        self.audits[0].start_time = current-datetime.timedelta(days=1)
-        self.audits[0].end_time = current+datetime.timedelta(days=1)
+        self.audits[0].start_time = current - datetime.timedelta(days=1)
+        self.audits[0].end_time = current + datetime.timedelta(days=1)
         result = audit_handler.check_audit_expired(self.audits[0])
         self.assertFalse(result)
 
         # current time > end_time
-        self.audits[0].end_time = current-datetime.timedelta(days=1)
+        self.audits[0].end_time = current - datetime.timedelta(days=1)
         result = audit_handler.check_audit_expired(self.audits[0])
         self.assertTrue(result)
         self.assertEqual(objects.audit.State.SUCCEEDED, self.audits[0].state)
diff --git a/watcher/tests/unit/decision_engine/cluster/test_cinder_cdmc.py b/watcher/tests/unit/decision_engine/cluster/test_cinder_cdmc.py
index 7208d22bf..1fdcbddfc 100644
--- a/watcher/tests/unit/decision_engine/cluster/test_cinder_cdmc.py
+++ b/watcher/tests/unit/decision_engine/cluster/test_cinder_cdmc.py
@@ -21,7 +21,6 @@ from watcher.tests.unit import base
 
 
 class TestCinderClusterDataModelCollector(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.useFixture(conf_fixture.ConfReloadFixture())
@@ -29,7 +28,6 @@ class TestCinderClusterDataModelCollector(base.TestCase):
     @mock.patch('keystoneclient.v3.client.Client', mock.Mock())
     @mock.patch.object(cinder_helper, 'CinderHelper')
     def test_cinder_cdmc_execute(self, m_cinder_helper_cls):
-
         m_cinder_helper = mock.Mock(name="cinder_helper")
         m_cinder_helper_cls.return_value = m_cinder_helper
 
@@ -38,7 +36,7 @@ class TestCinderClusterDataModelCollector(base.TestCase):
             zone='zone',
             status='enabled',
             state='up',
-            volume_type=['fake_type']
+            volume_type=['fake_type'],
         )
 
         fake_storage_pool = mock.Mock(
@@ -47,7 +45,7 @@ class TestCinderClusterDataModelCollector(base.TestCase):
             free_capacity_gb=20,
             provisioned_capacity_gb=10,
             allocated_capacity_gb=10,
-            virtual_free=20
+            virtual_free=20,
         )
         setattr(fake_storage_pool, 'name', 'host@backend#pool')
 
@@ -55,27 +53,34 @@ class TestCinderClusterDataModelCollector(base.TestCase):
             id=1,
             size=1,
             status='in-use',
-            attachments=[{"server_id": "server_id",
-                          "attachment_id": "attachment_id"}],
+            attachments=[
+                {"server_id": "server_id", "attachment_id": "attachment_id"}
+            ],
             multiattach='false',
             snapshot_id='',
             metadata='{"key": "value"}',
-            bootable='false'
+            bootable='false',
         )
         setattr(fake_volume, 'name', 'name')
-        setattr(fake_volume, 'os-vol-tenant-attr:tenant_id',
-                '0c003652-0cb1-4210-9005-fd5b92b1faa2')
+        setattr(
+            fake_volume,
+            'os-vol-tenant-attr:tenant_id',
+            '0c003652-0cb1-4210-9005-fd5b92b1faa2',
+        )
         setattr(fake_volume, 'os-vol-host-attr:host', 'host@backend#pool')
 
         # storage node list
         m_cinder_helper.get_storage_node_list.return_value = [
-            fake_storage_node]
+            fake_storage_node
+        ]
         m_cinder_helper.get_volume_type_by_backendname.return_value = [
-            'fake_type']
+            'fake_type'
+        ]
 
         # storage pool list
         m_cinder_helper.get_storage_pool_list.return_value = [
-            fake_storage_pool]
+            fake_storage_pool
+        ]
         # volume list
         m_cinder_helper.get_volume_list.return_value = [fake_volume]
 
@@ -83,7 +88,8 @@ class TestCinderClusterDataModelCollector(base.TestCase):
         m_osc = mock.Mock()
 
         cinder_cdmc = cinder.CinderClusterDataModelCollector(
-            config=m_config, osc=m_osc)
+            config=m_config, osc=m_osc
+        )
 
         cinder_cdmc.get_audit_scope_handler([])
         model = cinder_cdmc.execute()
@@ -108,8 +114,8 @@ class TestCinderClusterDataModelCollector(base.TestCase):
     @mock.patch('keystoneclient.v3.client.Client', mock.Mock())
     @mock.patch.object(cinder_helper, 'CinderHelper')
     def test_cinder_cdmc_total_capacity_gb_not_integer(
-            self, m_cinder_helper_cls):
-
+        self, m_cinder_helper_cls
+    ):
         m_cinder_helper = mock.Mock(name="cinder_helper")
         m_cinder_helper_cls.return_value = m_cinder_helper
 
@@ -118,7 +124,7 @@ class TestCinderClusterDataModelCollector(base.TestCase):
             zone='zone',
             status='enabled',
             state='up',
-            volume_type=['fake_type']
+            volume_type=['fake_type'],
         )
 
         fake_storage_pool = mock.Mock(
@@ -127,19 +133,22 @@ class TestCinderClusterDataModelCollector(base.TestCase):
             free_capacity_gb=20,
             provisioned_capacity_gb=10,
             allocated_capacity_gb=10,
-            virtual_free=20
+            virtual_free=20,
         )
         setattr(fake_storage_pool, 'name', 'host@backend#pool')
 
         # storage node list
         m_cinder_helper.get_storage_node_list.return_value = [
-            fake_storage_node]
+            fake_storage_node
+        ]
         m_cinder_helper.get_volume_type_by_backendname.return_value = [
-            'fake_type']
+            'fake_type'
+        ]
 
         # storage pool list
         m_cinder_helper.get_storage_pool_list.return_value = [
-            fake_storage_pool]
+            fake_storage_pool
+        ]
 
         # volume list
         m_cinder_helper.get_volume_list.return_value = []
@@ -148,8 +157,10 @@ class TestCinderClusterDataModelCollector(base.TestCase):
         m_osc = mock.Mock()
 
         cinder_cdmc = cinder.CinderClusterDataModelCollector(
-            config=m_config, osc=m_osc)
+            config=m_config, osc=m_osc
+        )
 
         cinder_cdmc.get_audit_scope_handler([])
-        self.assertRaises(exception.ClusterDataModelCollectionError,
-                          cinder_cdmc.execute)
+        self.assertRaises(
+            exception.ClusterDataModelCollectionError, cinder_cdmc.execute
+        )
diff --git a/watcher/tests/unit/decision_engine/cluster/test_cluster_data_model_collector.py b/watcher/tests/unit/decision_engine/cluster/test_cluster_data_model_collector.py
index 8df713ec0..1f874606f 100644
--- a/watcher/tests/unit/decision_engine/cluster/test_cluster_data_model_collector.py
+++ b/watcher/tests/unit/decision_engine/cluster/test_cluster_data_model_collector.py
@@ -24,7 +24,6 @@ from watcher.tests.unit import base as test_base
 
 
 class DummyClusterDataModelCollector(base.BaseClusterDataModelCollector):
-
     @property
     def notification_endpoints(self):
         return []
@@ -39,7 +38,6 @@ class DummyClusterDataModelCollector(base.BaseClusterDataModelCollector):
 
 
 class TestClusterDataModelCollector(test_base.TestCase):
-
     def test_is_singleton(self):
         m_config = mock.Mock()
         inst1 = DummyClusterDataModelCollector(config=m_config)
@@ -53,14 +51,15 @@ class TestClusterDataModelCollector(test_base.TestCase):
         collector.synchronize()
 
         self.assertIs(
-            collector._cluster_data_model, collector.cluster_data_model)
+            collector._cluster_data_model, collector.cluster_data_model
+        )
         self.assertIsNot(
             collector.cluster_data_model,
-            collector.get_latest_cluster_data_model())
+            collector.get_latest_cluster_data_model(),
+        )
 
 
 class TestComputeDataModelCollector(test_base.TestCase):
-
     def test_model_scope_is_none(self):
         m_config = mock.Mock()
         collector = nova.NovaClusterDataModelCollector(config=m_config)
@@ -71,7 +70,6 @@ class TestComputeDataModelCollector(test_base.TestCase):
 
 
 class TestStorageDataModelCollector(test_base.TestCase):
-
     def test_model_scope_is_none(self):
         m_config = mock.Mock()
         collector = cinder.CinderClusterDataModelCollector(config=m_config)
@@ -82,7 +80,6 @@ class TestStorageDataModelCollector(test_base.TestCase):
 
 
 class TestBareMetalDataModelCollector(test_base.TestCase):
-
     def test_model_scope_is_none(self):
         m_config = mock.Mock()
         collector = ironic.BaremetalClusterDataModelCollector(config=m_config)
diff --git a/watcher/tests/unit/decision_engine/cluster/test_nova_cdmc.py b/watcher/tests/unit/decision_engine/cluster/test_nova_cdmc.py
index 788e41399..498f213bb 100644
--- a/watcher/tests/unit/decision_engine/cluster/test_nova_cdmc.py
+++ b/watcher/tests/unit/decision_engine/cluster/test_nova_cdmc.py
@@ -34,9 +34,9 @@ from watcher.tests.unit.common import utils as test_utils
 
 
 @ddt.ddt
-class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
-                                        base.TestCase):
-
+class TestNovaClusterDataModelCollector(
+    test_utils.NovaResourcesMixin, base.TestCase
+):
     def setUp(self):
         super().setUp()
         self.useFixture(conf_fixture.ConfReloadFixture())
@@ -44,14 +44,19 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
     @mock.patch('keystoneclient.v3.client.Client', mock.Mock())
     @mock.patch.object(placement_helper, 'PlacementHelper')
     @mock.patch.object(nova_helper, 'NovaHelper')
-    @mock.patch.object(model_root.ModelRoot, 'extended_attributes_enabled',
-                       new_callable=mock.PropertyMock)
+    @mock.patch.object(
+        model_root.ModelRoot,
+        'extended_attributes_enabled',
+        new_callable=mock.PropertyMock,
+    )
     @ddt.data(False, True)
-    def test_nova_cdmc_execute(self,
-                               extended_attr_enabled,
-                               m_extended_attr_enabled,
-                               m_nova_helper_cls,
-                               m_placement_helper_cls):
+    def test_nova_cdmc_execute(
+        self,
+        extended_attr_enabled,
+        m_extended_attr_enabled,
+        m_nova_helper_cls,
+        m_placement_helper_cls,
+    ):
         # Set the extended_attributes_enabled configuration value
         m_extended_attr_enabled.return_value = extended_attr_enabled
 
@@ -63,26 +68,29 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
                 "reserved": 0,
                 "step_size": 1,
                 "min_unit": 1,
-                "max_unit": 8},
+                "max_unit": 8,
+            },
             orc.MEMORY_MB: {
                 "allocation_ratio": 1.5,
                 "total": 16039,
                 "reserved": 512,
                 "step_size": 1,
                 "min_unit": 1,
-                "max_unit": 16039},
+                "max_unit": 16039,
+            },
             orc.DISK_GB: {
                 "allocation_ratio": 1.0,
                 "total": 142,
                 "reserved": 0,
                 "step_size": 1,
                 "min_unit": 1,
-                "max_unit": 142}
+                "max_unit": 142,
+            },
         }
         m_placement_helper.get_usages_for_resource_provider.return_value = {
             orc.DISK_GB: 10,
             orc.MEMORY_MB: 100,
-            orc.VCPU: 0
+            orc.VCPU: 0,
         }
         m_placement_helper_cls.return_value = m_placement_helper
         m_nova_helper = mock.Mock(name="nova_helper")
@@ -105,14 +113,17 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
             servers=[
                 {
                     'name': 'fake_instance',
-                    'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b'
+                    'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b',
                 }
             ],
-            **minimal_node
+            **minimal_node,
         )
         fake_compute_node = self.create_openstacksdk_hypervisor(
-            service_details={'id': 123, 'host': 'test_hostname',
-                             'disabled_reason': ''},
+            service_details={
+                'id': 123,
+                'host': 'test_hostname',
+                'disabled_reason': '',
+            },
             memory_size=333,
             memory_used=100,
             free_disk_gb=222,
@@ -121,11 +132,14 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
             vcpus=4,
             vcpus_used=0,
             servers=None,  # Don't let the mock return a value for servers.
-            **minimal_node
+            **minimal_node,
         )
         fake_detailed_node = self.create_openstacksdk_hypervisor(
-            service_details={'id': 123, 'host': 'test_hostname',
-                             'disabled_reason': ''},
+            service_details={
+                'id': 123,
+                'host': 'test_hostname',
+                'disabled_reason': '',
+            },
             memory_size=333,
             memory_used=100,
             free_disk_gb=222,
@@ -133,12 +147,18 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
             local_disk_used=10,
             vcpus=4,
             vcpus_used=0,
-            **minimal_node_with_servers)
+            **minimal_node_with_servers,
+        )
         fake_instance = self.create_openstacksdk_server(
             id='ef500f7e-dac8-470f-960c-169486fce71b',
             name='fake_instance',
-            flavor={'ram': 333, 'disk': 222, 'vcpus': 4, 'id': 1,
-                    'extra_specs': {'hw_rng:allowed': 'True'}},
+            flavor={
+                'ram': 333,
+                'disk': 222,
+                'vcpus': 4,
+                'id': 1,
+                'extra_specs': {'hw_rng:allowed': 'True'},
+            },
             metadata={'hi': 'hello'},
             project_id='ff560f7e-dbc8-771f-960c-164482fce21b',
             pinned_availability_zone='nova',
@@ -147,19 +167,23 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
 
         # Returns the hypervisors with details (service_details) but no servers
         m_nova_helper.get_compute_node_list.return_value = [
-            nova_helper.Hypervisor.from_openstacksdk(fake_compute_node)]
+            nova_helper.Hypervisor.from_openstacksdk(fake_compute_node)
+        ]
         # Returns the hypervisor with servers and details (service_details).
         m_nova_helper.get_compute_node_by_name.return_value = [
-            nova_helper.Hypervisor.from_openstacksdk(fake_detailed_node)]
+            nova_helper.Hypervisor.from_openstacksdk(fake_detailed_node)
+        ]
         # Returns the hypervisor with details (service_details) but no servers.
         m_nova_helper.get_instance_list.return_value = [
-            nova_helper.Server.from_openstacksdk(fake_instance)]
+            nova_helper.Server.from_openstacksdk(fake_instance)
+        ]
 
         m_config = mock.Mock()
         m_osc = mock.Mock()
 
         nova_cdmc = nova.NovaClusterDataModelCollector(
-            config=m_config, osc=m_osc)
+            config=m_config, osc=m_osc
+        )
 
         nova_cdmc.get_audit_scope_handler([])
         model = nova_cdmc.execute()
@@ -176,28 +200,32 @@ class TestNovaClusterDataModelCollector(test_utils.NovaResourcesMixin,
         self.assertEqual(node.uuid, '160a0e7b-8b0b-4854-8257-9c71dff4efcc')
         self.assertEqual(instance.uuid, 'ef500f7e-dac8-470f-960c-169486fce71b')
 
-        memory_total = (node.memory-node.memory_mb_reserved)*node.memory_ratio
+        memory_total = (
+            node.memory - node.memory_mb_reserved
+        ) * node.memory_ratio
         self.assertEqual(node.memory_mb_capacity, memory_total)
 
-        disk_total = (node.disk-node.disk_gb_reserved)*node.disk_ratio
+        disk_total = (node.disk - node.disk_gb_reserved) * node.disk_ratio
         self.assertEqual(node.disk_gb_capacity, disk_total)
 
-        vcpus_total = (node.vcpus-node.vcpu_reserved)*node.vcpu_ratio
+        vcpus_total = (node.vcpus - node.vcpu_reserved) * node.vcpu_ratio
         self.assertEqual(node.vcpu_capacity, vcpus_total)
 
         if extended_attr_enabled:
             self.assertEqual('nova', instance.pinned_az)
-            self.assertEqual({'hw_rng:allowed': 'True'},
-                             instance.flavor_extra_specs)
+            self.assertEqual(
+                {'hw_rng:allowed': 'True'}, instance.flavor_extra_specs
+            )
         else:
             self.assertEqual('', instance.pinned_az)
             self.assertEqual({}, instance.flavor_extra_specs)
 
         m_nova_helper.get_compute_node_by_name.assert_called_once_with(
-            minimal_node['name'], servers=True, detailed=True)
+            minimal_node['name'], servers=True, detailed=True
+        )
         m_nova_helper.get_instance_list.assert_called_once_with(
             filters={'host': fake_compute_node.service_details['host']},
-            limit=1
+            limit=1,
         )
 
 
@@ -224,9 +252,12 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             'name': 'instance1',
             'pinned_availability_zone': 'nova',
             'flavor': {
-                'id': 'tiny', 'ram': 2, 'disk': 4, 'vcpus': 2,
-                'extra_specs': {}
-            }
+                'id': 'tiny',
+                'ram': 2,
+                'disk': 4,
+                'vcpus': 2,
+                'extra_specs': {},
+            },
         }
         inst1 = self.create_openstacksdk_server(**server_info)
 
@@ -237,39 +268,48 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             'name': 'instance2',
             'pinned_availability_zone': 'nova',
             'flavor': {
-                'id': 'tiny', 'ram': 2, 'disk': 4, 'vcpus': 2,
-                'extra_specs': {}
-            }
+                'id': 'tiny',
+                'ram': 2,
+                'disk': 4,
+                'vcpus': 2,
+                'extra_specs': {},
+            },
         }
         inst2 = self.create_openstacksdk_server(**server_info)
 
-        mock_instances = [nova_helper.Server.from_openstacksdk(
-            inst1), nova_helper.Server.from_openstacksdk(inst2)]
+        mock_instances = [
+            nova_helper.Server.from_openstacksdk(inst1),
+            nova_helper.Server.from_openstacksdk(inst2),
+        ]
         model_builder.nova_helper.get_instance_list.return_value = (
-            mock_instances)
+            mock_instances
+        )
         model_builder.add_instance_node(mock_node, mock_instances)
         # verify that when len(instances) <= 1000, limit == len(instance).
         model_builder.nova_helper.get_instance_list.assert_called_once_with(
-            filters={'host': mock_host}, limit=2)
+            filters={'host': mock_host}, limit=2
+        )
         fake_instance = model_builder._build_instance_node(mock_instances[1])
-        model_builder.model.add_instance.assert_called_once_with(
-            fake_instance)
+        model_builder.model.add_instance.assert_called_once_with(fake_instance)
 
         # verify that when len(instances) > 1000, limit == -1.
         mock_instance = mock.Mock()
         mock_instances = [mock_instance] * 1001
         model_builder.add_instance_node(mock_node, mock_instances)
         model_builder.nova_helper.get_instance_list.assert_called_with(
-            filters={'host': mock_host}, limit=-1)
+            filters={'host': mock_host}, limit=-1
+        )
 
     @ddt.unpack
     # unpacks (extended_attr_enabled, pinned_az_available)
     @ddt.data((True, True), (True, False), (False, True))
     @mock.patch.object(nova_helper.NovaHelper, 'is_pinned_az_available')
-    def test__build_instance_node_extended_fields(self,
-                                                  extended_attr_enabled,
-                                                  pinned_az_available,
-                                                  m_is_pinned_az_available):
+    def test__build_instance_node_extended_fields(
+        self,
+        extended_attr_enabled,
+        pinned_az_available,
+        m_is_pinned_az_available,
+    ):
         model_builder = nova.NovaModelBuilder(osc=mock.MagicMock())
         model_builder.model = mock.MagicMock()
         model_builder.model.extended_attributes_enabled = extended_attr_enabled
@@ -279,10 +319,15 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             'id': 'ef500f7e-dac8-470f-960c-169486fce711',
             'project_id': 'ff560f7e-dbc8-771f-960c-164482fce21b',
             'pinned_availability_zone': 'nova',
-            'flavor': {'ram': 333, 'disk': 222, 'vcpus': 4, 'id': 1,
-                       'extra_specs': {'hw_rng:allowed': 'True'}},
+            'flavor': {
+                'ram': 333,
+                'disk': 222,
+                'vcpus': 4,
+                'id': 1,
+                'extra_specs': {'hw_rng:allowed': 'True'},
+            },
             'vm_state': 'active',
-            'name': 'instance1'
+            'name': 'instance1',
         }
 
         fake_instance = self.create_openstacksdk_server(**server_info)
@@ -290,21 +335,24 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             nova_helper.Server.from_openstacksdk(fake_instance)
         )
 
-        self.assertEqual(fake_instance.uuid,
-                         'ef500f7e-dac8-470f-960c-169486fce711')
+        self.assertEqual(
+            fake_instance.uuid, 'ef500f7e-dac8-470f-960c-169486fce711'
+        )
         self.assertEqual(fake_instance.name, 'instance1')
         self.assertEqual(fake_instance.state, 'active')
         self.assertEqual(fake_instance.memory, 333)
         self.assertEqual(fake_instance.disk, 222)
         self.assertEqual(fake_instance.vcpus, 4)
-        self.assertEqual(fake_instance.project_id,
-                         'ff560f7e-dbc8-771f-960c-164482fce21b')
+        self.assertEqual(
+            fake_instance.project_id, 'ff560f7e-dbc8-771f-960c-164482fce21b'
+        )
 
         if extended_attr_enabled:
             expected_pinned_az = 'nova' if pinned_az_available else ''
             self.assertEqual(expected_pinned_az, fake_instance.pinned_az)
-            self.assertEqual({'hw_rng:allowed': 'True'},
-                             fake_instance.flavor_extra_specs)
+            self.assertEqual(
+                {'hw_rng:allowed': 'True'}, fake_instance.flavor_extra_specs
+            )
         else:
             self.assertEqual('', fake_instance.pinned_az)
             self.assertEqual({}, fake_instance.flavor_extra_specs)
@@ -312,10 +360,14 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
     def test_check_model(self):
         """Initialize collector ModelBuilder and test check model"""
 
-        m_scope = [{"compute": [
-            {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
-        ]}]
+        m_scope = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 5}]},
+                    {"availability_zones": [{"name": "av_a"}]},
+                ]
+            }
+        ]
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         self.assertTrue(t_nova_cluster._check_model_scope(m_scope))
@@ -326,10 +378,14 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         The seconds check_model should return false as the models are the same
         """
 
-        m_scope = [{"compute": [
-            {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
-        ]}]
+        m_scope = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 5}]},
+                    {"availability_zones": [{"name": "av_a"}]},
+                ]
+            }
+        ]
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         self.assertTrue(t_nova_cluster._check_model_scope(m_scope))
@@ -341,15 +397,23 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         Since the models differ both should return True for the update flag
         """
 
-        m_scope_one = [{"compute": [
-            {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
-        ]}]
+        m_scope_one = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 5}]},
+                    {"availability_zones": [{"name": "av_a"}]},
+                ]
+            }
+        ]
 
-        m_scope_two = [{"compute": [
-            {"host_aggregates": [{"id": 2}]},
-            {"availability_zones": [{"name": "av_b"}]}
-        ]}]
+        m_scope_two = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 2}]},
+                    {"availability_zones": [{"name": "av_b"}]},
+                ]
+            }
+        ]
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         self.assertTrue(t_nova_cluster._check_model_scope(m_scope_one))
@@ -360,18 +424,18 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
 
         m_scope_one = [
             {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
+            {"availability_zones": [{"name": "av_a"}]},
         ]
 
         m_scope_two = [
             {"host_aggregates": [{"id": 4}]},
-            {"availability_zones": [{"name": "av_b"}]}
+            {"availability_zones": [{"name": "av_b"}]},
         ]
 
-        reference = {'availability_zones':
-                     [{'name': 'av_a'}, {'name': 'av_b'}],
-                     'host_aggregates':
-                     [{'id': 5}, {'id': 4}]}
+        reference = {
+            'availability_zones': [{'name': 'av_a'}, {'name': 'av_b'}],
+            'host_aggregates': [{'id': 5}, {'id': 4}],
+        }
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         t_nova_cluster._merge_compute_scope(m_scope_one)
@@ -388,7 +452,8 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         )
         agg2 = nova_helper.Aggregate.from_openstacksdk(
             self.create_openstacksdk_aggregate(
-                id=5, name='example', hosts=['hostone', 'hosttwo'])
+                id=5, name='example', hosts=['hostone', 'hosttwo']
+            )
         )
         m_nova.return_value.get_aggregate_list.return_value = [agg1, agg2]
 
@@ -421,7 +486,8 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         svc2 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
                 id='ef500f7e-dac8-470f-960c-169486fce71b',
-                zone='av_a', host='hostone'
+                zone='av_a',
+                host='hostone',
             )
         )
         m_nova.return_value.get_service_list.return_value = [svc1, svc2]
@@ -472,20 +538,23 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         )
         agg2 = nova_helper.Aggregate.from_openstacksdk(
             self.create_openstacksdk_aggregate(
-                id=5, name='example', hosts=['hostone', 'hosttwo'])
+                id=5, name='example', hosts=['hostone', 'hosttwo']
+            )
         )
         m_nova.return_value.get_aggregate_list.return_value = [agg1, agg2]
 
         svc1 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
                 id='ee500f7e-dac8-470f-960c-169486fce71b',
-                zone='av_b', host='hostthree'
+                zone='av_b',
+                host='hostthree',
             )
         )
         svc2 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
                 id='ef500f7e-dac8-470f-960c-169486fce71b',
-                zone='av_a', host='hostone'
+                zone='av_a',
+                host='hostone',
             )
         )
         m_nova.return_value.get_service_list.return_value = [svc1, svc2]
@@ -493,7 +562,7 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         servers = [
             {
                 'name': 'fake_instance',
-                'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b'
+                'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b',
             }
         ]
         compute_node_one = self.create_openstacksdk_hypervisor(
@@ -510,14 +579,17 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             vcpus=4,
             vcpus_used=0,
             servers=servers,
-            service_details={'id': 123, 'host': 'hostone',
-                             'disabled_reason': ''},
+            service_details={
+                'id': 123,
+                'host': 'hostone',
+                'disabled_reason': '',
+            },
         )
 
         servers = [
             {
                 'name': 'fake_instance2',
-                'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b'
+                'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b',
             }
         ]
         compute_node_two = self.create_openstacksdk_hypervisor(
@@ -534,13 +606,16 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             vcpus=4,
             vcpus_used=0,
             servers=servers,
-            service_details={'id': 123, 'host': 'hosttwo',
-                             'disabled_reason': ''},
+            service_details={
+                'id': 123,
+                'host': 'hosttwo',
+                'disabled_reason': '',
+            },
         )
 
         m_nova.return_value.get_compute_node_by_name.side_effect = [
             [nova_helper.Hypervisor.from_openstacksdk(compute_node_one)],
-            [nova_helper.Hypervisor.from_openstacksdk(compute_node_two)]
+            [nova_helper.Hypervisor.from_openstacksdk(compute_node_two)],
         ]
 
         fake_instance_one = self.create_openstacksdk_server(
@@ -559,29 +634,37 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         )
         m_nova.return_value.get_instance_list.side_effect = [
             [nova_helper.Server.from_openstacksdk(fake_instance_one)],
-            [nova_helper.Server.from_openstacksdk(fake_instance_two)]
+            [nova_helper.Server.from_openstacksdk(fake_instance_two)],
         ]
 
-        m_scope = [{"compute": [
-            {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
-        ]}]
+        m_scope = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 5}]},
+                    {"availability_zones": [{"name": "av_a"}]},
+                ]
+            }
+        ]
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         t_nova_cluster.execute(m_scope)
         m_nova.return_value.get_compute_node_by_name.assert_any_call(
-            'hostone', servers=True, detailed=True)
+            'hostone', servers=True, detailed=True
+        )
         m_nova.return_value.get_compute_node_by_name.assert_any_call(
-            'hosttwo', servers=True, detailed=True)
+            'hosttwo', servers=True, detailed=True
+        )
         self.assertEqual(
-            m_nova.return_value.get_compute_node_by_name.call_count, 2)
+            m_nova.return_value.get_compute_node_by_name.call_count, 2
+        )
 
         m_nova.return_value.get_instance_list.assert_any_call(
-            filters={'host': 'hostone'}, limit=1)
+            filters={'host': 'hostone'}, limit=1
+        )
         m_nova.return_value.get_instance_list.assert_any_call(
-            filters={'host': 'hosttwo'}, limit=1)
-        self.assertEqual(
-            m_nova.return_value.get_instance_list.call_count, 2)
+            filters={'host': 'hosttwo'}, limit=1
+        )
+        self.assertEqual(m_nova.return_value.get_instance_list.call_count, 2)
 
     @mock.patch.object(futurist.Future, 'cancel')
     @mock.patch.object(placement_helper, 'PlacementHelper')
@@ -590,8 +673,14 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
     @mock.patch.object(nova_helper.NovaHelper, 'get_compute_node_by_name')
     @mock.patch.object(nova.NovaModelBuilder, 'add_instance_node')
     def test_add_physical_layer_instances_timeout(
-            self, m_add_instance_node, m_nh_compute_name,
-            m_nh_service, m_nh_aggr, m_placement, m_fut_cancel):
+        self,
+        m_add_instance_node,
+        m_nh_compute_name,
+        m_nh_service,
+        m_nh_aggr,
+        m_placement,
+        m_fut_cancel,
+    ):
         """Test add_physical_layer with timeout on collecting aggregates"""
         mock_placement = mock.Mock(name="placement_helper")
         mock_placement.get_inventories.return_value = dict()
@@ -603,22 +692,19 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         )
         agg2 = nova_helper.Aggregate.from_openstacksdk(
             self.create_openstacksdk_aggregate(
-                id=5, name='example', hosts=['hostone', 'hosttwo'])
+                id=5, name='example', hosts=['hostone', 'hosttwo']
+            )
         )
-        m_nh_aggr.return_value = ([agg1, agg2])
+        m_nh_aggr.return_value = [agg1, agg2]
 
         svc1 = nova_helper.Service.from_openstacksdk(
-            self.create_openstacksdk_service(
-                zone='av_b', host='hostthree'
-            )
+            self.create_openstacksdk_service(zone='av_b', host='hostthree')
         )
         svc2 = nova_helper.Service.from_openstacksdk(
-            self.create_openstacksdk_service(
-                zone='av_a', host='hostone'
-            )
+            self.create_openstacksdk_service(zone='av_a', host='hostone')
         )
 
-        m_nh_service.return_value = ([svc1, svc2])
+        m_nh_service.return_value = [svc1, svc2]
 
         compute_node_one_info = {
             'id': '796fee99-65dd-4262-aabb-fd2a1143faa6',
@@ -634,11 +720,12 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             'vcpus': 4,
             'vcpus_used': 0,
             'servers': [
-                {'name': 'fake_instance',
-                 'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b'}
+                {
+                    'name': 'fake_instance',
+                    'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b',
+                }
             ],
-            'service': {'id': 123, 'host': 'hostone',
-                        'disabled_reason': ''},
+            'service': {'id': 123, 'host': 'hostone', 'disabled_reason': ''},
         }
 
         compute_node_one = nova_helper.Hypervisor.from_openstacksdk(
@@ -659,11 +746,12 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             'vcpus': 4,
             'vcpus_used': 0,
             'servers': [
-                {'name': 'fake_instance2',
-                 'uuid': 'ef500f7e-dac8-47f0-960c-169486fce71b'}
+                {
+                    'name': 'fake_instance2',
+                    'uuid': 'ef500f7e-dac8-47f0-960c-169486fce71b',
+                }
             ],
-            'service': {'id': 123, 'host': 'hosttwo',
-                        'disabled_reason': ''},
+            'service': {'id': 123, 'host': 'hosttwo', 'disabled_reason': ''},
         }
 
         compute_node_two = nova_helper.Hypervisor.from_openstacksdk(
@@ -675,19 +763,23 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         self.flags(max_general_workers=1, group='watcher_decision_engine')
 
         m_nh_compute_name.side_effect = [
-            [compute_node_one], [compute_node_two]
+            [compute_node_one],
+            [compute_node_two],
         ]
 
-        m_scope = [{"compute": [
-            {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
-        ]}]
+        m_scope = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 5}]},
+                    {"availability_zones": [{"name": "av_a"}]},
+                ]
+            }
+        ]
 
         def fake_collector(self, *args):
             return time.sleep(0.5)
 
-        m_add_instance_node.side_effect = mock.Mock(
-            side_effect=fake_collector)
+        m_add_instance_node.side_effect = mock.Mock(side_effect=fake_collector)
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         # NOTE(dviroel): ModelBuilder reads the timeout directly
@@ -710,8 +802,12 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
     @mock.patch.object(nova.NovaModelBuilder, '_collect_aggregates')
     @mock.patch.object(nova.NovaModelBuilder, '_collect_zones')
     def test_add_physical_layer_aggregates_timeout(
-            self, m_collect_zones, m_collect_aggregates,
-            m_nh_node_name, m_nh_node_list):
+        self,
+        m_collect_zones,
+        m_collect_aggregates,
+        m_nh_node_name,
+        m_nh_node_list,
+    ):
         """Test add_physical_layer with timeout on collecting aggregates"""
 
         self.flags(max_general_workers=1, group='watcher_decision_engine')
@@ -720,9 +816,9 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             pass
 
         m_collect_aggregates.side_effect = mock.Mock(
-            side_effect=fake_collector)
-        m_collect_zones.side_effect = mock.Mock(
-            side_effect=fake_collector)
+            side_effect=fake_collector
+        )
+        m_collect_zones.side_effect = mock.Mock(side_effect=fake_collector)
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         # NOTE(dviroel): ModelBuilder reads the timeout directly
@@ -742,8 +838,9 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
 
     @mock.patch.object(placement_helper, 'PlacementHelper')
     @mock.patch.object(nova_helper, 'NovaHelper')
-    def test_add_physical_layer_with_baremetal_node(self, m_nova,
-                                                    m_placement_helper):
+    def test_add_physical_layer_with_baremetal_node(
+        self, m_nova, m_placement_helper
+    ):
         """"""
         mock_placement = mock.Mock(name="placement_helper")
         mock_placement.get_inventories.return_value = dict()
@@ -754,20 +851,23 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         )
         agg2 = nova_helper.Aggregate.from_openstacksdk(
             self.create_openstacksdk_aggregate(
-                id=5, name='example', hosts=['hostone', 'hosttwo'])
+                id=5, name='example', hosts=['hostone', 'hosttwo']
+            )
         )
         m_nova.return_value.get_aggregate_list.return_value = [agg1, agg2]
 
         svc1 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
                 id='ee500f7e-dac8-470f-960c-169486fce71b',
-                zone='av_b', host='hostthree'
+                zone='av_b',
+                host='hostthree',
             )
         )
         svc2 = nova_helper.Service.from_openstacksdk(
             self.create_openstacksdk_service(
                 id='ef500f7e-dac8-470f-960c-169486fce71b',
-                zone='av_a', host='hostone'
+                zone='av_a',
+                host='hostone',
             )
         )
         m_nova.return_value.get_service_list.return_value = [svc1, svc2]
@@ -775,7 +875,7 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         servers = [
             {
                 'name': 'fake_instance',
-                'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b'
+                'uuid': 'ef500f7e-dac8-470f-960c-169486fce71b',
             }
         ]
         compute_node = self.create_openstacksdk_hypervisor(
@@ -792,8 +892,11 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
             vcpus=4,
             vcpus_used=0,
             servers=servers,
-            service_details={'id': 123, 'host': 'hostone',
-                             'disabled_reason': ''},
+            service_details={
+                'id': 123,
+                'host': 'hostone',
+                'disabled_reason': '',
+            },
         )
 
         baremetal_node = self.create_openstacksdk_hypervisor(
@@ -806,12 +909,17 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
 
         m_nova.return_value.get_compute_node_by_name.side_effect = [
             [nova_helper.Hypervisor.from_openstacksdk(compute_node)],
-            [nova_helper.Hypervisor.from_openstacksdk(baremetal_node)]]
+            [nova_helper.Hypervisor.from_openstacksdk(baremetal_node)],
+        ]
 
-        m_scope = [{"compute": [
-            {"host_aggregates": [{"id": 5}]},
-            {"availability_zones": [{"name": "av_a"}]}
-        ]}]
+        m_scope = [
+            {
+                "compute": [
+                    {"host_aggregates": [{"id": 5}]},
+                    {"availability_zones": [{"name": "av_a"}]},
+                ]
+            }
+        ]
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
         model = t_nova_cluster.execute(m_scope)
@@ -819,17 +927,19 @@ class TestNovaModelBuilder(test_utils.NovaResourcesMixin, base.TestCase):
         compute_nodes = model.get_all_compute_nodes()
         self.assertEqual(1, len(compute_nodes))
         m_nova.return_value.get_compute_node_by_name.assert_any_call(
-            'hostone', servers=True, detailed=True)
+            'hostone', servers=True, detailed=True
+        )
         m_nova.return_value.get_compute_node_by_name.assert_any_call(
-            'hosttwo', servers=True, detailed=True)
+            'hosttwo', servers=True, detailed=True
+        )
         self.assertEqual(
-            m_nova.return_value.get_compute_node_by_name.call_count, 2)
+            m_nova.return_value.get_compute_node_by_name.call_count, 2
+        )
 
     def test_nova_model_builder_timeout_configuration(self):
         """Test that model builder timeout is configured"""
 
-        self.flags(compute_resources_collector_timeout=123,
-                   group='collector')
+        self.flags(compute_resources_collector_timeout=123, group='collector')
 
         t_nova_cluster = nova.NovaModelBuilder(mock.Mock())
 
diff --git a/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_base.py b/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_base.py
index 40f820ee1..1df92c750 100644
--- a/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_base.py
+++ b/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_base.py
@@ -52,7 +52,7 @@ class TestGrafanaTranslatorBase(base.BaseTestCase):
             'resource_type': 'compute_node',
             'period': '120',
             'aggregate': 'mean',
-            'granularity': None
+            'granularity': None,
         }
 
 
@@ -71,17 +71,21 @@ class TestBaseGrafanaTranslator(TestGrafanaTranslatorBase):
         """Initialize InfluxDBGrafanaTranslator and check data validation"""
 
         t_base_translator = base_translator.BaseGrafanaTranslator(
-            data=self.reference_data)
+            data=self.reference_data
+        )
 
-        self.assertIsInstance(t_base_translator,
-                              base_translator.BaseGrafanaTranslator)
+        self.assertIsInstance(
+            t_base_translator, base_translator.BaseGrafanaTranslator
+        )
 
     def test_validate_data_error(self):
         """Initialize InfluxDBGrafanaTranslator and check data validation"""
 
-        self.assertRaises(exception.InvalidParameter,
-                          base_translator.BaseGrafanaTranslator,
-                          data=[])
+        self.assertRaises(
+            exception.InvalidParameter,
+            base_translator.BaseGrafanaTranslator,
+            data=[],
+        )
 
     def test_extract_attribute(self):
         """Test that an attribute can be extracted from an object"""
@@ -89,10 +93,12 @@ class TestBaseGrafanaTranslator(TestGrafanaTranslatorBase):
         m_object = mock.Mock(hostname='test')
 
         t_base_translator = base_translator.BaseGrafanaTranslator(
-            data=self.reference_data)
+            data=self.reference_data
+        )
 
-        self.assertEqual('test', t_base_translator._extract_attribute(
-            m_object, 'hostname'))
+        self.assertEqual(
+            'test', t_base_translator._extract_attribute(m_object, 'hostname')
+        )
 
     def test_extract_attribute_error(self):
         """Test error on attempt to extract none existing attribute"""
@@ -101,7 +107,10 @@ class TestBaseGrafanaTranslator(TestGrafanaTranslatorBase):
         m_object.test = mock.PropertyMock(side_effect=AttributeError)
 
         t_base_translator = base_translator.BaseGrafanaTranslator(
-            data=self.reference_data)
+            data=self.reference_data
+        )
 
-        self.assertRaises(AttributeError, t_base_translator._extract_attribute(
-            m_object, 'test'))
+        self.assertRaises(
+            AttributeError,
+            t_base_translator._extract_attribute(m_object, 'test'),
+        )
diff --git a/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_influxdb.py b/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_influxdb.py
index 2974d81e0..5fafcfbb9 100644
--- a/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_influxdb.py
+++ b/watcher/tests/unit/decision_engine/datasources/grafana_translators/test_influxdb.py
@@ -24,8 +24,9 @@ from oslo_log import log
 
 from watcher.common import exception
 from watcher.decision_engine.datasources.grafana_translator import influxdb
-from watcher.tests.unit.decision_engine.datasources. \
-    grafana_translators import test_base
+from watcher.tests.unit.decision_engine.datasources.grafana_translators import (  # noqa: E501
+    test_base,
+)
 
 
 CONF = cfg.CONF
@@ -44,14 +45,14 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         super().setUp()
 
         self.p_conf = mock.patch.object(
-            influxdb, 'CONF',
-            new_callable=mock.PropertyMock)
+            influxdb, 'CONF', new_callable=mock.PropertyMock
+        )
         self.m_conf = self.p_conf.start()
         self.addCleanup(self.p_conf.stop)
 
         self.m_conf.grafana_translators.retention_periods = {
             'one_day': 86400,
-            'one_week': 604800
+            'one_week': 604800,
         }
 
     def test_retention_period_one_day(self):
@@ -60,8 +61,7 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         data = copy.copy(self.reference_data)
         data['query'] = "{4}"
 
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=data)
         params = t_influx.build_params()
         self.assertEqual(params['q'], 'one_day')
 
@@ -72,8 +72,7 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         data['query'] = "{4}"
 
         data['period'] = 90000
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=data)
         params = t_influx.build_params()
         self.assertEqual(params['q'], 'one_week')
 
@@ -85,12 +84,12 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         data['query'] = "{4}"
 
         data['period'] = 650000
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=data)
         params = t_influx.build_params()
         self.assertEqual(params['q'], 'one_week')
         m_log.warning.assert_called_once_with(
-            "Longest retention period is to short for desired period")
+            "Longest retention period is to short for desired period"
+        )
 
     def test_build_params_granularity(self):
         """Validate build params granularity"""
@@ -99,14 +98,9 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         data['granularity'] = None
         data['query'] = "{3}"
 
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=data)
 
-        raw_results = {
-            'db': 'production',
-            'epoch': 'ms',
-            'q': '1'
-        }
+        raw_results = {'db': 'production', 'epoch': 'ms', 'q': '1'}
 
         # InfluxDB build_params should replace granularity None optional with 1
         result = t_influx.build_params()
@@ -126,8 +120,7 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         data['granularity'] = 4
         data['query'] = "{0}{1}{2}{3}{4}"
 
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=data)
 
         raw_results = "counthyperion34one_day"
 
@@ -138,13 +131,14 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
     def test_extract_results(self):
         """Validate proper result extraction"""
 
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=self.reference_data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=self.reference_data)
 
-        raw_results = "{ \"results\": [{ \"series\": [{ " \
-                      "\"columns\": [\"time\",\"mean\"]," \
-                      "\"values\": [[1552500855000, " \
-                      "67.3550078657577]]}]}]}"
+        raw_results = (
+            "{ \"results\": [{ \"series\": [{ "
+            "\"columns\": [\"time\",\"mean\"],"
+            "\"values\": [[1552500855000, "
+            "67.3550078657577]]}]}]}"
+        )
 
         # Structure of InfluxDB time series data
         # { "results": [{
@@ -162,16 +156,17 @@ class TestInfluxDBGrafanaTranslator(test_base.TestGrafanaTranslatorBase):
         #                 }]
         # }]}
 
-        self.assertEqual(t_influx.extract_result(raw_results),
-                         67.3550078657577)
+        self.assertEqual(
+            t_influx.extract_result(raw_results), 67.3550078657577
+        )
 
     def test_extract_results_error(self):
         """Validate error on missing results"""
 
-        t_influx = influxdb.InfluxDBGrafanaTranslator(
-            data=self.reference_data)
+        t_influx = influxdb.InfluxDBGrafanaTranslator(data=self.reference_data)
 
         raw_results = "{}"
 
-        self.assertRaises(exception.NoSuchMetricForHost,
-                          t_influx.extract_result, raw_results)
+        self.assertRaises(
+            exception.NoSuchMetricForHost, t_influx.extract_result, raw_results
+        )
diff --git a/watcher/tests/unit/decision_engine/datasources/test_aetos_helper.py b/watcher/tests/unit/decision_engine/datasources/test_aetos_helper.py
index 11cfaa422..898c0f210 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_aetos_helper.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_aetos_helper.py
@@ -32,30 +32,27 @@ class TestAetosHelper(base.BaseTestCase):
     def test_get_fqdn_label(self):
         fqdn = 'fqdn_label'
         cfg.CONF.aetos_client.fqdn_label = fqdn
-        self.assertEqual(
-            fqdn,
-            self.helper._get_fqdn_label()
-        )
+        self.assertEqual(fqdn, self.helper._get_fqdn_label())
 
     def test_get_instance_uuid_label(self):
         instance_uuid = 'instance_uuid_label'
         cfg.CONF.aetos_client.instance_uuid_label = instance_uuid
-        self.assertEqual(
-            instance_uuid,
-            self.helper._get_instance_uuid_label()
-        )
+        self.assertEqual(instance_uuid, self.helper._get_instance_uuid_label())
 
     @mock.patch.object(obs_client_utils, 'get_prom_client_from_keystone')
     def test_setup_prometheus_client(self, mock_get_prom_client):
         cfg.CONF.aetos_client.interface = 'internal'
         cfg.CONF.aetos_client.region_name = 'RegionTwo'
 
-        opts = {'interface': 'internal',
-                'region_name': 'RegionTwo',
-                'service_type': 'metric-storage'}
+        opts = {
+            'interface': 'internal',
+            'region_name': 'RegionTwo',
+            'service_type': 'metric-storage',
+        }
         osc = mock.Mock()
         osc.session = mock.Mock()
         aetos_helper.AetosHelper(osc)
 
         mock_get_prom_client.assert_called_once_with(
-            osc.session, adapter_options=opts)
+            osc.session, adapter_options=opts
+        )
diff --git a/watcher/tests/unit/decision_engine/datasources/test_base.py b/watcher/tests/unit/decision_engine/datasources/test_base.py
index 0a78074fd..3c588347f 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_base.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_base.py
@@ -27,18 +27,15 @@ CONF = cfg.CONF
 
 
 class TestBaseDatasourceHelper(base.BaseTestCase):
-
     def test_query_retry(self):
         exc = Exception()
         method = mock.Mock()
         # first call will fail but second will succeed
         method.side_effect = [exc, True]
         # Max 2 attempts
-        CONF.set_override("query_max_retries", 2,
-                          group='watcher_datasources')
+        CONF.set_override("query_max_retries", 2, group='watcher_datasources')
         # Reduce sleep time to 0
-        CONF.set_override("query_interval", 0,
-                          group='watcher_datasources')
+        CONF.set_override("query_interval", 0, group='watcher_datasources')
 
         helper = datasource.DataSourceBase()
         helper.query_retry_reset = mock.Mock()
@@ -52,11 +49,9 @@ class TestBaseDatasourceHelper(base.BaseTestCase):
         # only third call will succeed
         method.side_effect = [exc, exc, True]
         # Max 2 attempts
-        CONF.set_override("query_max_retries", 2,
-                          group='watcher_datasources')
+        CONF.set_override("query_max_retries", 2, group='watcher_datasources')
         # Reduce sleep time to 0
-        CONF.set_override("query_interval", 0,
-                          group='watcher_datasources')
+        CONF.set_override("query_interval", 0, group='watcher_datasources')
 
         helper = datasource.DataSourceBase()
         helper.query_retry_reset = mock.Mock()
@@ -65,4 +60,5 @@ class TestBaseDatasourceHelper(base.BaseTestCase):
         self.assertIsNone(helper.query_retry(f=method))
         # query_retry_reset should be called twice
         helper.query_retry_reset.assert_has_calls(
-            [mock.call(exc), mock.call(exc)])
+            [mock.call(exc), mock.call(exc)]
+        )
diff --git a/watcher/tests/unit/decision_engine/datasources/test_gnocchi_helper.py b/watcher/tests/unit/decision_engine/datasources/test_gnocchi_helper.py
index cce6f92fe..5468aa772 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_gnocchi_helper.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_gnocchi_helper.py
@@ -28,30 +28,32 @@ CONF = cfg.CONF
 
 @mock.patch.object(clients.OpenStackClients, 'gnocchi')
 class TestGnocchiHelper(base.BaseTestCase):
-
     def setUp(self):
         super().setUp()
         self.osc_mock = mock.Mock()
         self.helper = gnocchi_helper.GnocchiHelper(osc=self.osc_mock)
         stat_agg_patcher = mock.patch.object(
-            self.helper, 'statistic_aggregation',
-            spec=gnocchi_helper.GnocchiHelper.statistic_aggregation)
+            self.helper,
+            'statistic_aggregation',
+            spec=gnocchi_helper.GnocchiHelper.statistic_aggregation,
+        )
         self.mock_aggregation = stat_agg_patcher.start()
         self.addCleanup(stat_agg_patcher.stop)
 
     def test_gnocchi_statistic_aggregation(self, mock_gnocchi):
         vcpus = 2
         mock_instance = mock.Mock(
-            id='16a86790-327a-45f9-bc82-45839f062fdc',
-            vcpus=vcpus)
+            id='16a86790-327a-45f9-bc82-45839f062fdc', vcpus=vcpus
+        )
 
         gnocchi = mock.MagicMock()
         # cpu time rate of change (ns)
-        mock_rate_measure = 360 * 10e+8 * vcpus * 5.5 / 100
+        mock_rate_measure = 360 * 10e8 * vcpus * 5.5 / 100
         expected_result = 5.5
 
         expected_measures = [
-            ["2017-02-02T09:00:00.000000", 360, mock_rate_measure]]
+            ["2017-02-02T09:00:00.000000", 360, mock_rate_measure]
+        ]
 
         gnocchi.metric.get_measures.return_value = expected_measures
         mock_gnocchi.return_value = gnocchi
@@ -73,18 +75,19 @@ class TestGnocchiHelper(base.BaseTestCase):
             stop=mock.ANY,
             resource_id=mock_instance.uuid,
             granularity=360,
-            aggregation="rate:mean")
+            aggregation="rate:mean",
+        )
 
     def test_gnocchi_statistic_series(self, mock_gnocchi):
         gnocchi = mock.MagicMock()
         expected_result = {
             "2017-02-02T09:00:00.000000": 5.5,
-            "2017-02-02T09:03:60.000000": 5.8
+            "2017-02-02T09:03:60.000000": 5.8,
         }
 
         expected_measures = [
             ["2017-02-02T09:00:00.000000", 360, 5.5],
-            ["2017-02-02T09:03:60.000000", 360, 5.8]
+            ["2017-02-02T09:03:60.000000", 360, 5.8],
         ]
 
         gnocchi.metric.get_measures.return_value = expected_measures
@@ -109,82 +112,82 @@ class TestGnocchiHelper(base.BaseTestCase):
 
         # invalidate instance_cpu_usage in metric map
         original_metric_value = helper.METRIC_MAP.get('instance_cpu_usage')
-        helper.METRIC_MAP.update(
-            instance_cpu_usage=None
-        )
+        helper.METRIC_MAP.update(instance_cpu_usage=None)
 
         self.assertRaises(
-            exception.MetricNotAvailable, helper.statistic_aggregation,
+            exception.MetricNotAvailable,
+            helper.statistic_aggregation,
             resource=mock.Mock(id='16a86790-327a-45f9-bc82-45839f062fdc'),
-            resource_type='instance', meter_name='instance_cpu_usage',
-            period=300, granularity=360, aggregate='mean',
+            resource_type='instance',
+            meter_name='instance_cpu_usage',
+            period=300,
+            granularity=360,
+            aggregate='mean',
         )
 
         # restore the metric map as it is a static attribute that does not get
         # restored between unit tests!
-        helper.METRIC_MAP.update(
-            instance_cpu_usage=original_metric_value
-        )
+        helper.METRIC_MAP.update(instance_cpu_usage=original_metric_value)
 
     def test_get_host_cpu_usage(self, mock_gnocchi):
         self.helper.get_host_cpu_usage('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'compute_node', 'host_cpu_usage', 600, 'mean',
-            300)
+            'compute1', 'compute_node', 'host_cpu_usage', 600, 'mean', 300
+        )
 
     def test_get_host_ram_usage(self, mock_gnocchi):
         self.helper.get_host_ram_usage('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'compute_node', 'host_ram_usage', 600, 'mean',
-            300)
+            'compute1', 'compute_node', 'host_ram_usage', 600, 'mean', 300
+        )
 
     def test_get_host_outlet_temperature(self, mock_gnocchi):
         self.helper.get_host_outlet_temp('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'compute_node', 'host_outlet_temp', 600, 'mean',
-            300)
+            'compute1', 'compute_node', 'host_outlet_temp', 600, 'mean', 300
+        )
 
     def test_get_host_inlet_temperature(self, mock_gnocchi):
         self.helper.get_host_inlet_temp('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'compute_node', 'host_inlet_temp', 600, 'mean',
-            300)
+            'compute1', 'compute_node', 'host_inlet_temp', 600, 'mean', 300
+        )
 
     def test_get_host_airflow(self, mock_gnocchi):
         self.helper.get_host_airflow('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'compute_node', 'host_airflow', 600, 'mean',
-            300)
+            'compute1', 'compute_node', 'host_airflow', 600, 'mean', 300
+        )
 
     def test_get_host_power(self, mock_gnocchi):
         self.helper.get_host_power('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'compute_node', 'host_power', 600, 'mean',
-            300)
+            'compute1', 'compute_node', 'host_power', 600, 'mean', 300
+        )
 
     def test_get_instance_cpu_usage(self, mock_gnocchi):
         self.helper.get_instance_cpu_usage('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'instance', 'instance_cpu_usage', 600, 'mean',
-            300)
+            'compute1', 'instance', 'instance_cpu_usage', 600, 'mean', 300
+        )
 
     def test_get_instance_memory_usage(self, mock_gnocchi):
         self.helper.get_instance_ram_usage('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'instance', 'instance_ram_usage', 600, 'mean',
-            300)
+            'compute1', 'instance', 'instance_ram_usage', 600, 'mean', 300
+        )
 
     def test_get_instance_ram_allocated(self, mock_gnocchi):
         self.helper.get_instance_ram_allocated('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'instance', 'instance_ram_allocated', 600, 'mean',
-            300)
+            'compute1', 'instance', 'instance_ram_allocated', 600, 'mean', 300
+        )
 
     def test_get_instance_root_disk_allocated(self, mock_gnocchi):
         self.helper.get_instance_root_disk_size('compute1', 600, 'mean', 300)
         self.mock_aggregation.assert_called_once_with(
-            'compute1', 'instance', 'instance_root_disk_size', 600, 'mean',
-            300)
+            'compute1', 'instance', 'instance_root_disk_size', 600, 'mean', 300
+        )
 
     def test_gnocchi_check_availability(self, mock_gnocchi):
         gnocchi = mock.MagicMock()
@@ -195,8 +198,9 @@ class TestGnocchiHelper(base.BaseTestCase):
         self.assertEqual('available', result)
 
     def test_gnocchi_check_availability_with_failure(self, mock_gnocchi):
-        cfg.CONF.set_override("query_max_retries", 1,
-                              group='watcher_datasources')
+        cfg.CONF.set_override(
+            "query_max_retries", 1, group='watcher_datasources'
+        )
         gnocchi = mock.MagicMock()
         gnocchi.status.get.side_effect = Exception()
         mock_gnocchi.return_value = gnocchi
@@ -215,8 +219,9 @@ class TestGnocchiHelper(base.BaseTestCase):
         self.assertEqual(expected_metrics, result)
 
     def test_gnocchi_list_metrics_with_failure(self, mock_gnocchi):
-        cfg.CONF.set_override("query_max_retries", 1,
-                              group='watcher_datasources')
+        cfg.CONF.set_override(
+            "query_max_retries", 1, group='watcher_datasources'
+        )
         gnocchi = mock.MagicMock()
         gnocchi.metric.list.side_effect = Exception()
         mock_gnocchi.return_value = gnocchi
diff --git a/watcher/tests/unit/decision_engine/datasources/test_grafana_helper.py b/watcher/tests/unit/decision_engine/datasources/test_grafana_helper.py
index 5e1dde8f5..973ecbf57 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_grafana_helper.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_grafana_helper.py
@@ -44,41 +44,46 @@ class TestGrafana(base.BaseTestCase):
         super().setUp()
 
         self.p_conf = mock.patch.object(
-            grafana, 'CONF',
-            new_callable=mock.PropertyMock)
+            grafana, 'CONF', new_callable=mock.PropertyMock
+        )
         self.m_conf = self.p_conf.start()
         self.addCleanup(self.p_conf.stop)
 
-        self.m_conf.grafana_client.token = \
+        self.m_conf.grafana_client.token = (
             "eyJrIjoiT0tTcG1pUlY2RnVKZTFVaDFsNFZXdE9ZWmNrMkZYbk=="
+        )
         self.m_conf.grafana_client.base_url = "https://grafana.proxy/api/"
         self.m_conf.grafana_client.project_id_map = {'host_cpu_usage': 7221}
-        self.m_conf.grafana_client.database_map = \
-            {'host_cpu_usage': 'mock_db'}
-        self.m_conf.grafana_client.attribute_map = \
-            {'host_cpu_usage': 'hostname'}
-        self.m_conf.grafana_client.translator_map = \
-            {'host_cpu_usage': 'influxdb'}
-        self.m_conf.grafana_client.query_map = \
-            {'host_cpu_usage': 'SELECT 100-{0}("{0}_value") FROM {3}.'
-                               'cpu_percent WHERE ("host" =~ /^{1}$/ AND '
-                               '"type_instance" =~/^idle$/ AND time > '
-                               '(now()-{2}m)'}
+        self.m_conf.grafana_client.database_map = {'host_cpu_usage': 'mock_db'}
+        self.m_conf.grafana_client.attribute_map = {
+            'host_cpu_usage': 'hostname'
+        }
+        self.m_conf.grafana_client.translator_map = {
+            'host_cpu_usage': 'influxdb'
+        }
+        self.m_conf.grafana_client.query_map = {
+            'host_cpu_usage': 'SELECT 100-{0}("{0}_value") FROM {3}.'
+            'cpu_percent WHERE ("host" =~ /^{1}$/ AND '
+            '"type_instance" =~/^idle$/ AND time > '
+            '(now()-{2}m)'
+        }
 
         self.m_grafana = grafana.GrafanaHelper(osc=mock.Mock())
         stat_agg_patcher = mock.patch.object(
-            self.m_grafana, 'statistic_aggregation',
-            spec=grafana.GrafanaHelper.statistic_aggregation)
+            self.m_grafana,
+            'statistic_aggregation',
+            spec=grafana.GrafanaHelper.statistic_aggregation,
+        )
         self.mock_aggregation = stat_agg_patcher.start()
         self.addCleanup(stat_agg_patcher.stop)
 
         self.m_compute_node = mock.Mock(
             id='16a86790-327a-45f9-bc82-45839f062fdc',
-            hostname='example.hostname.ch'
+            hostname='example.hostname.ch',
         )
         self.m_instance = mock.Mock(
             id='73b1ff78-aca7-404f-ac43-3ed16c1fa555',
-            human_id='example.hostname'
+            human_id='example.hostname',
         )
 
     def test_configured(self):
@@ -88,9 +93,7 @@ class TestGrafana(base.BaseTestCase):
         self.assertTrue(t_grafana.configured)
 
     def test_configured_error(self):
-        """Butcher the required configuration and test if configured is false
-
-        """
+        """Test that configured is False when required config is missing."""
 
         self.m_conf.grafana_client.base_url = ""
         t_grafana = grafana.GrafanaHelper(osc=mock.Mock())
@@ -116,7 +119,7 @@ class TestGrafana(base.BaseTestCase):
         self.assertRaises(
             exception.MetricNotAvailable,
             t_grafana.get_host_cpu_usage,
-            self.m_compute_node
+            self.m_compute_node,
         )
 
     @mock.patch.object(requests, 'get')
@@ -138,24 +141,28 @@ class TestGrafana(base.BaseTestCase):
 
         t_grafana = grafana.GrafanaHelper(osc=mock.Mock())
 
-        self.assertRaises(exception.MetricNotAvailable,
-                          t_grafana.statistic_aggregation,
-                          self.m_compute_node,
-                          'none existing meter', 60)
+        self.assertRaises(
+            exception.MetricNotAvailable,
+            t_grafana.statistic_aggregation,
+            self.m_compute_node,
+            'none existing meter',
+            60,
+        )
 
     @mock.patch.object(grafana.GrafanaHelper, '_request')
     def test_get_metric_raise_error(self, m_request):
-        """Test raising error when endpoint unable to deliver data for metric
-
-        """
+        """Test error raised when endpoint cannot deliver metric data."""
 
         m_request.return_value.content = "{}"
 
         t_grafana = grafana.GrafanaHelper(osc=mock.Mock())
 
-        self.assertRaises(exception.NoSuchMetricForHost,
-                          t_grafana.get_host_cpu_usage,
-                          self.m_compute_node, 60)
+        self.assertRaises(
+            exception.NoSuchMetricForHost,
+            t_grafana.get_host_cpu_usage,
+            self.m_compute_node,
+            60,
+        )
 
     def test_metric_builder(self):
         """Creates valid and invalid sets of configuration for metrics
@@ -198,13 +205,15 @@ class TestGrafana(base.BaseTestCase):
                 'project': 7221,
                 'attribute': 'hostname',
                 'translator': 'influxdb',
-                'query': 'SHOW SERIES'},
+                'query': 'SHOW SERIES',
+            },
             'instance_ram_allocated': {
                 'db': 'mock_db',
                 'project': 7221,
                 'attribute': 'human_id',
                 'translator': 'influxdb',
-                'query': 'SHOW SERIES'},
+                'query': 'SHOW SERIES',
+            },
         }
 
         t_grafana = grafana.GrafanaHelper(osc=mock.Mock())
@@ -212,89 +221,137 @@ class TestGrafana(base.BaseTestCase):
 
     @mock.patch.object(grafana.GrafanaHelper, '_request')
     def test_statistic_aggregation(self, m_request):
-        m_request.return_value.content = "{ \"results\": [{ \"series\": [{ " \
-                                         "\"columns\": [\"time\",\"mean\"]," \
-                                         "\"values\": [[1552500855000, " \
-                                         "67.3550078657577]]}]}]}"
+        m_request.return_value.content = (
+            "{ \"results\": [{ \"series\": [{ "
+            "\"columns\": [\"time\",\"mean\"],"
+            "\"values\": [[1552500855000, "
+            "67.3550078657577]]}]}]}"
+        )
 
         t_grafana = grafana.GrafanaHelper(osc=mock.Mock())
 
         result = t_grafana.statistic_aggregation(
-            self.m_compute_node, 'compute_node', 'host_cpu_usage', 60)
+            self.m_compute_node, 'compute_node', 'host_cpu_usage', 60
+        )
         self.assertEqual(result, 67.3550078657577)
 
     def test_get_host_cpu_usage(self):
         self.m_grafana.get_host_cpu_usage(self.m_compute_node, 60, 'min', 15)
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'compute_node', 'host_cpu_usage', 60, 'min',
-            15)
+            self.m_compute_node,
+            'compute_node',
+            'host_cpu_usage',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_host_ram_usage(self):
-        self.m_grafana.get_host_ram_usage(self.m_compute_node, 60,
-                                          'min', 15)
+        self.m_grafana.get_host_ram_usage(self.m_compute_node, 60, 'min', 15)
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'compute_node', 'host_ram_usage', 60, 'min',
-            15)
+            self.m_compute_node,
+            'compute_node',
+            'host_ram_usage',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_host_outlet_temperature(self):
-        self.m_grafana.get_host_outlet_temp(self.m_compute_node, 60,
-                                            'min', 15)
+        self.m_grafana.get_host_outlet_temp(self.m_compute_node, 60, 'min', 15)
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'compute_node', 'host_outlet_temp', 60, 'min',
-            15)
+            self.m_compute_node,
+            'compute_node',
+            'host_outlet_temp',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_host_inlet_temperature(self):
-        self.m_grafana.get_host_inlet_temp(self.m_compute_node, 60,
-                                           'min', 15)
+        self.m_grafana.get_host_inlet_temp(self.m_compute_node, 60, 'min', 15)
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'compute_node', 'host_inlet_temp', 60, 'min',
-            15)
+            self.m_compute_node,
+            'compute_node',
+            'host_inlet_temp',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_host_airflow(self):
-        self.m_grafana.get_host_airflow(self.m_compute_node, 60,
-                                        'min', 15)
+        self.m_grafana.get_host_airflow(self.m_compute_node, 60, 'min', 15)
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'compute_node', 'host_airflow', 60, 'min',
-            15)
+            self.m_compute_node, 'compute_node', 'host_airflow', 60, 'min', 15
+        )
 
     def test_get_host_power(self):
-        self.m_grafana.get_host_power(self.m_compute_node, 60,
-                                      'min', 15)
+        self.m_grafana.get_host_power(self.m_compute_node, 60, 'min', 15)
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'compute_node', 'host_power', 60, 'min',
-            15)
+            self.m_compute_node, 'compute_node', 'host_power', 60, 'min', 15
+        )
 
     def test_get_instance_cpu_usage(self):
-        self.m_grafana.get_instance_cpu_usage(self.m_compute_node, 60,
-                                              'min', 15)
+        self.m_grafana.get_instance_cpu_usage(
+            self.m_compute_node, 60, 'min', 15
+        )
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'instance', 'instance_cpu_usage', 60,
-            'min', 15)
+            self.m_compute_node,
+            'instance',
+            'instance_cpu_usage',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_instance_ram_usage(self):
-        self.m_grafana.get_instance_ram_usage(self.m_compute_node, 60,
-                                              'min', 15)
+        self.m_grafana.get_instance_ram_usage(
+            self.m_compute_node, 60, 'min', 15
+        )
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'instance', 'instance_ram_usage', 60,
-            'min', 15)
+            self.m_compute_node,
+            'instance',
+            'instance_ram_usage',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_instance_ram_allocated(self):
-        self.m_grafana.get_instance_ram_allocated(self.m_compute_node, 60,
-                                                  'min', 15)
+        self.m_grafana.get_instance_ram_allocated(
+            self.m_compute_node, 60, 'min', 15
+        )
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'instance', 'instance_ram_allocated', 60,
-            'min', 15)
+            self.m_compute_node,
+            'instance',
+            'instance_ram_allocated',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_instance_l3_cache_usage(self):
-        self.m_grafana.get_instance_l3_cache_usage(self.m_compute_node, 60,
-                                                   'min', 15)
+        self.m_grafana.get_instance_l3_cache_usage(
+            self.m_compute_node, 60, 'min', 15
+        )
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'instance', 'instance_l3_cache_usage', 60,
-            'min', 15)
+            self.m_compute_node,
+            'instance',
+            'instance_l3_cache_usage',
+            60,
+            'min',
+            15,
+        )
 
     def test_get_instance_root_disk_allocated(self):
-        self.m_grafana.get_instance_root_disk_size(self.m_compute_node, 60,
-                                                   'min', 15)
+        self.m_grafana.get_instance_root_disk_size(
+            self.m_compute_node, 60, 'min', 15
+        )
         self.mock_aggregation.assert_called_once_with(
-            self.m_compute_node, 'instance', 'instance_root_disk_size', 60,
-            'min', 15)
+            self.m_compute_node,
+            'instance',
+            'instance_root_disk_size',
+            60,
+            'min',
+            15,
+        )
diff --git a/watcher/tests/unit/decision_engine/datasources/test_manager.py b/watcher/tests/unit/decision_engine/datasources/test_manager.py
index eef69fa19..7b0d546e6 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_manager.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_manager.py
@@ -27,7 +27,6 @@ from watcher.tests.unit import base
 
 
 class TestDataSourceManager(base.BaseTestCase):
-
     def _dsm_config(self, **kwargs):
         dss = ['gnocchi']
         opts = dict(datasources=dss, metric_map_path=None)
@@ -50,22 +49,23 @@ class TestDataSourceManager(base.BaseTestCase):
     def test_metric_file_metric_override_grafana(self, m_config):
         """Grafana requires a different structure in the metric map"""
 
-        m_config.grafana_client.token = \
+        m_config.grafana_client.token = (
             "eyJrIjoiT0tTcG1pUlY2RnVKZTFVaDFsNFZXdE9ZWmNrMkZYbk=="
+        )
         m_config.grafana_client.base_url = "https://grafana.proxy/api/"
 
-        path = 'watcher.decision_engine.datasources.manager.' \
-               'DataSourceManager.load_metric_map'
+        path = (
+            'watcher.decision_engine.datasources.manager.'
+            'DataSourceManager.load_metric_map'
+        )
         metric_map = {
             'db': 'production_cloud',
             'project': '7485',
             'attribute': 'hostname',
             'translator': 'influxdb',
-            'query': 'SHOW SERIES'
-        }
-        retval = {
-            grafana.GrafanaHelper.NAME: {"host_airflow": metric_map}
+            'query': 'SHOW SERIES',
         }
+        retval = {grafana.GrafanaHelper.NAME: {"host_airflow": metric_map}}
         with mock.patch(path, return_value=retval):
             dsmcfg = self._dsm_config(datasources=['grafana'])
             manager = self._dsm(config=dsmcfg)
@@ -80,9 +80,7 @@ class TestDataSourceManager(base.BaseTestCase):
 
     def test_get_backend(self):
         manager = self._dsm()
-        backend = manager.get_backend(
-            ['host_cpu_usage', 'instance_cpu_usage']
-        )
+        backend = manager.get_backend(['host_cpu_usage', 'instance_cpu_usage'])
         self.assertEqual(backend, manager.gnocchi)
 
     def test_get_backend_order(self):
@@ -98,7 +96,7 @@ class TestDataSourceManager(base.BaseTestCase):
         self.assertRaises(
             exception.MetricNotAvailable,
             manager.get_backend,
-            ['host_cpu', 'instance_cpu_usage']
+            ['host_cpu', 'instance_cpu_usage'],
         )
 
     @mock.patch.object(gnocchi, 'GnocchiHelper')
@@ -108,11 +106,12 @@ class TestDataSourceManager(base.BaseTestCase):
         self.assertRaises(
             exception.MetricNotAvailable,
             manager.get_backend,
-            ['host_cpu_usage', 'instance_cpu_usage']
+            ['host_cpu_usage', 'instance_cpu_usage'],
         )
 
-    @mock.patch.object(grafana.GrafanaHelper, 'METRIC_MAP',
-                       {'host_cpu_usage': 'test'})
+    @mock.patch.object(
+        grafana.GrafanaHelper, 'METRIC_MAP', {'host_cpu_usage': 'test'}
+    )
     def test_get_backend_grafana(self):
         dss = ['grafana', 'gnocchi']
         dsmcfg = self._dsm_config(datasources=dss)
@@ -122,16 +121,15 @@ class TestDataSourceManager(base.BaseTestCase):
 
     @mock.patch.object(grafana, 'CONF')
     def test_dynamic_metric_map_grafana(self, m_config):
-        m_config.grafana_client.token = \
+        m_config.grafana_client.token = (
             "eyJrIjoiT0tTcG1pUlY2RnVKZTFVaDFsNFZXdE9ZWmNrMkZYbk=="
+        )
         m_config.grafana_client.base_url = "https://grafana.proxy/api/"
         m_config.grafana_client.project_id_map = {'host_cpu_usage': 7221}
         m_config.grafana_client.attribute_map = {'host_cpu_usage': 'hostname'}
         m_config.grafana_client.database_map = {'host_cpu_usage': 'mock_db'}
         m_config.grafana_client.translator_map = {'host_cpu_usage': 'influxdb'}
-        m_config.grafana_client.query_map = {
-            'host_cpu_usage': 'SHOW SERIES'
-        }
+        m_config.grafana_client.query_map = {'host_cpu_usage': 'SHOW SERIES'}
         dss = ['grafana', 'gnocchi']
         dsmcfg = self._dsm_config(datasources=dss)
         manager = self._dsm(config=dsmcfg)
@@ -144,37 +142,33 @@ class TestDataSourceManager(base.BaseTestCase):
         self.assertRaises(
             exception.NoDatasourceAvailable,
             manager.get_backend,
-            ['host_cpu_usage', 'instance_cpu_usage']
+            ['host_cpu_usage', 'instance_cpu_usage'],
         )
         dsmcfg = self._dsm_config(datasources=None)
         manager = self._dsm(config=dsmcfg)
         self.assertRaises(
             exception.NoDatasourceAvailable,
             manager.get_backend,
-            ['host_cpu_usage', 'instance_cpu_usage']
+            ['host_cpu_usage', 'instance_cpu_usage'],
         )
 
     def test_get_backend_no_metrics(self):
         manager = self._dsm()
         self.assertRaises(exception.InvalidParameter, manager.get_backend, [])
         self.assertRaises(
-            exception.InvalidParameter,
-            manager.get_backend,
-            None
+            exception.InvalidParameter, manager.get_backend, None
         )
 
     def test_datasource_validation_prometheus_and_aetos_conflict(self):
         """Test having both prometheus and aetos datasources raises error"""
         conflicting_datasources = [
             prometheus.PrometheusHelper.NAME,
-            aetos.AetosHelper.NAME
+            aetos.AetosHelper.NAME,
         ]
         dsmcfg = self._dsm_config(datasources=conflicting_datasources)
 
         self.assertRaises(
-            exception.DataSourceConfigConflict,
-            self._dsm,
-            config=dsmcfg
+            exception.DataSourceConfigConflict, self._dsm, config=dsmcfg
         )
 
     def test_datasource_validation_single_prometheus_ok(self):
diff --git a/watcher/tests/unit/decision_engine/datasources/test_prometheus_base.py b/watcher/tests/unit/decision_engine/datasources/test_prometheus_base.py
index 02cd99896..e5e3a6b42 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_prometheus_base.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_prometheus_base.py
@@ -32,92 +32,123 @@ class TestPrometheusBase(base.BaseTestCase):
         super().setUp()
 
         with (
-                mock.patch.object(
-                    prometheus_base.PrometheusBase, '_setup_prometheus_client',
-                    return_value=prometheus_client.PrometheusAPIClient('')),
-                mock.patch.object(
-                    prometheus_base.PrometheusBase, '_get_fqdn_label',
-                    return_value='fqdn'),
-                mock.patch.object(
-                    prometheus_base.PrometheusBase, '_get_instance_uuid_label',
-                    return_value='resource'),
-                mock.patch.object(
-                    prometheus_client.PrometheusAPIClient, '_get',
-                    return_value={'data': {'activeTargets': [
-                        {'labels': {
-                            'fqdn': 'marios-env.controlplane.domain',
-                            'instance': '10.0.1.2:9100', 'job': 'node',
-                            }},
-                        {'labels': {
-                            'fqdn': 'marios-env-again.controlplane.domain',
-                            'instance': 'localhost:9100', 'job': 'node'
-                            }}
-                        ]}})
-                ):
+            mock.patch.object(
+                prometheus_base.PrometheusBase,
+                '_setup_prometheus_client',
+                return_value=prometheus_client.PrometheusAPIClient(''),
+            ),
+            mock.patch.object(
+                prometheus_base.PrometheusBase,
+                '_get_fqdn_label',
+                return_value='fqdn',
+            ),
+            mock.patch.object(
+                prometheus_base.PrometheusBase,
+                '_get_instance_uuid_label',
+                return_value='resource',
+            ),
+            mock.patch.object(
+                prometheus_client.PrometheusAPIClient,
+                '_get',
+                return_value={
+                    'data': {
+                        'activeTargets': [
+                            {
+                                'labels': {
+                                    'fqdn': 'marios-env.controlplane.domain',
+                                    'instance': '10.0.1.2:9100',
+                                    'job': 'node',
+                                }
+                            },
+                            {
+                                'labels': {
+                                    'fqdn': 'marios-env-again.controlplane.domain',  # noqa: E501
+                                    'instance': 'localhost:9100',
+                                    'job': 'node',
+                                }
+                            },
+                        ]
+                    }
+                },
+            ),
+        ):
             self.helper = prometheus_base.PrometheusBase()
 
         self.helper._get_instance_uuid_label = mock.Mock(
-            return_value='resource')
-        self.helper._get_fqdn_label = mock.Mock(
-            return_value='fqdn')
+            return_value='resource'
+        )
+        self.helper._get_fqdn_label = mock.Mock(return_value='fqdn')
 
         stat_agg_patcher = mock.patch.object(
-            self.helper, 'statistic_aggregation',
-            spec=prometheus_base.PrometheusBase.statistic_aggregation)
+            self.helper,
+            'statistic_aggregation',
+            spec=prometheus_base.PrometheusBase.statistic_aggregation,
+        )
         self.mock_aggregation = stat_agg_patcher.start()
         self.addCleanup(stat_agg_patcher.stop)
         self.mock_instance = mock.Mock(
-            uuid='uuid-0',
-            memory=512,
-            disk=2,
-            vcpus=2)
+            uuid='uuid-0', memory=512, disk=2, vcpus=2
+        )
 
-    def _create_helper(self, fqdn_label='fqdn',
-                       instance_uuid_label='resource'):
+    def _create_helper(
+        self, fqdn_label='fqdn', instance_uuid_label='resource'
+    ):
         with (
-                mock.patch.object(
-                    prometheus_base.PrometheusBase, '_setup_prometheus_client',
-                    return_value=prometheus_client.PrometheusAPIClient('')
-                ),
-                mock.patch.object(
-                    prometheus_base.PrometheusBase,
-                    '_get_fqdn_label', return_value=fqdn_label
-                ),
-                mock.patch.object(
-                    prometheus_base.PrometheusBase,
-                    '_get_instance_uuid_label',
-                    return_value=instance_uuid_label
-                )):
+            mock.patch.object(
+                prometheus_base.PrometheusBase,
+                '_setup_prometheus_client',
+                return_value=prometheus_client.PrometheusAPIClient(''),
+            ),
+            mock.patch.object(
+                prometheus_base.PrometheusBase,
+                '_get_fqdn_label',
+                return_value=fqdn_label,
+            ),
+            mock.patch.object(
+                prometheus_base.PrometheusBase,
+                '_get_instance_uuid_label',
+                return_value=instance_uuid_label,
+            ),
+        ):
             helper = prometheus_base.PrometheusBase()
 
         helper._get_instance_uuid_label = mock.Mock(
-            return_value=instance_uuid_label)
-        helper._get_fqdn_label = mock.Mock(
-            return_value=fqdn_label)
+            return_value=instance_uuid_label
+        )
+        helper._get_fqdn_label = mock.Mock(return_value=fqdn_label)
         return helper
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_prometheus_statistic_aggregation(self, mock_prometheus_get,
-                                              mock_prometheus_query):
+    def test_prometheus_statistic_aggregation(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_node = mock.Mock(
-            uuid='1234',
-            hostname='marios-env.controlplane.domain')
+            uuid='1234', hostname='marios-env.controlplane.domain'
+        )
 
         expected_cpu_usage = 3.2706140350701673
 
         mock_prom_metric = mock.Mock(
             labels={'instance': '10.0.1.2:9100'},
             timestamp=1731065985.408,
-            value=expected_cpu_usage
+            value=expected_cpu_usage,
         )
 
         mock_prometheus_query.return_value = [mock_prom_metric]
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'fqdn': 'marios-env.controlplane.domain',
-                'instance': '10.0.1.2:9100', 'job': 'node',
-            }}]}}
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {
+                        'labels': {
+                            'fqdn': 'marios-env.controlplane.domain',
+                            'instance': '10.0.1.2:9100',
+                            'job': 'node',
+                        }
+                    }
+                ]
+            }
+        }
         helper = self._create_helper()
         result = helper.statistic_aggregation(
             resource=mock_node,
@@ -131,19 +162,21 @@ class TestPrometheusBase(base.BaseTestCase):
         mock_prometheus_query.assert_called_once_with(
             "100 - (avg by (fqdn)(rate(node_cpu_seconds_total"
             "{mode='idle',fqdn='marios-env.controlplane.domain'}[300s]))"
-            " * 100)")
+            " * 100)"
+        )
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_get_instance_cpu_usage(self, mock_prometheus_get,
-                                    mock_prometheus_query):
+    def test_get_instance_cpu_usage(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         expected_cpu_usage = 13.2706140350701673
 
         mock_prom_metric = mock.Mock(
             labels={'resource': 'uuid-0'},
             timestamp=1731065985.408,
-            value=expected_cpu_usage
+            value=expected_cpu_usage,
         )
         mock_prometheus_query.return_value = [mock_prom_metric]
         helper = self._create_helper()
@@ -154,60 +187,64 @@ class TestPrometheusBase(base.BaseTestCase):
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_get_instance_ram_usage(self, mock_prometheus_get,
-                                    mock_prometheus_query):
+    def test_get_instance_ram_usage(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         expected_ram_usage = 49.86
 
         mock_prom_metric = mock.Mock(
             labels={'resource': 'uuid-0'},
             timestamp=1731065985.408,
-            value=expected_ram_usage
+            value=expected_ram_usage,
         )
         mock_prometheus_query.return_value = [mock_prom_metric]
         helper = self._create_helper()
 
         ram_usage = helper.get_instance_ram_usage(
-            mock_instance, period=222, aggregate="max",
-            granularity=200)
+            mock_instance, period=222, aggregate="max", granularity=200
+        )
         self.assertIsInstance(ram_usage, float)
         self.assertEqual(expected_ram_usage, ram_usage)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_get_instance_ram_allocated(self, mock_prometheus_get,
-                                        mock_prometheus_query):
+    def test_get_instance_ram_allocated(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         helper = self._create_helper()
-        ram_allocated = helper.get_instance_ram_allocated(mock_instance,
-                                                          period=222,
-                                                          aggregate="max")
+        ram_allocated = helper.get_instance_ram_allocated(
+            mock_instance, period=222, aggregate="max"
+        )
         self.assertIsInstance(ram_allocated, float)
         self.assertEqual(512, ram_allocated)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_get_instance_root_disk_size(self, mock_prometheus_get,
-                                         mock_prometheus_query):
+    def test_get_instance_root_disk_size(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         helper = self._create_helper()
-        disk_size = helper.get_instance_root_disk_size(mock_instance,
-                                                       period=331,
-                                                       aggregate="avg")
+        disk_size = helper.get_instance_root_disk_size(
+            mock_instance, period=331, aggregate="avg"
+        )
         self.assertIsInstance(disk_size, float)
         self.assertEqual(2, disk_size)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_prometheus_stt_agg_instance_cpu_usage(self, mock_prometheus_get,
-                                                   mock_prometheus_query):
+    def test_prometheus_stt_agg_instance_cpu_usage(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         expected_cpu_usage = 13.2706140350701673
 
         mock_prom_metric = mock.Mock(
             labels={'resource': 'uuid-0'},
             timestamp=1731065985.408,
-            value=expected_cpu_usage
+            value=expected_cpu_usage,
         )
         mock_prometheus_query.return_value = [mock_prom_metric]
         helper = self._create_helper()
@@ -229,15 +266,16 @@ class TestPrometheusBase(base.BaseTestCase):
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_prometheus_stt_agg_instance_ram_usage(self, mock_prometheus_get,
-                                                   mock_prometheus_query):
+    def test_prometheus_stt_agg_instance_ram_usage(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         expected_ram_usage = 49.86
 
         mock_prom_metric = mock.Mock(
             labels={'resource': 'uuid-0'},
             timestamp=1731065985.408,
-            value=expected_ram_usage
+            value=expected_ram_usage,
         )
         mock_prometheus_query.return_value = [mock_prom_metric]
         helper = self._create_helper()
@@ -257,8 +295,9 @@ class TestPrometheusBase(base.BaseTestCase):
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_prometheus_stt_agg_instance_root_size(self, mock_prometheus_get,
-                                                   mock_prometheus_query):
+    def test_prometheus_stt_agg_instance_root_size(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         helper = self._create_helper()
         result_disk = helper.statistic_aggregation(
@@ -274,8 +313,9 @@ class TestPrometheusBase(base.BaseTestCase):
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, 'query')
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_prometheus_stt_agg_instance_ram_alloc(self, mock_prometheus_get,
-                                                   mock_prometheus_query):
+    def test_prometheus_stt_agg_instance_ram_alloc(
+        self, mock_prometheus_get, mock_prometheus_query
+    ):
         mock_instance = self.mock_instance
         helper = self._create_helper()
         result_memory = helper.statistic_aggregation(
@@ -291,21 +331,27 @@ class TestPrometheusBase(base.BaseTestCase):
 
     def test_statistic_aggregation_metric_unavailable(self):
         self.assertRaisesRegex(
-            NotImplementedError, 'does not support statistic_series',
-            self.helper.statistic_series
+            NotImplementedError,
+            'does not support statistic_series',
+            self.helper.statistic_series,
         )
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_prometheus_list_metrics(self, mock_prometheus_get):
         expected_metrics = {
-            'go_gc_duration_seconds', 'go_gc_duration_seconds_count',
-            'go_gc_duration_seconds_sum', 'go_goroutines'
+            'go_gc_duration_seconds',
+            'go_gc_duration_seconds_count',
+            'go_gc_duration_seconds_sum',
+            'go_goroutines',
         }
         mock_prometheus_get.return_value = {
-            'status': 'success', 'data': [
-                'go_gc_duration_seconds', 'go_gc_duration_seconds_count',
-                'go_gc_duration_seconds_sum', 'go_goroutines',
-            ]
+            'status': 'success',
+            'data': [
+                'go_gc_duration_seconds',
+                'go_gc_duration_seconds_count',
+                'go_gc_duration_seconds_sum',
+                'go_goroutines',
+            ],
         }
         result = self.helper.list_metrics()
         self.assertEqual(expected_metrics, result)
@@ -313,7 +359,8 @@ class TestPrometheusBase(base.BaseTestCase):
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_prometheus_list_metrics_error(self, mock_prometheus_get):
         mock_prometheus_get.side_effect = (
-            prometheus_client.PrometheusAPIClientError("nope"))
+            prometheus_client.PrometheusAPIClientError("nope")
+        )
         result = self.helper.list_metrics()
         self.assertEqual(set(), result)
 
@@ -323,12 +370,17 @@ class TestPrometheusBase(base.BaseTestCase):
             'status': 'success',
             'data': {
                 'startTime': '2024-11-05T12:59:56.962333207Z',
-                'CWD': '/prometheus', 'reloadConfigSuccess': True,
+                'CWD': '/prometheus',
+                'reloadConfigSuccess': True,
                 'lastConfigTime': '2024-11-05T12:59:56Z',
-                'corruptionCount': 0, 'goroutineCount': 30,
-                'GOMAXPROCS': 8, 'GOMEMLIMIT': 9223372036854775807,
-                'GOGC': '75', 'GODEBUG': '', 'storageRetention': '15d'
-            }
+                'corruptionCount': 0,
+                'goroutineCount': 30,
+                'GOMAXPROCS': 8,
+                'GOMEMLIMIT': 9223372036854775807,
+                'GOGC': '75',
+                'GODEBUG': '',
+                'storageRetention': '15d',
+            },
         }
         result = self.helper.check_availability()
         self.assertEqual('available', result)
@@ -336,7 +388,8 @@ class TestPrometheusBase(base.BaseTestCase):
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_prometheus_check_availability_error(self, mock_prometheus_get):
         mock_prometheus_get.side_effect = (
-            prometheus_client.PrometheusAPIClientError("nope"))
+            prometheus_client.PrometheusAPIClientError("nope")
+        )
         result = self.helper.check_availability()
         self.assertEqual('not available', result)
 
@@ -344,8 +397,13 @@ class TestPrometheusBase(base.BaseTestCase):
         cpu_use = self.helper.get_host_cpu_usage('someNode', 345, 'mean', 300)
         self.assertIsInstance(cpu_use, float)
         self.mock_aggregation.assert_called_once_with(
-            'someNode', 'compute_node', 'host_cpu_usage', period=345,
-            granularity=300, aggregate='mean')
+            'someNode',
+            'compute_node',
+            'host_cpu_usage',
+            period=345,
+            granularity=300,
+            aggregate='mean',
+        )
 
     def test_get_host_cpu_usage_none(self):
         self.mock_aggregation.return_value = None
@@ -356,23 +414,39 @@ class TestPrometheusBase(base.BaseTestCase):
         cpu_use = self.helper.get_host_cpu_usage('theNode', 223, 'max', 100)
         self.assertIsInstance(cpu_use, float)
         self.mock_aggregation.assert_called_once_with(
-            'theNode', 'compute_node', 'host_cpu_usage', period=223,
-            granularity=100, aggregate='min')
+            'theNode',
+            'compute_node',
+            'host_cpu_usage',
+            period=223,
+            granularity=100,
+            aggregate='min',
+        )
 
     def test_get_host_cpu_usage_min(self):
         cpu_use = self.helper.get_host_cpu_usage('theNode', 223, 'min', 100)
         self.assertIsInstance(cpu_use, float)
         self.mock_aggregation.assert_called_once_with(
-            'theNode', 'compute_node', 'host_cpu_usage', period=223,
-            granularity=100, aggregate='max')
+            'theNode',
+            'compute_node',
+            'host_cpu_usage',
+            period=223,
+            granularity=100,
+            aggregate='max',
+        )
 
     def test_get_host_ram_usage(self):
         ram_use = self.helper.get_host_ram_usage(
-            'anotherNode', 456, 'mean', 300)
+            'anotherNode', 456, 'mean', 300
+        )
         self.assertIsInstance(ram_use, float)
         self.mock_aggregation.assert_called_once_with(
-            'anotherNode', 'compute_node', 'host_ram_usage', period=456,
-            granularity=300, aggregate='mean')
+            'anotherNode',
+            'compute_node',
+            'host_ram_usage',
+            period=456,
+            granularity=300,
+            aggregate='mean',
+        )
 
     def test_get_host_ram_usage_none(self):
         self.mock_aggregation.return_value = None
@@ -380,171 +454,254 @@ class TestPrometheusBase(base.BaseTestCase):
         self.assertIsNone(ram_use, float)
         self.mock_aggregation.assert_called()
         self.mock_aggregation.assert_called_once_with(
-            'NOPE', 'compute_node', 'host_ram_usage', period=234,
-            granularity=567, aggregate='mean')
+            'NOPE',
+            'compute_node',
+            'host_ram_usage',
+            period=234,
+            granularity=567,
+            aggregate='mean',
+        )
 
     def test_get_host_ram_usage_max(self):
-        ram_use = self.helper.get_host_ram_usage(
-            'aNode', 456, 'max', 300)
+        ram_use = self.helper.get_host_ram_usage('aNode', 456, 'max', 300)
         self.assertIsInstance(ram_use, float)
         self.mock_aggregation.assert_called_once_with(
-            'aNode', 'compute_node', 'host_ram_usage', period=456,
-            granularity=300, aggregate='min')
+            'aNode',
+            'compute_node',
+            'host_ram_usage',
+            period=456,
+            granularity=300,
+            aggregate='min',
+        )
 
     def test_get_host_ram_usage_min(self):
-        ram_use = self.helper.get_host_ram_usage(
-            'aNode', 456, 'min', 300)
+        ram_use = self.helper.get_host_ram_usage('aNode', 456, 'min', 300)
         self.assertIsInstance(ram_use, float)
         self.mock_aggregation.assert_called_once_with(
-            'aNode', 'compute_node', 'host_ram_usage', period=456,
-            granularity=300, aggregate='max')
+            'aNode',
+            'compute_node',
+            'host_ram_usage',
+            period=456,
+            granularity=300,
+            aggregate='max',
+        )
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_build_prometheus_fqdn_host_instance_map(
-            self, mock_prometheus_get):
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'fqdn': 'foo.controlplane.domain',
-                'instance': '10.1.2.1:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'fqdn': 'bar.controlplane.domain',
-                'instance': '10.1.2.2:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'fqdn': 'baz.controlplane.domain',
-                'instance': '10.1.2.3:9100', 'job': 'node',
-            }},
-        ]}}
-        expected_fqdn_list = {'foo.controlplane.domain',
-                              'bar.controlplane.domain',
-                              'baz.controlplane.domain'}
-        expected_host_map = {'foo': 'foo.controlplane.domain',
-                             'bar': 'bar.controlplane.domain',
-                             'baz': 'baz.controlplane.domain'}
+        self, mock_prometheus_get
+    ):
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {
+                        'labels': {
+                            'fqdn': 'foo.controlplane.domain',
+                            'instance': '10.1.2.1:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'fqdn': 'bar.controlplane.domain',
+                            'instance': '10.1.2.2:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'fqdn': 'baz.controlplane.domain',
+                            'instance': '10.1.2.3:9100',
+                            'job': 'node',
+                        }
+                    },
+                ]
+            }
+        }
+        expected_fqdn_list = {
+            'foo.controlplane.domain',
+            'bar.controlplane.domain',
+            'baz.controlplane.domain',
+        }
+        expected_host_map = {
+            'foo': 'foo.controlplane.domain',
+            'bar': 'bar.controlplane.domain',
+            'baz': 'baz.controlplane.domain',
+        }
         helper = self._create_helper()
-        self.assertEqual(helper.prometheus_fqdn_labels,
-                         expected_fqdn_list)
-        self.assertEqual(helper.prometheus_host_instance_map,
-                         expected_host_map)
+        self.assertEqual(helper.prometheus_fqdn_labels, expected_fqdn_list)
+        self.assertEqual(
+            helper.prometheus_host_instance_map, expected_host_map
+        )
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_build_prometheus_fqdn_host_instance_map_dupl_fqdn(
-            self, mock_prometheus_get):
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'fqdn': 'foo.controlplane.domain',
-                'instance': '10.1.2.1:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'fqdn': 'foo.controlplane.domain',
-                'instance': '10.1.2.1:9229', 'job': 'podman',
-            }},
-            {'labels': {
-                'fqdn': 'bar.controlplane.domain',
-                'instance': '10.1.2.2:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'fqdn': 'baz.controlplane.domain',
-                'instance': '10.1.2.3:9100', 'job': 'node',
-            }},
-        ]}}
-        expected_fqdn_list = {'foo.controlplane.domain',
-                              'bar.controlplane.domain',
-                              'baz.controlplane.domain'}
-        expected_host_map = {'foo': 'foo.controlplane.domain',
-                             'bar': 'bar.controlplane.domain',
-                             'baz': 'baz.controlplane.domain'}
+        self, mock_prometheus_get
+    ):
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {
+                        'labels': {
+                            'fqdn': 'foo.controlplane.domain',
+                            'instance': '10.1.2.1:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'fqdn': 'foo.controlplane.domain',
+                            'instance': '10.1.2.1:9229',
+                            'job': 'podman',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'fqdn': 'bar.controlplane.domain',
+                            'instance': '10.1.2.2:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'fqdn': 'baz.controlplane.domain',
+                            'instance': '10.1.2.3:9100',
+                            'job': 'node',
+                        }
+                    },
+                ]
+            }
+        }
+        expected_fqdn_list = {
+            'foo.controlplane.domain',
+            'bar.controlplane.domain',
+            'baz.controlplane.domain',
+        }
+        expected_host_map = {
+            'foo': 'foo.controlplane.domain',
+            'bar': 'bar.controlplane.domain',
+            'baz': 'baz.controlplane.domain',
+        }
         helper = self._create_helper()
-        self.assertEqual(helper.prometheus_fqdn_labels,
-                         expected_fqdn_list)
-        self.assertEqual(helper.prometheus_host_instance_map,
-                         expected_host_map)
+        self.assertEqual(helper.prometheus_fqdn_labels, expected_fqdn_list)
+        self.assertEqual(
+            helper.prometheus_host_instance_map, expected_host_map
+        )
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_missing_prometheus_fqdn_label(self, mock_prometheus_get):
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'instance': '10.1.2.1:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'instance': '10.1.2.2:9100', 'job': 'node',
-            }},
-        ]}}
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {'labels': {'instance': '10.1.2.1:9100', 'job': 'node'}},
+                    {'labels': {'instance': '10.1.2.2:9100', 'job': 'node'}},
+                ]
+            }
+        }
         helper = self._create_helper()
         self.assertEqual(set(), helper.prometheus_fqdn_labels)
         self.assertEqual({}, helper.prometheus_host_instance_map)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_using_hostnames_not_fqdn(self, mock_prometheus_get):
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'fqdn': 'ena',
-                'instance': '10.1.2.1:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'fqdn': 'dyo',
-                'instance': '10.1.2.2:9100', 'job': 'node',
-            }},
-        ]}}
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {
+                        'labels': {
+                            'fqdn': 'ena',
+                            'instance': '10.1.2.1:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'fqdn': 'dyo',
+                            'instance': '10.1.2.2:9100',
+                            'job': 'node',
+                        }
+                    },
+                ]
+            }
+        }
         helper = self._create_helper()
         expected_fqdn_list = {'ena', 'dyo'}
-        self.assertEqual(
-            helper.prometheus_fqdn_labels, expected_fqdn_list)
+        self.assertEqual(helper.prometheus_fqdn_labels, expected_fqdn_list)
         self.assertEqual({}, helper.prometheus_host_instance_map)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_using_ips_not_fqdn(self, mock_prometheus_get):
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'ip_label': '10.1.2.1',
-                'instance': '10.1.2.1:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'ip_label': '10.1.2.2',
-                'instance': '10.1.2.2:9100', 'job': 'node',
-            }},
-        ]}}
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {
+                        'labels': {
+                            'ip_label': '10.1.2.1',
+                            'instance': '10.1.2.1:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'ip_label': '10.1.2.2',
+                            'instance': '10.1.2.2:9100',
+                            'job': 'node',
+                        }
+                    },
+                ]
+            }
+        }
         helper = self._create_helper(fqdn_label='ip_label')
         expected_fqdn_list = {'10.1.2.1', '10.1.2.2'}
-        self.assertEqual(
-            helper.prometheus_fqdn_labels, expected_fqdn_list)
+        self.assertEqual(helper.prometheus_fqdn_labels, expected_fqdn_list)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
     def test_override_prometheus_fqdn_label(self, mock_prometheus_get):
-        mock_prometheus_get.return_value = {'data': {'activeTargets': [
-            {'labels': {
-                'custom_fqdn_label': 'foo.controlplane.domain',
-                'instance': '10.1.2.1:9100', 'job': 'node',
-            }},
-            {'labels': {
-                'custom_fqdn_label': 'bar.controlplane.domain',
-                'instance': '10.1.2.2:9100', 'job': 'node',
-            }},
-        ]}}
-        expected_fqdn_list = {'foo.controlplane.domain',
-                              'bar.controlplane.domain'}
-        expected_host_map = {'foo': 'foo.controlplane.domain',
-                             'bar': 'bar.controlplane.domain'}
+        mock_prometheus_get.return_value = {
+            'data': {
+                'activeTargets': [
+                    {
+                        'labels': {
+                            'custom_fqdn_label': 'foo.controlplane.domain',
+                            'instance': '10.1.2.1:9100',
+                            'job': 'node',
+                        }
+                    },
+                    {
+                        'labels': {
+                            'custom_fqdn_label': 'bar.controlplane.domain',
+                            'instance': '10.1.2.2:9100',
+                            'job': 'node',
+                        }
+                    },
+                ]
+            }
+        }
+        expected_fqdn_list = {
+            'foo.controlplane.domain',
+            'bar.controlplane.domain',
+        }
+        expected_host_map = {
+            'foo': 'foo.controlplane.domain',
+            'bar': 'bar.controlplane.domain',
+        }
         helper = self._create_helper(fqdn_label='custom_fqdn_label')
-        self.assertEqual(helper.prometheus_fqdn_labels,
-                         expected_fqdn_list)
-        self.assertEqual(helper.prometheus_host_instance_map,
-                         expected_host_map)
+        self.assertEqual(helper.prometheus_fqdn_labels, expected_fqdn_list)
+        self.assertEqual(
+            helper.prometheus_host_instance_map, expected_host_map
+        )
 
     def test_resolve_prometheus_instance_label(self):
         expected_instance_label = 'marios-env.controlplane.domain'
         result = self.helper._resolve_prometheus_instance_label(
-            'marios-env.controlplane.domain')
+            'marios-env.controlplane.domain'
+        )
         self.assertEqual(result, expected_instance_label)
 
-        result = self.helper._resolve_prometheus_instance_label(
-            'marios-env')
+        result = self.helper._resolve_prometheus_instance_label('marios-env')
         self.assertEqual(result, expected_instance_label)
 
     @mock.patch.object(prometheus_client.PrometheusAPIClient, '_get')
-    def test_resolve_prometheus_instance_label_none(self,
-                                                    mock_prometheus_get):
+    def test_resolve_prometheus_instance_label_none(self, mock_prometheus_get):
         mock_prometheus_get.return_value = {'data': {'activeTargets': []}}
         result = self.helper._resolve_prometheus_instance_label('nope')
         self.assertIsNone(result)
@@ -553,44 +710,54 @@ class TestPrometheusBase(base.BaseTestCase):
     def test_build_prometheus_query_node_cpu_avg_agg(self):
         expected_query = (
             "100 - (avg by (fqdn)(rate(node_cpu_seconds_total"
-            "{mode='idle',fqdn='a_host'}[111s])) * 100)")
+            "{mode='idle',fqdn='a_host'}[111s])) * 100)"
+        )
         result = self.helper._build_prometheus_query(
-            'avg', 'node_cpu_seconds_total', 'a_host', '111')
+            'avg', 'node_cpu_seconds_total', 'a_host', '111'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_node_cpu_max_agg(self):
         expected_query = (
             "100 - (max by (fqdn)(rate(node_cpu_seconds_total"
-            "{mode='idle',fqdn='b_host'}[444s])) * 100)")
+            "{mode='idle',fqdn='b_host'}[444s])) * 100)"
+        )
         result = self.helper._build_prometheus_query(
-            'max', 'node_cpu_seconds_total', 'b_host', '444')
+            'max', 'node_cpu_seconds_total', 'b_host', '444'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_node_memory_avg_agg(self):
         expected_query = (
             "(node_memory_MemTotal_bytes{fqdn='c_host'} - avg_over_time"
             "(node_memory_MemAvailable_bytes{fqdn='c_host'}[555s])) "
-            "/ 1024")
+            "/ 1024"
+        )
         result = self.helper._build_prometheus_query(
-            'avg', 'node_memory_MemAvailable_bytes', 'c_host', '555')
+            'avg', 'node_memory_MemAvailable_bytes', 'c_host', '555'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_node_memory_min_agg(self):
         expected_query = (
             "(node_memory_MemTotal_bytes{fqdn='d_host'} - min_over_time"
             "(node_memory_MemAvailable_bytes{fqdn='d_host'}[222s])) "
-            "/ 1024")
+            "/ 1024"
+        )
         result = self.helper._build_prometheus_query(
-            'min', 'node_memory_MemAvailable_bytes', 'd_host', '222')
+            'min', 'node_memory_MemAvailable_bytes', 'd_host', '222'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_node_cpu_avg_agg_custom_label(self):
         self.helper.prometheus_fqdn_label = 'custom_fqdn_label'
         expected_query = (
             "100 - (avg by (custom_fqdn_label)(rate(node_cpu_seconds_total"
-            "{mode='idle',custom_fqdn_label='a_host'}[111s])) * 100)")
+            "{mode='idle',custom_fqdn_label='a_host'}[111s])) * 100)"
+        )
         result = self.helper._build_prometheus_query(
-            'avg', 'node_cpu_seconds_total', 'a_host', '111')
+            'avg', 'node_cpu_seconds_total', 'a_host', '111'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_node_memory_min_agg_custom_label(self):
@@ -598,9 +765,11 @@ class TestPrometheusBase(base.BaseTestCase):
         expected_query = (
             "(node_memory_MemTotal_bytes{custom_fqdn='d_host'} - min_over_time"
             "(node_memory_MemAvailable_bytes{custom_fqdn='d_host'}[222s])) "
-            "/ 1024")
+            "/ 1024"
+        )
         result = self.helper._build_prometheus_query(
-            'min', 'node_memory_MemAvailable_bytes', 'd_host', '222')
+            'min', 'node_memory_MemAvailable_bytes', 'd_host', '222'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_instance_memory_avg_agg(self):
@@ -608,7 +777,8 @@ class TestPrometheusBase(base.BaseTestCase):
             "avg_over_time(ceilometer_memory_usage{resource='uuid-0'}[555s])"
         )
         result = self.helper._build_prometheus_query(
-            'avg', 'ceilometer_memory_usage', 'uuid-0', '555')
+            'avg', 'ceilometer_memory_usage', 'uuid-0', '555'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_instance_memory_min_agg(self):
@@ -616,7 +786,8 @@ class TestPrometheusBase(base.BaseTestCase):
             "min_over_time(ceilometer_memory_usage{resource='uuid-0'}[222s])"
         )
         result = self.helper._build_prometheus_query(
-            'min', 'ceilometer_memory_usage', 'uuid-0', '222')
+            'min', 'ceilometer_memory_usage', 'uuid-0', '222'
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_instance_cpu_avg_agg(self):
@@ -626,8 +797,12 @@ class TestPrometheusBase(base.BaseTestCase):
             "/10e+8) *(100/2), 100)"
         )
         result = self.helper._build_prometheus_query(
-            'avg', 'ceilometer_cpu', 'uuid-0', '222',
-            resource=self.mock_instance)
+            'avg',
+            'ceilometer_cpu',
+            'uuid-0',
+            '222',
+            resource=self.mock_instance,
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_instance_cpu_max_agg(self):
@@ -636,25 +811,30 @@ class TestPrometheusBase(base.BaseTestCase):
             "ceilometer_cpu{resource='uuid-0'}[555s]))"
             "/10e+8) *(100/4), 100)"
         )
-        mock_instance = mock.Mock(
-            uuid='uuid-0',
-            memory=512,
-            disk=2,
-            vcpus=4)
+        mock_instance = mock.Mock(uuid='uuid-0', memory=512, disk=2, vcpus=4)
         result = self.helper._build_prometheus_query(
-            'max', 'ceilometer_cpu', 'uuid-0', '555', resource=mock_instance)
+            'max', 'ceilometer_cpu', 'uuid-0', '555', resource=mock_instance
+        )
         self.assertEqual(result, expected_query)
 
     def test_build_prometheus_query_error(self):
         self.assertRaisesRegex(
-            exception.InvalidParameter, 'Cannot process prometheus meter NOPE',
+            exception.InvalidParameter,
+            'Cannot process prometheus meter NOPE',
             self.helper._build_prometheus_query,
-            'min', 'NOPE', 'the_host', '222'
+            'min',
+            'NOPE',
+            'the_host',
+            '222',
         )
         self.assertRaisesRegex(
-            exception.InvalidParameter, 'instance_label None, period 333',
+            exception.InvalidParameter,
+            'instance_label None, period 333',
             self.helper._build_prometheus_query,
-            'min', 'node_cpu_seconds_total', None, '333'
+            'min',
+            'node_cpu_seconds_total',
+            None,
+            '333',
         )
 
     def test_resolve_prometheus_aggregate_vanilla(self):
@@ -669,8 +849,12 @@ class TestPrometheusBase(base.BaseTestCase):
 
     def test_resolve_prometheus_aggregate_unknown(self):
         self.assertRaisesRegex(
-            exception.InvalidParameter, 'Unknown Watcher aggregate NOPE.',
-            self.helper._resolve_prometheus_aggregate, 'NOPE', 'some_meter')
+            exception.InvalidParameter,
+            'Unknown Watcher aggregate NOPE.',
+            self.helper._resolve_prometheus_aggregate,
+            'NOPE',
+            'some_meter',
+        )
 
     def test_prometheus_query_custom_uuid_label(self):
         self.helper._get_instance_uuid_label.return_value = 'custom_uuid_label'
@@ -680,11 +864,8 @@ class TestPrometheusBase(base.BaseTestCase):
             "(rate(ceilometer_cpu{custom_uuid_label='uuid-0'}[555s]))"
             "/10e+8) *(100/4), 100)"
         )
-        mock_instance = mock.Mock(
-            uuid='uuid-0',
-            memory=512,
-            disk=2,
-            vcpus=4)
+        mock_instance = mock.Mock(uuid='uuid-0', memory=512, disk=2, vcpus=4)
         result = self.helper._build_prometheus_query(
-            'max', 'ceilometer_cpu', 'uuid-0', '555', resource=mock_instance)
+            'max', 'ceilometer_cpu', 'uuid-0', '555', resource=mock_instance
+        )
         self.assertEqual(result, expected_query)
diff --git a/watcher/tests/unit/decision_engine/datasources/test_prometheus_helper.py b/watcher/tests/unit/decision_engine/datasources/test_prometheus_helper.py
index 773ba5033..0d2c12842 100644
--- a/watcher/tests/unit/decision_engine/datasources/test_prometheus_helper.py
+++ b/watcher/tests/unit/decision_engine/datasources/test_prometheus_helper.py
@@ -29,33 +29,37 @@ class TestPrometheusHelper(base.BaseTestCase):
         cfg.CONF.prometheus_client.port = 9090
 
         with mock.patch.object(
-            prometheus_helper.PrometheusHelper,
-            '_setup_prometheus_client'
+            prometheus_helper.PrometheusHelper, '_setup_prometheus_client'
         ):
             self.helper = prometheus_helper.PrometheusHelper()
 
         # Set up patches for all methods used inside the
         # _setup_prometheus_client
         self.mock_init = mock.patch.object(
-            prometheus_client.PrometheusAPIClient, '__init__',
-            return_value=None).start()
+            prometheus_client.PrometheusAPIClient,
+            '__init__',
+            return_value=None,
+        ).start()
         self.addCleanup(self.mock_init.stop)
 
         self.mock_set_ca_cert = mock.patch.object(
-            prometheus_client.PrometheusAPIClient, 'set_ca_cert').start()
+            prometheus_client.PrometheusAPIClient, 'set_ca_cert'
+        ).start()
         self.addCleanup(self.mock_set_ca_cert.stop)
 
         self.mock_set_client_cert = mock.patch.object(
-            prometheus_client.PrometheusAPIClient, 'set_client_cert').start()
+            prometheus_client.PrometheusAPIClient, 'set_client_cert'
+        ).start()
         self.addCleanup(self.mock_set_client_cert.stop)
 
         self.mock_set_basic_auth = mock.patch.object(
-            prometheus_client.PrometheusAPIClient, 'set_basic_auth').start()
+            prometheus_client.PrometheusAPIClient, 'set_basic_auth'
+        ).start()
         self.addCleanup(self.mock_set_basic_auth.stop)
 
         self.mock_build_fqdn_labels = mock.patch.object(
-            prometheus_helper.PrometheusHelper,
-            '_build_prometheus_fqdn_labels').start()
+            prometheus_helper.PrometheusHelper, '_build_prometheus_fqdn_labels'
+        ).start()
         self.addCleanup(self.mock_build_fqdn_labels.stop)
 
     def test_unset_missing_prometheus_host(self):
@@ -63,24 +67,18 @@ class TestPrometheusHelper(base.BaseTestCase):
         self.assertRaisesRegex(
             exception.MissingParameter,
             'prometheus host must be set in watcher.conf',
-            prometheus_helper.PrometheusHelper
+            prometheus_helper.PrometheusHelper,
         )
 
     def test_get_fqdn_label(self):
         fqdn = 'fqdn_label'
         cfg.CONF.prometheus_client.fqdn_label = fqdn
-        self.assertEqual(
-            fqdn,
-            self.helper._get_fqdn_label()
-        )
+        self.assertEqual(fqdn, self.helper._get_fqdn_label())
 
     def test_get_instance_uuid_label(self):
         instance_uuid = 'instance_uuid_label'
         cfg.CONF.prometheus_client.instance_uuid_label = instance_uuid
-        self.assertEqual(
-            instance_uuid,
-            self.helper._get_instance_uuid_label()
-        )
+        self.assertEqual(instance_uuid, self.helper._get_instance_uuid_label())
 
     def test_setup_prometheus_client_no_auth_no_tls(self):
         cfg.CONF.prometheus_client.host = "somehost"
@@ -112,4 +110,5 @@ class TestPrometheusHelper(base.BaseTestCase):
         prometheus_helper.PrometheusHelper()
 
         self.mock_set_client_cert.assert_called_once_with(
-            "/cert/path", "/key/path")
+            "/cert/path", "/key/path"
+        )
diff --git a/watcher/tests/unit/decision_engine/fake_goals.py b/watcher/tests/unit/decision_engine/fake_goals.py
index d6291a5da..eb6bc8e4c 100644
--- a/watcher/tests/unit/decision_engine/fake_goals.py
+++ b/watcher/tests/unit/decision_engine/fake_goals.py
@@ -20,7 +20,6 @@ from watcher.decision_engine.goal.efficacy import specs
 
 
 class FakeGoal(base_goal.Goal):
-
     NAME = NotImplemented
     DISPLAY_NAME = NotImplemented
 
@@ -44,22 +43,14 @@ class FakeGoal(base_goal.Goal):
 
 class DummyIndicator(indicators.IndicatorSpecification):
     def __init__(self):
-        super().__init__(
-            name="dummy",
-            description="Dummy indicator",
-            unit="%",
-        )
+        super().__init__(name="dummy", description="Dummy indicator", unit="%")
 
     @property
     def schema(self):
-        return {
-            "type": "integer",
-            "minimum": 0
-            }
+        return {"type": "integer", "minimum": 0}
 
 
 class DummySpec1(efficacy_base.EfficacySpecification):
-
     def get_indicators_specifications(self):
         return [DummyIndicator()]
 
diff --git a/watcher/tests/unit/decision_engine/fake_metal_helper.py b/watcher/tests/unit/decision_engine/fake_metal_helper.py
index 45a52d9ee..f6b173cd1 100644
--- a/watcher/tests/unit/decision_engine/fake_metal_helper.py
+++ b/watcher/tests/unit/decision_engine/fake_metal_helper.py
@@ -20,11 +20,13 @@ from unittest import mock
 from watcher.common.metal_helper import constants as m_constants
 
 
-def get_mock_metal_node(node_id=None,
-                        power_state=m_constants.PowerState.ON,
-                        running_vms=0,
-                        hostname=None,
-                        compute_state='up'):
+def get_mock_metal_node(
+    node_id=None,
+    power_state=m_constants.PowerState.ON,
+    running_vms=0,
+    hostname=None,
+    compute_state='up',
+):
     node_id = node_id or str(uuid.uuid4())
     # NOTE(lpetrut): the hostname is important for some of the tests,
     # which expect it to match the fake cluster model.
@@ -33,9 +35,7 @@ def get_mock_metal_node(node_id=None,
     hypervisor_node_dict = {
         'hypervisor_hostname': hostname,
         'running_vms': running_vms,
-        'service': {
-            'host': hostname,
-        },
+        'service': {'host': hostname},
         'state': compute_state,
     }
     hypervisor_node = mock.Mock(**hypervisor_node_dict)
diff --git a/watcher/tests/unit/decision_engine/fake_strategies.py b/watcher/tests/unit/decision_engine/fake_strategies.py
index 87725f2e2..478a0da82 100644
--- a/watcher/tests/unit/decision_engine/fake_strategies.py
+++ b/watcher/tests/unit/decision_engine/fake_strategies.py
@@ -19,7 +19,6 @@ from watcher.decision_engine.strategy.strategies import base as base_strategy
 
 
 class FakeStrategy(base_strategy.BaseStrategy):
-
     NAME = NotImplemented
     DISPLAY_NAME = NotImplemented
     GOAL_NAME = NotImplemented
@@ -61,9 +60,7 @@ class FakeDummy1Strategy1(FakeStrategy):
 
     @classmethod
     def get_config_opts(cls):
-        return [
-            cfg.StrOpt('test_opt', help="Option used for testing."),
-        ]
+        return [cfg.StrOpt('test_opt', help="Option used for testing.")]
 
 
 class FakeDummy1Strategy2(FakeStrategy):
diff --git a/watcher/tests/unit/decision_engine/loading/test_collector_loader.py b/watcher/tests/unit/decision_engine/loading/test_collector_loader.py
index 2806644e2..e5345bd4d 100644
--- a/watcher/tests/unit/decision_engine/loading/test_collector_loader.py
+++ b/watcher/tests/unit/decision_engine/loading/test_collector_loader.py
@@ -27,16 +27,17 @@ from watcher.tests.unit.decision_engine.model import faker_cluster_state
 
 
 class TestClusterDataModelCollectorLoader(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.useFixture(conf_fixture.ConfReloadFixture())
         self.collector_loader = (
-            default_loading.ClusterDataModelCollectorLoader())
+            default_loading.ClusterDataModelCollectorLoader()
+        )
 
     def test_load_collector_with_empty_model(self):
         self.assertRaises(
-            exception.LoadingError, self.collector_loader.load, None)
+            exception.LoadingError, self.collector_loader.load, None
+        )
 
     def test_collector_loader(self):
         fake_driver = "fake"
@@ -46,31 +47,37 @@ class TestClusterDataModelCollectorLoader(base.TestCase):
                 name=fake_driver,
                 entry_point=(
                     f"{faker_cluster_state.FakerModelCollector.__module__}:"
-                    f"{faker_cluster_state.FakerModelCollector.__name__}"),
+                    f"{faker_cluster_state.FakerModelCollector.__name__}"
+                ),
                 plugin=faker_cluster_state.FakerModelCollector,
                 obj=None,
             ),
             namespace="watcher_cluster_data_model_collectors",
         )
 
-        with mock.patch.object(drivermanager,
-                               "DriverManager") as m_driver_manager:
+        with mock.patch.object(
+            drivermanager, "DriverManager"
+        ) as m_driver_manager:
             m_driver_manager.return_value = fake_driver_call
             loaded_collector = self.collector_loader.load("fake")
 
         self.assertIsInstance(
-            loaded_collector, faker_cluster_state.FakerModelCollector)
+            loaded_collector, faker_cluster_state.FakerModelCollector
+        )
 
 
 class TestLoadClusterDataModelCollectors(base.TestCase):
-
     collector_loader = default_loading.ClusterDataModelCollectorLoader()
 
     scenarios = [
-        (collector_name,
-         {"collector_name": collector_name, "collector_cls": collector_cls})
-        for collector_name, collector_cls
-        in collector_loader.list_available().items()]
+        (
+            collector_name,
+            {"collector_name": collector_name, "collector_cls": collector_cls},
+        )
+        for collector_name, collector_cls in (
+            collector_loader.list_available().items()
+        )
+    ]
 
     def setUp(self):
         super().setUp()
diff --git a/watcher/tests/unit/decision_engine/loading/test_default_strategy_loader.py b/watcher/tests/unit/decision_engine/loading/test_default_strategy_loader.py
index d6307b638..db0fd417b 100644
--- a/watcher/tests/unit/decision_engine/loading/test_default_strategy_loader.py
+++ b/watcher/tests/unit/decision_engine/loading/test_default_strategy_loader.py
@@ -24,34 +24,36 @@ from watcher.tests.unit import base
 
 
 class TestDefaultStrategyLoader(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.strategy_loader = default_loading.DefaultStrategyLoader()
 
     def test_load_strategy_with_empty_model(self):
         self.assertRaises(
-            exception.LoadingError, self.strategy_loader.load, None)
+            exception.LoadingError, self.strategy_loader.load, None
+        )
 
     def test_strategy_loader(self):
         dummy_strategy_name = "dummy"
         # Set up the fake Stevedore extensions
         fake_extmanager_call = extension.ExtensionManager.make_test_instance(
-            extensions=[extension.Extension(
-                name=dummy_strategy_name,
-                entry_point=(
-                    f"{dummy_strategy.DummyStrategy.__module__}:"
-                    f"{dummy_strategy.DummyStrategy.__name__}"),
-                plugin=dummy_strategy.DummyStrategy,
-                obj=None,
-            )],
+            extensions=[
+                extension.Extension(
+                    name=dummy_strategy_name,
+                    entry_point=(
+                        f"{dummy_strategy.DummyStrategy.__module__}:"
+                        f"{dummy_strategy.DummyStrategy.__name__}"
+                    ),
+                    plugin=dummy_strategy.DummyStrategy,
+                    obj=None,
+                )
+            ],
             namespace="watcher_strategies",
         )
 
         with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
             m_ext_manager.return_value = fake_extmanager_call
-            loaded_strategy = self.strategy_loader.load(
-                "dummy")
+            loaded_strategy = self.strategy_loader.load("dummy")
 
         self.assertEqual("dummy", loaded_strategy.name)
         self.assertEqual("Dummy strategy", loaded_strategy.display_name)
@@ -63,14 +65,17 @@ class TestDefaultStrategyLoader(base.TestCase):
 
 
 class TestLoadStrategiesWithDefaultStrategyLoader(base.TestCase):
-
     strategy_loader = default_loading.DefaultStrategyLoader()
 
     scenarios = [
-        (strategy_name,
-         {"strategy_name": strategy_name, "strategy_cls": strategy_cls})
-        for strategy_name, strategy_cls
-        in strategy_loader.list_available().items()]
+        (
+            strategy_name,
+            {"strategy_name": strategy_name, "strategy_cls": strategy_cls},
+        )
+        for strategy_name, strategy_cls in (
+            strategy_loader.list_available().items()
+        )
+    ]
 
     def test_load_strategies(self):
         strategy = self.strategy_loader.load(self.strategy_name)
diff --git a/watcher/tests/unit/decision_engine/loading/test_goal_loader.py b/watcher/tests/unit/decision_engine/loading/test_goal_loader.py
index 6f53e8c24..f63623695 100644
--- a/watcher/tests/unit/decision_engine/loading/test_goal_loader.py
+++ b/watcher/tests/unit/decision_engine/loading/test_goal_loader.py
@@ -24,25 +24,25 @@ from watcher.tests.unit import base
 
 
 class TestDefaultGoalLoader(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.goal_loader = default_loading.DefaultGoalLoader()
 
     def test_load_goal_with_empty_model(self):
-        self.assertRaises(
-            exception.LoadingError, self.goal_loader.load, None)
+        self.assertRaises(exception.LoadingError, self.goal_loader.load, None)
 
     def test_goal_loader(self):
         dummy_goal_name = "dummy"
         # Set up the fake Stevedore extensions
         fake_extmanager_call = extension.ExtensionManager.make_test_instance(
-            extensions=[extension.Extension(
-                name=dummy_goal_name,
-                entry_point=f"{goals.Dummy.__module__}:{goals.Dummy.__name__}",
-                plugin=goals.Dummy,
-                obj=None,
-            )],
+            extensions=[
+                extension.Extension(
+                    name=dummy_goal_name,
+                    entry_point=f"{goals.Dummy.__module__}:{goals.Dummy.__name__}",
+                    plugin=goals.Dummy,
+                    obj=None,
+                )
+            ],
             namespace="watcher_goals",
         )
 
@@ -60,15 +60,13 @@ class TestDefaultGoalLoader(base.TestCase):
 
 
 class TestLoadGoalsWithDefaultGoalLoader(base.TestCase):
-
     goal_loader = default_loading.DefaultGoalLoader()
 
     # test matrix (1 test execution per goal entry point)
     scenarios = [
-        (goal_name,
-         {"goal_name": goal_name, "goal_cls": goal_cls})
-        for goal_name, goal_cls
-        in goal_loader.list_available().items()]
+        (goal_name, {"goal_name": goal_name, "goal_cls": goal_cls})
+        for goal_name, goal_cls in goal_loader.list_available().items()
+    ]
 
     def test_load_goals(self):
         goal = self.goal_loader.load(self.goal_name)
diff --git a/watcher/tests/unit/decision_engine/messaging/test_audit_endpoint.py b/watcher/tests/unit/decision_engine/messaging/test_audit_endpoint.py
index 12041d7f5..c9162df86 100644
--- a/watcher/tests/unit/decision_engine/messaging/test_audit_endpoint.py
+++ b/watcher/tests/unit/decision_engine/messaging/test_audit_endpoint.py
@@ -29,10 +29,11 @@ class TestAuditEndpoint(base.DbTestCase):
         super().setUp()
         self.goal = obj_utils.create_test_goal(self.context)
         self.audit_template = obj_utils.create_test_audit_template(
-            self.context)
+            self.context
+        )
         self.audit = obj_utils.create_test_audit(
-            self.context,
-            audit_template_id=self.audit_template.id)
+            self.context, audit_template_id=self.audit_template.id
+        )
 
     @mock.patch.object(continuous_handler.ContinuousAuditHandler, 'start')
     @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector")
@@ -42,8 +43,9 @@ class TestAuditEndpoint(base.DbTestCase):
         audit_handler = oneshot_handler.OneShotAuditHandler
         endpoint = audit_endpoint.AuditEndpoint(audit_handler)
 
-        with mock.patch.object(oneshot_handler.OneShotAuditHandler,
-                               'execute') as mock_call:
+        with mock.patch.object(
+            oneshot_handler.OneShotAuditHandler, 'execute'
+        ) as mock_call:
             mock_call.return_value = 0
             endpoint.do_trigger_audit(self.context, self.audit.uuid)
 
@@ -58,9 +60,9 @@ class TestAuditEndpoint(base.DbTestCase):
         endpoint = audit_endpoint.AuditEndpoint(audit_handler)
 
         with mock.patch.object(endpoint.executor, 'submit') as mock_call:
-            mock_execute = mock.call(endpoint.do_trigger_audit,
-                                     self.context,
-                                     self.audit.uuid)
+            mock_execute = mock.call(
+                endpoint.do_trigger_audit, self.context, self.audit.uuid
+            )
             endpoint.trigger_audit(self.context, self.audit.uuid)
 
         mock_call.assert_has_calls([mock_execute])
diff --git a/watcher/tests/unit/decision_engine/messaging/test_data_model_endpoint.py b/watcher/tests/unit/decision_engine/messaging/test_data_model_endpoint.py
index 4c68c4d7e..06f018339 100644
--- a/watcher/tests/unit/decision_engine/messaging/test_data_model_endpoint.py
+++ b/watcher/tests/unit/decision_engine/messaging/test_data_model_endpoint.py
@@ -33,8 +33,8 @@ class TestDataModelEndpoint(unittest.TestCase):
         audit_uuid = utils.generate_uuid()
 
         result = self.endpoint_instance.get_audit_scope(
-            context=None,
-            audit=audit_uuid)
+            context=None, audit=audit_uuid
+        )
         self.assertEqual('fake_scope', result)
 
     @mock.patch.object(audit.Audit, 'get_by_name')
@@ -46,7 +46,8 @@ class TestDataModelEndpoint(unittest.TestCase):
             exception.InvalidIdentity,
             self.endpoint_instance.get_audit_scope,
             context=None,
-            audit=audit_name)
+            audit=audit_name,
+        )
 
     @mock.patch.object(manager, 'CollectorManager', mock.Mock())
     def test_get_data_model_info(self):
diff --git a/watcher/tests/unit/decision_engine/model/faker_cluster_and_metrics.py b/watcher/tests/unit/decision_engine/model/faker_cluster_and_metrics.py
index 58a15612a..5cad95e12 100644
--- a/watcher/tests/unit/decision_engine/model/faker_cluster_and_metrics.py
+++ b/watcher/tests/unit/decision_engine/model/faker_cluster_and_metrics.py
@@ -25,7 +25,6 @@ from watcher.decision_engine.model.collector import base
 
 
 class FakerModelCollector(base.BaseClusterDataModelCollector):
-
     def __init__(self, config=None, osc=None, audit_scope=None):
         if config is None:
             config = mock.Mock()
@@ -83,27 +82,39 @@ class FakeGnocchiMetrics:
     def __init__(self, model):
         self.model = model
 
-    def mock_get_statistics(self, resource=None, resource_type=None,
-                            meter_name=None, period=300, aggregate='mean',
-                            granularity=300):
+    def mock_get_statistics(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=300,
+        aggregate='mean',
+        granularity=300,
+    ):
         if meter_name == 'host_cpu_usage':
             return self.get_compute_node_cpu_util(
-                resource, period, aggregate, granularity)
+                resource, period, aggregate, granularity
+            )
         elif meter_name == 'host_ram_usage':
             return self.get_compute_node_ram_util(
-                resource, period, aggregate, granularity)
+                resource, period, aggregate, granularity
+            )
         elif meter_name == 'instance_cpu_usage':
             return self.get_instance_cpu_util(
-                resource, period, aggregate, granularity)
+                resource, period, aggregate, granularity
+            )
         elif meter_name == 'instance_ram_usage':
             return self.get_instance_ram_util(
-                resource, period, aggregate, granularity)
+                resource, period, aggregate, granularity
+            )
         elif meter_name == 'instance_root_disk_size':
             return self.get_instance_disk_root_size(
-                resource, period, aggregate, granularity)
+                resource, period, aggregate, granularity
+            )
 
-    def get_compute_node_cpu_util(self, resource, period,
-                                  aggregate, granularity):
+    def get_compute_node_cpu_util(
+        self, resource, period, aggregate, granularity
+    ):
         """Calculates node utilization dynamically.
 
         node CPU utilization should consider
@@ -117,13 +128,15 @@ class FakeGnocchiMetrics:
         util_sum = 0.0
         for instance in instances:
             total_cpu_util = instance.vcpus * self.get_instance_cpu_util(
-                instance, period, aggregate, granularity)
+                instance, period, aggregate, granularity
+            )
             util_sum += total_cpu_util / 100.0
         util_sum /= node.vcpus
         return util_sum * 100.0
 
-    def get_compute_node_ram_util(self, resource, period, aggregate,
-                                  granularity):
+    def get_compute_node_ram_util(
+        self, resource, period, aggregate, granularity
+    ):
         # Returns mock host ram usage in KB based on the allocated
         # instances.
         node = self.model.get_node_by_uuid(resource.uuid)
@@ -131,12 +144,12 @@ class FakeGnocchiMetrics:
         util_sum = 0.0
         for instance in instances:
             util_sum += self.get_instance_ram_util(
-                instance, period, aggregate, granularity)
+                instance, period, aggregate, granularity
+            )
         return util_sum / 1024
 
     @staticmethod
-    def get_instance_cpu_util(resource, period, aggregate,
-                              granularity):
+    def get_instance_cpu_util(resource, period, aggregate, granularity):
         instance_cpu_util = dict()
         instance_cpu_util['INSTANCE_0'] = 10
         instance_cpu_util['INSTANCE_1'] = 30
@@ -151,8 +164,7 @@ class FakeGnocchiMetrics:
         return instance_cpu_util[str(resource.uuid)]
 
     @staticmethod
-    def get_instance_ram_util(resource, period, aggregate,
-                              granularity):
+    def get_instance_ram_util(resource, period, aggregate, granularity):
         instance_ram_util = dict()
         instance_ram_util['INSTANCE_0'] = 1
         instance_ram_util['INSTANCE_1'] = 2
@@ -167,8 +179,7 @@ class FakeGnocchiMetrics:
         return instance_ram_util[str(resource.uuid)]
 
     @staticmethod
-    def get_instance_disk_root_size(resource, period, aggregate,
-                                    granularity):
+    def get_instance_disk_root_size(resource, period, aggregate, granularity):
         instance_disk_util = dict()
         instance_disk_util['INSTANCE_0'] = 10
         instance_disk_util['INSTANCE_1'] = 15
diff --git a/watcher/tests/unit/decision_engine/model/faker_cluster_state.py b/watcher/tests/unit/decision_engine/model/faker_cluster_state.py
index 6d7bb41c3..0e27feaf1 100644
--- a/watcher/tests/unit/decision_engine/model/faker_cluster_state.py
+++ b/watcher/tests/unit/decision_engine/model/faker_cluster_state.py
@@ -34,7 +34,6 @@ volume_uuid_mapping = {
 
 
 class FakerModelCollector(base.BaseClusterDataModelCollector):
-
     def __init__(self, config=None, osc=None, audit_scope=None):
         if config is None:
             config = mock.Mock(period=777)
@@ -71,7 +70,7 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
         # number max of instance per node
         node_instance_count = 7
         # total number of virtual machine
-        instance_count = (node_count * node_instance_count)
+        instance_count = node_count * node_instance_count
 
         for id_ in range(0, node_count):
             node_uuid = f"Node_{id_}"
@@ -110,9 +109,8 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
                 "disk": 20,
                 "disk_capacity": 20,
                 "vcpus": 10,
-                "metadata":
-                    '{"optimize": true,"top": "floor","nested": {"x": "y"}}',
-                "project_id": project_id
+                "metadata": '{"optimize": true,"top": "floor","nested": {"x": "y"}}',  # noqa: E501
+                "project_id": project_id,
             }
 
             instance = element.Instance(**instance_attributes)
@@ -169,7 +167,8 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
 
     def generate_scenario_9_with_3_active_plus_1_disabled_nodes(self):
         return self.load_model(
-            'scenario_9_with_3_active_plus_1_disabled_nodes.xml')
+            'scenario_9_with_3_active_plus_1_disabled_nodes.xml'
+        )
 
     def generate_scenario_10(self):
         return self.load_model('scenario_10.xml')
@@ -182,7 +181,6 @@ class FakerModelCollector(base.BaseClusterDataModelCollector):
 
 
 class FakerStorageModelCollector(base.BaseClusterDataModelCollector):
-
     def __init__(self, config=None, osc=None, audit_scope=None):
         if config is None:
             config = mock.Mock(period=777)
@@ -211,7 +209,6 @@ class FakerStorageModelCollector(base.BaseClusterDataModelCollector):
         return self._cluster_data_model or self.build_scenario_1()
 
     def build_scenario_1(self):
-
         model = modelroot.StorageModelRoot()
         # number of nodes
         node_count = 2
@@ -280,14 +277,13 @@ class FakerStorageModelCollector(base.BaseClusterDataModelCollector):
                 "size": 40,
                 "status": "in-use",
                 "uuid": uuid,
-                "attachments":
-                    '[{"server_id": "server","attachment_id": "attachment"}]',
+                "attachments": '[{"server_id": "server","attachment_id": "attachment"}]',  # noqa: E501
                 "name": name,
                 "multiattach": 'True',
                 "snapshot_id": uuid,
                 "project_id": "91FFFE30-78A0-4152-ACD2-8310FF274DC9",
                 "metadata": '{"readonly": false,"attached_mode": "rw"}',
-                "bootable": 'False'
+                "bootable": 'False',
             }
             volume = element.Volume(**volume_attributes)
             model.add_volume(volume)
@@ -316,7 +312,6 @@ class FakerStorageModelCollector(base.BaseClusterDataModelCollector):
 
 
 class FakerBaremetalModelCollector(base.BaseClusterDataModelCollector):
-
     def __init__(self, config=None, osc=None):
         if config is None:
             config = mock.Mock(period=777)
@@ -356,7 +351,7 @@ class FakerBaremetalModelCollector(base.BaseClusterDataModelCollector):
                 "power_state": "power on",
                 "maintenance": "false",
                 "maintenance_reason": "null",
-                "extra": {"compute_node_id": i}
+                "extra": {"compute_node_id": i},
             }
             node = element.IronicNode(**node_attributes)
             model.add_node(node)
@@ -368,7 +363,6 @@ class FakerBaremetalModelCollector(base.BaseClusterDataModelCollector):
 
 
 class FakerEmptyModelCollector(base.BaseClusterDataModelCollector):
-
     def __init__(self, config=None, osc=None):
         if config is None:
             config = mock.Mock(period=777)
diff --git a/watcher/tests/unit/decision_engine/model/gnocchi_metrics.py b/watcher/tests/unit/decision_engine/model/gnocchi_metrics.py
index ec2cf38b5..f469fb2be 100644
--- a/watcher/tests/unit/decision_engine/model/gnocchi_metrics.py
+++ b/watcher/tests/unit/decision_engine/model/gnocchi_metrics.py
@@ -23,9 +23,15 @@ class FakeGnocchiMetrics:
     def empty_one_metric(self, emptytype):
         self.emptytype = emptytype
 
-    def mock_get_statistics(self, resource=None, resource_type=None,
-                            meter_name=None, period=None, aggregate='mean',
-                            granularity=None):
+    def mock_get_statistics(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=None,
+        aggregate='mean',
+        granularity=None,
+    ):
         result = 0
         if meter_name == 'host_cpu_usage':
             result = self.get_usage_compute_node_cpu(resource)
@@ -45,8 +51,14 @@ class FakeGnocchiMetrics:
             result = self.get_average_usage_instance_memory(resource)
         return result
 
-    def mock_get_statistics_nn(self, resource=None, meter_name=None,
-                               period=None, aggregate='mean', granularity=300):
+    def mock_get_statistics_nn(
+        self,
+        resource=None,
+        meter_name=None,
+        period=None,
+        aggregate='mean',
+        granularity=300,
+    ):
         """Statistics for noisy neighbor strategy
 
         Signature should match DataSourceBase.get_instance_l3_cache_usage
@@ -59,9 +71,15 @@ class FakeGnocchiMetrics:
             result = self.get_average_l3_cache_previous(resource)
         return result
 
-    def mock_get_statistics_wb(self, resource=None, resource_type=None,
-                               meter_name=None, period=None, aggregate='mean',
-                               granularity=300):
+    def mock_get_statistics_wb(
+        self,
+        resource=None,
+        resource_type=None,
+        meter_name=None,
+        period=None,
+        aggregate='mean',
+        granularity=300,
+    ):
         """Statistics for workload balance strategy"""
 
         result = 0.0
@@ -93,9 +111,11 @@ class FakeGnocchiMetrics:
 
         mock = {}
         mock['73b09e16-35b7-4922-804e-e8f5d9b740fc'] = 34.5 * (
-            oslo_utils.units.Ki)
+            oslo_utils.units.Ki
+        )
         mock['cae81432-1631-4d4e-b29c-6f3acdcde906'] = 30.5 * (
-            oslo_utils.units.Ki)
+            oslo_utils.units.Ki
+        )
         mock['INSTANCE_3'] = 60 * oslo_utils.units.Ki
         mock['INSTANCE_4'] = 22.5 * oslo_utils.units.Ki
 
diff --git a/watcher/tests/unit/decision_engine/model/notification/fake_managers.py b/watcher/tests/unit/decision_engine/model/notification/fake_managers.py
index 7f2cbd5c7..b9f39c796 100644
--- a/watcher/tests/unit/decision_engine/model/notification/fake_managers.py
+++ b/watcher/tests/unit/decision_engine/model/notification/fake_managers.py
@@ -22,7 +22,6 @@ from watcher.tests.unit.decision_engine.model import faker_cluster_state
 
 
 class FakeManager(service_manager.ServiceManager):
-
     API_VERSION = '1.0'
 
     fake_cdmc = faker_cluster_state.FakerModelCollector()
@@ -53,13 +52,10 @@ class FakeManager(service_manager.ServiceManager):
 
     @property
     def notification_endpoints(self):
-        return [
-            novanotification.VersionedNotification(self.fake_cdmc),
-        ]
+        return [novanotification.VersionedNotification(self.fake_cdmc)]
 
 
 class FakeStorageManager(FakeManager):
-
     fake_cdmc = faker_cluster_state.FakerStorageModelCollector()
 
     @property
diff --git a/watcher/tests/unit/decision_engine/model/notification/test_cinder_notifications.py b/watcher/tests/unit/decision_engine/model/notification/test_cinder_notifications.py
index 6a8992728..d6c575957 100644
--- a/watcher/tests/unit/decision_engine/model/notification/test_cinder_notifications.py
+++ b/watcher/tests/unit/decision_engine/model/notification/test_cinder_notifications.py
@@ -33,7 +33,6 @@ from watcher.tests.unit.decision_engine.model.notification import fake_managers
 
 
 class NotificationTestCase(base_test.TestCase):
-
     @staticmethod
     def load_message(filename):
         cwd = os.path.abspath(os.path.dirname(__file__))
@@ -46,7 +45,6 @@ class NotificationTestCase(base_test.TestCase):
 
 
 class TestReceiveCinderNotifications(NotificationTestCase):
-
     FAKE_METADATA = {'message_id': None, 'timestamp': None}
 
     def setUp(self):
@@ -58,13 +56,14 @@ class TestReceiveCinderNotifications(NotificationTestCase):
         self.addCleanup(p_from_dict.stop)
 
         p_get_service_list = mock.patch.object(
-            db_api.Connection, 'get_service_list')
+            db_api.Connection, 'get_service_list'
+        )
         p_update_service = mock.patch.object(
-            db_api.Connection, 'update_service')
+            db_api.Connection, 'update_service'
+        )
         m_get_service_list = p_get_service_list.start()
         m_update_service = p_update_service.start()
-        fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow())
+        fake_service = utils.get_test_service(created_at=timeutils.utcnow())
 
         m_get_service_list.return_value = [fake_service]
         m_update_service.return_value = fake_service.copy()
@@ -82,8 +81,12 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'capacity.host1@backend1#pool1', 'capacity.pool',
-            expected_message, self.FAKE_METADATA)
+            self.context,
+            'capacity.host1@backend1#pool1',
+            'capacity.pool',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
     @mock.patch.object(cnotification.VolumeCreateEnd, 'info')
     def test_cinder_receive_volume_create_end(self, m_info):
@@ -95,8 +98,12 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'volume.host_0@backend_0#pool_0',
-            'volume.create.end', expected_message, self.FAKE_METADATA)
+            self.context,
+            'volume.host_0@backend_0#pool_0',
+            'volume.create.end',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
     @mock.patch.object(cnotification.VolumeUpdateEnd, 'info')
     def test_cinder_receive_volume_update_end(self, m_info):
@@ -108,8 +115,12 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'volume.host_0@backend_0#pool_0',
-            'volume.update.end', expected_message, self.FAKE_METADATA)
+            self.context,
+            'volume.host_0@backend_0#pool_0',
+            'volume.update.end',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
     @mock.patch.object(cnotification.VolumeAttachEnd, 'info')
     def test_cinder_receive_volume_attach_end(self, m_info):
@@ -121,8 +132,12 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'volume.host_0@backend_0#pool_0',
-            'volume.attach.end', expected_message, self.FAKE_METADATA)
+            self.context,
+            'volume.host_0@backend_0#pool_0',
+            'volume.attach.end',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
     @mock.patch.object(cnotification.VolumeDetachEnd, 'info')
     def test_cinder_receive_volume_detach_end(self, m_info):
@@ -134,8 +149,12 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'volume.host_0@backend_0#pool_0',
-            'volume.detach.end', expected_message, self.FAKE_METADATA)
+            self.context,
+            'volume.host_0@backend_0#pool_0',
+            'volume.detach.end',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
     @mock.patch.object(cnotification.VolumeResizeEnd, 'info')
     def test_cinder_receive_volume_resize_end(self, m_info):
@@ -147,8 +166,12 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'volume.host_0@backend_0#pool_0',
-            'volume.resize.end', expected_message, self.FAKE_METADATA)
+            self.context,
+            'volume.host_0@backend_0#pool_0',
+            'volume.resize.end',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
     @mock.patch.object(cnotification.VolumeDeleteEnd, 'info')
     def test_cinder_receive_volume_delete_end(self, m_info):
@@ -160,12 +183,15 @@ class TestReceiveCinderNotifications(NotificationTestCase):
 
         de_service.notification_handler.dispatcher.dispatch(incoming)
         m_info.assert_called_once_with(
-            self.context, 'volume.host_0@backend_0#pool_0',
-            'volume.delete.end', expected_message, self.FAKE_METADATA)
+            self.context,
+            'volume.host_0@backend_0#pool_0',
+            'volume.delete.end',
+            expected_message,
+            self.FAKE_METADATA,
+        )
 
 
 class TestCinderNotifications(NotificationTestCase):
-
     FAKE_METADATA = {'message_id': None, 'timestamp': None}
 
     def setUp(self):
@@ -218,13 +244,16 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='380',
             provisioned_capacity_gb='120',
-            allocated_capacity_gb='120')
+            allocated_capacity_gb='120',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_mock)
+            side_effect=lambda name: return_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
@@ -270,28 +299,31 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='460',
             provisioned_capacity_gb='40',
-            allocated_capacity_gb='40')
+            allocated_capacity_gb='40',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         # storage_node_by_name mock
         return_node_mock = mock.Mock()
         return_node_mock.configure_mock(
-            host='host_2@backend_2',
-            zone='nova',
-            state='up',
-            status='enabled')
+            host='host_2@backend_2', zone='nova', state='up', status='enabled'
+        )
 
         m_get_storage_node_by_name = mock.Mock(
-            side_effect=lambda name: return_node_mock)
+            side_effect=lambda name: return_node_mock
+        )
 
         m_get_volume_type_by_backendname = mock.Mock(
-            side_effect=lambda name: [mock.Mock('backend_2')])
+            side_effect=lambda name: [mock.Mock('backend_2')]
+        )
         m_cinder_helper.return_value = mock.Mock(
             get_storage_pool_by_name=m_get_storage_pool_by_name,
             get_storage_node_by_name=m_get_storage_node_by_name,
-            get_volume_type_by_backendname=m_get_volume_type_by_backendname)
+            get_volume_type_by_backendname=m_get_volume_type_by_backendname,
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
@@ -337,13 +369,16 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='380',
             provisioned_capacity_gb='120',
-            allocated_capacity_gb='120')
+            allocated_capacity_gb='120',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
@@ -384,13 +419,16 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='380',
             provisioned_capacity_gb='120',
-            allocated_capacity_gb='120')
+            allocated_capacity_gb='120',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
@@ -431,36 +469,40 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='460',
             provisioned_capacity_gb='40',
-            allocated_capacity_gb='40')
+            allocated_capacity_gb='40',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         # create storage_node_by_name mock
         return_node_mock = mock.Mock()
         return_node_mock.configure_mock(
-            host='host_2@backend_2',
-            zone='nova',
-            state='up',
-            status='enabled')
+            host='host_2@backend_2', zone='nova', state='up', status='enabled'
+        )
 
         m_get_storage_node_by_name = mock.Mock(
-            side_effect=lambda name: return_node_mock)
+            side_effect=lambda name: return_node_mock
+        )
 
         m_get_volume_type_by_backendname = mock.Mock(
-            side_effect=lambda name: [mock.Mock('backend_2')])
+            side_effect=lambda name: [mock.Mock('backend_2')]
+        )
 
         m_cinder_helper.return_value = mock.Mock(
             get_storage_pool_by_name=m_get_storage_pool_by_name,
             get_storage_node_by_name=m_get_storage_node_by_name,
-            get_volume_type_by_backendname=m_get_volume_type_by_backendname)
+            get_volume_type_by_backendname=m_get_volume_type_by_backendname,
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
         handler = cnotification.VolumeCreateEnd(self.fake_cdmc)
 
         message = self.load_message(
-            'scenario_1_volume-create_pool_notfound.json')
+            'scenario_1_volume-create_pool_notfound.json'
+        )
         handler.info(
             ctxt=self.context,
             publisher_id=message['publisher_id'],
@@ -489,9 +531,11 @@ class TestCinderNotifications(NotificationTestCase):
         """test creating error volume unmapped"""
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=exception.PoolNotFound(name="TEST"))
+            side_effect=exception.PoolNotFound(name="TEST")
+        )
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
@@ -533,13 +577,16 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='420',
             provisioned_capacity_gb='80',
-            allocated_capacity_gb='80')
+            allocated_capacity_gb='80',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         message = self.load_message('scenario_1_volume-update.json')
         handler.info(
@@ -565,13 +612,16 @@ class TestCinderNotifications(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='460',
             provisioned_capacity_gb='40',
-            allocated_capacity_gb='40')
+            allocated_capacity_gb='40',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         storage_model = self.fake_cdmc.generate_scenario_1()
         self.fake_cdmc.cluster_data_model = storage_model
@@ -594,7 +644,9 @@ class TestCinderNotifications(NotificationTestCase):
         # volume does not exists after consuming
         self.assertRaises(
             exception.VolumeNotFound,
-            storage_model.get_volume_by_uuid, volume_0_uuid)
+            storage_model.get_volume_by_uuid,
+            volume_0_uuid,
+        )
 
         # check that capacity was updated
         pool_0_name = 'host_0@backend_0#pool_0'
@@ -608,15 +660,15 @@ class TestCinderNotifications(NotificationTestCase):
 
 
 class TestCinderNotificationsEmptyModel(NotificationTestCase):
-
     FAKE_METADATA = {'message_id': None, 'timestamp': None}
 
     def setUp(self):
         super().setUp()
         self.fake_cdmc = faker_cluster_state.FakerEmptyModelCollector()
 
-    @mock.patch.object(cnotification.CapacityNotificationEndpoint,
-                       'update_pool')
+    @mock.patch.object(
+        cnotification.CapacityNotificationEndpoint, 'update_pool'
+    )
     def test_cinder_capacity_empty_model(self, m_update_pool):
         """test consuming capacity"""
 
@@ -635,8 +687,9 @@ class TestCinderNotificationsEmptyModel(NotificationTestCase):
 
     @mock.patch.object(cnotification.VolumeCreateEnd, 'update_volume')
     @mock.patch.object(cinder_helper, 'CinderHelper')
-    def test_cinder_volume_create_empty_model(self, m_update_volume,
-                                              m_cinder_helper):
+    def test_cinder_volume_create_empty_model(
+        self, m_update_volume, m_cinder_helper
+    ):
         """test creating volume in existing pool and node"""
 
         # create storage_pool_by_name mock
@@ -647,13 +700,16 @@ class TestCinderNotificationsEmptyModel(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='380',
             provisioned_capacity_gb='120',
-            allocated_capacity_gb='120')
+            allocated_capacity_gb='120',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         handler = cnotification.VolumeCreateEnd(self.fake_cdmc)
 
@@ -671,8 +727,9 @@ class TestCinderNotificationsEmptyModel(NotificationTestCase):
 
     @mock.patch.object(cnotification.VolumeUpdateEnd, 'update_volume')
     @mock.patch.object(cinder_helper, 'CinderHelper')
-    def test_cinder_volume_update_empty_model(self, m_update_volume,
-                                              m_cinder_helper):
+    def test_cinder_volume_update_empty_model(
+        self, m_update_volume, m_cinder_helper
+    ):
         """test updating volume in existing pool and node"""
 
         handler = cnotification.VolumeUpdateEnd(self.fake_cdmc)
@@ -685,13 +742,16 @@ class TestCinderNotificationsEmptyModel(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='420',
             provisioned_capacity_gb='80',
-            allocated_capacity_gb='80')
+            allocated_capacity_gb='80',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         message = self.load_message('scenario_1_volume-update.json')
         handler.info(
@@ -708,8 +768,9 @@ class TestCinderNotificationsEmptyModel(NotificationTestCase):
 
     @mock.patch.object(cinder_helper, 'CinderHelper')
     @mock.patch.object(cnotification.VolumeDeleteEnd, 'delete_volume')
-    def test_cinder_volume_delete_empty_model(self, m_delete_volume,
-                                              m_cinder_helper):
+    def test_cinder_volume_delete_empty_model(
+        self, m_delete_volume, m_cinder_helper
+    ):
         """test deleting volume when model is empty"""
 
         # create storage_pool_by name mock
@@ -720,13 +781,16 @@ class TestCinderNotificationsEmptyModel(NotificationTestCase):
             total_capacity_gb='500',
             free_capacity_gb='460',
             provisioned_capacity_gb='40',
-            allocated_capacity_gb='40')
+            allocated_capacity_gb='40',
+        )
 
         m_get_storage_pool_by_name = mock.Mock(
-            side_effect=lambda name: return_pool_mock)
+            side_effect=lambda name: return_pool_mock
+        )
 
         m_cinder_helper.return_value = mock.Mock(
-            get_storage_pool_by_name=m_get_storage_pool_by_name)
+            get_storage_pool_by_name=m_get_storage_pool_by_name
+        )
 
         handler = cnotification.VolumeDeleteEnd(self.fake_cdmc)
 
diff --git a/watcher/tests/unit/decision_engine/model/notification/test_notifications.py b/watcher/tests/unit/decision_engine/model/notification/test_notifications.py
index 2a44f3f01..930ed7eac 100644
--- a/watcher/tests/unit/decision_engine/model/notification/test_notifications.py
+++ b/watcher/tests/unit/decision_engine/model/notification/test_notifications.py
@@ -30,14 +30,12 @@ from watcher.tests.unit.decision_engine.model.notification import fake_managers
 
 
 class DummyManager(fake_managers.FakeManager):
-
     @property
     def notification_endpoints(self):
         return [DummyNotification(self.fake_cdmc)]
 
 
 class DummyNotification(base.NotificationEndpoint):
-
     @property
     def filter_rule(self):
         return filtering.NotificationFilter(
@@ -51,7 +49,6 @@ class DummyNotification(base.NotificationEndpoint):
 
 
 class NotificationTestCase(base_test.TestCase):
-
     def load_message(self, filename):
         cwd = os.path.abspath(os.path.dirname(__file__))
         data_folder = os.path.join(cwd, "data")
@@ -63,7 +60,6 @@ class NotificationTestCase(base_test.TestCase):
 
 
 class TestReceiveNotifications(NotificationTestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -87,9 +83,12 @@ class TestReceiveNotifications(NotificationTestCase):
         de_service.notification_handler.dispatcher.dispatch(incoming)
 
         m_info.assert_called_once_with(
-            self.context, 'nova-compute', 'compute.dummy',
+            self.context,
+            'nova-compute',
+            'compute.dummy',
             {'data': {'nested': 'TEST'}},
-            {'message_id': None, 'timestamp': None})
+            {'message_id': None, 'timestamp': None},
+        )
 
     @mock.patch.object(watcher_service.ServiceHeartbeat, 'send_beat')
     @mock.patch.object(DummyNotification, 'info')
diff --git a/watcher/tests/unit/decision_engine/model/notification/test_nova_notifications.py b/watcher/tests/unit/decision_engine/model/notification/test_nova_notifications.py
index f0f983f69..3813d51df 100644
--- a/watcher/tests/unit/decision_engine/model/notification/test_nova_notifications.py
+++ b/watcher/tests/unit/decision_engine/model/notification/test_nova_notifications.py
@@ -38,7 +38,6 @@ from watcher.tests.unit.decision_engine.model.notification import fake_managers
 
 
 class NotificationTestCase(test_utils.NovaResourcesMixin, base_test.TestCase):
-
     @staticmethod
     def load_message(filename):
         cwd = os.path.abspath(os.path.dirname(__file__))
@@ -51,7 +50,6 @@ class NotificationTestCase(test_utils.NovaResourcesMixin, base_test.TestCase):
 
 
 class TestReceiveNovaNotifications(NotificationTestCase):
-
     FAKE_METADATA = {'message_id': None, 'timestamp': None}
     FAKE_NOTIFICATIONS = {
         'instance.create.end': 'instance-create-end.json',
@@ -72,16 +70,18 @@ class TestReceiveNovaNotifications(NotificationTestCase):
         'instance.rebuild.end': 'instance-rebuild-end.json',
         'instance.rescue.end': 'instance-rescue-end.json',
         'instance.update': 'instance-update.json',
-        'instance.live_migration_force_complete.end':
-        'instance-live_migration_force_complete-end.json',
-        'instance.live_migration_post_dest.end':
-        'instance-live_migration_post_dest-end.json',
+        'instance.live_migration_force_complete.end': (
+            'instance-live_migration_force_complete-end.json'
+        ),
+        'instance.live_migration_post_dest.end': (
+            'instance-live_migration_post_dest-end.json'
+        ),
         'instance.delete.end': 'instance-delete-end.json',
         'instance.soft_delete.end': 'instance-soft_delete-end.json',
         'service.create': 'service-create.json',
         'service.delete': 'service-delete.json',
         'service.update': 'service-update.json',
-        }
+    }
 
     def setUp(self):
         super().setUp()
@@ -91,7 +91,8 @@ class TestReceiveNovaNotifications(NotificationTestCase):
         m_from_dict.return_value = self.context
         self.addCleanup(p_from_dict.stop)
         p_heartbeat = mock.patch.object(
-            watcher_service.ServiceHeartbeat, "send_beat")
+            watcher_service.ServiceHeartbeat, "send_beat"
+        )
         self.m_heartbeat = p_heartbeat.start()
         self.addCleanup(p_heartbeat.stop)
 
@@ -109,13 +110,16 @@ class TestReceiveNovaNotifications(NotificationTestCase):
 
             de_service.notification_handler.dispatcher.dispatch(incoming)
             m_info.assert_called_with(
-                self.context, publisher_id, n_type,
-                expected_message, self.FAKE_METADATA)
+                self.context,
+                publisher_id,
+                n_type,
+                expected_message,
+                self.FAKE_METADATA,
+            )
 
 
 @ddt.ddt
 class TestNovaNotifications(NotificationTestCase):
-
     FAKE_METADATA = {'message_id': None, 'timestamp': None}
 
     def setUp(self):
@@ -165,14 +169,13 @@ class TestNovaNotifications(NotificationTestCase):
 
     @mock.patch.object(placement_helper, 'PlacementHelper')
     @mock.patch.object(nova_helper, "NovaHelper")
-    def test_nova_service_create(self, m_nova_helper_cls,
-                                 m_placement_helper):
+    def test_nova_service_create(self, m_nova_helper_cls, m_placement_helper):
         mock_placement = mock.Mock(name="placement_helper")
         mock_placement.get_inventories.return_value = dict()
         mock_placement.get_usages_for_resource_provider.return_value = {
             orc.DISK_GB: 10,
             orc.MEMORY_MB: 100,
-            orc.VCPU: 0
+            orc.VCPU: 0,
         }
         m_placement_helper.return_value = mock_placement
         m_get_compute_node_by_hostname = mock.Mock(
@@ -186,14 +189,18 @@ class TestNovaNotifications(NotificationTestCase):
                     vcpus=42,
                     local_disk_free=974,
                     local_disk_size=1337,
-                    service_details={'id': 123, 'host': 'host2',
-                                     'disabled_reason': ''},
-                    )
+                    service_details={
+                        'id': 123,
+                        'host': 'host2',
+                        'disabled_reason': '',
+                    },
+                )
             )
         )
         m_nova_helper_cls.return_value = mock.Mock(
             get_compute_node_by_hostname=m_get_compute_node_by_hostname,
-            name='m_nova_helper')
+            name='m_nova_helper',
+        )
 
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
         self.fake_cdmc.cluster_data_model = compute_model
@@ -203,7 +210,9 @@ class TestNovaNotifications(NotificationTestCase):
 
         self.assertRaises(
             exception.ComputeNodeNotFound,
-            compute_model.get_node_by_name, new_node_name)
+            compute_model.get_node_by_name,
+            new_node_name,
+        )
 
         message = self.load_message('service-create.json')
         handler.info(
@@ -241,7 +250,9 @@ class TestNovaNotifications(NotificationTestCase):
         # After
         self.assertRaises(
             exception.ComputeNodeNotFound,
-            compute_model.get_node_by_name, node0_name)
+            compute_model.get_node_by_name,
+            node0_name,
+        )
 
     def test_nova_instance_update(self):
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
@@ -294,14 +305,14 @@ class TestNovaNotifications(NotificationTestCase):
     @mock.patch.object(nova_helper, "NovaHelper")
     @ddt.data(False, True)
     def test_nova_instance_update_notfound_still_creates(
-            self, extended_attr_enabled, m_nova_helper_cls,
-            m_placement_helper):
+        self, extended_attr_enabled, m_nova_helper_cls, m_placement_helper
+    ):
         mock_placement = mock.Mock(name="placement_helper")
         mock_placement.get_inventories.return_value = dict()
         mock_placement.get_usages_for_resource_provider.return_value = {
             orc.DISK_GB: 10,
             orc.MEMORY_MB: 100,
-            orc.VCPU: 0
+            orc.VCPU: 0,
         }
         m_placement_helper.return_value = mock_placement
         m_get_compute_node_by_hostname = mock.Mock(
@@ -315,19 +326,24 @@ class TestNovaNotifications(NotificationTestCase):
                     vcpus=42,
                     local_disk_free=974,
                     local_disk_size=1337,
-                    service_details={'id': 123, 'host': 'Node_2',
-                                     'disabled_reason': ''},
-                    )
+                    service_details={
+                        'id': 123,
+                        'host': 'Node_2',
+                        'disabled_reason': '',
+                    },
                 )
+            )
         )
         m_nova_helper_cls.return_value = mock.Mock(
             get_compute_node_by_hostname=m_get_compute_node_by_hostname,
-            name='m_nova_helper')
+            name='m_nova_helper',
+        )
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
         self.fake_cdmc.cluster_data_model = compute_model
         # Set the extended_attributes_enabled configuration value
         self.fake_cdmc.cluster_data_model.extended_attributes_enabled = (
-            extended_attr_enabled)
+            extended_attr_enabled
+        )
 
         handler = novanotification.VersionedNotification(self.fake_cdmc)
 
@@ -362,12 +378,15 @@ class TestNovaNotifications(NotificationTestCase):
 
     @mock.patch.object(nova_helper, "NovaHelper")
     def test_instance_update_node_notfound_set_unmapped(
-            self, m_nova_helper_cls):
+        self, m_nova_helper_cls
+    ):
         m_get_compute_node_by_hostname = mock.Mock(
-            side_effect=exception.ComputeNodeNotFound(name="TEST"))
+            side_effect=exception.ComputeNodeNotFound(name="TEST")
+        )
         m_nova_helper_cls.return_value = mock.Mock(
             get_compute_node_by_hostname=m_get_compute_node_by_hostname,
-            name='m_nova_helper')
+            name='m_nova_helper',
+        )
 
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
         self.fake_cdmc.cluster_data_model = compute_model
@@ -375,8 +394,7 @@ class TestNovaNotifications(NotificationTestCase):
 
         instance0_uuid = '9966d6bd-a45c-4e1c-9d57-3054899a3ec7'
 
-        message = self.load_message(
-            'scenario3_notfound_instance-update.json')
+        message = self.load_message('scenario3_notfound_instance-update.json')
 
         handler.info(
             ctxt=self.context,
@@ -396,21 +414,22 @@ class TestNovaNotifications(NotificationTestCase):
         m_get_compute_node_by_hostname.assert_any_call('Node_2')
         self.assertRaises(
             exception.ComputeNodeNotFound,
-            compute_model.get_node_by_uuid, 'Node_2')
+            compute_model.get_node_by_uuid,
+            'Node_2',
+        )
 
     @mock.patch.object(placement_helper, 'PlacementHelper')
     @mock.patch.object(nova_helper, 'NovaHelper')
     @ddt.data(False, True)
-    def test_nova_instance_create(self,
-                                  extended_attr_enabled,
-                                  m_nova_helper_cls,
-                                  m_placement_helper):
+    def test_nova_instance_create(
+        self, extended_attr_enabled, m_nova_helper_cls, m_placement_helper
+    ):
         mock_placement = mock.Mock(name="placement_helper")
         mock_placement.get_inventories.return_value = dict()
         mock_placement.get_usages_for_resource_provider.return_value = {
             orc.DISK_GB: 10,
             orc.MEMORY_MB: 100,
-            orc.VCPU: 0
+            orc.VCPU: 0,
         }
         m_placement_helper.return_value = mock_placement
         m_get_compute_node_by_hostname = mock.Mock(
@@ -425,20 +444,25 @@ class TestNovaNotifications(NotificationTestCase):
                     vcpus=42,
                     local_disk_free=974,
                     local_disk_size=1337,
-                    service_details={'id': 123, 'host': 'compute',
-                                     'disabled_reason': ''},
-                    )
+                    service_details={
+                        'id': 123,
+                        'host': 'compute',
+                        'disabled_reason': '',
+                    },
                 )
+            )
         )
         m_nova_helper_cls.return_value = mock.Mock(
             get_compute_node_by_hostname=m_get_compute_node_by_hostname,
-            name='m_nova_helper')
+            name='m_nova_helper',
+        )
 
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
         self.fake_cdmc.cluster_data_model = compute_model
         # Set the extended_attributes_enabled configuration value
         self.fake_cdmc.cluster_data_model.extended_attributes_enabled = (
-            extended_attr_enabled)
+            extended_attr_enabled
+        )
 
         handler = novanotification.VersionedNotification(self.fake_cdmc)
 
@@ -446,7 +470,9 @@ class TestNovaNotifications(NotificationTestCase):
 
         self.assertRaises(
             exception.InstanceNotFound,
-            compute_model.get_instance_by_uuid, instance0_uuid)
+            compute_model.get_instance_by_uuid,
+            instance0_uuid,
+        )
 
         message = self.load_message('instance-create-end.json')
         handler.info(
@@ -459,20 +485,24 @@ class TestNovaNotifications(NotificationTestCase):
 
         hostname = message['payload']['nova_object.data']['host']
         node = self.fake_cdmc.cluster_data_model.get_node_by_instance_uuid(
-            instance0_uuid)
+            instance0_uuid
+        )
         self.assertEqual(hostname, node.hostname)
         m_get_compute_node_by_hostname.assert_called_once_with(hostname)
 
         instance0 = self.fake_cdmc.cluster_data_model.get_instance_by_uuid(
-            instance0_uuid)
+            instance0_uuid
+        )
 
         self.assertEqual(element.InstanceState.ACTIVE.value, instance0.state)
         self.assertEqual(1, instance0.vcpus)
         self.assertEqual(1, instance0.disk)
         self.assertEqual(512, instance0.memory)
         if extended_attr_enabled:
-            self.assertEqual({'hw:watchdog_action': 'disabled'},
-                             instance0.flavor_extra_specs)
+            self.assertEqual(
+                {'hw:watchdog_action': 'disabled'},
+                instance0.flavor_extra_specs,
+            )
             # NOTE(dviroel): pinned_az is not available in nova notifications
             self.assertEqual('', instance0.pinned_az)
         else:
@@ -501,7 +531,9 @@ class TestNovaNotifications(NotificationTestCase):
         # After
         self.assertRaises(
             exception.InstanceNotFound,
-            compute_model.get_instance_by_uuid, instance0_uuid)
+            compute_model.get_instance_by_uuid,
+            instance0_uuid,
+        )
 
     def test_nova_instance_soft_delete_end(self):
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
@@ -525,7 +557,9 @@ class TestNovaNotifications(NotificationTestCase):
         # After
         self.assertRaises(
             exception.InstanceNotFound,
-            compute_model.get_instance_by_uuid, instance0_uuid)
+            compute_model.get_instance_by_uuid,
+            instance0_uuid,
+        )
 
     def test_live_migrated_force_end(self):
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
@@ -536,7 +570,8 @@ class TestNovaNotifications(NotificationTestCase):
         node = compute_model.get_node_by_instance_uuid(instance0_uuid)
         self.assertEqual('fa69c544-906b-4a6a-a9c6-c1f7a8078c73', node.uuid)
         message = self.load_message(
-            'instance-live_migration_force_complete-end.json')
+            'instance-live_migration_force_complete-end.json'
+        )
         handler.info(
             ctxt=self.context,
             publisher_id=message['publisher_id'],
@@ -557,7 +592,8 @@ class TestNovaNotifications(NotificationTestCase):
         node = compute_model.get_node_by_instance_uuid(instance0_uuid)
         self.assertEqual('fa69c544-906b-4a6a-a9c6-c1f7a8078c73', node.uuid)
         message = self.load_message(
-            'instance-live_migration_post_dest-end.json')
+            'instance-live_migration_post_dest-end.json'
+        )
         handler.info(
             ctxt=self.context,
             publisher_id=message['publisher_id'],
@@ -607,7 +643,8 @@ class TestNovaNotifications(NotificationTestCase):
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
         self.fake_cdmc.cluster_data_model = compute_model
         self.fake_cdmc.cluster_data_model.extended_attributes_enabled = (
-            extended_attr_enabled)
+            extended_attr_enabled
+        )
         handler = novanotification.VersionedNotification(self.fake_cdmc)
 
         instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
@@ -625,8 +662,10 @@ class TestNovaNotifications(NotificationTestCase):
             metadata=self.FAKE_METADATA,
         )
         if extended_attr_enabled:
-            self.assertEqual({'hw:watchdog_action': 'disabled'},
-                             instance0.flavor_extra_specs)
+            self.assertEqual(
+                {'hw:watchdog_action': 'disabled'},
+                instance0.flavor_extra_specs,
+            )
         else:
             self.assertEqual({}, instance0.flavor_extra_specs)
 
@@ -756,7 +795,8 @@ class TestNovaNotifications(NotificationTestCase):
         compute_model = self.fake_cdmc.generate_scenario_3_with_2_nodes()
         self.fake_cdmc.cluster_data_model = compute_model
         self.fake_cdmc.cluster_data_model.extended_attributes_enabled = (
-            extended_attr_enabled)
+            extended_attr_enabled
+        )
 
         handler = novanotification.VersionedNotification(self.fake_cdmc)
         instance0_uuid = '73b09e16-35b7-4922-804e-e8f5d9b740fc'
@@ -767,8 +807,7 @@ class TestNovaNotifications(NotificationTestCase):
         # NOTE(dviroel): extra_specs are empty generated scenario
         self.assertEqual({}, instance0.flavor_extra_specs)
 
-        message = self.load_message(
-            'instance-resize_confirm-end.json')
+        message = self.load_message('instance-resize_confirm-end.json')
         handler.info(
             ctxt=self.context,
             publisher_id=message['publisher_id'],
@@ -780,9 +819,9 @@ class TestNovaNotifications(NotificationTestCase):
         self.assertEqual('fa69c544-906b-4a6a-a9c6-c1f7a8078c73', node.uuid)
         self.assertEqual(element.InstanceState.ACTIVE.value, instance0.state)
 
-        expected_extra_specs = {
-            'hw:watchdog_action': 'disabled'
-        } if extended_attr_enabled else {}
+        expected_extra_specs = (
+            {'hw:watchdog_action': 'disabled'} if extended_attr_enabled else {}
+        )
         self.assertEqual(expected_extra_specs, instance0.flavor_extra_specs)
 
     def test_nova_instance_restore_end(self):
@@ -903,7 +942,8 @@ class TestNovaNotifications(NotificationTestCase):
         )
 
         self.assertEqual(
-            element.InstanceState.SUSPENDED.value, instance0.state)
+            element.InstanceState.SUSPENDED.value, instance0.state
+        )
 
     def test_info_no_cdm(self):
         # Tests that a notification is received before an audit has been
@@ -913,12 +953,17 @@ class TestNovaNotifications(NotificationTestCase):
         payload = {
             'nova_object.data': {
                 'uuid': '9966d6bd-a45c-4e1c-9d57-3054899a3ec7',
-                'host': None
+                'host': None,
             }
         }
         with mock.patch.object(handler, 'update_instance') as update_instance:
-            handler.info(mock.sentinel.ctxt, 'publisher_id', 'instance.update',
-                         payload, metadata={})
+            handler.info(
+                mock.sentinel.ctxt,
+                'publisher_id',
+                'instance.update',
+                payload,
+                metadata={},
+            )
             # update_instance should not be called since we did not add an
             # Instance object to the CDM since the CDM does not exist yet.
             update_instance.assert_not_called()
@@ -930,8 +975,9 @@ class TestNovaNotifications(NotificationTestCase):
         message = self.load_message('instance-create-end.json')
 
         # get_instance_by_uuid should not be called when creating instance
-        with mock.patch.object(self.fake_cdmc.cluster_data_model,
-                               'get_instance_by_uuid') as mock_get:
+        with mock.patch.object(
+            self.fake_cdmc.cluster_data_model, 'get_instance_by_uuid'
+        ) as mock_get:
             handler.info(
                 ctxt=self.context,
                 publisher_id=message['publisher_id'],
diff --git a/watcher/tests/unit/decision_engine/model/test_element.py b/watcher/tests/unit/decision_engine/model/test_element.py
index 53791a821..b65d1c0c0 100644
--- a/watcher/tests/unit/decision_engine/model/test_element.py
+++ b/watcher/tests/unit/decision_engine/model/test_element.py
@@ -20,55 +20,77 @@ from watcher.tests.unit import base
 
 
 class TestElement(base.TestCase):
-
     scenarios = [
-        ("ComputeNode_with_all_fields", dict(
-            cls=element.Instance,
-            data={
-                'uuid': 'FAKE_UUID',
-                'state': 'state',
-                'hostname': 'hostname',
-                'memory': 111,
-                'vcpus': 222,
-                'disk': 333,
-            })),
-        ("ComputeNode_with_some_fields", dict(
-            cls=element.Instance,
-            data={
-                'uuid': 'FAKE_UUID',
-                'state': 'state',
-                'vcpus': 222,
-                'disk': 333,
-            })),
-        ("Instance_with_all_fields", dict(
-            cls=element.Instance,
-            data={
-                'uuid': 'FAKE_UUID',
-                'state': 'state',
-                'hostname': 'hostname',
-                'name': 'name',
-                'memory': 111,
-                'vcpus': 222,
-                'disk': 333,
-            })),
-        ("Instance_with_some_fields", dict(
-            cls=element.Instance,
-            data={
-                'uuid': 'FAKE_UUID',
-                'state': 'state',
-                'vcpus': 222,
-                'disk': 333,
-            })),
-        ("Instance_with_extended_fields", dict(
-            cls=element.Instance,
-            data={
-                'uuid': 'FAKE_UUID',
-                'state': 'state',
-                'vcpus': 222,
-                'disk': 333,
-                'pinned_az': 'nova',
-                'flavor_extra_specs': {"spec1": "value1", "spec2": "value2"},
-            })),
+        (
+            "ComputeNode_with_all_fields",
+            dict(
+                cls=element.Instance,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'state': 'state',
+                    'hostname': 'hostname',
+                    'memory': 111,
+                    'vcpus': 222,
+                    'disk': 333,
+                },
+            ),
+        ),
+        (
+            "ComputeNode_with_some_fields",
+            dict(
+                cls=element.Instance,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'state': 'state',
+                    'vcpus': 222,
+                    'disk': 333,
+                },
+            ),
+        ),
+        (
+            "Instance_with_all_fields",
+            dict(
+                cls=element.Instance,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'state': 'state',
+                    'hostname': 'hostname',
+                    'name': 'name',
+                    'memory': 111,
+                    'vcpus': 222,
+                    'disk': 333,
+                },
+            ),
+        ),
+        (
+            "Instance_with_some_fields",
+            dict(
+                cls=element.Instance,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'state': 'state',
+                    'vcpus': 222,
+                    'disk': 333,
+                },
+            ),
+        ),
+        (
+            "Instance_with_extended_fields",
+            dict(
+                cls=element.Instance,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'state': 'state',
+                    'vcpus': 222,
+                    'disk': 333,
+                    'pinned_az': 'nova',
+                    'flavor_extra_specs': {
+                        "spec1": "value1",
+                        "spec2": "value2",
+                    },
+                },
+            ),
+        ),
     ]
 
     def test_as_xml_element(self):
@@ -77,80 +99,103 @@ class TestElement(base.TestCase):
 
 
 class TestStorageElement(base.TestCase):
-
     scenarios = [
-        ("StorageNode_with_all_fields", dict(
-            cls=element.StorageNode,
-            data={
-                'host': 'host@backend',
-                'zone': 'zone',
-                'status': 'enabled',
-                'state': 'up',
-                'volume_type': ['volume_type'],
-            })),
-        ("Pool_with_all_fields", dict(
-            cls=element.Pool,
-            data={
-                'name': 'host@backend#pool',
-                'total_volumes': 1,
-                'total_capacity_gb': 500,
-                'free_capacity_gb': 420,
-                'provisioned_capacity_gb': 80,
-                'allocated_capacity_gb': 80,
-                'virtual_free': 420,
-            })),
-        ("Pool_without_virtual_free_fields", dict(
-            cls=element.Pool,
-            data={
-                'name': 'host@backend#pool',
-                'total_volumes': 1,
-                'total_capacity_gb': 500,
-                'free_capacity_gb': 420,
-                'provisioned_capacity_gb': 80,
-                'allocated_capacity_gb': 80,
-            })),
-        ("Volume_with_all_fields", dict(
-            cls=element.Volume,
-            data={
-                'uuid': 'FAKE_UUID',
-                'size': 1,
-                'status': 'in-use',
-                'attachments': '[{"key": "value"}]',
-                'name': 'name',
-                'multiattach': 'false',
-                'snapshot_id': '',
-                'project_id': '8ea272ec-52d2-475e-9151-0f3ed8c674d1',
-                'metadata': '{"key": "value"}',
-                'bootable': 'false',
-                'human_id': 'human_id',
-            })),
-        ("Volume_without_bootable_fields", dict(
-            cls=element.Volume,
-            data={
-                'uuid': 'FAKE_UUID',
-                'size': 1,
-                'status': 'in-use',
-                'attachments': '[]',
-                'name': 'name',
-                'multiattach': 'false',
-                'snapshot_id': '',
-                'project_id': '777d7968-9b61-4cc0-844d-a95a6fc22d8c',
-                'metadata': '{"key": "value"}',
-                'human_id': 'human_id',
-            })),
-        ("Volume_without_human_id_fields", dict(
-            cls=element.Volume,
-            data={
-                'uuid': 'FAKE_UUID',
-                'size': 1,
-                'status': 'in-use',
-                'attachments': '[]',
-                'name': 'name',
-                'multiattach': 'false',
-                'snapshot_id': '',
-                'project_id': '2e65af64-1898-4cee-bfee-af3fc7f76d16',
-                'metadata': '{"key": "value"}',
-            })),
+        (
+            "StorageNode_with_all_fields",
+            dict(
+                cls=element.StorageNode,
+                data={
+                    'host': 'host@backend',
+                    'zone': 'zone',
+                    'status': 'enabled',
+                    'state': 'up',
+                    'volume_type': ['volume_type'],
+                },
+            ),
+        ),
+        (
+            "Pool_with_all_fields",
+            dict(
+                cls=element.Pool,
+                data={
+                    'name': 'host@backend#pool',
+                    'total_volumes': 1,
+                    'total_capacity_gb': 500,
+                    'free_capacity_gb': 420,
+                    'provisioned_capacity_gb': 80,
+                    'allocated_capacity_gb': 80,
+                    'virtual_free': 420,
+                },
+            ),
+        ),
+        (
+            "Pool_without_virtual_free_fields",
+            dict(
+                cls=element.Pool,
+                data={
+                    'name': 'host@backend#pool',
+                    'total_volumes': 1,
+                    'total_capacity_gb': 500,
+                    'free_capacity_gb': 420,
+                    'provisioned_capacity_gb': 80,
+                    'allocated_capacity_gb': 80,
+                },
+            ),
+        ),
+        (
+            "Volume_with_all_fields",
+            dict(
+                cls=element.Volume,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'size': 1,
+                    'status': 'in-use',
+                    'attachments': '[{"key": "value"}]',
+                    'name': 'name',
+                    'multiattach': 'false',
+                    'snapshot_id': '',
+                    'project_id': '8ea272ec-52d2-475e-9151-0f3ed8c674d1',
+                    'metadata': '{"key": "value"}',
+                    'bootable': 'false',
+                    'human_id': 'human_id',
+                },
+            ),
+        ),
+        (
+            "Volume_without_bootable_fields",
+            dict(
+                cls=element.Volume,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'size': 1,
+                    'status': 'in-use',
+                    'attachments': '[]',
+                    'name': 'name',
+                    'multiattach': 'false',
+                    'snapshot_id': '',
+                    'project_id': '777d7968-9b61-4cc0-844d-a95a6fc22d8c',
+                    'metadata': '{"key": "value"}',
+                    'human_id': 'human_id',
+                },
+            ),
+        ),
+        (
+            "Volume_without_human_id_fields",
+            dict(
+                cls=element.Volume,
+                data={
+                    'uuid': 'FAKE_UUID',
+                    'size': 1,
+                    'status': 'in-use',
+                    'attachments': '[]',
+                    'name': 'name',
+                    'multiattach': 'false',
+                    'snapshot_id': '',
+                    'project_id': '2e65af64-1898-4cee-bfee-af3fc7f76d16',
+                    'metadata': '{"key": "value"}',
+                },
+            ),
+        ),
     ]
 
     def test_as_xml_element(self):
@@ -159,26 +204,33 @@ class TestStorageElement(base.TestCase):
 
 
 class TestIronicElement(base.TestCase):
-
     scenarios = [
-        ("IronicNode_with_all_fields", dict(
-            cls=element.IronicNode,
-            data={
-                "uuid": 'FAKE_UUID',
-                "power_state": 'up',
-                "maintenance": "false",
-                "maintenance_reason": "null",
-                "extra": {"compute_node_id": 1}
-            })),
-        ("IronicNode_with_some_fields", dict(
-            cls=element.IronicNode,
-            data={
-                "uuid": 'FAKE_UUID',
-                "power_state": 'up',
-                "maintenance": "false",
-                "extra": {"compute_node_id": 1}
-            })),
-        ]
+        (
+            "IronicNode_with_all_fields",
+            dict(
+                cls=element.IronicNode,
+                data={
+                    "uuid": 'FAKE_UUID',
+                    "power_state": 'up',
+                    "maintenance": "false",
+                    "maintenance_reason": "null",
+                    "extra": {"compute_node_id": 1},
+                },
+            ),
+        ),
+        (
+            "IronicNode_with_some_fields",
+            dict(
+                cls=element.IronicNode,
+                data={
+                    "uuid": 'FAKE_UUID',
+                    "power_state": 'up',
+                    "maintenance": "false",
+                    "extra": {"compute_node_id": 1},
+                },
+            ),
+        ),
+    ]
 
     def test_as_xml_element(self):
         el = self.cls(**self.data)
diff --git a/watcher/tests/unit/decision_engine/model/test_model.py b/watcher/tests/unit/decision_engine/model/test_model.py
index b2db82046..7b0b4b986 100644
--- a/watcher/tests/unit/decision_engine/model/test_model.py
+++ b/watcher/tests/unit/decision_engine/model/test_model.py
@@ -29,7 +29,6 @@ from watcher.tests.unit.decision_engine.model import faker_cluster_state
 
 
 class TestModel(base.TestCase):
-
     def load_data(self, filename):
         cwd = os.path.abspath(os.path.dirname(__file__))
         data_folder = os.path.join(cwd, "data")
@@ -69,17 +68,24 @@ class TestModel(base.TestCase):
     @mock.patch('watcher.decision_engine.model.model_root.LOG')
     def test_get_model_to_list(self, mock_log, mock_instances, mock_nodes):
         fake_compute_node = element.ComputeNode(
-            uuid='fake_node_uuid', hostname="hostname0")
-        fake_instance = element.Instance(
-            uuid='fake_instance_uuid')
+            uuid='fake_node_uuid', hostname="hostname0"
+        )
+        fake_instance = element.Instance(uuid='fake_instance_uuid')
 
         mock_nodes.return_value = {'fake_node_uuid': fake_compute_node}
         mock_instances.return_value = [fake_instance]
 
         expected_keys = [
-            'server_uuid', 'node_uuid', 'node_state', 'node_hostname',
-            'node_status', 'server_flavor_extra_specs', 'server_locked',
-            'server_pinned_az', 'server_state', 'server_watcher_exclude'
+            'server_uuid',
+            'node_uuid',
+            'node_state',
+            'node_hostname',
+            'node_status',
+            'server_flavor_extra_specs',
+            'server_locked',
+            'server_pinned_az',
+            'server_state',
+            'server_watcher_exclude',
         ]
 
         result = model_root.ModelRoot().to_list()
@@ -89,19 +95,25 @@ class TestModel(base.TestCase):
         self.assertEqual(sorted(expected_keys), sorted(result_keys))
 
         mock_log.debug.assert_any_call(
-            'Attribute %s for Instance: %s is not provided', 'name',
-            'fake_instance_uuid'
+            'Attribute %s for Instance: %s is not provided',
+            'name',
+            'fake_instance_uuid',
         )
         mock_log.debug.assert_any_call(
-            'Attribute %s for Compute: %s is not provided', 'memory',
-            'hostname0'
+            'Attribute %s for Compute: %s is not provided',
+            'memory',
+            'hostname0',
         )
 
         # test compute node has no instance
         mock_instances.return_value = []
 
-        expected_keys = ['node_hostname', 'node_status',
-                         'node_state', 'node_uuid']
+        expected_keys = [
+            'node_hostname',
+            'node_status',
+            'node_state',
+            'node_uuid',
+        ]
 
         result = model_root.ModelRoot().to_list()
         self.assertEqual(1, len(result))
@@ -117,7 +129,8 @@ class TestModel(base.TestCase):
         self.assertEqual(len(model_list), 8)
         self.assertEqual(
             model_list[0]['server_uuid'],
-            'd000ef1f-dc19-4982-9383-087498bfde03')
+            'd000ef1f-dc19-4982-9383-087498bfde03',
+        )
 
     def test_model_to_xml_all_fields(self):
         struct_str = self.load_data('scenario_2_with_metrics.xml')
@@ -159,8 +172,9 @@ class TestModel(base.TestCase):
         model.add_node(node)
         self.assertEqual(node, model.get_node_by_uuid(uuid_))
         model.remove_node(node)
-        self.assertRaises(exception.ComputeNodeNotFound,
-                          model.get_node_by_uuid, uuid_)
+        self.assertRaises(
+            exception.ComputeNodeNotFound, model.get_node_by_uuid, uuid_
+        )
 
     def test_get_all_compute_nodes(self):
         model = model_root.ModelRoot()
@@ -210,8 +224,9 @@ class TestModel(base.TestCase):
         model.add_node(node)
 
         fake_name = 'fake_node'
-        self.assertRaises(exception.ComputeNodeNotFound,
-                          model.get_node_by_name, fake_name)
+        self.assertRaises(
+            exception.ComputeNodeNotFound, model.get_node_by_name, fake_name
+        )
 
     def test_node_from_uuid_raise(self):
         model = model_root.ModelRoot()
@@ -221,8 +236,9 @@ class TestModel(base.TestCase):
         model.add_node(node)
 
         uuid2 = f"{uuidutils.generate_uuid()}"
-        self.assertRaises(exception.ComputeNodeNotFound,
-                          model.get_node_by_uuid, uuid2)
+        self.assertRaises(
+            exception.ComputeNodeNotFound, model.get_node_by_uuid, uuid2
+        )
 
     def test_remove_node_raise(self):
         model = model_root.ModelRoot()
@@ -235,8 +251,9 @@ class TestModel(base.TestCase):
         node2 = element.ComputeNode(id=2)
         node2.uuid = uuid2
 
-        self.assertRaises(exception.ComputeNodeNotFound,
-                          model.remove_node, node2)
+        self.assertRaises(
+            exception.ComputeNodeNotFound, model.remove_node, node2
+        )
 
     def test_assert_node_raise(self):
         model = model_root.ModelRoot()
@@ -244,19 +261,26 @@ class TestModel(base.TestCase):
         node = element.ComputeNode(id=1)
         node.uuid = uuid_
         model.add_node(node)
-        self.assertRaises(exception.IllegalArgumentException,
-                          model.assert_node, "objet_qcq")
+        self.assertRaises(
+            exception.IllegalArgumentException, model.assert_node, "objet_qcq"
+        )
 
     def test_instance_from_uuid_raise(self):
         fake_cluster = faker_cluster_state.FakerModelCollector()
         model = fake_cluster.generate_scenario_1()
-        self.assertRaises(exception.InstanceNotFound,
-                          model.get_instance_by_uuid, "valeur_qcq")
+        self.assertRaises(
+            exception.InstanceNotFound,
+            model.get_instance_by_uuid,
+            "valeur_qcq",
+        )
 
     def test_assert_instance_raise(self):
         model = model_root.ModelRoot()
-        self.assertRaises(exception.IllegalArgumentException,
-                          model.assert_instance, "valeur_qcq")
+        self.assertRaises(
+            exception.IllegalArgumentException,
+            model.assert_instance,
+            "valeur_qcq",
+        )
 
     def test_get_node_instances(self):
         fake_cluster = faker_cluster_state.FakerModelCollector()
@@ -296,7 +320,6 @@ class TestModel(base.TestCase):
 
 
 class TestStorageModel(base.TestCase):
-
     def load_data(self, filename):
         cwd = os.path.abspath(os.path.dirname(__file__))
         data_folder = os.path.join(cwd, "data")
@@ -320,7 +343,8 @@ class TestStorageModel(base.TestCase):
         expected_struct_str = self.load_data('storage_scenario_1.xml')
         model2 = model_root.StorageModelRoot.from_xml(expected_struct_str)
         self.assertTrue(
-            model_root.StorageModelRoot.is_isomorphic(model2, model1))
+            model_root.StorageModelRoot.is_isomorphic(model2, model1)
+        )
 
     def test_build_model_from_xml(self):
         fake_cluster = faker_cluster_state.FakerStorageModelCollector()
@@ -335,23 +359,26 @@ class TestStorageModel(base.TestCase):
         model = model_root.StorageModelRoot()
         node = element.StorageNode(host="host@backend")
         model.add_node(node)
-        self.assertRaises(exception.IllegalArgumentException,
-                          model.assert_node, "obj")
+        self.assertRaises(
+            exception.IllegalArgumentException, model.assert_node, "obj"
+        )
 
     def test_assert_pool_raise(self):
         model = model_root.StorageModelRoot()
         pool = element.Pool(name="host@backend#pool")
         model.add_pool(pool)
-        self.assertRaises(exception.IllegalArgumentException,
-                          model.assert_pool, "obj")
+        self.assertRaises(
+            exception.IllegalArgumentException, model.assert_pool, "obj"
+        )
 
     def test_assert_volume_raise(self):
         model = model_root.StorageModelRoot()
         uuid_ = f"{uuidutils.generate_uuid()}"
         volume = element.Volume(uuid=uuid_)
         model.add_volume(volume)
-        self.assertRaises(exception.IllegalArgumentException,
-                          model.assert_volume, "obj")
+        self.assertRaises(
+            exception.IllegalArgumentException, model.assert_volume, "obj"
+        )
 
     def test_add_node(self):
         model = model_root.StorageModelRoot()
@@ -374,8 +401,9 @@ class TestStorageModel(base.TestCase):
         model.add_node(node)
         self.assertEqual(node, model.get_node_by_name(hostname))
         model.remove_node(node)
-        self.assertRaises(exception.StorageNodeNotFound,
-                          model.get_node_by_name, hostname)
+        self.assertRaises(
+            exception.StorageNodeNotFound, model.get_node_by_name, hostname
+        )
 
     def test_remove_pool(self):
         model = model_root.StorageModelRoot()
@@ -384,8 +412,9 @@ class TestStorageModel(base.TestCase):
         model.add_pool(pool)
         self.assertEqual(pool, model.get_pool_by_pool_name(pool_name))
         model.remove_pool(pool)
-        self.assertRaises(exception.PoolNotFound,
-                          model.get_pool_by_pool_name, pool_name)
+        self.assertRaises(
+            exception.PoolNotFound, model.get_pool_by_pool_name, pool_name
+        )
 
     def test_map_unmap_pool(self):
         model = model_root.StorageModelRoot()
@@ -416,8 +445,9 @@ class TestStorageModel(base.TestCase):
         model.add_volume(volume)
         self.assertEqual(volume, model.get_volume_by_uuid(uuid_))
         model.remove_volume(volume)
-        self.assertRaises(exception.VolumeNotFound,
-                          model.get_volume_by_uuid, uuid_)
+        self.assertRaises(
+            exception.VolumeNotFound, model.get_volume_by_uuid, uuid_
+        )
 
     def test_map_unmap_volume(self):
         model = model_root.StorageModelRoot()
@@ -497,7 +527,6 @@ class TestStorageModel(base.TestCase):
 
 
 class TestBaremetalModel(base.TestCase):
-
     def load_data(self, filename):
         cwd = os.path.abspath(os.path.dirname(__file__))
         data_folder = os.path.join(cwd, "data")
@@ -518,7 +547,8 @@ class TestBaremetalModel(base.TestCase):
         expected_struct_str = self.load_data('ironic_scenario_1.xml')
         model2 = model_root.BaremetalModelRoot.from_xml(expected_struct_str)
         self.assertTrue(
-            model_root.BaremetalModelRoot.is_isomorphic(model2, model1))
+            model_root.BaremetalModelRoot.is_isomorphic(model2, model1)
+        )
 
     def test_build_model_from_xml(self):
         fake_cluster = faker_cluster_state.FakerBaremetalModelCollector()
@@ -534,8 +564,9 @@ class TestBaremetalModel(base.TestCase):
         node_uuid = uuidutils.generate_uuid()
         node = element.IronicNode(uuid=node_uuid)
         model.add_node(node)
-        self.assertRaises(exception.IllegalArgumentException,
-                          model.assert_node, "obj")
+        self.assertRaises(
+            exception.IllegalArgumentException, model.assert_node, "obj"
+        )
 
     def test_add_node(self):
         model = model_root.BaremetalModelRoot()
@@ -551,8 +582,9 @@ class TestBaremetalModel(base.TestCase):
         model.add_node(node)
         self.assertEqual(node, model.get_node_by_uuid(node_uuid))
         model.remove_node(node)
-        self.assertRaises(exception.IronicNodeNotFound,
-                          model.get_node_by_uuid, node_uuid)
+        self.assertRaises(
+            exception.IronicNodeNotFound, model.get_node_by_uuid, node_uuid
+        )
 
     def test_get_all_ironic_nodes(self):
         model = model_root.BaremetalModelRoot()
diff --git a/watcher/tests/unit/decision_engine/planner/test_node_resource_consolidation.py b/watcher/tests/unit/decision_engine/planner/test_node_resource_consolidation.py
index 002747bc4..d1decc938 100644
--- a/watcher/tests/unit/decision_engine/planner/test_node_resource_consolidation.py
+++ b/watcher/tests/unit/decision_engine/planner/test_node_resource_consolidation.py
@@ -29,34 +29,37 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestActionScheduling(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.goal = db_utils.create_test_goal(name="server_consolidation")
         self.strategy = db_utils.create_test_strategy(
-            name="node_resource_consolidation")
+            name="node_resource_consolidation"
+        )
         self.audit = db_utils.create_test_audit(
-            uuid=utils.generate_uuid(), strategy_id=self.strategy.id)
+            uuid=utils.generate_uuid(), strategy_id=self.strategy.id
+        )
         self.planner = pbase.NodeResourceConsolidationPlanner(mock.Mock())
 
     def test_schedule_actions(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "host1",
-            "destination_node": "host2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"source_node": "host1", "destination_node": "host2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
         with mock.patch.object(
-            pbase.NodeResourceConsolidationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.NodeResourceConsolidationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
 
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_action.call_count)
@@ -66,105 +69,135 @@ class TestActionScheduling(base.DbTestCase):
 
     def test_schedule_two_actions(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
         server1_uuid = "b199db0c-1408-4d52-b5a5-5ca14de0ff36"
         server2_uuid = "b199db0c-1408-4d52-b5a5-5ca14de0ff37"
-        solution.add_action(action_type="migrate",
-                            resource_id=server1_uuid,
-                            input_parameters={
-                                "source_node": "host1",
-                                "destination_node": "host2",
-                            })
+        solution.add_action(
+            action_type="migrate",
+            resource_id=server1_uuid,
+            input_parameters={
+                "source_node": "host1",
+                "destination_node": "host2",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id=server2_uuid,
-                            input_parameters={
-                                "source_node": "host1",
-                                "destination_node": "host3",
-                            })
+        solution.add_action(
+            action_type="migrate",
+            resource_id=server2_uuid,
+            input_parameters={
+                "source_node": "host1",
+                "destination_node": "host3",
+            },
+        )
 
         with mock.patch.object(
-            pbase.NodeResourceConsolidationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.NodeResourceConsolidationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(2, m_create_action.call_count)
         # check order
         filters = {'action_plan_id': action_plan.id}
         actions = objects.Action.dbapi.get_action_list(self.context, filters)
         self.assertEqual(
-            server1_uuid, actions[0]['input_parameters'].get('resource_id'))
+            server1_uuid, actions[0]['input_parameters'].get('resource_id')
+        )
         self.assertEqual(
-            server2_uuid, actions[1]['input_parameters'].get('resource_id'))
+            server2_uuid, actions[1]['input_parameters'].get('resource_id')
+        )
         self.assertIn(actions[0]['uuid'], actions[1]['parents'])
 
     def test_schedule_actions_with_unknown_action(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "src_uuid_node": "host1",
-            "dst_uuid_node": "host2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"src_uuid_node": "host1", "dst_uuid_node": "host2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="new_action_type",
-                            resource_id="",
-                            input_parameters={})
+        solution.add_action(
+            action_type="new_action_type", resource_id="", input_parameters={}
+        )
 
         with mock.patch.object(
-            pbase.NodeResourceConsolidationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.NodeResourceConsolidationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             self.assertRaises(
                 exception.UnsupportedActionType,
                 self.planner.schedule,
-                self.context, self.audit.id, solution)
+                self.context,
+                self.audit.id,
+                solution,
+            )
         self.assertEqual(2, m_create_action.call_count)
 
     def test_schedule_migrate_change_state_actions(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        solution.add_action(action_type="change_nova_service_state",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters={"state": "disabled"})
+        solution.add_action(
+            action_type="change_nova_service_state",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters={"state": "disabled"},
+        )
 
-        solution.add_action(action_type="change_nova_service_state",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff37",
-                            input_parameters={"state": "disabled"})
+        solution.add_action(
+            action_type="change_nova_service_state",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff37",
+            input_parameters={"state": "disabled"},
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="f6416850-da28-4047-a547-8c49f53e95fe",
-                            input_parameters={"source_node": "host1"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="f6416850-da28-4047-a547-8c49f53e95fe",
+            input_parameters={"source_node": "host1"},
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="bb404e74-2caf-447b-bd1e-9234db386ca5",
-                            input_parameters={"source_node": "host2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="bb404e74-2caf-447b-bd1e-9234db386ca5",
+            input_parameters={"source_node": "host2"},
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="f6416850-da28-4047-a547-8c49f53e95ff",
-                            input_parameters={"source_node": "host1"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="f6416850-da28-4047-a547-8c49f53e95ff",
+            input_parameters={"source_node": "host1"},
+        )
 
-        solution.add_action(action_type="change_nova_service_state",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters={"state": "enabled"})
+        solution.add_action(
+            action_type="change_nova_service_state",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters={"state": "enabled"},
+        )
 
-        solution.add_action(action_type="change_nova_service_state",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff37",
-                            input_parameters={"state": "enabled"})
+        solution.add_action(
+            action_type="change_nova_service_state",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff37",
+            input_parameters={"state": "enabled"},
+        )
 
         with mock.patch.object(
-                pbase.NodeResourceConsolidationPlanner, "create_action",
-                wraps=self.planner.create_action
+            pbase.NodeResourceConsolidationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(7, m_create_action.call_count)
         # check order
@@ -202,27 +235,28 @@ class TestActionScheduling(base.DbTestCase):
 
 
 class TestDefaultPlanner(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.planner = pbase.NodeResourceConsolidationPlanner(mock.Mock())
 
         self.goal = obj_utils.create_test_goal(self.context)
         self.strategy = obj_utils.create_test_strategy(
-            self.context, goal_id=self.goal.id)
+            self.context, goal_id=self.goal.id
+        )
         obj_utils.create_test_audit_template(
-            self.context, goal_id=self.goal.id, strategy_id=self.strategy.id)
+            self.context, goal_id=self.goal.id, strategy_id=self.strategy.id
+        )
 
         p = mock.patch.object(db_api.BaseConnection, 'create_action_plan')
         self.mock_create_action_plan = p.start()
         self.mock_create_action_plan.side_effect = (
-            self._simulate_action_plan_create)
+            self._simulate_action_plan_create
+        )
         self.addCleanup(p.stop)
 
         q = mock.patch.object(db_api.BaseConnection, 'create_action')
         self.mock_create_action = q.start()
-        self.mock_create_action.side_effect = (
-            self._simulate_action_create)
+        self.mock_create_action.side_effect = self._simulate_action_create
         self.addCleanup(q.stop)
 
     def _simulate_action_plan_create(self, action_plan):
@@ -237,9 +271,10 @@ class TestDefaultPlanner(base.DbTestCase):
     def test_scheduler_warning_empty_action_plan(self, m_get_by_name):
         m_get_by_name.return_value = self.strategy
         audit = db_utils.create_test_audit(
-            goal_id=self.goal.id, strategy_id=self.strategy.id)
-        fake_solution = mock.MagicMock(efficacy_indicators=[],
-                                       actions=[])
+            goal_id=self.goal.id, strategy_id=self.strategy.id
+        )
+        fake_solution = mock.MagicMock(efficacy_indicators=[], actions=[])
         action_plan = self.planner.schedule(
-            self.context, audit.id, fake_solution)
+            self.context, audit.id, fake_solution
+        )
         self.assertIsNotNone(action_plan.uuid)
diff --git a/watcher/tests/unit/decision_engine/planner/test_planner_manager.py b/watcher/tests/unit/decision_engine/planner/test_planner_manager.py
index c0bc85bb8..ff8b5dba1 100644
--- a/watcher/tests/unit/decision_engine/planner/test_planner_manager.py
+++ b/watcher/tests/unit/decision_engine/planner/test_planner_manager.py
@@ -25,5 +25,6 @@ class TestPlannerManager(base.TestCase):
         cfg.CONF.set_override('planner', "weight", group='watcher_planner')
         manager = planner.PlannerManager()
         selected_planner = cfg.CONF.watcher_planner.planner
-        self.assertIsInstance(manager.load(selected_planner),
-                              weight.WeightPlanner)
+        self.assertIsInstance(
+            manager.load(selected_planner), weight.WeightPlanner
+        )
diff --git a/watcher/tests/unit/decision_engine/planner/test_weight_planner.py b/watcher/tests/unit/decision_engine/planner/test_weight_planner.py
index 57d628064..c8460e10b 100644
--- a/watcher/tests/unit/decision_engine/planner/test_weight_planner.py
+++ b/watcher/tests/unit/decision_engine/planner/test_weight_planner.py
@@ -37,7 +37,8 @@ class SolutionFaker:
         sercon = strategies.BasicConsolidation(config=mock.Mock())
         sercon.compute_model = current_state_cluster.generate_scenario_1()
         sercon.gnocchi = mock.MagicMock(
-            get_statistics=metrics.mock_get_statistics)
+            get_statistics=metrics.mock_get_statistics
+        )
         return sercon.execute()
 
 
@@ -48,21 +49,23 @@ class SolutionFakerSingleHyp:
         current_state_cluster = faker_cluster_state.FakerModelCollector()
         sercon = strategies.BasicConsolidation(config=mock.Mock())
         sercon.compute_model = (
-            current_state_cluster.generate_scenario_3_with_2_nodes())
+            current_state_cluster.generate_scenario_3_with_2_nodes()
+        )
         sercon.gnocchi = mock.MagicMock(
-            get_statistics=metrics.mock_get_statistics)
+            get_statistics=metrics.mock_get_statistics
+        )
 
         return sercon.execute()
 
 
 class TestActionScheduling(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.goal = db_utils.create_test_goal(name="dummy")
         self.strategy = db_utils.create_test_strategy(name="dummy")
         self.audit = db_utils.create_test_audit(
-            uuid=utils.generate_uuid(), strategy_id=self.strategy.id)
+            uuid=utils.generate_uuid(), strategy_id=self.strategy.id
+        )
         self.planner = pbase.WeightPlanner(
             mock.Mock(
                 weights={
@@ -82,7 +85,9 @@ class TestActionScheduling(base.DbTestCase):
                     'change_nova_service_state': 1,
                     'nop': 1,
                     'new_action_type': 70,
-                }))
+                },
+            )
+        )
 
     @mock.patch.object(utils, "generate_uuid")
     def test_schedule_actions(self, m_generate_uuid):
@@ -99,37 +104,56 @@ class TestActionScheduling(base.DbTestCase):
             # "99999999-9999-9999-9999-999999999999",
         ]
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
         self.planner.config.weights = {'migrate': 3}
         action_plan = self.planner.schedule(
-            self.context, self.audit.id, solution)
+            self.context, self.audit.id, solution
+        )
 
         self.assertIsNotNone(action_plan.uuid)
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
         expected_edges = []
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -148,49 +172,77 @@ class TestActionScheduling(base.DbTestCase):
             "55555555-5555-5555-5555-555555555555",  # Nop 1
         ]
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
         # We create the migrate action before but we then schedule
         # after the nop action
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
-        solution.add_action(action_type="nop",
-                            input_parameters={"message": "Hello world"})
+        solution.add_action(
+            action_type="nop", input_parameters={"message": "Hello world"}
+        )
 
         self.planner.config.weights = {'migrate': 3, 'nop': 5}
 
         action_plan = self.planner.schedule(
-            self.context, self.audit.id, solution)
+            self.context, self.audit.id, solution
+        )
 
         self.assertIsNotNone(action_plan.uuid)
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'nop',
-               'parents': [],
-               'uuid': '55555555-5555-5555-5555-555555555555'},
-              {'action_type': 'migrate',
-               'parents': ['55555555-5555-5555-5555-555555555555'],
-               'uuid': '44444444-4444-4444-4444-444444444444'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'nop',
+                    'parents': [],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': ['55555555-5555-5555-5555-555555555555'],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            )
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -205,48 +257,68 @@ class TestActionScheduling(base.DbTestCase):
             "11111111-1111-1111-1111-111111111111",  # Migrate 1
             "22222222-2222-2222-2222-222222222222",  # new_action_type
             "33333333-3333-3333-3333-333333333333",
-
         ]
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "src_uuid_node": "server1",
-            "dst_uuid_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters=parameters)
+        parameters = {"src_uuid_node": "server1", "dst_uuid_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="new_action_type",
-                            resource_id="",
-                            input_parameters={})
+        solution.add_action(
+            action_type="new_action_type", resource_id="", input_parameters={}
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'new_action_type',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'migrate',
-               'parents': ['22222222-2222-2222-2222-222222222222'],
-               'uuid': '11111111-1111-1111-1111-111111111111'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'new_action_type',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': ['22222222-2222-2222-2222-222222222222'],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+            )
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -271,45 +343,68 @@ class TestActionScheduling(base.DbTestCase):
         ]
         m_nova.return_value = 'server1'
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server1",
-            "destination_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server1", "destination_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"flavor": "x1"})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={"flavor": "x1"},
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111'],
-               'uuid': '22222222-2222-2222-2222-222222222222'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': ['11111111-1111-1111-1111-111111111111'],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+            )
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -319,7 +414,8 @@ class TestActionScheduling(base.DbTestCase):
 
     @mock.patch.object(utils, "generate_uuid")
     def test_schedule_3_migrate_1_resize_1_acpi_actions_1_swimlane(
-            self, m_generate_uuid):
+        self, m_generate_uuid
+    ):
         self.planner.config.parallelization["migrate"] = 1
         m_generate_uuid.side_effect = [
             "00000000-0000-0000-0000-000000000000",  # Action plan
@@ -335,77 +431,128 @@ class TestActionScheduling(base.DbTestCase):
         ]
 
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server0",
-            "destination_node": "server1",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server0", "destination_node": "server1"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server2",
-                                              "destination_node": "server3"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server2",
+                "destination_node": "server3",
+            },
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={'flavor': 'x1'},
+        )
 
-        solution.add_action(action_type="turn_host_to_acpi_s3_state",
-                            resource_id="server1",
-                            input_parameters={})
+        solution.add_action(
+            action_type="turn_host_to_acpi_s3_state",
+            resource_id="server1",
+            input_parameters={},
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111'],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'migrate',
-               'parents': ['22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111'],
-               'uuid': '22222222-2222-2222-2222-222222222222'}),
-             ({'action_type': 'resize',
-               'parents': ['33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'},
-              {'action_type': 'turn_host_to_acpi_s3_state',
-               'parents': ['44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': ['22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'},
-              {'action_type': 'resize',
-               'parents': ['33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': ['11111111-1111-1111-1111-111111111111'],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': ['22222222-2222-2222-2222-222222222222'],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': ['11111111-1111-1111-1111-111111111111'],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+            ),
+            (
+                {
+                    'action_type': 'resize',
+                    'parents': ['33333333-3333-3333-3333-333333333333'],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+                {
+                    'action_type': 'turn_host_to_acpi_s3_state',
+                    'parents': ['44444444-4444-4444-4444-444444444444'],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': ['22222222-2222-2222-2222-222222222222'],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': ['33333333-3333-3333-3333-333333333333'],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -415,7 +562,8 @@ class TestActionScheduling(base.DbTestCase):
 
     @mock.patch.object(utils, "generate_uuid")
     def test_schedule_migrate_resize_acpi_actions_2_swimlanes(
-            self, m_generate_uuid):
+        self, m_generate_uuid
+    ):
         self.planner.config.parallelization["migrate"] = 2
         m_generate_uuid.side_effect = [
             "00000000-0000-0000-0000-000000000000",  # Action plan
@@ -431,80 +579,137 @@ class TestActionScheduling(base.DbTestCase):
         ]
 
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server0",
-            "destination_node": "server1",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server0", "destination_node": "server1"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server2",
-                                              "destination_node": "server3"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server2",
+                "destination_node": "server3",
+            },
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={'flavor': 'x1'},
+        )
 
-        solution.add_action(action_type="turn_host_to_acpi_s3_state",
-                            resource_id="server1",
-                            input_parameters={})
+        solution.add_action(
+            action_type="turn_host_to_acpi_s3_state",
+            resource_id="server1",
+            input_parameters={},
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'}),
-             ({'action_type': 'resize',
-               'parents': ['33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'},
-              {'action_type': 'turn_host_to_acpi_s3_state',
-               'parents': ['44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'}),
-             ({'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'},
-              {'action_type': 'resize',
-               'parents': ['33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+            ),
+            (
+                {
+                    'action_type': 'resize',
+                    'parents': ['33333333-3333-3333-3333-333333333333'],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+                {
+                    'action_type': 'turn_host_to_acpi_s3_state',
+                    'parents': ['44444444-4444-4444-4444-444444444444'],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': ['33333333-3333-3333-3333-333333333333'],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -514,7 +719,8 @@ class TestActionScheduling(base.DbTestCase):
 
     @mock.patch.object(utils, "generate_uuid")
     def test_schedule_migrate_resize_acpi_actions_3_swimlanes(
-            self, m_generate_uuid):
+        self, m_generate_uuid
+    ):
         self.planner.config.parallelization["migrate"] = 3
         m_generate_uuid.side_effect = [
             "00000000-0000-0000-0000-000000000000",  # Action plan
@@ -530,85 +736,144 @@ class TestActionScheduling(base.DbTestCase):
         ]
 
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server0",
-            "destination_node": "server1",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server0", "destination_node": "server1"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server2",
-                                              "destination_node": "server3"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server2",
+                "destination_node": "server3",
+            },
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={'flavor': 'x1'},
+        )
 
-        solution.add_action(action_type="turn_host_to_acpi_s3_state",
-                            resource_id="server1",
-                            input_parameters={})
+        solution.add_action(
+            action_type="turn_host_to_acpi_s3_state",
+            resource_id="server1",
+            input_parameters={},
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'},
-              {'action_type': 'turn_host_to_acpi_s3_state',
-               'parents': ['44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '33333333-3333-3333-3333-333333333333'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '44444444-4444-4444-4444-444444444444'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+                {
+                    'action_type': 'turn_host_to_acpi_s3_state',
+                    'parents': ['44444444-4444-4444-4444-444444444444'],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -617,8 +882,7 @@ class TestActionScheduling(base.DbTestCase):
             self.assertIn(pair, edges)
 
     @mock.patch.object(utils, "generate_uuid")
-    def test_schedule_three_migrate_two_resize_actions(
-            self, m_generate_uuid):
+    def test_schedule_three_migrate_two_resize_actions(self, m_generate_uuid):
         self.planner.config.parallelization["migrate"] = 3
         self.planner.config.parallelization["resize"] = 2
         m_generate_uuid.side_effect = [
@@ -635,101 +899,176 @@ class TestActionScheduling(base.DbTestCase):
         ]
 
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server0",
-            "destination_node": "server1",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server0", "destination_node": "server1"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server2",
-                                              "destination_node": "server3"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server2",
+                "destination_node": "server3",
+            },
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={'flavor': 'x1'},
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="b189db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="b189db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters={'flavor': 'x1'},
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '33333333-3333-3333-3333-333333333333'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '33333333-3333-3333-3333-333333333333'},
-              {'action_type': 'resize',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222',
-                           '33333333-3333-3333-3333-333333333333'],
-               'uuid': '55555555-5555-5555-5555-555555555555'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                        '33333333-3333-3333-3333-333333333333',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -739,7 +1078,8 @@ class TestActionScheduling(base.DbTestCase):
 
     @mock.patch.object(utils, "generate_uuid")
     def test_schedule_5_migrate_2_resize_actions_for_2_swimlanes(
-            self, m_generate_uuid):
+        self, m_generate_uuid
+    ):
         self.planner.config.parallelization["migrate"] = 2
         self.planner.config.parallelization["resize"] = 2
         m_generate_uuid.side_effect = [
@@ -756,135 +1096,261 @@ class TestActionScheduling(base.DbTestCase):
         ]
 
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server6"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server6",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server2",
-                                              "destination_node": "server6"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server2",
+                "destination_node": "server6",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server3",
-                                              "destination_node": "server6"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server3",
+                "destination_node": "server6",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server4",
-                                              "destination_node": "server6"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server4",
+                "destination_node": "server6",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={"source_node": "server5",
-                                              "destination_node": "server6"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="DOESNOTMATTER",
+            input_parameters={
+                "source_node": "server5",
+                "destination_node": "server6",
+            },
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={'flavor': 'x1'},
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="DOESNOTMATTER",
-                            input_parameters={'flavor': 'x2'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="DOESNOTMATTER",
+            input_parameters={'flavor': 'x2'},
+        )
 
-        solution.add_action(action_type="turn_host_to_acpi_s3_state",
-                            resource_id="DOESNOTMATTER")
+        solution.add_action(
+            action_type="turn_host_to_acpi_s3_state",
+            resource_id="DOESNOTMATTER",
+        )
 
         with mock.patch.object(
-            pbase.WeightPlanner, "create_scheduled_actions",
-            wraps=self.planner.create_scheduled_actions
+            pbase.WeightPlanner,
+            "create_scheduled_actions",
+            wraps=self.planner.create_scheduled_actions,
         ) as m_create_scheduled_actions:
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_scheduled_actions.call_count)
         action_graph = m_create_scheduled_actions.call_args[0][0]
 
-        expected_edges = \
-            [({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '11111111-1111-1111-1111-111111111111'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '44444444-4444-4444-4444-444444444444'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'}),
-             ({'action_type': 'migrate',
-               'parents': [],
-               'uuid': '22222222-2222-2222-2222-222222222222'},
-              {'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '44444444-4444-4444-4444-444444444444'}),
-             ({'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '33333333-3333-3333-3333-333333333333'},
-              {'action_type': 'migrate',
-               'parents': ['33333333-3333-3333-3333-333333333333',
-                           '44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': ['11111111-1111-1111-1111-111111111111',
-                           '22222222-2222-2222-2222-222222222222'],
-               'uuid': '44444444-4444-4444-4444-444444444444'},
-              {'action_type': 'migrate',
-               'parents': ['33333333-3333-3333-3333-333333333333',
-                           '44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'}),
-             ({'action_type': 'migrate',
-               'parents': ['33333333-3333-3333-3333-333333333333',
-                           '44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'},
-              {'action_type': 'resize',
-               'parents': ['55555555-5555-5555-5555-555555555555'],
-               'uuid': '66666666-6666-6666-6666-666666666666'}),
-             ({'action_type': 'migrate',
-               'parents': ['33333333-3333-3333-3333-333333333333',
-                           '44444444-4444-4444-4444-444444444444'],
-               'uuid': '55555555-5555-5555-5555-555555555555'},
-              {'action_type': 'resize',
-               'parents': ['55555555-5555-5555-5555-555555555555'],
-               'uuid': '77777777-7777-7777-7777-777777777777'}),
-             ({'action_type': 'resize',
-               'parents': ['55555555-5555-5555-5555-555555555555'],
-               'uuid': '66666666-6666-6666-6666-666666666666'},
-              {'action_type': 'turn_host_to_acpi_s3_state',
-               'parents': ['66666666-6666-6666-6666-666666666666',
-                           '77777777-7777-7777-7777-777777777777'],
-               'uuid': '88888888-8888-8888-8888-888888888888'}),
-             ({'action_type': 'resize',
-               'parents': ['55555555-5555-5555-5555-555555555555'],
-               'uuid': '77777777-7777-7777-7777-777777777777'},
-              {'action_type': 'turn_host_to_acpi_s3_state',
-               'parents': ['66666666-6666-6666-6666-666666666666',
-                           '77777777-7777-7777-7777-777777777777'],
-               'uuid': '88888888-8888-8888-8888-888888888888'})]
+        expected_edges = [
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '11111111-1111-1111-1111-111111111111',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [],
+                    'uuid': '22222222-2222-2222-2222-222222222222',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '33333333-3333-3333-3333-333333333333',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '33333333-3333-3333-3333-333333333333',
+                        '44444444-4444-4444-4444-444444444444',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '11111111-1111-1111-1111-111111111111',
+                        '22222222-2222-2222-2222-222222222222',
+                    ],
+                    'uuid': '44444444-4444-4444-4444-444444444444',
+                },
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '33333333-3333-3333-3333-333333333333',
+                        '44444444-4444-4444-4444-444444444444',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '33333333-3333-3333-3333-333333333333',
+                        '44444444-4444-4444-4444-444444444444',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': ['55555555-5555-5555-5555-555555555555'],
+                    'uuid': '66666666-6666-6666-6666-666666666666',
+                },
+            ),
+            (
+                {
+                    'action_type': 'migrate',
+                    'parents': [
+                        '33333333-3333-3333-3333-333333333333',
+                        '44444444-4444-4444-4444-444444444444',
+                    ],
+                    'uuid': '55555555-5555-5555-5555-555555555555',
+                },
+                {
+                    'action_type': 'resize',
+                    'parents': ['55555555-5555-5555-5555-555555555555'],
+                    'uuid': '77777777-7777-7777-7777-777777777777',
+                },
+            ),
+            (
+                {
+                    'action_type': 'resize',
+                    'parents': ['55555555-5555-5555-5555-555555555555'],
+                    'uuid': '66666666-6666-6666-6666-666666666666',
+                },
+                {
+                    'action_type': 'turn_host_to_acpi_s3_state',
+                    'parents': [
+                        '66666666-6666-6666-6666-666666666666',
+                        '77777777-7777-7777-7777-777777777777',
+                    ],
+                    'uuid': '88888888-8888-8888-8888-888888888888',
+                },
+            ),
+            (
+                {
+                    'action_type': 'resize',
+                    'parents': ['55555555-5555-5555-5555-555555555555'],
+                    'uuid': '77777777-7777-7777-7777-777777777777',
+                },
+                {
+                    'action_type': 'turn_host_to_acpi_s3_state',
+                    'parents': [
+                        '66666666-6666-6666-6666-666666666666',
+                        '77777777-7777-7777-7777-777777777777',
+                    ],
+                    'uuid': '88888888-8888-8888-8888-888888888888',
+                },
+            ),
+        ]
 
-        edges = sorted([(src.as_dict(), dst.as_dict())
-                        for src, dst in action_graph.edges()],
-                       key=lambda pair: pair[0]['uuid'])
+        edges = sorted(
+            [
+                (src.as_dict(), dst.as_dict())
+                for src, dst in action_graph.edges()
+            ],
+            key=lambda pair: pair[0]['uuid'],
+        )
         for src, dst in edges:
-            for key in ('id', 'action_plan', 'action_plan_id', 'created_at',
-                        'input_parameters', 'deleted_at', 'updated_at',
-                        'state', 'status_message'):
+            for key in (
+                'id',
+                'action_plan',
+                'action_plan_id',
+                'created_at',
+                'input_parameters',
+                'deleted_at',
+                'updated_at',
+                'state',
+                'status_message',
+            ):
                 del src[key]
                 del dst[key]
 
@@ -894,7 +1360,6 @@ class TestActionScheduling(base.DbTestCase):
 
 
 class TestWeightPlanner(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.planner = pbase.WeightPlanner(mock.Mock())
@@ -902,25 +1367,27 @@ class TestWeightPlanner(base.DbTestCase):
             'nop': 0,
             'sleep': 1,
             'change_nova_service_state': 2,
-            'migrate': 3
+            'migrate': 3,
         }
 
         self.goal = obj_utils.create_test_goal(self.context)
         self.strategy = obj_utils.create_test_strategy(
-            self.context, goal_id=self.goal.id)
+            self.context, goal_id=self.goal.id
+        )
         obj_utils.create_test_audit_template(
-            self.context, goal_id=self.goal.id, strategy_id=self.strategy.id)
+            self.context, goal_id=self.goal.id, strategy_id=self.strategy.id
+        )
 
         p = mock.patch.object(db_api.BaseConnection, 'create_action_plan')
         self.mock_create_action_plan = p.start()
         self.mock_create_action_plan.side_effect = (
-            self._simulate_action_plan_create)
+            self._simulate_action_plan_create
+        )
         self.addCleanup(p.stop)
 
         q = mock.patch.object(db_api.BaseConnection, 'create_action')
         self.mock_create_action = q.start()
-        self.mock_create_action.side_effect = (
-            self._simulate_action_create)
+        self.mock_create_action.side_effect = self._simulate_action_create
         self.addCleanup(q.stop)
 
     def _simulate_action_plan_create(self, action_plan):
@@ -935,9 +1402,10 @@ class TestWeightPlanner(base.DbTestCase):
     def test_scheduler_warning_empty_action_plan(self, m_get_by_name):
         m_get_by_name.return_value = self.strategy
         audit = db_utils.create_test_audit(
-            goal_id=self.goal.id, strategy_id=self.strategy.id)
-        fake_solution = mock.MagicMock(efficacy_indicators=[],
-                                       actions=[])
+            goal_id=self.goal.id, strategy_id=self.strategy.id
+        )
+        fake_solution = mock.MagicMock(efficacy_indicators=[], actions=[])
         action_plan = self.planner.schedule(
-            self.context, audit.id, fake_solution)
+            self.context, audit.id, fake_solution
+        )
         self.assertIsNotNone(action_plan.uuid)
diff --git a/watcher/tests/unit/decision_engine/planner/test_workload_stabilization_planner.py b/watcher/tests/unit/decision_engine/planner/test_workload_stabilization_planner.py
index a79b2757c..d9a21fb6c 100644
--- a/watcher/tests/unit/decision_engine/planner/test_workload_stabilization_planner.py
+++ b/watcher/tests/unit/decision_engine/planner/test_workload_stabilization_planner.py
@@ -40,7 +40,8 @@ class SolutionFaker:
         sercon = strategies.BasicConsolidation(config=mock.Mock())
         sercon._compute_model = current_state_cluster.generate_scenario_1()
         sercon.gnocchi = mock.MagicMock(
-            get_statistics=metrics.mock_get_statistics)
+            get_statistics=metrics.mock_get_statistics
+        )
         return sercon.execute()
 
 
@@ -51,21 +52,23 @@ class SolutionFakerSingleHyp:
         current_state_cluster = faker_cluster_state.FakerModelCollector()
         sercon = strategies.BasicConsolidation(config=mock.Mock())
         sercon._compute_model = (
-            current_state_cluster.generate_scenario_3_with_2_nodes())
+            current_state_cluster.generate_scenario_3_with_2_nodes()
+        )
         sercon.gnocchi = mock.MagicMock(
-            get_statistics=metrics.mock_get_statistics)
+            get_statistics=metrics.mock_get_statistics
+        )
 
         return sercon.execute()
 
 
 class TestActionScheduling(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.goal = db_utils.create_test_goal(name="dummy")
         self.strategy = db_utils.create_test_strategy(name="dummy")
         self.audit = db_utils.create_test_audit(
-            uuid=utils.generate_uuid(), strategy_id=self.strategy.id)
+            uuid=utils.generate_uuid(), strategy_id=self.strategy.id
+        )
         self.planner = pbase.WorkloadStabilizationPlanner(mock.Mock())
         self.useFixture(
             fixtures.MockPatch("watcher.common.clients.get_sdk_connection")
@@ -74,23 +77,25 @@ class TestActionScheduling(base.DbTestCase):
 
     def test_schedule_actions(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server1",
-            "destination_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server1", "destination_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
         with mock.patch.object(
-            pbase.WorkloadStabilizationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.WorkloadStabilizationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             self.planner.config.weights = {'migrate': 3}
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
 
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(1, m_create_action.call_count)
@@ -100,26 +105,29 @@ class TestActionScheduling(base.DbTestCase):
 
     def test_schedule_two_actions(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server1",
-            "destination_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server1", "destination_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="nop",
-                            input_parameters={"message": "Hello world"})
+        solution.add_action(
+            action_type="nop", input_parameters={"message": "Hello world"}
+        )
 
         with mock.patch.object(
-            pbase.WorkloadStabilizationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.WorkloadStabilizationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             self.planner.config.weights = {'migrate': 3, 'nop': 5}
             action_plan = self.planner.schedule(
-                self.context, self.audit.id, solution)
+                self.context, self.audit.id, solution
+            )
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(2, m_create_action.call_count)
         # check order
@@ -130,49 +138,56 @@ class TestActionScheduling(base.DbTestCase):
 
     def test_schedule_actions_with_unknown_action(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "src_uuid_node": "server1",
-            "dst_uuid_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"src_uuid_node": "server1", "dst_uuid_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="new_action_type",
-                            resource_id="",
-                            input_parameters={})
+        solution.add_action(
+            action_type="new_action_type", resource_id="", input_parameters={}
+        )
 
         with mock.patch.object(
-            pbase.WorkloadStabilizationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.WorkloadStabilizationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             with mock.patch.object(nova_helper, 'NovaHelper') as m_nova:
                 self.planner.config.weights = {'migrate': 0}
-                self.assertRaises(KeyError, self.planner.schedule,
-                                  self.context, self.audit.id, solution)
+                self.assertRaises(
+                    KeyError,
+                    self.planner.schedule,
+                    self.context,
+                    self.audit.id,
+                    solution,
+                )
                 assert not m_nova.called
         self.assertEqual(2, m_create_action.call_count)
 
     def test_schedule_actions_with_unsupported_action(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "src_uuid_node": "server1",
-            "dst_uuid_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"src_uuid_node": "server1", "dst_uuid_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="new_action_type",
-                            resource_id="",
-                            input_parameters={})
+        solution.add_action(
+            action_type="new_action_type", resource_id="", input_parameters={}
+        )
         with mock.patch.object(
-            pbase.WorkloadStabilizationPlanner, "create_action",
-            wraps=self.planner.create_action
+            pbase.WorkloadStabilizationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             with mock.patch.object(nova_helper, 'NovaHelper') as m_nova:
                 self.planner.config.weights = {
@@ -182,10 +197,15 @@ class TestActionScheduling(base.DbTestCase):
                     'sleep': 3,
                     'change_nova_service_state': 4,
                     'nop': 5,
-                    'new_action_type': 6}
-                self.assertRaises(exception.UnsupportedActionType,
-                                  self.planner.schedule,
-                                  self.context, self.audit.id, solution)
+                    'new_action_type': 6,
+                }
+                self.assertRaises(
+                    exception.UnsupportedActionType,
+                    self.planner.schedule,
+                    self.context,
+                    self.audit.id,
+                    solution,
+                )
                 assert not m_nova.called
         self.assertEqual(2, m_create_action.call_count)
 
@@ -193,28 +213,32 @@ class TestActionScheduling(base.DbTestCase):
     def test_schedule_migrate_resize_actions(self, mock_nova):
         mock_nova.return_value = 'server1'
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server1",
-            "destination_node": "server2",
-        }
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        parameters = {"source_node": "server1", "destination_node": "server2"}
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters={"flavor": "x1"})
+        solution.add_action(
+            action_type="resize",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters={"flavor": "x1"},
+        )
 
         with mock.patch.object(
-                pbase.WorkloadStabilizationPlanner, "create_action",
-                wraps=self.planner.create_action
+            pbase.WorkloadStabilizationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
             with mock.patch.object(nova_helper, 'NovaHelper') as m_nova:
                 self.planner.config.weights = {'migrate': 3, 'resize': 2}
                 action_plan = self.planner.schedule(
-                    self.context, self.audit.id, solution)
+                    self.context, self.audit.id, solution
+                )
                 self.assertEqual(1, m_nova.call_count)
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(2, m_create_action.call_count)
@@ -227,41 +251,53 @@ class TestActionScheduling(base.DbTestCase):
 
     def test_schedule_migrate_resize_acpi_s3_actions(self):
         solution = dsol.DefaultSolution(
-            goal=mock.Mock(), strategy=self.strategy)
+            goal=mock.Mock(), strategy=self.strategy
+        )
 
-        parameters = {
-            "source_node": "server1",
-            "destination_node": "server2",
-        }
+        parameters = {"source_node": "server1", "destination_node": "server2"}
         parent_migration = "b199db0c-1408-4d52-b5a5-5ca14de0ff36"
-        solution.add_action(action_type="migrate",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+        solution.add_action(
+            action_type="migrate",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
 
-        solution.add_action(action_type="resize",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters={'flavor': 'x1'})
+        solution.add_action(
+            action_type="resize",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters={'flavor': 'x1'},
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="f6416850-da28-4047-a547-8c49f53e95fe",
-                            input_parameters={"source_node": "server1",
-                                              "destination_node": "server2"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="f6416850-da28-4047-a547-8c49f53e95fe",
+            input_parameters={
+                "source_node": "server1",
+                "destination_node": "server2",
+            },
+        )
 
-        solution.add_action(action_type="migrate",
-                            resource_id="bb404e74-2caf-447b-bd1e-9234db386ca5",
-                            input_parameters={"source_node": "server2",
-                                              "destination_node": "server3"})
+        solution.add_action(
+            action_type="migrate",
+            resource_id="bb404e74-2caf-447b-bd1e-9234db386ca5",
+            input_parameters={
+                "source_node": "server2",
+                "destination_node": "server3",
+            },
+        )
 
-        solution.add_action(action_type="turn_host_to_acpi_s3_state",
-                            resource_id="server1",
-                            input_parameters={})
+        solution.add_action(
+            action_type="turn_host_to_acpi_s3_state",
+            resource_id="server1",
+            input_parameters={},
+        )
 
         with mock.patch.object(
-                pbase.WorkloadStabilizationPlanner, "create_action",
-                wraps=self.planner.create_action
+            pbase.WorkloadStabilizationPlanner,
+            "create_action",
+            wraps=self.planner.create_action,
         ) as m_create_action:
-            with mock.patch.object(
-                    nova_helper, 'NovaHelper') as m_nova:
+            with mock.patch.object(nova_helper, 'NovaHelper') as m_nova:
                 m_nova().get_hostname.return_value = 'server1'
                 m_nova().get_instance_by_uuid.return_value = ['uuid1']
                 self.planner.config.weights = {
@@ -270,9 +306,11 @@ class TestActionScheduling(base.DbTestCase):
                     'migrate': 2,
                     'sleep': 3,
                     'change_nova_service_state': 4,
-                    'nop': 5}
+                    'nop': 5,
+                }
                 action_plan = self.planner.schedule(
-                    self.context, self.audit.id, solution)
+                    self.context, self.audit.id, solution
+                )
                 self.assertEqual(3, m_nova.call_count)
         self.assertIsNotNone(action_plan.uuid)
         self.assertEqual(5, m_create_action.call_count)
@@ -292,7 +330,6 @@ class TestActionScheduling(base.DbTestCase):
 
 
 class TestDefaultPlanner(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.planner = pbase.WorkloadStabilizationPlanner(mock.Mock())
@@ -300,25 +337,27 @@ class TestDefaultPlanner(base.DbTestCase):
             'nop': 0,
             'sleep': 1,
             'change_nova_service_state': 2,
-            'migrate': 3
+            'migrate': 3,
         }
 
         self.goal = obj_utils.create_test_goal(self.context)
         self.strategy = obj_utils.create_test_strategy(
-            self.context, goal_id=self.goal.id)
+            self.context, goal_id=self.goal.id
+        )
         obj_utils.create_test_audit_template(
-            self.context, goal_id=self.goal.id, strategy_id=self.strategy.id)
+            self.context, goal_id=self.goal.id, strategy_id=self.strategy.id
+        )
 
         p = mock.patch.object(db_api.BaseConnection, 'create_action_plan')
         self.mock_create_action_plan = p.start()
         self.mock_create_action_plan.side_effect = (
-            self._simulate_action_plan_create)
+            self._simulate_action_plan_create
+        )
         self.addCleanup(p.stop)
 
         q = mock.patch.object(db_api.BaseConnection, 'create_action')
         self.mock_create_action = q.start()
-        self.mock_create_action.side_effect = (
-            self._simulate_action_create)
+        self.mock_create_action.side_effect = self._simulate_action_create
         self.addCleanup(q.stop)
 
     def _simulate_action_plan_create(self, action_plan):
@@ -333,11 +372,12 @@ class TestDefaultPlanner(base.DbTestCase):
     def test_scheduler_warning_empty_action_plan(self, m_get_by_name):
         m_get_by_name.return_value = self.strategy
         audit = db_utils.create_test_audit(
-            goal_id=self.goal.id, strategy_id=self.strategy.id)
-        fake_solution = mock.MagicMock(efficacy_indicators=[],
-                                       actions=[])
+            goal_id=self.goal.id, strategy_id=self.strategy.id
+        )
+        fake_solution = mock.MagicMock(efficacy_indicators=[], actions=[])
         action_plan = self.planner.schedule(
-            self.context, audit.id, fake_solution)
+            self.context, audit.id, fake_solution
+        )
         self.assertIsNotNone(action_plan.uuid)
 
 
@@ -351,7 +391,8 @@ class TestActionValidator(base.DbTestCase):
         self.r_helper = mock.Mock(spec=nova_helper.NovaHelper)
         self.r_helper_cls.return_value = self.r_helper
         r_nova_helper = mock.patch.object(
-            nova_helper, "NovaHelper", self.r_helper_cls)
+            nova_helper, "NovaHelper", self.r_helper_cls
+        )
 
         r_nova_helper.start()
 
@@ -359,10 +400,13 @@ class TestActionValidator(base.DbTestCase):
 
     def test_resize_validate_parents(self):
         resize_object = pbase.ResizeActionValidator()
-        action = {'uuid': 'fcec56cd-74c1-406b-a7c1-81ef9f0c1393',
-                  'input_parameters': {'resource_id': self.INSTANCE_UUID}}
-        resource_action_map = {self.INSTANCE_UUID: [
-            ('action_uuid', 'migrate')]}
+        action = {
+            'uuid': 'fcec56cd-74c1-406b-a7c1-81ef9f0c1393',
+            'input_parameters': {'resource_id': self.INSTANCE_UUID},
+        }
+        resource_action_map = {
+            self.INSTANCE_UUID: [('action_uuid', 'migrate')]
+        }
         self.r_helper.get_hostname.return_value = 'server1'
         self.r_helper.get_instance_by_uuid.return_value = ['instance']
         result = resize_object.validate_parents(resource_action_map, action)
@@ -370,14 +414,19 @@ class TestActionValidator(base.DbTestCase):
 
     def test_migrate_validate_parents(self):
         migrate_object = pbase.MigrationActionValidator()
-        action = {'uuid': '712f1701-4c1b-4076-bfcf-3f23cfec6c3b',
-                  'input_parameters': {'source_node': 'server1',
-                                       'resource_id': self.INSTANCE_UUID}}
+        action = {
+            'uuid': '712f1701-4c1b-4076-bfcf-3f23cfec6c3b',
+            'input_parameters': {
+                'source_node': 'server1',
+                'resource_id': self.INSTANCE_UUID,
+            },
+        }
         resource_action_map = {}
         expected_map = {
             '94ae2f92-b7fd-4da7-9e97-f13504ae98c4': [
-                ('712f1701-4c1b-4076-bfcf-3f23cfec6c3b', 'migrate')],
-            'server1': [
-                ('712f1701-4c1b-4076-bfcf-3f23cfec6c3b', 'migrate')]}
+                ('712f1701-4c1b-4076-bfcf-3f23cfec6c3b', 'migrate')
+            ],
+            'server1': [('712f1701-4c1b-4076-bfcf-3f23cfec6c3b', 'migrate')],
+        }
         migrate_object.validate_parents(resource_action_map, action)
         self.assertEqual(resource_action_map, expected_map)
diff --git a/watcher/tests/unit/decision_engine/scope/fake_scopes.py b/watcher/tests/unit/decision_engine/scope/fake_scopes.py
index fcfc6144e..c829c29ab 100644
--- a/watcher/tests/unit/decision_engine/scope/fake_scopes.py
+++ b/watcher/tests/unit/decision_engine/scope/fake_scopes.py
@@ -18,56 +18,71 @@ from watcher.tests.unit.decision_engine.model import faker_cluster_state
 
 vum = faker_cluster_state.volume_uuid_mapping
 
-fake_scope_1 = [{'compute': [{'availability_zones': [{'name': 'AZ1'},
-                                                     {'name': 'AZ3'}]},
-                             {'exclude': [
-                                 {'instances': [
-                                     {'uuid': 'INSTANCE_6'}]},
-                             ]}]
-                 }
+fake_scope_1 = [
+    {
+        'compute': [
+            {'availability_zones': [{'name': 'AZ1'}, {'name': 'AZ3'}]},
+            {'exclude': [{'instances': [{'uuid': 'INSTANCE_6'}]}]},
+        ]
+    }
+]
+
+compute_scope = [
+    {
+        'compute': [
+            {'host_aggregates': [{'id': '*'}]},
+            {'availability_zones': [{'name': 'AZ1'}, {'name': 'AZ2'}]},
+            {
+                'exclude': [
+                    {
+                        'instances': [
+                            {'uuid': 'INSTANCE_1'},
+                            {'uuid': 'INSTANCE_2'},
+                        ]
+                    },
+                    {
+                        'compute_nodes': [
+                            {'name': 'Node_1'},
+                            {'name': 'Node_2'},
+                        ]
+                    },
                 ]
+            },
+        ]
+    }
+]
 
-compute_scope = [{'compute': [{'host_aggregates': [{'id': '*'}]},
-                              {'availability_zones': [{'name': 'AZ1'},
-                                                      {'name': 'AZ2'}]},
-                              {'exclude': [
-                                  {'instances': [
-                                      {'uuid': 'INSTANCE_1'},
-                                      {'uuid': 'INSTANCE_2'}]},
-                                  {'compute_nodes': [
-                                      {'name': 'Node_1'},
-                                      {'name': 'Node_2'}]}
-                              ]}]
-                  }
-                 ]
-
-fake_scope_2 = [{'storage': [{'availability_zones': [{'name': 'zone_0'}]},
-                             {'exclude': [
-                                 {'volumes': [
-                                     {'uuid': vum['volume_1']}]},
-
-                                 {'storage_pools': [
-                                     {'name': 'host_0@backend_0#pool_1'}]}
-                             ]}]
-                 }
+fake_scope_2 = [
+    {
+        'storage': [
+            {'availability_zones': [{'name': 'zone_0'}]},
+            {
+                'exclude': [
+                    {'volumes': [{'uuid': vum['volume_1']}]},
+                    {'storage_pools': [{'name': 'host_0@backend_0#pool_1'}]},
                 ]
+            },
+        ]
+    }
+]
 
-fake_scope_3 = [{'compute': [{'host_aggregates': [{'id': '1'}]},
-                             {'exclude': []
-                              }]
-                 }
-                ]
+fake_scope_3 = [
+    {'compute': [{'host_aggregates': [{'id': '1'}]}, {'exclude': []}]}
+]
 
 baremetal_scope = [
-    {'baremetal': [
-        {'exclude': [
-            {'ironic_nodes': [
-                {'uuid': 'c5941348-5a87-4016-94d4-4f9e0ce2b87a'},
-                {'uuid': 'c5941348-5a87-4016-94d4-4f9e0ce2b87c'}
+    {
+        'baremetal': [
+            {
+                'exclude': [
+                    {
+                        'ironic_nodes': [
+                            {'uuid': 'c5941348-5a87-4016-94d4-4f9e0ce2b87a'},
+                            {'uuid': 'c5941348-5a87-4016-94d4-4f9e0ce2b87c'},
+                        ]
+                    }
                 ]
-             }
-            ]
-         }
+            }
         ]
-     }
+    }
 ]
diff --git a/watcher/tests/unit/decision_engine/scope/test_baremetal.py b/watcher/tests/unit/decision_engine/scope/test_baremetal.py
index 5f766eb90..24b995840 100644
--- a/watcher/tests/unit/decision_engine/scope/test_baremetal.py
+++ b/watcher/tests/unit/decision_engine/scope/test_baremetal.py
@@ -23,7 +23,6 @@ from watcher.tests.unit.decision_engine.scope import fake_scopes
 
 
 class TestBaremetalScope(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_cluster = faker_cluster_state.FakerBaremetalModelCollector()
@@ -32,9 +31,8 @@ class TestBaremetalScope(base.TestCase):
     def test_exclude_all_ironic_nodes(self):
         cluster = self.fake_cluster.generate_scenario_1()
         baremetal.BaremetalScope(
-            self.audit_scope,
-            mock.Mock(),
-            osc=mock.Mock()).get_scoped_model(cluster)
+            self.audit_scope, mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
 
         self.assertEqual({}, cluster.get_all_ironic_nodes())
 
@@ -42,20 +40,24 @@ class TestBaremetalScope(base.TestCase):
         nodes_to_exclude = []
         resources = fake_scopes.baremetal_scope[0]['baremetal'][0]['exclude']
         baremetal.BaremetalScope(
-            self.audit_scope, mock.Mock(), osc=mock.Mock()).exclude_resources(
-                resources,
-                nodes=nodes_to_exclude)
+            self.audit_scope, mock.Mock(), osc=mock.Mock()
+        ).exclude_resources(resources, nodes=nodes_to_exclude)
 
-        self.assertEqual(sorted(nodes_to_exclude),
-                         sorted(['c5941348-5a87-4016-94d4-4f9e0ce2b87a',
-                                 'c5941348-5a87-4016-94d4-4f9e0ce2b87c']))
+        self.assertEqual(
+            sorted(nodes_to_exclude),
+            sorted(
+                [
+                    'c5941348-5a87-4016-94d4-4f9e0ce2b87a',
+                    'c5941348-5a87-4016-94d4-4f9e0ce2b87c',
+                ]
+            ),
+        )
 
     def test_remove_nodes_from_model(self):
         cluster = self.fake_cluster.generate_scenario_1()
         baremetal.BaremetalScope(
-            self.audit_scope,
-            mock.Mock(),
-            osc=mock.Mock()).remove_nodes_from_model(
-                ['c5941348-5a87-4016-94d4-4f9e0ce2b87a'],
-                cluster)
+            self.audit_scope, mock.Mock(), osc=mock.Mock()
+        ).remove_nodes_from_model(
+            ['c5941348-5a87-4016-94d4-4f9e0ce2b87a'], cluster
+        )
         self.assertEqual(len(cluster.get_all_ironic_nodes()), 1)
diff --git a/watcher/tests/unit/decision_engine/scope/test_compute.py b/watcher/tests/unit/decision_engine/scope/test_compute.py
index ab570ed76..8d6ff869d 100644
--- a/watcher/tests/unit/decision_engine/scope/test_compute.py
+++ b/watcher/tests/unit/decision_engine/scope/test_compute.py
@@ -30,7 +30,6 @@ from watcher.tests.unit.decision_engine.scope import fake_scopes
 
 
 class TestComputeScope(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.useFixture(
@@ -43,25 +42,27 @@ class TestComputeScope(base.TestCase):
         cluster = self.fake_cluster.generate_scenario_1()
         audit_scope = fake_scopes.fake_scope_1
         mock_zone_list.return_value = [
-            mock.Mock(zone=f'AZ{i}',
-                      host={f'hostname_{i}': {}})
-            for i in range(4)]
-        model = compute.ComputeScope(audit_scope, mock.Mock(),
-                                     osc=mock.Mock()).get_scoped_model(cluster)
+            mock.Mock(zone=f'AZ{i}', host={f'hostname_{i}': {}})
+            for i in range(4)
+        ]
+        model = compute.ComputeScope(
+            audit_scope, mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
 
         # NOTE(adisky):INSTANCE_6 is not excluded from model it will be tagged
         # as 'exclude' TRUE, blueprint compute-cdm-include-all-instances
         expected_edges = [
             ('d020ef1f-dc19-4982-9383-087498bfde03', 'Node_1'),
-            ('d060ef1f-dc19-4982-9383-087498bfde03', 'Node_3')
+            ('d060ef1f-dc19-4982-9383-087498bfde03', 'Node_3'),
         ]
         self.assertEqual(sorted(expected_edges), sorted(model.edges()))
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_service_list')
     def test_get_scoped_model_without_scope(self, mock_zone_list):
         model = self.fake_cluster.generate_scenario_1()
-        compute.ComputeScope([], mock.Mock(),
-                             osc=mock.Mock()).get_scoped_model(model)
+        compute.ComputeScope(
+            [], mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(model)
         assert not mock_zone_list.called
 
     def test_remove_instance(self):
@@ -69,7 +70,7 @@ class TestComputeScope(base.TestCase):
         compute.ComputeScope([], mock.Mock(), osc=mock.Mock()).remove_instance(
             model,
             model.get_instance_by_uuid('d020ef1f-dc19-4982-9383-087498bfde03'),
-            'Node_1'
+            'Node_1',
         )
         expected_edges = [
             ('d000ef1f-dc19-4982-9383-087498bfde03', 'Node_0'),
@@ -86,20 +87,24 @@ class TestComputeScope(base.TestCase):
     def test_collect_aggregates(self, mock_aggregate):
         allowed_nodes = []
         mock_aggregate.return_value = [
-            mock.Mock(id=i, hosts=[f'Node_{i}']) for i in range(2)]
-        compute.ComputeScope([{'host_aggregates': [{'id': 1}, {'id': 2}]}],
-                             mock.Mock(), osc=mock.Mock())._collect_aggregates(
-            [{'id': 1}, {'id': 2}], allowed_nodes)
+            mock.Mock(id=i, hosts=[f'Node_{i}']) for i in range(2)
+        ]
+        compute.ComputeScope(
+            [{'host_aggregates': [{'id': 1}, {'id': 2}]}],
+            mock.Mock(),
+            osc=mock.Mock(),
+        )._collect_aggregates([{'id': 1}, {'id': 2}], allowed_nodes)
         self.assertEqual(['Node_1'], allowed_nodes)
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_aggregate_list')
     def test_aggregates_wildcard_is_used(self, mock_aggregate):
         allowed_nodes = []
         mock_aggregate.return_value = [
-            mock.Mock(id=i, hosts=[f'Node_{i}']) for i in range(2)]
-        compute.ComputeScope([{'host_aggregates': [{'id': '*'}]}],
-                             mock.Mock(), osc=mock.Mock())._collect_aggregates(
-            [{'id': '*'}], allowed_nodes)
+            mock.Mock(id=i, hosts=[f'Node_{i}']) for i in range(2)
+        ]
+        compute.ComputeScope(
+            [{'host_aggregates': [{'id': '*'}]}], mock.Mock(), osc=mock.Mock()
+        )._collect_aggregates([{'id': '*'}], allowed_nodes)
         self.assertEqual(['Node_0', 'Node_1'], allowed_nodes)
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_aggregate_list')
@@ -108,170 +113,207 @@ class TestComputeScope(base.TestCase):
         mock_aggregate.return_value = [mock.Mock(id=i) for i in range(2)]
         scope_handler = compute.ComputeScope(
             [{'host_aggregates': [{'id': '*'}, {'id': 1}]}],
-            mock.Mock(), osc=mock.Mock())
-        self.assertRaises(exception.WildcardCharacterIsUsed,
-                          scope_handler._collect_aggregates,
-                          [{'id': '*'}, {'id': 1}],
-                          allowed_nodes)
+            mock.Mock(),
+            osc=mock.Mock(),
+        )
+        self.assertRaises(
+            exception.WildcardCharacterIsUsed,
+            scope_handler._collect_aggregates,
+            [{'id': '*'}, {'id': 1}],
+            allowed_nodes,
+        )
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_aggregate_list')
     def test_aggregates_with_names_and_ids(self, mock_aggregate):
         allowed_nodes = []
-        mock_collection = [mock.Mock(id=i, hosts=[f'Node_{i}'])
-                           for i in range(2)]
+        mock_collection = [
+            mock.Mock(id=i, hosts=[f'Node_{i}']) for i in range(2)
+        ]
         mock_collection[0].name = 'HA_0'
         mock_collection[1].name = 'HA_1'
 
         mock_aggregate.return_value = mock_collection
 
-        compute.ComputeScope([{'host_aggregates': [{'name': 'HA_1'},
-                                                   {'id': 0}]}],
-                             mock.Mock(), osc=mock.Mock())._collect_aggregates(
-            [{'name': 'HA_1'}, {'id': 0}], allowed_nodes)
+        compute.ComputeScope(
+            [{'host_aggregates': [{'name': 'HA_1'}, {'id': 0}]}],
+            mock.Mock(),
+            osc=mock.Mock(),
+        )._collect_aggregates([{'name': 'HA_1'}, {'id': 0}], allowed_nodes)
         self.assertEqual(['Node_0', 'Node_1'], allowed_nodes)
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_service_list')
     def test_collect_zones(self, mock_zone_list):
         allowed_nodes = []
         mock_zone_list.return_value = [
-            mock.Mock(zone=f"AZ{i + 1}",
-                      host={f'Node_{2 * i}': 1,
-                            f'Node_{2 * i + 1}': 2})
-            for i in range(2)]
-        compute.ComputeScope([{'availability_zones': [{'name': "AZ1"}]}],
-                             mock.Mock(), osc=mock.Mock())._collect_zones(
-            [{'name': "AZ1"}], allowed_nodes)
+            mock.Mock(
+                zone=f"AZ{i + 1}",
+                host={f'Node_{2 * i}': 1, f'Node_{2 * i + 1}': 2},
+            )
+            for i in range(2)
+        ]
+        compute.ComputeScope(
+            [{'availability_zones': [{'name': "AZ1"}]}],
+            mock.Mock(),
+            osc=mock.Mock(),
+        )._collect_zones([{'name': "AZ1"}], allowed_nodes)
         self.assertEqual(['Node_0', 'Node_1'], sorted(allowed_nodes))
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_service_list')
     def test_zones_wildcard_is_used(self, mock_zone_list):
         allowed_nodes = []
         mock_zone_list.return_value = [
-            mock.Mock(zone=f"AZ{i + 1}",
-                      host={f'Node_{2 * i}': 1,
-                            f'Node_{2 * i + 1}': 2})
-            for i in range(2)]
-        compute.ComputeScope([{'availability_zones': [{'name': "*"}]}],
-                             mock.Mock(), osc=mock.Mock())._collect_zones(
-            [{'name': "*"}], allowed_nodes)
-        self.assertEqual(['Node_0', 'Node_1', 'Node_2', 'Node_3'],
-                         sorted(allowed_nodes))
+            mock.Mock(
+                zone=f"AZ{i + 1}",
+                host={f'Node_{2 * i}': 1, f'Node_{2 * i + 1}': 2},
+            )
+            for i in range(2)
+        ]
+        compute.ComputeScope(
+            [{'availability_zones': [{'name': "*"}]}],
+            mock.Mock(),
+            osc=mock.Mock(),
+        )._collect_zones([{'name': "*"}], allowed_nodes)
+        self.assertEqual(
+            ['Node_0', 'Node_1', 'Node_2', 'Node_3'], sorted(allowed_nodes)
+        )
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_service_list')
     def test_zones_wildcard_with_other_ids(self, mock_zone_list):
         allowed_nodes = []
         mock_zone_list.return_value = [
-            mock.Mock(zone=f"AZ{i + 1}",
-                      host={f'Node_{2 * i}': 1,
-                            f'Node_{2 * i + 1}': 2})
-            for i in range(2)]
+            mock.Mock(
+                zone=f"AZ{i + 1}",
+                host={f'Node_{2 * i}': 1, f'Node_{2 * i + 1}': 2},
+            )
+            for i in range(2)
+        ]
         scope_handler = compute.ComputeScope(
             [{'availability_zones': [{'name': "*"}, {'name': 'AZ1'}]}],
-            mock.Mock(), osc=mock.Mock())
-        self.assertRaises(exception.WildcardCharacterIsUsed,
-                          scope_handler._collect_zones,
-                          [{'name': "*"}, {'name': 'AZ1'}],
-                          allowed_nodes)
+            mock.Mock(),
+            osc=mock.Mock(),
+        )
+        self.assertRaises(
+            exception.WildcardCharacterIsUsed,
+            scope_handler._collect_zones,
+            [{'name': "*"}, {'name': 'AZ1'}],
+            allowed_nodes,
+        )
 
     def test_compute_schema(self):
         test_scope = fake_scopes.compute_scope
         validators.Draft4Validator(
             audit_template.AuditTemplatePostType._build_schema()
-            ).validate(test_scope)
+        ).validate(test_scope)
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_aggregate_list')
     def test_exclude_resource(self, mock_aggregate):
-        mock_collection = [mock.Mock(id=i, hosts=[f'Node_{i}'])
-                           for i in range(2)]
+        mock_collection = [
+            mock.Mock(id=i, hosts=[f'Node_{i}']) for i in range(2)
+        ]
         mock_collection[0].name = 'HA_0'
         mock_collection[1].name = 'HA_1'
         mock_aggregate.return_value = mock_collection
 
-        resources_to_exclude = [{'host_aggregates': [{'name': 'HA_1'},
-                                                     {'id': 0}]},
-                                {'instances': [{'uuid': 'INSTANCE_1'},
-                                               {'uuid': 'INSTANCE_2'}]},
-                                {'compute_nodes': [{'name': 'Node_2'},
-                                                   {'name': 'Node_3'}]},
-                                {'instance_metadata': [{'optimize': True},
-                                                       {'optimize1': False}]},
-                                {'projects': [{'uuid': 'PROJECT_1'},
-                                              {'uuid': 'PROJECT_2'}]}]
+        resources_to_exclude = [
+            {'host_aggregates': [{'name': 'HA_1'}, {'id': 0}]},
+            {'instances': [{'uuid': 'INSTANCE_1'}, {'uuid': 'INSTANCE_2'}]},
+            {'compute_nodes': [{'name': 'Node_2'}, {'name': 'Node_3'}]},
+            {'instance_metadata': [{'optimize': True}, {'optimize1': False}]},
+            {'projects': [{'uuid': 'PROJECT_1'}, {'uuid': 'PROJECT_2'}]},
+        ]
         instances_to_exclude = []
         nodes_to_exclude = []
         instance_metadata = []
         projects_to_exclude = []
-        compute.ComputeScope([], mock.Mock(),
-                             osc=mock.Mock()).exclude_resources(
-            resources_to_exclude, instances=instances_to_exclude,
-            nodes=nodes_to_exclude, instance_metadata=instance_metadata,
-            projects=projects_to_exclude)
+        compute.ComputeScope(
+            [], mock.Mock(), osc=mock.Mock()
+        ).exclude_resources(
+            resources_to_exclude,
+            instances=instances_to_exclude,
+            nodes=nodes_to_exclude,
+            instance_metadata=instance_metadata,
+            projects=projects_to_exclude,
+        )
 
-        self.assertEqual(['Node_0', 'Node_1', 'Node_2', 'Node_3'],
-                         sorted(nodes_to_exclude))
-        self.assertEqual(['INSTANCE_1', 'INSTANCE_2'],
-                         sorted(instances_to_exclude))
-        self.assertEqual([{'optimize': True}, {'optimize1': False}],
-                         instance_metadata)
-        self.assertEqual(['PROJECT_1', 'PROJECT_2'],
-                         sorted(projects_to_exclude))
+        self.assertEqual(
+            ['Node_0', 'Node_1', 'Node_2', 'Node_3'], sorted(nodes_to_exclude)
+        )
+        self.assertEqual(
+            ['INSTANCE_1', 'INSTANCE_2'], sorted(instances_to_exclude)
+        )
+        self.assertEqual(
+            [{'optimize': True}, {'optimize1': False}], instance_metadata
+        )
+        self.assertEqual(
+            ['PROJECT_1', 'PROJECT_2'], sorted(projects_to_exclude)
+        )
 
     def test_exclude_instances_with_given_metadata(self):
         cluster = self.fake_cluster.generate_scenario_1()
         instance_metadata = [{'optimize': True}]
         instances_to_remove = set()
         compute.ComputeScope(
-            [], mock.Mock(),
-            osc=mock.Mock()).exclude_instances_with_given_metadata(
-                instance_metadata, cluster, instances_to_remove)
-        instance_uuids = sorted([
-            f'd{i:02}0ef1f-dc19-4982-9383-087498bfde03' for i in range(35)
-        ])
+            [], mock.Mock(), osc=mock.Mock()
+        ).exclude_instances_with_given_metadata(
+            instance_metadata, cluster, instances_to_remove
+        )
+        instance_uuids = sorted(
+            [f'd{i:02}0ef1f-dc19-4982-9383-087498bfde03' for i in range(35)]
+        )
         self.assertEqual(instance_uuids, sorted(instances_to_remove))
 
         instance_metadata = [{'optimize': False}]
         instances_to_remove = set()
         compute.ComputeScope(
-            [], mock.Mock(),
-            osc=mock.Mock()).exclude_instances_with_given_metadata(
-                instance_metadata, cluster, instances_to_remove)
+            [], mock.Mock(), osc=mock.Mock()
+        ).exclude_instances_with_given_metadata(
+            instance_metadata, cluster, instances_to_remove
+        )
         self.assertEqual(set(), instances_to_remove)
 
     def test_exclude_instances_with_given_project(self):
         cluster = self.fake_cluster.generate_scenario_1()
         instances_to_exclude = set()
-        projects_to_exclude = ['26F03131-32CB-4697-9D61-9123F87A8147',
-                               '109F7909-0607-4712-B32C-5CC6D49D2F15']
+        projects_to_exclude = [
+            '26F03131-32CB-4697-9D61-9123F87A8147',
+            '109F7909-0607-4712-B32C-5CC6D49D2F15',
+        ]
         compute.ComputeScope(
-            [], mock.Mock(),
-            osc=mock.Mock()).exclude_instances_with_given_project(
-                projects_to_exclude, cluster, instances_to_exclude)
+            [], mock.Mock(), osc=mock.Mock()
+        ).exclude_instances_with_given_project(
+            projects_to_exclude, cluster, instances_to_exclude
+        )
         self.assertEqual(
-            ['d010ef1f-dc19-4982-9383-087498bfde03',
-             'd020ef1f-dc19-4982-9383-087498bfde03'],
-            sorted(instances_to_exclude)
+            [
+                'd010ef1f-dc19-4982-9383-087498bfde03',
+                'd020ef1f-dc19-4982-9383-087498bfde03',
+            ],
+            sorted(instances_to_exclude),
         )
 
     def test_remove_nodes_from_model(self):
         model = self.fake_cluster.generate_scenario_1()
-        compute.ComputeScope([], mock.Mock(),
-                             osc=mock.Mock()).remove_nodes_from_model(
-            ['hostname_1', 'hostname_2'], model)
+        compute.ComputeScope(
+            [], mock.Mock(), osc=mock.Mock()
+        ).remove_nodes_from_model(['hostname_1', 'hostname_2'], model)
         expected_edges = [
             ('d000ef1f-dc19-4982-9383-087498bfde03', 'Node_0'),
             ('d010ef1f-dc19-4982-9383-087498bfde03', 'Node_0'),
             ('d060ef1f-dc19-4982-9383-087498bfde03', 'Node_3'),
-            ('d070ef1f-dc19-4982-9383-087498bfde03', 'Node_4')]
+            ('d070ef1f-dc19-4982-9383-087498bfde03', 'Node_4'),
+        ]
         self.assertEqual(sorted(expected_edges), sorted(model.edges()))
 
     def test_update_exclude_instances_in_model(self):
         model = self.fake_cluster.generate_scenario_1()
         compute.ComputeScope(
-            [], mock.Mock(),
-            osc=mock.Mock()
+            [], mock.Mock(), osc=mock.Mock()
         ).update_exclude_instance_in_model(
-            ['d010ef1f-dc19-4982-9383-087498bfde03',
-             'd020ef1f-dc19-4982-9383-087498bfde03'], model
+            [
+                'd010ef1f-dc19-4982-9383-087498bfde03',
+                'd020ef1f-dc19-4982-9383-087498bfde03',
+            ],
+            model,
         )
         expected_edges = [
             ('d000ef1f-dc19-4982-9383-087498bfde03', 'Node_0'),
@@ -281,27 +323,30 @@ class TestComputeScope(base.TestCase):
             ('d040ef1f-dc19-4982-9383-087498bfde03', 'Node_2'),
             ('d050ef1f-dc19-4982-9383-087498bfde03', 'Node_2'),
             ('d060ef1f-dc19-4982-9383-087498bfde03', 'Node_3'),
-            ('d070ef1f-dc19-4982-9383-087498bfde03', 'Node_4')]
+            ('d070ef1f-dc19-4982-9383-087498bfde03', 'Node_4'),
+        ]
         self.assertEqual(sorted(expected_edges), sorted(model.edges()))
         self.assertFalse(
             model.get_instance_by_uuid(
                 'd000ef1f-dc19-4982-9383-087498bfde03'
-            ).watcher_exclude)
+            ).watcher_exclude
+        )
         self.assertTrue(
             model.get_instance_by_uuid(
                 'd010ef1f-dc19-4982-9383-087498bfde03'
-            ).watcher_exclude)
+            ).watcher_exclude
+        )
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_aggregate_list')
-    def test_get_scoped_model_with_hostaggregate_null(
-            self, mock_list):
+    def test_get_scoped_model_with_hostaggregate_null(self, mock_list):
         cluster = self.fake_cluster.generate_scenario_1()
         audit_scope = fake_scopes.fake_scope_3
-        mock_list.return_value = [mock.Mock(id=i,
-                                            name=f"HA_{i}")
-                                  for i in range(2)]
-        model = compute.ComputeScope(audit_scope, mock.Mock(),
-                                     osc=mock.Mock()).get_scoped_model(cluster)
+        mock_list.return_value = [
+            mock.Mock(id=i, name=f"HA_{i}") for i in range(2)
+        ]
+        model = compute.ComputeScope(
+            audit_scope, mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
         self.assertEqual(0, len(model.edges()))
 
     @mock.patch.object(nova_helper.NovaHelper, 'get_service_list')
@@ -312,16 +357,17 @@ class TestComputeScope(base.TestCase):
         audit_scope.extend(fake_scopes.fake_scope_1)
         audit_scope.extend(fake_scopes.fake_scope_2)
         mock_zone_list.return_value = [
-            mock.Mock(zone=f'AZ{i}',
-                      host={f'hostname_{i}': {}})
-            for i in range(4)]
-        model = compute.ComputeScope(audit_scope, mock.Mock(),
-                                     osc=mock.Mock()).get_scoped_model(cluster)
+            mock.Mock(zone=f'AZ{i}', host={f'hostname_{i}': {}})
+            for i in range(4)
+        ]
+        model = compute.ComputeScope(
+            audit_scope, mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
 
         # NOTE(adisky):INSTANCE_6 is not excluded from model it will be tagged
         # as 'exclude' TRUE, blueprint compute-cdm-include-all-instances
         expected_edges = [
             ('d020ef1f-dc19-4982-9383-087498bfde03', 'Node_1'),
-            ('d060ef1f-dc19-4982-9383-087498bfde03', 'Node_3')
+            ('d060ef1f-dc19-4982-9383-087498bfde03', 'Node_3'),
         ]
         self.assertEqual(sorted(expected_edges), sorted(model.edges()))
diff --git a/watcher/tests/unit/decision_engine/scope/test_storage.py b/watcher/tests/unit/decision_engine/scope/test_storage.py
index 59833b739..5a0773649 100644
--- a/watcher/tests/unit/decision_engine/scope/test_storage.py
+++ b/watcher/tests/unit/decision_engine/scope/test_storage.py
@@ -25,7 +25,6 @@ from watcher.tests.unit.decision_engine.scope import fake_scopes
 
 
 class TestStorageScope(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_cluster = faker_cluster_state.FakerStorageModelCollector()
@@ -35,21 +34,27 @@ class TestStorageScope(base.TestCase):
         cluster = self.fake_cluster.generate_scenario_1()
         audit_scope = fake_scopes.fake_scope_2
         mock_zone_list.return_value = [
-            mock.Mock(zone=f'zone_{i}',
-                      host=f'host_{i}@backend_{i}')
-            for i in range(2)]
-        model = storage.StorageScope(audit_scope, mock.Mock(),
-                                     osc=mock.Mock()).get_scoped_model(cluster)
-        expected_edges = [(faker_cluster_state.volume_uuid_mapping['volume_0'],
-                           'host_0@backend_0#pool_0'),
-                          ('host_0@backend_0#pool_0', 'host_0@backend_0')]
+            mock.Mock(zone=f'zone_{i}', host=f'host_{i}@backend_{i}')
+            for i in range(2)
+        ]
+        model = storage.StorageScope(
+            audit_scope, mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
+        expected_edges = [
+            (
+                faker_cluster_state.volume_uuid_mapping['volume_0'],
+                'host_0@backend_0#pool_0',
+            ),
+            ('host_0@backend_0#pool_0', 'host_0@backend_0'),
+        ]
         self.assertEqual(sorted(expected_edges), sorted(model.edges()))
 
     @mock.patch.object(cinder_helper.CinderHelper, 'get_storage_node_list')
     def test_get_scoped_model_without_scope(self, mock_zone_list):
         cluster = self.fake_cluster.generate_scenario_1()
-        storage.StorageScope([], mock.Mock(),
-                             osc=mock.Mock()).get_scoped_model(cluster)
+        storage.StorageScope(
+            [], mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
         assert not mock_zone_list.called
 
     @mock.patch.object(cinder_helper.CinderHelper, 'get_storage_node_list')
@@ -57,41 +62,47 @@ class TestStorageScope(base.TestCase):
         allowed_nodes = []
         az_scope = [{'name': 'zone_1'}]
         mock_zone_list.return_value = [
-            mock.Mock(zone=f'zone_{i}',
-                      host=f'host_{i}@backend_{i}')
-            for i in range(2)]
-        storage.StorageScope([{'availability _zones': az_scope}],
-                             mock.Mock(), osc=mock.Mock())._collect_zones(
-            az_scope, allowed_nodes)
+            mock.Mock(zone=f'zone_{i}', host=f'host_{i}@backend_{i}')
+            for i in range(2)
+        ]
+        storage.StorageScope(
+            [{'availability _zones': az_scope}], mock.Mock(), osc=mock.Mock()
+        )._collect_zones(az_scope, allowed_nodes)
         self.assertEqual(['host_1@backend_1'], sorted(allowed_nodes))
 
         # storage scope with az wildcard
         az_scope = [{'name': '*'}]
         del allowed_nodes[:]
-        storage.StorageScope([{'availability _zones': az_scope}],
-                             mock.Mock(), osc=mock.Mock())._collect_zones(
-            az_scope, allowed_nodes)
-        self.assertEqual(['host_0@backend_0', 'host_1@backend_1'],
-                         sorted(allowed_nodes))
+        storage.StorageScope(
+            [{'availability _zones': az_scope}], mock.Mock(), osc=mock.Mock()
+        )._collect_zones(az_scope, allowed_nodes)
+        self.assertEqual(
+            ['host_0@backend_0', 'host_1@backend_1'], sorted(allowed_nodes)
+        )
 
         # storage scope with az wildcard and other
         az_scope = [{'name': '*'}, {'name': 'zone_0'}]
         del allowed_nodes[:]
         scope_handler = storage.StorageScope(
-            [{'availability _zones': az_scope}], mock.Mock(), osc=mock.Mock())
-        self.assertRaises(exception.WildcardCharacterIsUsed,
-                          scope_handler._collect_zones,
-                          az_scope, allowed_nodes)
+            [{'availability _zones': az_scope}], mock.Mock(), osc=mock.Mock()
+        )
+        self.assertRaises(
+            exception.WildcardCharacterIsUsed,
+            scope_handler._collect_zones,
+            az_scope,
+            allowed_nodes,
+        )
 
     @mock.patch.object(cinder_helper.CinderHelper, 'get_storage_node_list')
-    @mock.patch.object(cinder_helper.CinderHelper,
-                       'get_volume_type_by_backendname')
+    @mock.patch.object(
+        cinder_helper.CinderHelper, 'get_volume_type_by_backendname'
+    )
     def test_collect_vtype(self, mock_vt_list, mock_zone_list):
         allowed_nodes = []
         mock_zone_list.return_value = [
-            mock.Mock(zone=f'zone_{i}',
-                      host=f'host_{i}@backend_{i}')
-            for i in range(2)]
+            mock.Mock(zone=f'zone_{i}', host=f'host_{i}@backend_{i}')
+            for i in range(2)
+        ]
 
         def side_effect(arg):
             if arg == 'backend_0':
@@ -102,62 +113,80 @@ class TestStorageScope(base.TestCase):
         mock_vt_list.side_effect = side_effect
 
         vt_scope = [{'name': 'type_1'}]
-        storage.StorageScope([{'volume_types': vt_scope}],
-                             mock.Mock(), osc=mock.Mock())._collect_vtype(
-            vt_scope, allowed_nodes)
+        storage.StorageScope(
+            [{'volume_types': vt_scope}], mock.Mock(), osc=mock.Mock()
+        )._collect_vtype(vt_scope, allowed_nodes)
         self.assertEqual(['host_1@backend_1'], sorted(allowed_nodes))
 
         # storage scope with vt wildcard
         vt_scope = [{'name': '*'}]
         del allowed_nodes[:]
-        storage.StorageScope([{'volume_types': vt_scope}],
-                             mock.Mock(), osc=mock.Mock())._collect_vtype(
-            vt_scope, allowed_nodes)
-        self.assertEqual(['host_0@backend_0', 'host_1@backend_1'],
-                         sorted(allowed_nodes))
+        storage.StorageScope(
+            [{'volume_types': vt_scope}], mock.Mock(), osc=mock.Mock()
+        )._collect_vtype(vt_scope, allowed_nodes)
+        self.assertEqual(
+            ['host_0@backend_0', 'host_1@backend_1'], sorted(allowed_nodes)
+        )
 
         # storage scope with vt wildcard and other
         vt_scope = [{'name': '*'}, {'name': 'type_0'}]
         del allowed_nodes[:]
-        scope_handler = storage.StorageScope([{'volume_types': vt_scope}],
-                                             mock.Mock(), osc=mock.Mock())
-        self.assertRaises(exception.WildcardCharacterIsUsed,
-                          scope_handler._collect_vtype,
-                          vt_scope, allowed_nodes)
+        scope_handler = storage.StorageScope(
+            [{'volume_types': vt_scope}], mock.Mock(), osc=mock.Mock()
+        )
+        self.assertRaises(
+            exception.WildcardCharacterIsUsed,
+            scope_handler._collect_vtype,
+            vt_scope,
+            allowed_nodes,
+        )
 
     def test_exclude_resources(self):
         pools_to_exclude = []
         projects_to_exclude = []
         volumes_to_exclude = []
-        resources = [{'volumes': [{'uuid': 'VOLUME_1'},
-                                  {'uuid': 'VOLUME_2'}]
-                      },
-                     {'storage_pools': [{'name': 'host_0@backend_0#pool_1'},
-                                        {'name': 'host_1@backend_1#pool_1'}]
-                      },
-                     {'projects': [{'uuid': 'PROJECT_1'},
-                                   {'uuid': 'PROJECT_2'},
-                                   {'uuid': 'PROJECT_3'}]
-                      }
-                     ]
-        storage.StorageScope(resources, mock.Mock(),
-                             osc=mock.Mock()).exclude_resources(
-            resources, pools=pools_to_exclude, projects=projects_to_exclude,
-            volumes=volumes_to_exclude)
+        resources = [
+            {'volumes': [{'uuid': 'VOLUME_1'}, {'uuid': 'VOLUME_2'}]},
+            {
+                'storage_pools': [
+                    {'name': 'host_0@backend_0#pool_1'},
+                    {'name': 'host_1@backend_1#pool_1'},
+                ]
+            },
+            {
+                'projects': [
+                    {'uuid': 'PROJECT_1'},
+                    {'uuid': 'PROJECT_2'},
+                    {'uuid': 'PROJECT_3'},
+                ]
+            },
+        ]
+        storage.StorageScope(
+            resources, mock.Mock(), osc=mock.Mock()
+        ).exclude_resources(
+            resources,
+            pools=pools_to_exclude,
+            projects=projects_to_exclude,
+            volumes=volumes_to_exclude,
+        )
         self.assertEqual(['VOLUME_1', 'VOLUME_2'], volumes_to_exclude)
-        self.assertEqual(['PROJECT_1', 'PROJECT_2', 'PROJECT_3'],
-                         projects_to_exclude)
-        self.assertEqual(['host_0@backend_0#pool_1',
-                          'host_1@backend_1#pool_1'], pools_to_exclude)
+        self.assertEqual(
+            ['PROJECT_1', 'PROJECT_2', 'PROJECT_3'], projects_to_exclude
+        )
+        self.assertEqual(
+            ['host_0@backend_0#pool_1', 'host_1@backend_1#pool_1'],
+            pools_to_exclude,
+        )
 
     def test_exclude_volumes(self):
         cluster = self.fake_cluster.generate_scenario_1()
-        exclude = [faker_cluster_state.volume_uuid_mapping['volume_0'],
-                   faker_cluster_state.volume_uuid_mapping['volume_3'],
-                   ]
-        storage.StorageScope([], mock.Mock(),
-                             osc=mock.Mock()).exclude_volumes(exclude,
-                                                              cluster)
+        exclude = [
+            faker_cluster_state.volume_uuid_mapping['volume_0'],
+            faker_cluster_state.volume_uuid_mapping['volume_3'],
+        ]
+        storage.StorageScope([], mock.Mock(), osc=mock.Mock()).exclude_volumes(
+            exclude, cluster
+        )
         self.assertNotIn(exclude[0], cluster.get_all_volumes().keys())
         self.assertNotIn(exclude[1], cluster.get_all_volumes().keys())
 
@@ -166,18 +195,18 @@ class TestStorageScope(base.TestCase):
         exclude = ['host_0@backend_0#pool_0']
         node_name = (exclude[0].split('#'))[0]
 
-        storage.StorageScope([], mock.Mock(),
-                             osc=mock.Mock()).exclude_pools(exclude,
-                                                            cluster)
+        storage.StorageScope([], mock.Mock(), osc=mock.Mock()).exclude_pools(
+            exclude, cluster
+        )
         node = cluster.get_node_by_name(node_name)
         self.assertNotIn(exclude, cluster.get_node_pools(node))
 
     def test_exclude_projects(self):
         cluster = self.fake_cluster.generate_scenario_1()
         exclude = ['project_1', 'project_2']
-        storage.StorageScope([], mock.Mock(),
-                             osc=mock.Mock()).exclude_projects(exclude,
-                                                               cluster)
+        storage.StorageScope(
+            [], mock.Mock(), osc=mock.Mock()
+        ).exclude_projects(exclude, cluster)
         projects = []
         volumes = cluster.get_all_volumes()
         for volume_id in volumes:
@@ -189,11 +218,12 @@ class TestStorageScope(base.TestCase):
     def test_remove_nodes_from_model(self):
         cluster = self.fake_cluster.generate_scenario_1()
         nodes_to_remove = ['host_0@backend_0']
-        storage.StorageScope([], mock.Mock(),
-                             osc=mock.Mock()).remove_nodes_from_model(
-            nodes_to_remove, cluster)
-        self.assertEqual(['host_1@backend_1'],
-                         list(cluster.get_all_storage_nodes()))
+        storage.StorageScope(
+            [], mock.Mock(), osc=mock.Mock()
+        ).remove_nodes_from_model(nodes_to_remove, cluster)
+        self.assertEqual(
+            ['host_1@backend_1'], list(cluster.get_all_storage_nodes())
+        )
 
     @mock.patch.object(cinder_helper.CinderHelper, 'get_storage_node_list')
     def test_get_scoped_model_with_multi_scopes(self, mock_zone_list):
@@ -203,12 +233,17 @@ class TestStorageScope(base.TestCase):
         audit_scope.extend(fake_scopes.fake_scope_2)
         audit_scope.extend(fake_scopes.fake_scope_1)
         mock_zone_list.return_value = [
-            mock.Mock(zone=f'zone_{i}',
-                      host=f'host_{i}@backend_{i}')
-            for i in range(2)]
-        model = storage.StorageScope(audit_scope, mock.Mock(),
-                                     osc=mock.Mock()).get_scoped_model(cluster)
-        expected_edges = [(faker_cluster_state.volume_uuid_mapping['volume_0'],
-                           'host_0@backend_0#pool_0'),
-                          ('host_0@backend_0#pool_0', 'host_0@backend_0')]
+            mock.Mock(zone=f'zone_{i}', host=f'host_{i}@backend_{i}')
+            for i in range(2)
+        ]
+        model = storage.StorageScope(
+            audit_scope, mock.Mock(), osc=mock.Mock()
+        ).get_scoped_model(cluster)
+        expected_edges = [
+            (
+                faker_cluster_state.volume_uuid_mapping['volume_0'],
+                'host_0@backend_0#pool_0',
+            ),
+            ('host_0@backend_0#pool_0', 'host_0@backend_0'),
+        ]
         self.assertEqual(sorted(expected_edges), sorted(model.edges()))
diff --git a/watcher/tests/unit/decision_engine/scoring/test_dummy_scorer.py b/watcher/tests/unit/decision_engine/scoring/test_dummy_scorer.py
index 803031c67..564712ba5 100644
--- a/watcher/tests/unit/decision_engine/scoring/test_dummy_scorer.py
+++ b/watcher/tests/unit/decision_engine/scoring/test_dummy_scorer.py
@@ -22,7 +22,6 @@ from watcher.tests.unit import base
 
 
 class TestDummyScorer(base.TestCase):
-
     def test_metadata(self):
         scorer = dummy_scorer.DummyScorer(config=None)
         self.assertEqual('dummy_scorer', scorer.get_name())
@@ -41,8 +40,9 @@ class TestDummyScorer(base.TestCase):
         self._assert_result(scorer, 0, '[0, 0, 0, 0, 600, 0, 0, 0, 0]')
         self._assert_result(scorer, 1, '[85, 0, 0, 0, 0, 0, 0, 0, 0]')
         self._assert_result(scorer, 2, '[0, 0, 0, 1100, 1100, 0, 0, 0, 0]')
-        self._assert_result(scorer, 3,
-                            '[0, 0, 0, 0, 0, 70000000, 70000000, 0, 0]')
+        self._assert_result(
+            scorer, 3, '[0, 0, 0, 0, 0, 70000000, 70000000, 0, 0]'
+        )
 
     def _assert_result(self, scorer, expected, features):
         result_str = scorer.calculate_score(features)
diff --git a/watcher/tests/unit/decision_engine/scoring/test_dummy_scoring_container.py b/watcher/tests/unit/decision_engine/scoring/test_dummy_scoring_container.py
index 201d23d83..d1ca0d3db 100644
--- a/watcher/tests/unit/decision_engine/scoring/test_dummy_scoring_container.py
+++ b/watcher/tests/unit/decision_engine/scoring/test_dummy_scoring_container.py
@@ -22,10 +22,8 @@ from watcher.tests.unit import base
 
 
 class TestDummyScoringContainer(base.TestCase):
-
     def test_get_scoring_engine_list(self):
-        scorers = (dummy_scoring_container.DummyScoringContainer
-                                          .get_scoring_engine_list())
+        scorers = dummy_scoring_container.DummyScoringContainer.get_scoring_engine_list()  # noqa: E501
 
         self.assertEqual(3, len(scorers))
         self.assertEqual('dummy_min_scorer', scorers[0].get_name())
@@ -33,8 +31,7 @@ class TestDummyScoringContainer(base.TestCase):
         self.assertEqual('dummy_avg_scorer', scorers[2].get_name())
 
     def test_scorers(self):
-        scorers = (dummy_scoring_container.DummyScoringContainer
-                                          .get_scoring_engine_list())
+        scorers = dummy_scoring_container.DummyScoringContainer.get_scoring_engine_list()  # noqa: E501
 
         self._assert_result(scorers[0], 1.1, '[1.1, 2.2, 4, 8]')
         self._assert_result(scorers[1], 8, '[1.1, 2.2, 4, 8]')
diff --git a/watcher/tests/unit/decision_engine/scoring/test_scoring_factory.py b/watcher/tests/unit/decision_engine/scoring/test_scoring_factory.py
index c2b29abf2..828d6eaba 100644
--- a/watcher/tests/unit/decision_engine/scoring/test_scoring_factory.py
+++ b/watcher/tests/unit/decision_engine/scoring/test_scoring_factory.py
@@ -20,7 +20,6 @@ from watcher.tests.unit import base
 
 
 class TestScoringFactory(base.TestCase):
-
     def test_get_scoring_engine(self):
         scorer = scoring_factory.get_scoring_engine('dummy_scorer')
         self.assertEqual('dummy_scorer', scorer.get_name())
@@ -35,15 +34,18 @@ class TestScoringFactory(base.TestCase):
         self.assertEqual('dummy_avg_scorer', scorer.get_name())
 
         self.assertRaises(
-            KeyError,
-            scoring_factory.get_scoring_engine,
-            'non_existing_scorer')
+            KeyError, scoring_factory.get_scoring_engine, 'non_existing_scorer'
+        )
 
     def test_get_scoring_engine_list(self):
         scoring_engines = scoring_factory.get_scoring_engine_list()
 
-        engine_names = {'dummy_scorer', 'dummy_min_scorer',
-                        'dummy_max_scorer', 'dummy_avg_scorer'}
+        engine_names = {
+            'dummy_scorer',
+            'dummy_min_scorer',
+            'dummy_max_scorer',
+            'dummy_avg_scorer',
+        }
 
         for scorer in scoring_engines:
             self.assertIn(scorer.get_name(), engine_names)
diff --git a/watcher/tests/unit/decision_engine/solution/test_default_solution.py b/watcher/tests/unit/decision_engine/solution/test_default_solution.py
index 09be3a56f..b1fb231ef 100644
--- a/watcher/tests/unit/decision_engine/solution/test_default_solution.py
+++ b/watcher/tests/unit/decision_engine/solution/test_default_solution.py
@@ -21,44 +21,50 @@ from watcher.tests.unit import base
 
 
 class TestDefaultSolution(base.TestCase):
-
     def test_default_solution(self):
         solution = default.DefaultSolution(
             goal=mock.Mock(),
-            strategy=strategies.DummyStrategy(config=mock.Mock()))
-        parameters = {
-            "source_node": "server1",
-            "destination_node": "server2",
-        }
-        solution.add_action(action_type="nop",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
-                            input_parameters=parameters)
+            strategy=strategies.DummyStrategy(config=mock.Mock()),
+        )
+        parameters = {"source_node": "server1", "destination_node": "server2"}
+        solution.add_action(
+            action_type="nop",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+            input_parameters=parameters,
+        )
         self.assertEqual(1, len(solution.actions))
         expected_action_type = "nop"
         expected_parameters = {
             "source_node": "server1",
             "destination_node": "server2",
-            "resource_id": "b199db0c-1408-4d52-b5a5-5ca14de0ff36"
+            "resource_id": "b199db0c-1408-4d52-b5a5-5ca14de0ff36",
         }
-        self.assertEqual(expected_action_type,
-                         solution.actions[0].get('action_type'))
-        self.assertEqual(expected_parameters,
-                         solution.actions[0].get('input_parameters'))
+        self.assertEqual(
+            expected_action_type, solution.actions[0].get('action_type')
+        )
+        self.assertEqual(
+            expected_parameters, solution.actions[0].get('input_parameters')
+        )
         self.assertEqual('weight', solution.strategy.planner)
 
     def test_default_solution_with_no_input_parameters(self):
         solution = default.DefaultSolution(
             goal=mock.Mock(),
-            strategy=strategies.DummyStrategy(config=mock.Mock()))
-        solution.add_action(action_type="nop",
-                            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36")
+            strategy=strategies.DummyStrategy(config=mock.Mock()),
+        )
+        solution.add_action(
+            action_type="nop",
+            resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36",
+        )
         self.assertEqual(1, len(solution.actions))
         expected_action_type = "nop"
         expected_parameters = {
             "resource_id": "b199db0c-1408-4d52-b5a5-5ca14de0ff36"
         }
-        self.assertEqual(expected_action_type,
-                         solution.actions[0].get('action_type'))
-        self.assertEqual(expected_parameters,
-                         solution.actions[0].get('input_parameters'))
+        self.assertEqual(
+            expected_action_type, solution.actions[0].get('action_type')
+        )
+        self.assertEqual(
+            expected_parameters, solution.actions[0].get('input_parameters')
+        )
         self.assertEqual('weight', solution.strategy.planner)
diff --git a/watcher/tests/unit/decision_engine/strategy/context/test_strategy_context.py b/watcher/tests/unit/decision_engine/strategy/context/test_strategy_context.py
index a718d246e..9e2328977 100644
--- a/watcher/tests/unit/decision_engine/strategy/context/test_strategy_context.py
+++ b/watcher/tests/unit/decision_engine/strategy/context/test_strategy_context.py
@@ -27,19 +27,22 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestStrategyContext(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         obj_utils.create_test_goal(self.context, id=1, name="DUMMY")
         audit_template = obj_utils.create_test_audit_template(
-            self.context, uuid=utils.generate_uuid())
+            self.context, uuid=utils.generate_uuid()
+        )
         self.audit = obj_utils.create_test_audit(
-            self.context, audit_template_id=audit_template.id)
+            self.context, audit_template_id=audit_template.id
+        )
         self.fake_cluster = faker_cluster_state.FakerModelCollector()
 
         p_model = mock.patch.object(
-            strategies.DummyStrategy, "compute_model",
-            new_callable=mock.PropertyMock)
+            strategies.DummyStrategy,
+            "compute_model",
+            new_callable=mock.PropertyMock,
+        )
         self.m_model = p_model.start()
         self.addCleanup(p_model.stop)
 
@@ -49,25 +52,32 @@ class TestStrategyContext(base.DbTestCase):
 
     @mock.patch.object(d_selector.DefaultStrategySelector, 'select')
     def test_execute_strategy(self, mock_call):
-        mock_call.return_value = strategies.DummyStrategy(
-            config=mock.Mock())
+        mock_call.return_value = strategies.DummyStrategy(config=mock.Mock())
         solution = self.strategy_context.execute_strategy(
-            self.audit, self.context)
+            self.audit, self.context
+        )
         self.assertIsInstance(solution, default.DefaultSolution)
 
-    @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector",
-                       mock.Mock())
+    @mock.patch.object(
+        manager.CollectorManager, "get_cluster_model_collector", mock.Mock()
+    )
     def test_execute_force_dummy(self):
         goal = obj_utils.create_test_goal(
-            self.context, id=50, uuid=utils.generate_uuid(), name="my_goal")
+            self.context, id=50, uuid=utils.generate_uuid(), name="my_goal"
+        )
 
         strategy = obj_utils.create_test_strategy(
-            self.context, id=42, uuid=utils.generate_uuid(), name="dummy",
-            goal_id=goal.id)
+            self.context,
+            id=42,
+            uuid=utils.generate_uuid(),
+            name="dummy",
+            goal_id=goal.id,
+        )
 
         audit = obj_utils.create_test_audit(
             self.context,
-            id=2, name=f'My Audit {2}',
+            id=2,
+            name=f'My Audit {2}',
             goal_id=goal.id,
             strategy_id=strategy.id,
             uuid=utils.generate_uuid(),
@@ -78,24 +88,28 @@ class TestStrategyContext(base.DbTestCase):
         self.assertEqual(len(solution.actions), 3)
 
     @mock.patch.object(strategies.BasicConsolidation, "execute")
-    @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector",
-                       mock.Mock())
+    @mock.patch.object(
+        manager.CollectorManager, "get_cluster_model_collector", mock.Mock()
+    )
     def test_execute_force_basic(self, mock_call):
         expected_strategy = "basic"
         mock_call.return_value = expected_strategy
 
-        obj_utils.create_test_goal(self.context, id=50,
-                                   uuid=utils.generate_uuid(),
-                                   name="my_goal")
+        obj_utils.create_test_goal(
+            self.context, id=50, uuid=utils.generate_uuid(), name="my_goal"
+        )
 
-        strategy = obj_utils.create_test_strategy(self.context,
-                                                  id=42,
-                                                  uuid=utils.generate_uuid(),
-                                                  name=expected_strategy)
+        strategy = obj_utils.create_test_strategy(
+            self.context,
+            id=42,
+            uuid=utils.generate_uuid(),
+            name=expected_strategy,
+        )
 
         audit = obj_utils.create_test_audit(
             self.context,
-            id=2, name=f'My Audit {2}',
+            id=2,
+            name=f'My Audit {2}',
             strategy_id=strategy.id,
             uuid=utils.generate_uuid(),
         )
diff --git a/watcher/tests/unit/decision_engine/strategy/selector/test_strategy_selector.py b/watcher/tests/unit/decision_engine/strategy/selector/test_strategy_selector.py
index c5e47b0cd..4944cb91d 100644
--- a/watcher/tests/unit/decision_engine/strategy/selector/test_strategy_selector.py
+++ b/watcher/tests/unit/decision_engine/strategy/selector/test_strategy_selector.py
@@ -25,13 +25,13 @@ from watcher.tests.unit import base
 
 
 class TestStrategySelector(base.TestCase):
-
     @mock.patch.object(default_loader.DefaultStrategyLoader, 'load')
     def test_select_with_strategy_name(self, m_load):
         expected_goal = 'dummy'
         expected_strategy = "dummy"
         strategy_selector = default_selector.DefaultStrategySelector(
-            expected_goal, expected_strategy, osc=None)
+            expected_goal, expected_strategy, osc=None
+        )
         strategy_selector.select()
         m_load.assert_called_once_with(expected_strategy, osc=None)
 
@@ -42,18 +42,21 @@ class TestStrategySelector(base.TestCase):
         expected_goal = 'dummy'
         expected_strategy = "dummy"
         strategy_selector = default_selector.DefaultStrategySelector(
-            expected_goal, osc=None)
+            expected_goal, osc=None
+        )
         strategy_selector.select()
         m_load.assert_called_once_with(expected_strategy, osc=None)
 
     def test_select_non_existing_strategy(self):
         strategy_selector = default_selector.DefaultStrategySelector(
-            "dummy", "NOT_FOUND")
+            "dummy", "NOT_FOUND"
+        )
         self.assertRaises(exception.LoadingError, strategy_selector.select)
 
     @mock.patch.object(default_loader.DefaultStrategyLoader, 'list_available')
     def test_select_no_available_strategy_for_goal(self, m_list_available):
         m_list_available.return_value = {}
         strategy_selector = default_selector.DefaultStrategySelector("dummy")
-        self.assertRaises(exception.NoAvailableStrategyForGoal,
-                          strategy_selector.select)
+        self.assertRaises(
+            exception.NoAvailableStrategyForGoal, strategy_selector.select
+        )
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_actuator.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_actuator.py
index a02db537a..462a486ff 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_actuator.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_actuator.py
@@ -23,7 +23,6 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestActuator(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
         self.strategy = strategies.Actuator(config=mock.Mock())
@@ -31,7 +30,8 @@ class TestActuator(TestBaseStrategy):
     def test_actuator_strategy(self):
         fake_action = {"action_type": "TEST", "input_parameters": {"a": "b"}}
         self.strategy.input_parameters = utils.Struct(
-            {"actions": [fake_action]})
+            {"actions": [fake_action]}
+        )
         solution = self.strategy.execute()
         self.assertEqual(1, len(solution.actions))
         self.assertEqual([fake_action], solution.actions)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_base.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_base.py
index 73077ca72..57279c72c 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_base.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_base.py
@@ -24,7 +24,6 @@ from watcher.tests.unit.decision_engine.model import faker_cluster_state
 
 
 class TestBaseStrategy(base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -32,14 +31,18 @@ class TestBaseStrategy(base.TestCase):
         self.fake_c_cluster = faker_cluster_state.FakerModelCollector()
 
         p_c_model = mock.patch.object(
-            strategies.BaseStrategy, "compute_model",
-            new_callable=mock.PropertyMock)
+            strategies.BaseStrategy,
+            "compute_model",
+            new_callable=mock.PropertyMock,
+        )
         self.m_c_model = p_c_model.start()
         self.addCleanup(p_c_model.stop)
 
         p_audit_scope = mock.patch.object(
-            strategies.BaseStrategy, "audit_scope",
-            new_callable=mock.PropertyMock)
+            strategies.BaseStrategy,
+            "audit_scope",
+            new_callable=mock.PropertyMock,
+        )
         self.m_audit_scope = p_audit_scope.start()
         self.addCleanup(p_audit_scope.stop)
 
@@ -50,11 +53,11 @@ class TestBaseStrategy(base.TestCase):
 
 
 class TestBaseStrategyDatasource(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
         self.strategy = strategies.DummyStrategy(
-            config=mock.Mock(datasources=None))
+            config=mock.Mock(datasources=None)
+        )
 
     @mock.patch.object(strategies.BaseStrategy, 'osc', None)
     @mock.patch.object(manager, 'DataSourceManager')
@@ -65,15 +68,17 @@ class TestBaseStrategyDatasource(TestBaseStrategy):
         m_conf.watcher_datasources.datasources = dss
 
         # Make sure we access the property and not the underlying function.
-        m_manager.return_value.get_backend.return_value = \
+        m_manager.return_value.get_backend.return_value = (
             mock.NonCallableMock()
+        )
 
         # Access the property so that the configuration is read in order to
         # get the correct datasource
         self.strategy.datasource_backend
 
         m_manager.assert_called_once_with(
-            config=m_conf.watcher_datasources, osc=None)
+            config=m_conf.watcher_datasources, osc=None
+        )
 
     @mock.patch.object(strategies.BaseStrategy, 'osc', None)
     @mock.patch.object(manager, 'DataSourceManager')
@@ -84,15 +89,17 @@ class TestBaseStrategyDatasource(TestBaseStrategy):
         m_conf.watcher_datasources.datasources = dss
 
         # Make sure we access the property and not the underlying function.
-        m_manager.return_value.get_backend.return_value = \
+        m_manager.return_value.get_backend.return_value = (
             mock.NonCallableMock()
+        )
 
         # Access the property so that the configuration is read in order to
         # get the correct datasource
         self.strategy.datasource_backend
 
         m_manager.assert_called_once_with(
-            config=m_conf.watcher_datasources, osc=None)
+            config=m_conf.watcher_datasources, osc=None
+        )
 
     @mock.patch.object(strategies.BaseStrategy, 'osc', None)
     @mock.patch.object(manager, 'DataSourceManager')
@@ -102,8 +109,7 @@ class TestBaseStrategyDatasource(TestBaseStrategy):
 
         datasources = mock.Mock(datasources=['gnocchi'])
 
-        self.strategy = strategies.DummyStrategy(
-            config=datasources)
+        self.strategy = strategies.DummyStrategy(config=datasources)
 
         m_conf.watcher_datasources.datasources = ['gnocchi']
 
@@ -111,19 +117,18 @@ class TestBaseStrategyDatasource(TestBaseStrategy):
         # get the correct datasource
         self.strategy.datasource_backend
 
-        m_manager.assert_called_once_with(
-            config=datasources, osc=None)
+        m_manager.assert_called_once_with(config=datasources, osc=None)
 
 
 class TestBaseStrategyException(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
 
     def test_exception_model(self):
         self.m_c_model.return_value = None
         self.assertRaises(
-            exception.ClusterStateNotDefined, self.strategy.execute)
+            exception.ClusterStateNotDefined, self.strategy.execute
+        )
 
     def test_exception_stale_cdm(self):
         self.fake_c_cluster.set_cluster_data_model_as_stale()
@@ -133,4 +138,5 @@ class TestBaseStrategyException(TestBaseStrategy):
             # TODO(Dantali0n) This should return ClusterStale,
             #  improve set_cluster_data_model_as_stale().
             exception.ClusterStateNotDefined,
-            self.strategy.execute)
+            self.strategy.execute,
+        )
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_basic_consolidation.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_basic_consolidation.py
index d40d92736..21b586943 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_basic_consolidation.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_basic_consolidation.py
@@ -31,11 +31,14 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestBasicConsolidation(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics,
+            },
+        )
     ]
 
     def setUp(self):
@@ -43,28 +46,30 @@ class TestBasicConsolidation(TestBaseStrategy):
         # fake metrics
         self.fake_metrics = self.fake_datasource_cls()
 
-        p_osc = mock.patch.object(
-            clients, "OpenStackClients")
+        p_osc = mock.patch.object(clients, "OpenStackClients")
         self.m_osc = p_osc.start()
         self.addCleanup(p_osc.stop)
 
         p_datasource = mock.patch.object(
-            strategies.BasicConsolidation, 'datasource_backend',
-            new_callable=mock.PropertyMock)
+            strategies.BasicConsolidation,
+            'datasource_backend',
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         self.m_datasource.return_value = mock.Mock(
             get_host_cpu_usage=self.fake_metrics.get_usage_compute_node_cpu,
-            get_instance_cpu_usage=self.fake_metrics.
-            get_average_usage_instance_cpu
+            get_instance_cpu_usage=self.fake_metrics.get_average_usage_instance_cpu,
         )
         self.strategy = strategies.BasicConsolidation(
-            config=mock.Mock(datasource=self.datasource))
+            config=mock.Mock(datasource=self.datasource)
+        )
 
     def test_cluster_size(self):
         size_cluster = len(
-            self.fake_c_cluster.generate_scenario_1().get_all_compute_nodes())
+            self.fake_c_cluster.generate_scenario_1().get_all_compute_nodes()
+        )
         size_cluster_assert = 5
         self.assertEqual(size_cluster_assert, size_cluster)
 
@@ -72,14 +77,26 @@ class TestBasicConsolidation(TestBaseStrategy):
         model = self.fake_c_cluster.generate_scenario_1()
         self.m_c_model.return_value = model
         node_1_score = 0.023333333333333317
-        self.assertEqual(node_1_score, self.strategy.calculate_score_node(
-            model.get_node_by_uuid("Node_1")))
+        self.assertEqual(
+            node_1_score,
+            self.strategy.calculate_score_node(
+                model.get_node_by_uuid("Node_1")
+            ),
+        )
         node_2_score = 0.26666666666666666
-        self.assertEqual(node_2_score, self.strategy.calculate_score_node(
-            model.get_node_by_uuid("Node_2")))
+        self.assertEqual(
+            node_2_score,
+            self.strategy.calculate_score_node(
+                model.get_node_by_uuid("Node_2")
+            ),
+        )
         node_0_score = 0.023333333333333317
-        self.assertEqual(node_0_score, self.strategy.calculate_score_node(
-            model.get_node_by_uuid("Node_0")))
+        self.assertEqual(
+            node_0_score,
+            self.strategy.calculate_score_node(
+                model.get_node_by_uuid("Node_0")
+            ),
+        )
 
     def test_basic_consolidation_score_instance(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -90,35 +107,40 @@ class TestBasicConsolidation(TestBaseStrategy):
         instance_0_score = 0.023333333333333317
         self.assertEqual(
             instance_0_score,
-            self.strategy.calculate_score_instance(instance_0))
+            self.strategy.calculate_score_instance(instance_0),
+        )
         instance_1 = model.get_instance_by_uuid(
             "d010ef1f-dc19-4982-9383-087498bfde03"
         )
         instance_1_score = 0.023333333333333317
         self.assertEqual(
             instance_1_score,
-            self.strategy.calculate_score_instance(instance_1))
+            self.strategy.calculate_score_instance(instance_1),
+        )
         instance_2 = model.get_instance_by_uuid(
             "d020ef1f-dc19-4982-9383-087498bfde03"
         )
         instance_2_score = 0.033333333333333326
         self.assertEqual(
             instance_2_score,
-            self.strategy.calculate_score_instance(instance_2))
+            self.strategy.calculate_score_instance(instance_2),
+        )
         instance_6 = model.get_instance_by_uuid(
             "d060ef1f-dc19-4982-9383-087498bfde03"
         )
         instance_6_score = 0.02666666666666669
         self.assertEqual(
             instance_6_score,
-            self.strategy.calculate_score_instance(instance_6))
+            self.strategy.calculate_score_instance(instance_6),
+        )
         instance_7 = model.get_instance_by_uuid(
             "d070ef1f-dc19-4982-9383-087498bfde03"
         )
         instance_7_score = 0.013333333333333345
         self.assertEqual(
             instance_7_score,
-            self.strategy.calculate_score_instance(instance_7))
+            self.strategy.calculate_score_instance(instance_7),
+        )
 
     def test_basic_consolidation_score_instance_disk(self):
         model = self.fake_c_cluster.generate_scenario_5_with_instance_disk_0()
@@ -127,7 +149,8 @@ class TestBasicConsolidation(TestBaseStrategy):
         instance_0_score = 0.023333333333333355
         self.assertEqual(
             instance_0_score,
-            self.strategy.calculate_score_instance(instance_0))
+            self.strategy.calculate_score_instance(instance_0),
+        )
 
     def test_basic_consolidation_weight(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -143,7 +166,8 @@ class TestBasicConsolidation(TestBaseStrategy):
         instance_0_weight_assert = 3.1999999999999997
         self.assertEqual(
             instance_0_weight_assert,
-            self.strategy.calculate_weight(instance_0, cores, disk, mem))
+            self.strategy.calculate_weight(instance_0, cores, disk, mem),
+        )
 
     def test_check_migration(self):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
@@ -163,15 +187,19 @@ class TestBasicConsolidation(TestBaseStrategy):
         all_nodes = model.get_all_compute_nodes()
         node0 = all_nodes[list(all_nodes.keys())[0]]
 
-        self.assertFalse(self.strategy.check_threshold(
-            node0, 1000, 1000, 1000))
+        self.assertFalse(
+            self.strategy.check_threshold(node0, 1000, 1000, 1000)
+        )
 
     def test_basic_consolidation_works_on_model_copy(self):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
         self.m_c_model.return_value = copy.deepcopy(model)
 
-        self.assertTrue(model_root.ModelRoot.is_isomorphic(
-            model, self.strategy.compute_model))
+        self.assertTrue(
+            model_root.ModelRoot.is_isomorphic(
+                model, self.strategy.compute_model
+            )
+        )
         self.assertIsNot(model, self.strategy.compute_model)
 
     def test_basic_consolidation_migration(self):
@@ -181,14 +209,16 @@ class TestBasicConsolidation(TestBaseStrategy):
         solution = self.strategy.execute()
 
         actions_counter = collections.Counter(
-            [action.get('action_type') for action in solution.actions])
+            [action.get('action_type') for action in solution.actions]
+        )
 
         expected_num_migrations = 1
         expected_power_state = 1
 
         num_migrations = actions_counter.get("migrate", 0)
         num_node_state_change = actions_counter.get(
-            "change_nova_service_state", 0)
+            "change_nova_service_state", 0
+        )
         self.assertEqual(expected_num_migrations, num_migrations)
         self.assertEqual(expected_power_state, num_node_state_change)
 
@@ -199,7 +229,8 @@ class TestBasicConsolidation(TestBaseStrategy):
         solution = self.strategy.execute()
 
         actions_counter = collections.Counter(
-            [action.get('action_type') for action in solution.actions])
+            [action.get('action_type') for action in solution.actions]
+        )
 
         expected_num_migrations = 5
         expected_power_state = 3
@@ -207,7 +238,8 @@ class TestBasicConsolidation(TestBaseStrategy):
 
         num_migrations = actions_counter.get("migrate", 0)
         num_node_state_change = actions_counter.get(
-            "change_nova_service_state", 0)
+            "change_nova_service_state", 0
+        )
 
         global_efficacy_value = solution.global_efficacy[0].get('value', 0)
 
@@ -218,8 +250,8 @@ class TestBasicConsolidation(TestBaseStrategy):
     # calculate_weight
     def test_execute_no_workload(self):
         model = (
-            self.fake_c_cluster
-            .generate_scenario_4_with_1_node_no_instance())
+            self.fake_c_cluster.generate_scenario_4_with_1_node_no_instance()
+        )
         self.m_c_model.return_value = model
 
         with mock.patch.object(
@@ -228,8 +260,9 @@ class TestBasicConsolidation(TestBaseStrategy):
             mock_score_call.return_value = 0
             solution = self.strategy.execute()
 
-            self.assertEqual(0,
-                             solution.efficacy.global_efficacy[0].get('value'))
+            self.assertEqual(
+                0, solution.efficacy.global_efficacy[0].get('value')
+            )
 
     def test_check_parameters(self):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
@@ -244,14 +277,19 @@ class TestBasicConsolidation(TestBaseStrategy):
     def test_parameter_backwards_compat(self):
         # Set the deprecated node values to a none default value
         self.strategy.input_parameters.update(
-            {'aggregation_method': {
-                "instance": "mean",
-                "compute_node": "mean",
-                "node": 'min'}})
+            {
+                'aggregation_method': {
+                    "instance": "mean",
+                    "compute_node": "mean",
+                    "node": 'min',
+                }
+            }
+        )
 
         # Pre execute method handles backwards compatibility of parameters
         self.strategy.pre_execute()
 
         # assert that the compute_node values are updated to the those of node
         self.assertEqual(
-            'min', self.strategy.aggregation_method['compute_node'])
+            'min', self.strategy.aggregation_method['compute_node']
+        )
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_strategy.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_strategy.py
index 2717c84dc..da2bf9479 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_strategy.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_strategy.py
@@ -24,7 +24,6 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestDummyStrategy(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
         self.strategy = strategies.DummyStrategy(config=mock.Mock())
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_with_scorer.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_with_scorer.py
index f1a09983a..ddc71db7b 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_with_scorer.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_dummy_with_scorer.py
@@ -24,7 +24,6 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestDummyWithScorer(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
         self.strategy = strategies.DummyWithScorer(config=mock.Mock())
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_host_maintenance.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_host_maintenance.py
index 014b8fdd7..a2c7b385d 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_host_maintenance.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_host_maintenance.py
@@ -27,48 +27,54 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestHostMaintenance(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
         self.strategy = strategies.HostMaintenance(config=mock.Mock())
 
     def test_get_instance_state_str(self):
         mock_instance = mock.MagicMock(state="active")
-        self.assertEqual("active",
-                         self.strategy.get_instance_state_str(mock_instance))
+        self.assertEqual(
+            "active", self.strategy.get_instance_state_str(mock_instance)
+        )
 
         mock_instance.state = element.InstanceState("active")
-        self.assertEqual("active",
-                         self.strategy.get_instance_state_str(mock_instance))
+        self.assertEqual(
+            "active", self.strategy.get_instance_state_str(mock_instance)
+        )
 
         mock_instance.state = None
         self.assertRaises(
             exception.WatcherException,
             self.strategy.get_instance_state_str,
-            mock_instance)
+            mock_instance,
+        )
 
     def test_get_node_status_str(self):
         mock_node = mock.MagicMock(status="enabled")
-        self.assertEqual("enabled",
-                         self.strategy.get_node_status_str(mock_node))
+        self.assertEqual(
+            "enabled", self.strategy.get_node_status_str(mock_node)
+        )
 
         mock_node.status = element.ServiceState("enabled")
-        self.assertEqual("enabled",
-                         self.strategy.get_node_status_str(mock_node))
+        self.assertEqual(
+            "enabled", self.strategy.get_node_status_str(mock_node)
+        )
 
         mock_node.status = None
         self.assertRaises(
             exception.WatcherException,
             self.strategy.get_node_status_str,
-            mock_node)
+            mock_node,
+        )
 
     def test_get_node_capacity(self):
         model = self.fake_c_cluster.generate_scenario_1()
         self.m_c_model.return_value = model
         node_0 = model.get_node_by_uuid("Node_0")
         node_capacity = dict(cpu=40, ram=132, disk=250)
-        self.assertEqual(node_capacity,
-                         self.strategy.get_node_capacity(node_0))
+        self.assertEqual(
+            node_capacity, self.strategy.get_node_capacity(node_0)
+        )
 
     def test_host_fits(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -82,11 +88,16 @@ class TestHostMaintenance(TestBaseStrategy):
         self.m_c_model.return_value = model
         node_0 = model.get_node_by_uuid('Node_0')
         self.strategy.add_action_enable_compute_node(node_0)
-        expected = [{'action_type': 'change_nova_service_state',
-                     'input_parameters': {
-                         'state': 'enabled',
-                         'resource_id': 'Node_0',
-                         'resource_name': 'hostname_0'}}]
+        expected = [
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'state': 'enabled',
+                    'resource_id': 'Node_0',
+                    'resource_name': 'hostname_0',
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_add_action_maintain_compute_node(self):
@@ -94,12 +105,17 @@ class TestHostMaintenance(TestBaseStrategy):
         self.m_c_model.return_value = model
         node_0 = model.get_node_by_uuid('Node_0')
         self.strategy.add_action_maintain_compute_node(node_0)
-        expected = [{'action_type': 'change_nova_service_state',
-                     'input_parameters': {
-                         'state': 'disabled',
-                         'disabled_reason': 'watcher_maintaining',
-                         'resource_id': 'Node_0',
-                         'resource_name': 'hostname_0'}}]
+        expected = [
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_maintaining',
+                    'resource_id': 'Node_0',
+                    'resource_name': 'hostname_0',
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle(self):
@@ -108,18 +124,22 @@ class TestHostMaintenance(TestBaseStrategy):
         node_0 = model.get_node_by_uuid('Node_0')
         node_1 = model.get_node_by_uuid('Node_1')
         instance_0 = model.get_instance_by_uuid(
-
             "d000ef1f-dc19-4982-9383-087498bfde03"
         )
         self.strategy.instance_handle(instance_0, node_0, node_1)
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {'destination_node': node_1.hostname,
-                                          'source_node': node_0.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': instance_0.uuid,
-                                          'resource_name': instance_0.name
-                                          }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_without_dest_node(self):
@@ -131,12 +151,17 @@ class TestHostMaintenance(TestBaseStrategy):
         )
         self.strategy.instance_handle(instance_0, node_0)
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {'source_node': node_0.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': instance_0.uuid,
-                                          'resource_name': instance_0.name
-                                          }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_host_migration(self):
@@ -152,20 +177,28 @@ class TestHostMaintenance(TestBaseStrategy):
         )
         self.strategy.host_migration(node_0, node_1)
         self.assertEqual(2, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {'destination_node': node_1.hostname,
-                                          'source_node': node_0.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': instance_0.uuid,
-                                          'resource_name': instance_0.name
-                                          }},
-                    {'action_type': 'migrate',
-                     'input_parameters': {'destination_node': node_1.hostname,
-                                          'source_node': node_0.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': instance_1.uuid,
-                                          'resource_name': instance_1.name
-                                          }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_1.uuid,
+                    'resource_name': instance_1.name,
+                },
+            },
+        ]
         self.assertIn(expected[0], self.strategy.solution.actions)
         self.assertIn(expected[1], self.strategy.solution.actions)
 
@@ -179,8 +212,9 @@ class TestHostMaintenance(TestBaseStrategy):
         # It will return true, if backup node is passed
         self.assertTrue(self.strategy.safe_maintain(node_0, node_1))
 
-        model = self.fake_c_cluster.\
-            generate_scenario_1_with_all_nodes_disable()
+        model = (
+            self.fake_c_cluster.generate_scenario_1_with_all_nodes_disable()
+        )
         self.m_c_model.return_value = model
         node_0 = model.get_node_by_uuid('Node_0')
         # It will return false, if there is no backup node
@@ -198,8 +232,7 @@ class TestHostMaintenance(TestBaseStrategy):
         self.assertRaises(exception.ComputeNodeNotFound, self.strategy.execute)
 
     def test_strategy(self):
-        model = self.fake_c_cluster. \
-            generate_scenario_9_with_3_active_plus_1_disabled_nodes()
+        model = self.fake_c_cluster.generate_scenario_9_with_3_active_plus_1_disabled_nodes()  # noqa: E501
         self.m_c_model.return_value = model
         node_2 = model.get_node_by_uuid('Node_2')
         node_3 = model.get_node_by_uuid('Node_3')
@@ -208,28 +241,41 @@ class TestHostMaintenance(TestBaseStrategy):
         result = self.strategy.pre_execute()
         self.assertIsNone(result)
 
-        self.strategy.input_parameters = {"maintenance_node": 'hostname_2',
-                                          "backup_node": 'hostname_3'}
+        self.strategy.input_parameters = {
+            "maintenance_node": 'hostname_2',
+            "backup_node": 'hostname_3',
+        }
         self.strategy.do_execute()
 
-        expected = [{'action_type': 'change_nova_service_state',
-                     'input_parameters': {
-                         'resource_id': 'Node_3',
-                         'resource_name': 'hostname_3',
-                         'state': 'enabled'}},
-                    {'action_type': 'change_nova_service_state',
-                     'input_parameters': {
-                         'resource_id': 'Node_2',
-                         'resource_name': 'hostname_2',
-                         'state': 'disabled',
-                         'disabled_reason': 'watcher_maintaining'}},
-                    {'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': node_3.hostname,
-                         'source_node': node_2.hostname,
-                         'migration_type': 'live',
-                         'resource_id': instance_4.uuid,
-                         'resource_name': instance_4.name}}]
+        expected = [
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': 'Node_3',
+                    'resource_name': 'hostname_3',
+                    'state': 'enabled',
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': 'Node_2',
+                    'resource_name': 'hostname_2',
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_maintaining',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_3.hostname,
+                    'source_node': node_2.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_4.uuid,
+                    'resource_name': instance_4.name,
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
         result = self.strategy.post_execute()
@@ -241,10 +287,12 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.input_parameters = parameters
 
         # Parameters should default to False when not provided
-        self.assertFalse(self.strategy.input_parameters.get(
-            'disable_live_migration', False))
-        self.assertFalse(self.strategy.input_parameters.get(
-            'disable_cold_migration', False))
+        self.assertFalse(
+            self.strategy.input_parameters.get('disable_live_migration', False)
+        )
+        self.assertFalse(
+            self.strategy.input_parameters.get('disable_cold_migration', False)
+        )
 
     def test_add_action_stop_instance(self):
         """Test add_action_stop_instance method"""
@@ -257,8 +305,12 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.add_action_stop_instance(instance_0)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'stop', 'input_parameters': {
-            'resource_id': instance_0.uuid}}]
+        expected = [
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_0.uuid},
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_both_migrations_disabled_active_instance(self):
@@ -273,14 +325,18 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.input_parameters = {
             'maintenance_node': 'hostname_0',
             'disable_live_migration': True,
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.instance_handle(instance_0, node_0)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'stop', 'input_parameters': {
-            'resource_id': instance_0.uuid}}]
+        expected = [
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_0.uuid},
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_both_migrations_disabled_inactive_instance(self):
@@ -296,7 +352,7 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.input_parameters = {
             'maintenance_node': 'hostname_0',
             'disable_live_migration': True,
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.instance_handle(instance_1, node_0)
@@ -320,14 +376,18 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.instance_handle(instance_0, node_0, node_1)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': node_1.hostname,
-                         'source_node': node_0.hostname,
-                         'migration_type': 'cold',
-                         'resource_id': instance_0.uuid,
-                         'resource_name': instance_0.name
-                     }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'cold',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_live_migration_disabled_inactive_instance(self):
@@ -349,14 +409,18 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.instance_handle(instance_1, node_0, node_1)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': node_1.hostname,
-                         'source_node': node_0.hostname,
-                         'migration_type': 'cold',
-                         'resource_id': instance_1.uuid,
-                         'resource_name': instance_1.name
-                     }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'cold',
+                    'resource_id': instance_1.uuid,
+                    'resource_name': instance_1.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_cold_migration_disabled_active_instance(self):
@@ -371,20 +435,24 @@ class TestHostMaintenance(TestBaseStrategy):
 
         self.strategy.input_parameters = {
             'maintenance_node': 'hostname_0',
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.instance_handle(instance_0, node_0, node_1)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': node_1.hostname,
-                         'source_node': node_0.hostname,
-                         'migration_type': 'live',
-                         'resource_id': instance_0.uuid,
-                         'resource_name': instance_0.name
-                     }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_cold_migration_disabled_inactive_instance(self):
@@ -400,7 +468,7 @@ class TestHostMaintenance(TestBaseStrategy):
 
         self.strategy.input_parameters = {
             'maintenance_node': 'hostname_0',
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.instance_handle(instance_1, node_0, node_1)
@@ -418,21 +486,23 @@ class TestHostMaintenance(TestBaseStrategy):
             "d000ef1f-dc19-4982-9383-087498bfde03"
         )
 
-        self.strategy.input_parameters = {
-            'maintenance_node': 'hostname_0',
-        }
+        self.strategy.input_parameters = {'maintenance_node': 'hostname_0'}
 
         self.strategy.instance_handle(instance_0, node_0, node_1)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': node_1.hostname,
-                         'source_node': node_0.hostname,
-                         'migration_type': 'live',
-                         'resource_id': instance_0.uuid,
-                         'resource_name': instance_0.name
-                     }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_instance_handle_no_migrations_disabled_inactive_instance(self):
@@ -446,21 +516,23 @@ class TestHostMaintenance(TestBaseStrategy):
         )
         instance_1.state = 'stopped'
 
-        self.strategy.input_parameters = {
-            'maintenance_node': 'hostname_0',
-        }
+        self.strategy.input_parameters = {'maintenance_node': 'hostname_0'}
 
         self.strategy.instance_handle(instance_1, node_0, node_1)
 
         self.assertEqual(1, len(self.strategy.solution.actions))
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': node_1.hostname,
-                         'source_node': node_0.hostname,
-                         'migration_type': 'cold',
-                         'resource_id': instance_1.uuid,
-                         'resource_name': instance_1.name
-                     }}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'cold',
+                    'resource_id': instance_1.uuid,
+                    'resource_name': instance_1.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_host_migration_with_both_migrations_disabled(self):
@@ -479,7 +551,7 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.input_parameters = {
             'maintenance_node': 'hostname_0',
             'disable_live_migration': True,
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.host_migration(node_0, node_1)
@@ -487,10 +559,14 @@ class TestHostMaintenance(TestBaseStrategy):
         # Should generate stop actions for all instances
         self.assertEqual(2, len(self.strategy.solution.actions))
         expected_actions = [
-            {'action_type': 'stop', 'input_parameters': {
-                'resource_id': instance_0.uuid}},
-            {'action_type': 'stop', 'input_parameters': {
-                'resource_id': instance_1.uuid}}
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_0.uuid},
+            },
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_1.uuid},
+            },
         ]
         for action in expected_actions:
             self.assertIn(action, self.strategy.solution.actions)
@@ -518,22 +594,26 @@ class TestHostMaintenance(TestBaseStrategy):
         # Should generate cold migrate actions for all instances
         self.assertEqual(2, len(self.strategy.solution.actions))
         expected_actions = [
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'destination_node': node_1.hostname,
-                 'source_node': node_0.hostname,
-                 'migration_type': 'cold',
-                 'resource_id': instance_0.uuid,
-                 'resource_name': instance_0.name
-             }},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'destination_node': node_1.hostname,
-                 'source_node': node_0.hostname,
-                 'migration_type': 'cold',
-                 'resource_id': instance_1.uuid,
-                 'resource_name': instance_1.name
-             }}
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'cold',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': node_1.hostname,
+                    'source_node': node_0.hostname,
+                    'migration_type': 'cold',
+                    'resource_id': instance_1.uuid,
+                    'resource_name': instance_1.name,
+                },
+            },
         ]
         for action in expected_actions:
             self.assertIn(action, self.strategy.solution.actions)
@@ -555,7 +635,7 @@ class TestHostMaintenance(TestBaseStrategy):
             'maintenance_node': 'hostname_0',
             'backup_node': 'hostname_1',
             'disable_live_migration': True,
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         result = self.strategy.safe_maintain(node_0, node_1)
@@ -566,17 +646,23 @@ class TestHostMaintenance(TestBaseStrategy):
         self.assertEqual(3, len(self.strategy.solution.actions))
 
         expected_actions = [
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'resource_id': node_0.uuid,
-                 'resource_name': node_0.hostname,
-                 'state': 'disabled',
-                 'disabled_reason': 'watcher_maintaining'
-             }},
-            {'action_type': 'stop', 'input_parameters': {
-                'resource_id': instance_0.uuid}},
-            {'action_type': 'stop', 'input_parameters': {
-                'resource_id': instance_1.uuid}}
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': node_0.uuid,
+                    'resource_name': node_0.hostname,
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_maintaining',
+                },
+            },
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_0.uuid},
+            },
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_1.uuid},
+            },
         ]
         for action in expected_actions:
             self.assertIn(action, self.strategy.solution.actions)
@@ -596,7 +682,7 @@ class TestHostMaintenance(TestBaseStrategy):
         self.strategy.input_parameters = {
             'maintenance_node': 'hostname_0',
             'disable_live_migration': True,
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.try_maintain(node_0)
@@ -605,17 +691,23 @@ class TestHostMaintenance(TestBaseStrategy):
         self.assertEqual(3, len(self.strategy.solution.actions))
 
         expected_actions = [
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'resource_id': node_0.uuid,
-                 'resource_name': node_0.hostname,
-                 'state': 'disabled',
-                 'disabled_reason': 'watcher_maintaining'
-             }},
-            {'action_type': 'stop', 'input_parameters': {
-                'resource_id': instance_0.uuid}},
-            {'action_type': 'stop', 'input_parameters': {
-                'resource_id': instance_1.uuid}}
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': node_0.uuid,
+                    'resource_name': node_0.hostname,
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_maintaining',
+                },
+            },
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_0.uuid},
+            },
+            {
+                'action_type': 'stop',
+                'input_parameters': {'resource_id': instance_1.uuid},
+            },
         ]
         for action in expected_actions:
             self.assertIn(action, self.strategy.solution.actions)
@@ -628,7 +720,7 @@ class TestHostMaintenance(TestBaseStrategy):
             'maintenance_node': 'hostname_0',
             'backup_node': 'hostname_1',
             'disable_live_migration': True,
-            'disable_cold_migration': True
+            'disable_cold_migration': True,
         }
 
         self.strategy.do_execute()
@@ -637,8 +729,11 @@ class TestHostMaintenance(TestBaseStrategy):
         self.assertEqual(3, len(self.strategy.solution.actions))
 
         # Check that we have stop actions
-        stop_actions = [action for action in self.strategy.solution.actions
-                        if action['action_type'] == 'stop']
+        stop_actions = [
+            action
+            for action in self.strategy.solution.actions
+            if action['action_type'] == 'stop'
+        ]
         self.assertEqual(2, len(stop_actions))
 
     def test_strategy_with_live_migration_disabled(self):
@@ -658,9 +753,10 @@ class TestHostMaintenance(TestBaseStrategy):
 
         # Check that we have cold migrate actions
         cold_migrate_actions = [
-            action for action in self.strategy.solution.actions
-            if action['action_type'] == 'migrate' and
-            action['input_parameters']['migration_type'] == 'cold'
+            action
+            for action in self.strategy.solution.actions
+            if action['action_type'] == 'migrate'
+            and action['input_parameters']['migration_type'] == 'cold'
         ]
         self.assertEqual(2, len(cold_migrate_actions))
 
@@ -684,24 +780,33 @@ class TestHostMaintenance(TestBaseStrategy):
         self.assertEqual(3, len(self.strategy.solution.actions))
 
         expected_actions = [
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'resource_id': node_0.uuid,
-                 'resource_name': node_0.hostname,
-                 'state': 'disabled',
-                 'disabled_reason': 'watcher_maintaining'}},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'source_node': node_0.hostname,
-                 'migration_type': 'live',
-                 'resource_id': instance_0.uuid,
-                 'resource_name': instance_0.name}},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'source_node': node_0.hostname,
-                 'migration_type': 'live',
-                 'resource_id': instance_1.uuid,
-                 'resource_name': instance_1.name}}
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': node_0.uuid,
+                    'resource_name': node_0.hostname,
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_maintaining',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_0.uuid,
+                    'resource_name': instance_0.name,
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'source_node': node_0.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance_1.uuid,
+                    'resource_name': instance_1.name,
+                },
+            },
         ]
 
         for action in expected_actions:
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_node_resource_consolidation.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_node_resource_consolidation.py
index 5ca6ae362..594569b34 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_node_resource_consolidation.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_node_resource_consolidation.py
@@ -27,11 +27,11 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestNodeResourceConsolidation(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
         self.strategy = strategies.NodeResourceConsolidation(
-            config=mock.Mock())
+            config=mock.Mock()
+        )
         self.model = self.fake_c_cluster.generate_scenario_10()
         self.m_c_model.return_value = self.model
         self.strategy.input_parameters = {'host_choice': 'auto'}
@@ -40,17 +40,20 @@ class TestNodeResourceConsolidation(TestBaseStrategy):
         planner = 'node_resource_consolidation'
         self.assertEqual('auto', self.strategy.host_choice)
         self.assertNotEqual(planner, self.strategy.planner)
-        self.strategy.input_parameters.update(
-            {'host_choice': 'specify'})
+        self.strategy.input_parameters.update({'host_choice': 'specify'})
         self.strategy.pre_execute()
         self.assertEqual(planner, self.strategy.planner)
         self.assertEqual('specify', self.strategy.host_choice)
 
     def test_check_resources(self):
-        instance = [self.model.get_instance_by_uuid(
-            "6ae05517-a512-462d-9d83-90c313b5a8ff")]
+        instance = [
+            self.model.get_instance_by_uuid(
+                "6ae05517-a512-462d-9d83-90c313b5a8ff"
+            )
+        ]
         dest = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c972")
+            "89dce55c-8e74-4402-b23f-32aaf216c972"
+        )
         # test destination is null
         result = self.strategy.check_resources(instance, [])
         self.assertFalse(result)
@@ -61,11 +64,14 @@ class TestNodeResourceConsolidation(TestBaseStrategy):
 
     def test_select_destination(self):
         instance0 = self.model.get_instance_by_uuid(
-            "6ae05517-a512-462d-9d83-90c313b5a8ff")
+            "6ae05517-a512-462d-9d83-90c313b5a8ff"
+        )
         source = self.model.get_node_by_instance_uuid(
-            "6ae05517-a512-462d-9d83-90c313b5a8ff")
+            "6ae05517-a512-462d-9d83-90c313b5a8ff"
+        )
         expected = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c972")
+            "89dce55c-8e74-4402-b23f-32aaf216c972"
+        )
         # test destination is null
         result = self.strategy.select_destination(instance0, source, [])
         self.assertIsNone(result)
@@ -84,110 +90,149 @@ class TestNodeResourceConsolidation(TestBaseStrategy):
     def test_add_migrate_actions_with_auto(self):
         self.strategy.host_choice = 'auto'
         source = self.model.get_node_by_instance_uuid(
-            "6ae05517-a512-462d-9d83-90c313b5a8ff")
+            "6ae05517-a512-462d-9d83-90c313b5a8ff"
+        )
         nodes = list(self.model.get_all_compute_nodes().values())
         nodes.remove(source)
         self.strategy.add_migrate_actions([source], nodes)
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'migration_type': 'live',
-                         'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f1',
-                         'resource_name': 'INSTANCE_1',
-                         'source_node': 'hostname_0'}},
-                    {'action_type': 'migrate',
-                     'input_parameters': {
-                         'migration_type': 'live',
-                         'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8ff',
-                         'resource_name': 'INSTANCE_0',
-                         'source_node': 'hostname_0'}}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f1',
+                    'resource_name': 'INSTANCE_1',
+                    'source_node': 'hostname_0',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8ff',
+                    'resource_name': 'INSTANCE_0',
+                    'source_node': 'hostname_0',
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_add_migrate_actions_with_specify(self):
         self.strategy.host_choice = 'specify'
         source = self.model.get_node_by_instance_uuid(
-            "6ae05517-a512-462d-9d83-90c313b5a8ff")
+            "6ae05517-a512-462d-9d83-90c313b5a8ff"
+        )
         nodes = list(self.model.get_all_compute_nodes().values())
         nodes.remove(source)
         self.strategy.add_migrate_actions([source], nodes)
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': 'hostname_1',
-                         'migration_type': 'live',
-                         'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f1',
-                         'resource_name': 'INSTANCE_1',
-                         'source_node': 'hostname_0'}},
-                    {'action_type': 'migrate',
-                     'input_parameters': {
-                         'destination_node': 'hostname_2',
-                         'migration_type': 'live',
-                         'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8ff',
-                         'resource_name': 'INSTANCE_0',
-                         'source_node': 'hostname_0'}}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': 'hostname_1',
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f1',
+                    'resource_name': 'INSTANCE_1',
+                    'source_node': 'hostname_0',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': 'hostname_2',
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8ff',
+                    'resource_name': 'INSTANCE_0',
+                    'source_node': 'hostname_0',
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_add_migrate_actions_with_no_action(self):
         self.strategy.host_choice = 'specify'
         source = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c971")
+            "89dce55c-8e74-4402-b23f-32aaf216c971"
+        )
         dest = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c972")
+            "89dce55c-8e74-4402-b23f-32aaf216c972"
+        )
         self.strategy.add_migrate_actions([source], [dest])
         self.assertEqual([], self.strategy.solution.actions)
 
     def test_add_change_node_state_actions_with_exeception(self):
-        self.assertRaises(exception.IllegalArgumentException,
-                          self.strategy.add_change_node_state_actions,
-                          [], 'down')
+        self.assertRaises(
+            exception.IllegalArgumentException,
+            self.strategy.add_change_node_state_actions,
+            [],
+            'down',
+        )
 
     def test_add_change_node_state_actions(self):
         node1 = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c972")
+            "89dce55c-8e74-4402-b23f-32aaf216c972"
+        )
         node2 = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c97f")
+            "89dce55c-8e74-4402-b23f-32aaf216c97f"
+        )
         # disable two nodes
         status = element.ServiceState.DISABLED.value
         result = self.strategy.add_change_node_state_actions(
-            [node1, node2], status)
+            [node1, node2], status
+        )
         self.assertEqual([node1, node2], result)
-        expected = [{
-            'action_type': 'change_nova_service_state',
-            'input_parameters': {
-                'disabled_reason': 'Watcher node resource '
-                                   'consolidation strategy',
-                'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c972',
-                'resource_name': 'hostname_2',
-                'state': 'disabled'}},
+        expected = [
             {
-            'action_type': 'change_nova_service_state',
-            'input_parameters': {
-                'disabled_reason': 'Watcher node resource consolidation '
-                                   'strategy',
-                'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c97f',
-                'resource_name': 'hostname_0',
-                'state': 'disabled'}}]
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'disabled_reason': 'Watcher node resource '
+                    'consolidation strategy',
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c972',
+                    'resource_name': 'hostname_2',
+                    'state': 'disabled',
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'disabled_reason': 'Watcher node resource consolidation '
+                    'strategy',
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c97f',
+                    'resource_name': 'hostname_0',
+                    'state': 'disabled',
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_add_change_node_state_actions_one_disabled(self):
         node1 = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c972")
+            "89dce55c-8e74-4402-b23f-32aaf216c972"
+        )
         node2 = self.model.get_node_by_uuid(
-            "89dce55c-8e74-4402-b23f-32aaf216c97f")
+            "89dce55c-8e74-4402-b23f-32aaf216c97f"
+        )
         # disable two nodes
         status = element.ServiceState.DISABLED.value
 
         # one enable, one disable
         node1.status = element.ServiceState.DISABLED.value
         result = self.strategy.add_change_node_state_actions(
-            [node1, node2], status)
+            [node1, node2], status
+        )
         self.assertEqual([node2], result)
-        expected = [{
-            'action_type': 'change_nova_service_state',
-            'input_parameters': {
-                'disabled_reason': 'Watcher node resource consolidation '
-                                   'strategy',
-                'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c97f',
-                'resource_name': 'hostname_0',
-                'state': 'disabled'}}]
+        expected = [
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'disabled_reason': 'Watcher node resource consolidation '
+                    'strategy',
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c97f',
+                    'resource_name': 'hostname_0',
+                    'state': 'disabled',
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_get_nodes_migrate_failed_return_null(self):
@@ -195,29 +240,35 @@ class TestNodeResourceConsolidation(TestBaseStrategy):
         result = self.strategy.get_nodes_migrate_failed()
         self.assertEqual([], result)
         self.strategy.audit = mock.Mock(
-            audit_type=objects.audit.AuditType.ONESHOT.value)
+            audit_type=objects.audit.AuditType.ONESHOT.value
+        )
         result = self.strategy.get_nodes_migrate_failed()
         self.assertEqual([], result)
 
     @mock.patch.object(objects.action.Action, 'list')
     def test_get_nodes_migrate_failed(self, mock_list):
         self.strategy.audit = mock.Mock(
-            audit_type=objects.audit.AuditType.CONTINUOUS.value)
+            audit_type=objects.audit.AuditType.CONTINUOUS.value
+        )
         fake_action = obj_utils.get_test_action(
             self.context,
             state=objects.action.State.FAILED,
             action_type='migrate',
             input_parameters={
-                'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f1'})
+                'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f1'
+            },
+        )
         mock_list.return_value = [fake_action]
         result = self.strategy.get_nodes_migrate_failed()
         expected = self.model.get_node_by_uuid(
-            '89dce55c-8e74-4402-b23f-32aaf216c97f')
+            '89dce55c-8e74-4402-b23f-32aaf216c97f'
+        )
         self.assertEqual([expected], result)
 
     def test_group_nodes_with_ONESHOT(self):
         self.strategy.audit = mock.Mock(
-            audit_type=objects.audit.AuditType.ONESHOT.value)
+            audit_type=objects.audit.AuditType.ONESHOT.value
+        )
         nodes = list(self.model.get_all_compute_nodes().values())
         result = self.strategy.group_nodes(nodes)
         node0 = self.model.get_node_by_name('hostname_0')
@@ -238,13 +289,16 @@ class TestNodeResourceConsolidation(TestBaseStrategy):
     @mock.patch.object(objects.action.Action, 'list')
     def test_group_nodes_with_CONTINUOUS(self, mock_list):
         self.strategy.audit = mock.Mock(
-            audit_type=objects.audit.AuditType.CONTINUOUS.value)
+            audit_type=objects.audit.AuditType.CONTINUOUS.value
+        )
         fake_action = obj_utils.get_test_action(
             self.context,
             state=objects.action.State.FAILED,
             action_type='migrate',
             input_parameters={
-                'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f6'})
+                'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f6'
+            },
+        )
         mock_list.return_value = [fake_action]
         nodes = list(self.model.get_all_compute_nodes().values())
         result = self.strategy.group_nodes(nodes)
@@ -270,76 +324,109 @@ class TestNodeResourceConsolidation(TestBaseStrategy):
             state=objects.action.State.FAILED,
             action_type='migrate',
             input_parameters={
-                'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f6'})
+                'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f6'
+            },
+        )
         mock_list.return_value = [fake_action]
         mock_audit = mock.Mock(
-            audit_type=objects.audit.AuditType.CONTINUOUS.value)
+            audit_type=objects.audit.AuditType.CONTINUOUS.value
+        )
         self.strategy.host_choice = 'auto'
         self.strategy.do_execute(mock_audit)
         expected = [
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'disabled_reason': 'Watcher node resource consolidation '
-                                    'strategy',
-                 'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c975',
-                 'resource_name': 'hostname_5',
-                 'state': 'disabled'}},
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'disabled_reason': 'Watcher node resource consolidation '
-                                    'strategy',
-                 'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c974',
-                 'resource_name': 'hostname_4',
-                 'state': 'disabled'}},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'migration_type': 'live',
-                 'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f7',
-                 'resource_name': 'INSTANCE_7',
-                 'source_node': 'hostname_4'}},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'migration_type': 'live',
-                 'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f8',
-                 'resource_name': 'INSTANCE_8',
-                 'source_node': 'hostname_7'}},
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c975',
-                 'resource_name': 'hostname_5',
-                 'state': 'enabled'}},
-            {'action_type': 'change_nova_service_state',
-             'input_parameters': {
-                 'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c974',
-                 'resource_name': 'hostname_4',
-                 'state': 'enabled'}}]
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'disabled_reason': 'Watcher node resource consolidation '
+                    'strategy',
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c975',
+                    'resource_name': 'hostname_5',
+                    'state': 'disabled',
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'disabled_reason': 'Watcher node resource consolidation '
+                    'strategy',
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c974',
+                    'resource_name': 'hostname_4',
+                    'state': 'disabled',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f7',
+                    'resource_name': 'INSTANCE_7',
+                    'source_node': 'hostname_4',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f8',
+                    'resource_name': 'INSTANCE_8',
+                    'source_node': 'hostname_7',
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c975',
+                    'resource_name': 'hostname_5',
+                    'state': 'enabled',
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'resource_id': '89dce55c-8e74-4402-b23f-32aaf216c974',
+                    'resource_name': 'hostname_4',
+                    'state': 'enabled',
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_execute_with_specify(self):
         mock_audit = mock.Mock(
-            audit_type=objects.audit.AuditType.ONESHOT.value)
+            audit_type=objects.audit.AuditType.ONESHOT.value
+        )
         self.strategy.host_choice = 'specify'
         self.strategy.do_execute(mock_audit)
         expected = [
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'destination_node': 'hostname_2',
-                 'migration_type': 'live',
-                 'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f6',
-                 'resource_name': 'INSTANCE_6',
-                 'source_node': 'hostname_3'}},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'destination_node': 'hostname_0',
-                 'migration_type': 'live',
-                 'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f7',
-                 'resource_name': 'INSTANCE_7',
-                 'source_node': 'hostname_4'}},
-            {'action_type': 'migrate',
-             'input_parameters': {
-                 'destination_node': 'hostname_1',
-                 'migration_type': 'live',
-                 'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f8',
-                 'resource_name': 'INSTANCE_8',
-                 'source_node': 'hostname_7'}}]
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': 'hostname_2',
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f6',
+                    'resource_name': 'INSTANCE_6',
+                    'source_node': 'hostname_3',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': 'hostname_0',
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f7',
+                    'resource_name': 'INSTANCE_7',
+                    'source_node': 'hostname_4',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': 'hostname_1',
+                    'migration_type': 'live',
+                    'resource_id': '6ae05517-a512-462d-9d83-90c313b5a8f8',
+                    'resource_name': 'INSTANCE_8',
+                    'source_node': 'hostname_7',
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_noisy_neighbor.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_noisy_neighbor.py
index 42b32452f..7f39bd741 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_noisy_neighbor.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_noisy_neighbor.py
@@ -29,11 +29,14 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestNoisyNeighbor(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics,
+            },
+        )
     ]
 
     def setUp(self):
@@ -42,13 +45,16 @@ class TestNoisyNeighbor(TestBaseStrategy):
         self.f_metrics = self.fake_datasource_cls()
 
         p_datasource = mock.patch.object(
-            strategies.NoisyNeighbor, "datasource_backend",
-            new_callable=mock.PropertyMock)
+            strategies.NoisyNeighbor,
+            "datasource_backend",
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         self.m_datasource.return_value = mock.Mock(
-            get_instance_l3_cache_usage=self.f_metrics.mock_get_statistics_nn)
+            get_instance_l3_cache_usage=self.f_metrics.mock_get_statistics_nn
+        )
         self.strategy = strategies.NoisyNeighbor(config=mock.Mock())
 
         self.strategy.input_parameters = utils.Struct()
@@ -93,11 +99,9 @@ class TestNoisyNeighbor(TestBaseStrategy):
         self.strategy.cache_threshold = 35
         self.strategy.period = 100
         n1, n2 = self.strategy.group_hosts()
-        mig_source_node = max(n1.keys(), key=lambda a:
-                              n1[a]['priority_vm'])
+        mig_source_node = max(n1.keys(), key=lambda a: n1[a]['priority_vm'])
         instance_to_mig = n1[mig_source_node]['noisy_vm']
-        dest_hosts = self.strategy.filter_dest_servers(
-            n2, instance_to_mig)
+        dest_hosts = self.strategy.filter_dest_servers(n2, instance_to_mig)
 
         self.assertEqual(1, len(dest_hosts))
         self.assertEqual('Node_0', dest_hosts[0].uuid)
@@ -105,8 +109,9 @@ class TestNoisyNeighbor(TestBaseStrategy):
     def test_execute_no_workload(self):
         self.strategy.cache_threshold = 35
         self.strategy.period = 100
-        model = self.fake_c_cluster.\
-            generate_scenario_4_with_1_node_no_instance()
+        model = (
+            self.fake_c_cluster.generate_scenario_4_with_1_node_no_instance()
+        )
         self.m_c_model.return_value = model
 
         solution = self.strategy.execute()
@@ -119,7 +124,8 @@ class TestNoisyNeighbor(TestBaseStrategy):
         self.m_c_model.return_value = model
         solution = self.strategy.execute()
         actions_counter = collections.Counter(
-            [action.get('action_type') for action in solution.actions])
+            [action.get('action_type') for action in solution.actions]
+        )
 
         num_migrations = actions_counter.get("migrate", 0)
         self.assertEqual(1, num_migrations)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_outlet_temp_control.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_outlet_temp_control.py
index 85c2b137a..403a6091b 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_outlet_temp_control.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_outlet_temp_control.py
@@ -29,11 +29,14 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestOutletTempControl(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics,
+            },
+        )
     ]
 
     def setUp(self):
@@ -42,16 +45,20 @@ class TestOutletTempControl(TestBaseStrategy):
         self.fake_metrics = self.fake_datasource_cls()
 
         p_datasource = mock.patch.object(
-            strategies.OutletTempControl, 'datasource_backend',
-            new_callable=mock.PropertyMock)
+            strategies.OutletTempControl,
+            'datasource_backend',
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         self.m_datasource.return_value = mock.Mock(
             statistic_aggregation=self.fake_metrics.mock_get_statistics,
-            NAME=self.fake_metrics.NAME)
+            NAME=self.fake_metrics.NAME,
+        )
         self.strategy = strategies.OutletTempControl(
-            config=mock.Mock(datasource=self.datasource))
+            config=mock.Mock(datasource=self.datasource)
+        )
 
         self.strategy.input_parameters = utils.Struct()
         self.strategy.input_parameters.update({'threshold': 34.3})
@@ -61,20 +68,24 @@ class TestOutletTempControl(TestBaseStrategy):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
         self.m_c_model.return_value = model
         n1, n2 = self.strategy.group_hosts_by_outlet_temp()
-        self.assertEqual("af69c544-906b-4a6a-a9c6-c1f7a8078c73",
-                         n1[0]['compute_node'].uuid)
-        self.assertEqual("fa69c544-906b-4a6a-a9c6-c1f7a8078c73",
-                         n2[0]['compute_node'].uuid)
+        self.assertEqual(
+            "af69c544-906b-4a6a-a9c6-c1f7a8078c73", n1[0]['compute_node'].uuid
+        )
+        self.assertEqual(
+            "fa69c544-906b-4a6a-a9c6-c1f7a8078c73", n2[0]['compute_node'].uuid
+        )
 
     def test_choose_instance_to_migrate(self):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
         self.m_c_model.return_value = model
         n1, n2 = self.strategy.group_hosts_by_outlet_temp()
         instance_to_mig = self.strategy.choose_instance_to_migrate(n1)
-        self.assertEqual('af69c544-906b-4a6a-a9c6-c1f7a8078c73',
-                         instance_to_mig[0].uuid)
-        self.assertEqual('a4cab39b-9828-413a-bf88-f76921bf1517',
-                         instance_to_mig[1].uuid)
+        self.assertEqual(
+            'af69c544-906b-4a6a-a9c6-c1f7a8078c73', instance_to_mig[0].uuid
+        )
+        self.assertEqual(
+            'a4cab39b-9828-413a-bf88-f76921bf1517', instance_to_mig[1].uuid
+        )
 
     def test_filter_dest_servers(self):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
@@ -83,12 +94,15 @@ class TestOutletTempControl(TestBaseStrategy):
         instance_to_mig = self.strategy.choose_instance_to_migrate(n1)
         dest_hosts = self.strategy.filter_dest_servers(n2, instance_to_mig[1])
         self.assertEqual(1, len(dest_hosts))
-        self.assertEqual("fa69c544-906b-4a6a-a9c6-c1f7a8078c73",
-                         dest_hosts[0]['compute_node'].uuid)
+        self.assertEqual(
+            "fa69c544-906b-4a6a-a9c6-c1f7a8078c73",
+            dest_hosts[0]['compute_node'].uuid,
+        )
 
     def test_execute_no_workload(self):
-        model = self.fake_c_cluster.\
-            generate_scenario_4_with_1_node_no_instance()
+        model = (
+            self.fake_c_cluster.generate_scenario_4_with_1_node_no_instance()
+        )
         self.m_c_model.return_value = model
 
         solution = self.strategy.execute()
@@ -99,7 +113,8 @@ class TestOutletTempControl(TestBaseStrategy):
         self.m_c_model.return_value = model
         solution = self.strategy.execute()
         actions_counter = collections.Counter(
-            [action.get('action_type') for action in solution.actions])
+            [action.get('action_type') for action in solution.actions]
+        )
 
         num_migrations = actions_counter.get("migrate", 0)
         self.assertEqual(1, num_migrations)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_saving_energy.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_saving_energy.py
index 44cce7057..d53dab767 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_saving_energy.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_saving_energy.py
@@ -26,23 +26,23 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestSavingEnergy(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
 
-        self.fake_nodes = [fake_metal_helper.get_mock_metal_node(),
-                           fake_metal_helper.get_mock_metal_node()]
+        self.fake_nodes = [
+            fake_metal_helper.get_mock_metal_node(),
+            fake_metal_helper.get_mock_metal_node(),
+        ]
         self._metal_helper = mock.Mock()
         self._metal_helper.list_compute_nodes.return_value = self.fake_nodes
 
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
 
-        self.strategy = strategies.SavingEnergy(
-            config=mock.Mock())
+        self.strategy = strategies.SavingEnergy(config=mock.Mock())
         self.strategy.input_parameters = utils.Struct()
         self.strategy.input_parameters.update(
-            {'free_used_percent': 10.0,
-             'min_free_hosts_num': 1})
+            {'free_used_percent': 10.0, 'min_free_hosts_num': 1}
+        )
         self.strategy.free_used_percent = 10.0
         self.strategy.min_free_hosts_num = 1
         self.strategy._metal_helper = self._metal_helper
@@ -52,11 +52,13 @@ class TestSavingEnergy(TestBaseStrategy):
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.ON,
                 hostname='hostname_0',
-                running_vms=2),
+                running_vms=2,
+            ),
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.OFF,
                 hostname='hostname_1',
-                running_vms=2),
+                running_vms=2,
+            ),
         ]
 
         self.strategy.get_hosts_pool()
@@ -70,11 +72,13 @@ class TestSavingEnergy(TestBaseStrategy):
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.ON,
                 hostname='hostname_0',
-                running_vms=0),
+                running_vms=0,
+            ),
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.ON,
                 hostname='hostname_1',
-                running_vms=0),
+                running_vms=0,
+            ),
         ]
 
         self.strategy.get_hosts_pool()
@@ -88,11 +92,13 @@ class TestSavingEnergy(TestBaseStrategy):
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.OFF,
                 hostname='hostname_0',
-                running_vms=0),
+                running_vms=0,
+            ),
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.OFF,
                 hostname='hostname_1',
-                running_vms=0),
+                running_vms=0,
+            ),
         ]
 
         self.strategy.get_hosts_pool()
@@ -106,11 +112,13 @@ class TestSavingEnergy(TestBaseStrategy):
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.OFF,
                 hostname='hostname_0',
-                running_vms=0),
+                running_vms=0,
+            ),
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.OFF,
                 hostname='hostname_10',
-                running_vms=0),
+                running_vms=0,
+            ),
         ]
         self.strategy.get_hosts_pool()
 
@@ -131,8 +139,8 @@ class TestSavingEnergy(TestBaseStrategy):
     def test_save_energy_poweroff(self):
         self.strategy.free_poweron_node_pool = [
             mock.Mock(uuid='922d4762-0bc5-4b30-9cb9-48ab644dd861'),
-            mock.Mock(uuid='922d4762-0bc5-4b30-9cb9-48ab644dd862')
-            ]
+            mock.Mock(uuid='922d4762-0bc5-4b30-9cb9-48ab644dd862'),
+        ]
         self.strategy.save_energy()
         self.assertEqual(len(self.strategy.solution.actions), 1)
         action = self.strategy.solution.actions[0]
@@ -143,11 +151,13 @@ class TestSavingEnergy(TestBaseStrategy):
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.ON,
                 hostname='hostname_0',
-                running_vms=0),
+                running_vms=0,
+            ),
             fake_metal_helper.get_mock_metal_node(
                 power_state=m_constants.PowerState.ON,
                 hostname='hostname_1',
-                running_vms=0),
+                running_vms=0,
+            ),
         ]
 
         model = self.fake_c_cluster.generate_scenario_1()
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_storage_capacity_balance.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_storage_capacity_balance.py
index 031f070f8..a37e4cf21 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_storage_capacity_balance.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_storage_capacity_balance.py
@@ -29,7 +29,6 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestStorageCapacityBalance(TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
 
@@ -45,20 +44,28 @@ class TestStorageCapacityBalance(TestBaseStrategy):
 
             return fake_pool
 
-        self.fake_pool1 = test_fake_pool('host1@IPSAN-1#pool1',
-                                         '60', '100', '90')
+        self.fake_pool1 = test_fake_pool(
+            'host1@IPSAN-1#pool1', '60', '100', '90'
+        )
 
-        self.fake_pool2 = test_fake_pool('host1@IPSAN-1#pool2',
-                                         '20', '100', '80')
+        self.fake_pool2 = test_fake_pool(
+            'host1@IPSAN-1#pool2', '20', '100', '80'
+        )
 
-        self.fake_pool3 = test_fake_pool('host1@IPSAN-1#local_vstorage',
-                                         '20', '100', '80')
-        self.fake_pools = [self.fake_pool1, self.fake_pool2,
-                           self.fake_pool3]
+        self.fake_pool3 = test_fake_pool(
+            'host1@IPSAN-1#local_vstorage', '20', '100', '80'
+        )
+        self.fake_pools = [self.fake_pool1, self.fake_pool2, self.fake_pool3]
 
-        def test_fake_vol(id, name, size, status, bootable,
-                          migration_status=None,
-                          volume_type=None):
+        def test_fake_vol(
+            id,
+            name,
+            size,
+            status,
+            bootable,
+            migration_status=None,
+            volume_type=None,
+        ):
             fake_vol = mock.MagicMock()
             fake_vol.id = id
             fake_vol.name = name
@@ -71,28 +78,52 @@ class TestStorageCapacityBalance(TestBaseStrategy):
 
             return fake_vol
 
-        self.fake_vol1 = test_fake_vol('922d4762-0bc5-4b30-9cb9-48ab644dd861',
-                                       'test_volume1', 4,
-                                       'available', 'true', 'success',
-                                       volume_type='type2')
-        self.fake_vol2 = test_fake_vol('922d4762-0bc5-4b30-9cb9-48ab644dd862',
-                                       'test_volume2', 10,
-                                       'in-use', 'false')
-        self.fake_vol3 = test_fake_vol('922d4762-0bc5-4b30-9cb9-48ab644dd863',
-                                       'test_volume3', 4,
-                                       'in-use', 'true', volume_type='type2')
-        self.fake_vol4 = test_fake_vol('922d4762-0bc5-4b30-9cb9-48ab644dd864',
-                                       'test_volume4', 10,
-                                       'error', 'true')
-        self.fake_vol5 = test_fake_vol('922d4762-0bc5-4b30-9cb9-48ab644dd865',
-                                       'test_volume5', 15,
-                                       'in-use', 'true')
+        self.fake_vol1 = test_fake_vol(
+            '922d4762-0bc5-4b30-9cb9-48ab644dd861',
+            'test_volume1',
+            4,
+            'available',
+            'true',
+            'success',
+            volume_type='type2',
+        )
+        self.fake_vol2 = test_fake_vol(
+            '922d4762-0bc5-4b30-9cb9-48ab644dd862',
+            'test_volume2',
+            10,
+            'in-use',
+            'false',
+        )
+        self.fake_vol3 = test_fake_vol(
+            '922d4762-0bc5-4b30-9cb9-48ab644dd863',
+            'test_volume3',
+            4,
+            'in-use',
+            'true',
+            volume_type='type2',
+        )
+        self.fake_vol4 = test_fake_vol(
+            '922d4762-0bc5-4b30-9cb9-48ab644dd864',
+            'test_volume4',
+            10,
+            'error',
+            'true',
+        )
+        self.fake_vol5 = test_fake_vol(
+            '922d4762-0bc5-4b30-9cb9-48ab644dd865',
+            'test_volume5',
+            15,
+            'in-use',
+            'true',
+        )
 
-        self.fake_volumes = [self.fake_vol1,
-                             self.fake_vol2,
-                             self.fake_vol3,
-                             self.fake_vol4,
-                             self.fake_vol5]
+        self.fake_volumes = [
+            self.fake_vol1,
+            self.fake_vol2,
+            self.fake_vol3,
+            self.fake_vol4,
+            self.fake_vol5,
+        ]
 
         def test_fake_snap(vol_id):
             fake_snap = mock.MagicMock()
@@ -100,8 +131,9 @@ class TestStorageCapacityBalance(TestBaseStrategy):
 
             return fake_snap
 
-        self.fake_snap = [test_fake_snap(
-            '922d4762-0bc5-4b30-9cb9-48ab644dd865')]
+        self.fake_snap = [
+            test_fake_snap('922d4762-0bc5-4b30-9cb9-48ab644dd865')
+        ]
 
         def test_fake_volume_type(type_name, extra_specs):
             fake_type = mock.MagicMock()
@@ -110,11 +142,10 @@ class TestStorageCapacityBalance(TestBaseStrategy):
 
             return fake_type
 
-        self.fake_types = [test_fake_volume_type(
-            'type1', {'volume_backend_name': 'pool1'}),
-            test_fake_volume_type(
-            'type2', {'volume_backend_name': 'pool2'})
-            ]
+        self.fake_types = [
+            test_fake_volume_type('type1', {'volume_backend_name': 'pool1'}),
+            test_fake_volume_type('type2', {'volume_backend_name': 'pool2'}),
+        ]
 
         self.fake_c_cluster = faker_cluster_state.FakerStorageModelCollector()
 
@@ -126,23 +157,27 @@ class TestStorageCapacityBalance(TestBaseStrategy):
         self.m_cinder = cinder_helper.CinderHelper(osc=osc)
 
         self.m_cinder.get_storage_pool_list = mock.Mock(
-            return_value=self.fake_pools)
+            return_value=self.fake_pools
+        )
         self.m_cinder.get_volume_list = mock.Mock(
-            return_value=self.fake_volumes)
+            return_value=self.fake_volumes
+        )
         self.m_cinder.get_volume_snapshots_list = mock.Mock(
-            return_value=self.fake_snap)
+            return_value=self.fake_snap
+        )
         self.m_cinder.get_volume_type_list = mock.Mock(
-            return_value=self.fake_types)
+            return_value=self.fake_types
+        )
 
         model = self.fake_c_cluster.generate_scenario_1()
         self.m_c_model.return_value = model
 
         self.strategy = strategies.StorageCapacityBalance(
-            config=mock.Mock(), osc=osc)
+            config=mock.Mock(), osc=osc
+        )
         self.strategy._cinder = self.m_cinder
         self.strategy.input_parameters = utils.Struct()
-        self.strategy.input_parameters.update(
-            {'volume_threshold': 80.0})
+        self.strategy.input_parameters.update({'volume_threshold': 80.0})
         self.strategy.volume_threshold = 80.0
 
     def test_get_pools(self):
@@ -171,27 +206,32 @@ class TestStorageCapacityBalance(TestBaseStrategy):
 
     def test_get_volume_type_by_name(self):
         vol_type = self.strategy.get_volume_type_by_name(
-            self.m_cinder, 'pool1')
+            self.m_cinder, 'pool1'
+        )
         self.assertEqual(len(vol_type), 1)
 
         vol_type = self.strategy.get_volume_type_by_name(
-            self.m_cinder, 'ks3200')
+            self.m_cinder, 'ks3200'
+        )
         self.assertEqual(len(vol_type), 0)
 
     def test_check_pool_type(self):
         pool_type = self.strategy.check_pool_type(
-            self.fake_vol3, self.fake_pool1)
+            self.fake_vol3, self.fake_pool1
+        )
         self.assertIsNotNone(pool_type)
 
         pool_type = self.strategy.check_pool_type(
-            self.fake_vol3, self.fake_pool2)
+            self.fake_vol3, self.fake_pool2
+        )
         self.assertIsNone(pool_type)
 
     def test_migrate_fit(self):
         self.strategy.config.ex_pools = "local_vstorage"
         pools = self.strategy.get_pools(self.m_cinder)
         self.strategy.source_pools, self.strategy.dest_pools = (
-            self.strategy.group_pools(pools, 0.60))
+            self.strategy.group_pools(pools, 0.60)
+        )
         target_pool = self.strategy.migrate_fit(self.fake_vol2, 0.60)
         self.assertIsNotNone(target_pool)
 
@@ -205,7 +245,8 @@ class TestStorageCapacityBalance(TestBaseStrategy):
         self.strategy.config.ex_pools = "local_vstorage"
         pools = self.strategy.get_pools(self.m_cinder)
         self.strategy.source_pools, self.strategy.dest_pools = (
-            self.strategy.group_pools(pools, 0.50))
+            self.strategy.group_pools(pools, 0.50)
+        )
         target_pool = self.strategy.retype_fit(self.fake_vol1, 0.50)
         self.assertIsNotNone(target_pool)
 
@@ -219,21 +260,18 @@ class TestStorageCapacityBalance(TestBaseStrategy):
         self.assertIsNone(target_pool)
 
     def test_execute(self):
-        self.strategy.input_parameters.update(
-            {'volume_threshold': 45.0})
+        self.strategy.input_parameters.update({'volume_threshold': 45.0})
         self.strategy.config.ex_pools = "local_vstorage"
         solution = self.strategy.execute()
         self.assertEqual(len(solution.actions), 1)
 
         setattr(self.fake_pool1, 'free_capacity_gb', '60')
-        self.strategy.input_parameters.update(
-            {'volume_threshold': 50.0})
+        self.strategy.input_parameters.update({'volume_threshold': 50.0})
         solution = self.strategy.execute()
         self.assertEqual(len(solution.actions), 2)
 
         setattr(self.fake_pool1, 'free_capacity_gb', '60')
-        self.strategy.input_parameters.update(
-            {'volume_threshold': 60.0})
+        self.strategy.input_parameters.update({'volume_threshold': 60.0})
 
         solution = self.strategy.execute()
         self.assertEqual(len(solution.actions), 3)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_strategy_endpoint.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_strategy_endpoint.py
index 792205671..4012a4379 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_strategy_endpoint.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_strategy_endpoint.py
@@ -20,22 +20,29 @@ from watcher.tests.unit import base
 
 
 class TestStrategyEndpoint(base.BaseTestCase):
-
     def test_collect_metrics(self):
         datasource = mock.MagicMock()
         datasource.list_metrics.return_value = ["m1", "m2"]
-        datasource.METRIC_MAP = {"metric1": "m1", "metric2": "m2",
-                                 "metric3": "m3"}
+        datasource.METRIC_MAP = {
+            "metric1": "m1",
+            "metric2": "m2",
+            "metric3": "m3",
+        }
         strategy = mock.MagicMock()
         strategy.DATASOURCE_METRICS = ["metric1", "metric2", "metric3"]
         strategy.config.datasource = "gnocchi"
         se = strategy_base.StrategyEndpoint(mock.MagicMock())
         result = se._collect_metrics(strategy, datasource)
-        expected_result = {'type': 'Metrics',
-                           'state': [{"m1": "available"},
-                                     {"m2": "available"},
-                                     {"m3": "not available"}],
-                           'mandatory': False, 'comment': ''}
+        expected_result = {
+            'type': 'Metrics',
+            'state': [
+                {"m1": "available"},
+                {"m2": "available"},
+                {"m3": "not available"},
+            ],
+            'mandatory': False,
+            'comment': '',
+        }
         self.assertEqual(expected_result, result)
 
     def test_get_datasource_status(self):
@@ -45,9 +52,12 @@ class TestStrategyEndpoint(base.BaseTestCase):
         datasource.check_availability.return_value = "available"
         se = strategy_base.StrategyEndpoint(mock.MagicMock())
         result = se._get_datasource_status(strategy, datasource)
-        expected_result = {'type': 'Datasource',
-                           'state': "gnocchi: available",
-                           'mandatory': True, 'comment': ''}
+        expected_result = {
+            'type': 'Datasource',
+            'state': "gnocchi: available",
+            'mandatory': True,
+            'comment': '',
+        }
         self.assertEqual(expected_result, result)
 
     def test_get_cdm(self):
@@ -57,9 +67,14 @@ class TestStrategyEndpoint(base.BaseTestCase):
         strategy.baremetal_model = mock.MagicMock()
         se = strategy_base.StrategyEndpoint(mock.MagicMock())
         result = se._get_cdm(strategy)
-        expected_result = {'type': 'CDM',
-                           'state': [{"compute_model": "available"},
-                                     {"storage_model": "not available"},
-                                     {"baremetal_model": "available"}],
-                           'mandatory': True, 'comment': ''}
+        expected_result = {
+            'type': 'CDM',
+            'state': [
+                {"compute_model": "available"},
+                {"storage_model": "not available"},
+                {"baremetal_model": "available"},
+            ],
+            'mandatory': True,
+            'comment': '',
+        }
         self.assertEqual(expected_result, result)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_uniform_airflow.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_uniform_airflow.py
index 41a8a5f12..fdc642bcb 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_uniform_airflow.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_uniform_airflow.py
@@ -29,11 +29,14 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestUniformAirflow(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics,
+            },
+        )
     ]
 
     def setUp(self):
@@ -42,21 +45,29 @@ class TestUniformAirflow(TestBaseStrategy):
         self.fake_metrics = self.fake_datasource_cls()
 
         p_datasource = mock.patch.object(
-            strategies.UniformAirflow, 'datasource_backend',
-            new_callable=mock.PropertyMock)
+            strategies.UniformAirflow,
+            'datasource_backend',
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         self.m_datasource.return_value = mock.Mock(
             statistic_aggregation=self.fake_metrics.mock_get_statistics,
-            NAME=self.fake_metrics.NAME)
+            NAME=self.fake_metrics.NAME,
+        )
         self.strategy = strategies.UniformAirflow(
-            config=mock.Mock(datasource=self.datasource))
+            config=mock.Mock(datasource=self.datasource)
+        )
         self.strategy.input_parameters = utils.Struct()
-        self.strategy.input_parameters.update({'threshold_airflow': 400.0,
-                                               'threshold_inlet_t': 28.0,
-                                               'threshold_power': 350.0,
-                                               'period': 300})
+        self.strategy.input_parameters.update(
+            {
+                'threshold_airflow': 400.0,
+                'threshold_inlet_t': 28.0,
+                'threshold_power': 350.0,
+                'period': 300,
+            }
+        )
         self.strategy.threshold_airflow = 400
         self.strategy.threshold_inlet_t = 28
         self.strategy.threshold_power = 350
@@ -68,7 +79,8 @@ class TestUniformAirflow(TestBaseStrategy):
         self.m_c_model.return_value = model
         node = model.get_node_by_uuid('Node_0')
         cores_used, mem_used, disk_used = (
-            self.strategy.calculate_used_resource(node))
+            self.strategy.calculate_used_resource(node)
+        )
         self.assertEqual((cores_used, mem_used, disk_used), (25, 4, 40))
 
     def test_group_hosts_by_airflow(self):
@@ -90,9 +102,13 @@ class TestUniformAirflow(TestBaseStrategy):
 
         self.assertEqual(instance_to_mig[0].uuid, 'Node_0')
         self.assertEqual(len(instance_to_mig[1]), 1)
-        self.assertIn(instance_to_mig[1][0].uuid,
-                      {'cae81432-1631-4d4e-b29c-6f3acdcde906',
-                       '73b09e16-35b7-4922-804e-e8f5d9b740fc'})
+        self.assertIn(
+            instance_to_mig[1][0].uuid,
+            {
+                'cae81432-1631-4d4e-b29c-6f3acdcde906',
+                '73b09e16-35b7-4922-804e-e8f5d9b740fc',
+            },
+        )
 
     def test_choose_instance_to_migrate_all(self):
         model = self.fake_c_cluster.generate_scenario_7_with_2_nodes()
@@ -104,9 +120,13 @@ class TestUniformAirflow(TestBaseStrategy):
 
         self.assertEqual(instance_to_mig[0].uuid, 'Node_0')
         self.assertEqual(len(instance_to_mig[1]), 2)
-        self.assertEqual({'cae81432-1631-4d4e-b29c-6f3acdcde906',
-                          '73b09e16-35b7-4922-804e-e8f5d9b740fc'},
-                         {inst.uuid for inst in instance_to_mig[1]})
+        self.assertEqual(
+            {
+                'cae81432-1631-4d4e-b29c-6f3acdcde906',
+                '73b09e16-35b7-4922-804e-e8f5d9b740fc',
+            },
+            {inst.uuid for inst in instance_to_mig[1]},
+        )
 
     def test_choose_instance_notfound(self):
         model = self.fake_c_cluster.generate_scenario_7_with_2_nodes()
@@ -127,20 +147,26 @@ class TestUniformAirflow(TestBaseStrategy):
         n1, n2 = self.strategy.group_hosts_by_airflow()
         instance_to_mig = self.strategy.choose_instance_to_migrate(n1)
         dest_hosts = self.strategy.filter_destination_hosts(
-            n2, instance_to_mig[1])
+            n2, instance_to_mig[1]
+        )
 
         self.assertEqual(len(dest_hosts), 1)
         self.assertEqual(dest_hosts[0]['node'].uuid, 'Node_1')
-        self.assertIn(instance_to_mig[1][0].uuid,
-                      {'cae81432-1631-4d4e-b29c-6f3acdcde906',
-                       '73b09e16-35b7-4922-804e-e8f5d9b740fc'})
+        self.assertIn(
+            instance_to_mig[1][0].uuid,
+            {
+                'cae81432-1631-4d4e-b29c-6f3acdcde906',
+                '73b09e16-35b7-4922-804e-e8f5d9b740fc',
+            },
+        )
 
     def test_execute_no_workload(self):
         self.strategy.threshold_airflow = 300
         self.strategy.threshold_inlet_t = 25
         self.strategy.threshold_power = 300
-        model = self.fake_c_cluster.\
-            generate_scenario_4_with_1_node_no_instance()
+        model = (
+            self.fake_c_cluster.generate_scenario_4_with_1_node_no_instance()
+        )
         self.m_c_model.return_value = model
         solution = self.strategy.execute()
         self.assertEqual([], solution.actions)
@@ -153,7 +179,8 @@ class TestUniformAirflow(TestBaseStrategy):
         self.m_c_model.return_value = model
         solution = self.strategy.execute()
         actions_counter = collections.Counter(
-            [action.get('action_type') for action in solution.actions])
+            [action.get('action_type') for action in solution.actions]
+        )
 
         num_migrations = actions_counter.get("migrate", 0)
         self.assertEqual(num_migrations, 2)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_vm_workload_consolidation.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_vm_workload_consolidation.py
index 7aad52883..9653eb419 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_vm_workload_consolidation.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_vm_workload_consolidation.py
@@ -29,12 +29,16 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestVMWorkloadConsolidation(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls":
-          faker_cluster_and_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": (
+                    faker_cluster_and_metrics.FakeGnocchiMetrics
+                ),
+            },
+        )
     ]
 
     def setUp(self):
@@ -44,29 +48,30 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         self.fake_c_cluster = faker_cluster_and_metrics.FakerModelCollector()
 
         p_datasource = mock.patch.object(
-            strategies.VMWorkloadConsolidation, 'datasource_backend',
-            new_callable=mock.PropertyMock)
+            strategies.VMWorkloadConsolidation,
+            'datasource_backend',
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         # fake metrics
         self.fake_metrics = self.fake_datasource_cls(
-            self.m_c_model.return_value)
+            self.m_c_model.return_value
+        )
 
         self.m_datasource.return_value = mock.Mock(
-            get_instance_cpu_usage=(
-                self.fake_metrics.get_instance_cpu_util),
-            get_instance_ram_usage=(
-                self.fake_metrics.get_instance_ram_util),
+            get_instance_cpu_usage=(self.fake_metrics.get_instance_cpu_util),
+            get_instance_ram_usage=(self.fake_metrics.get_instance_ram_util),
             get_instance_root_disk_size=(
-                self.fake_metrics.get_instance_disk_root_size),
-            get_host_cpu_usage=(
-                self.fake_metrics.get_compute_node_cpu_util),
-            get_host_ram_usage=(
-                self.fake_metrics.get_compute_node_ram_util)
-            )
+                self.fake_metrics.get_instance_disk_root_size
+            ),
+            get_host_cpu_usage=(self.fake_metrics.get_compute_node_cpu_util),
+            get_host_ram_usage=(self.fake_metrics.get_compute_node_ram_util),
+        )
         self.strategy = strategies.VMWorkloadConsolidation(
-            config=mock.Mock(datasources=self.datasource))
+            config=mock.Mock(datasources=self.datasource)
+        )
 
     def test_get_instance_utilization(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -75,8 +80,8 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         instance_0 = model.get_instance_by_uuid("INSTANCE_0")
         instance_util = dict(cpu=1.0, ram=1, disk=10)
         self.assertEqual(
-            instance_util,
-            self.strategy.get_instance_utilization(instance_0))
+            instance_util, self.strategy.get_instance_utilization(instance_0)
+        )
 
     def test_get_node_utilization(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -84,9 +89,7 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         self.fake_metrics.model = model
         node_0 = model.get_node_by_uuid("Node_0")
         node_util = dict(cpu=1.0, ram=1, disk=10)
-        self.assertEqual(
-            node_util,
-            self.strategy.get_node_utilization(node_0))
+        self.assertEqual(node_util, self.strategy.get_node_utilization(node_0))
 
     def test_get_node_utilization_using_host_metrics(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -104,8 +107,8 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         exp_cpu_usage = cpu_usage * node_0.vcpus / 100
         exp_node_util = dict(cpu=exp_cpu_usage, ram=512, disk=10)
         self.assertEqual(
-            exp_node_util,
-            self.strategy.get_node_utilization(node_0))
+            exp_node_util, self.strategy.get_node_utilization(node_0)
+        )
 
     def test_get_node_utilization_after_migrations(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -119,7 +122,8 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         host_ram_usage_mb = 512
         data_src.get_host_cpu_usage = mock.Mock(return_value=cpu_usage)
         data_src.get_host_ram_usage = mock.Mock(
-            return_value=host_ram_usage_mb * 1024)
+            return_value=host_ram_usage_mb * 1024
+        )
 
         instance_uuid = 'INSTANCE_0'
         instance = model.get_instance_by_uuid(instance_uuid)
@@ -130,28 +134,28 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         # Ensure that we take into account planned migrations when
         # determining node utilization
         exp_node_0_cpu_usage = (
-            cpu_usage * node_0.vcpus) / 100 - instance_util['cpu']
+            cpu_usage * node_0.vcpus
+        ) / 100 - instance_util['cpu']
         exp_node_1_cpu_usage = (
-            cpu_usage * node_1.vcpus) / 100 + instance_util['cpu']
+            cpu_usage * node_1.vcpus
+        ) / 100 + instance_util['cpu']
 
         exp_node_0_ram_usage = host_ram_usage_mb - instance.memory
         exp_node_1_ram_usage = host_ram_usage_mb + instance.memory
 
         exp_node_0_util = dict(
-            cpu=exp_node_0_cpu_usage,
-            ram=exp_node_0_ram_usage,
-            disk=0)
+            cpu=exp_node_0_cpu_usage, ram=exp_node_0_ram_usage, disk=0
+        )
         exp_node_1_util = dict(
-            cpu=exp_node_1_cpu_usage,
-            ram=exp_node_1_ram_usage,
-            disk=25)
+            cpu=exp_node_1_cpu_usage, ram=exp_node_1_ram_usage, disk=25
+        )
 
         self.assertEqual(
-            exp_node_0_util,
-            self.strategy.get_node_utilization(node_0))
+            exp_node_0_util, self.strategy.get_node_utilization(node_0)
+        )
         self.assertEqual(
-            exp_node_1_util,
-            self.strategy.get_node_utilization(node_1))
+            exp_node_1_util, self.strategy.get_node_utilization(node_1)
+        )
 
     def test_get_node_capacity(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -178,8 +182,12 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         expected_cru = {'cpu': 0.05, 'disk': 0.05, 'ram': 0.0234375}
         self.assertEqual(expected_cru, cru)
 
-    def _test_add_migration(self, instance_state, expect_migration=True,
-                            expected_migration_type="live"):
+    def _test_add_migration(
+        self,
+        instance_state,
+        expect_migration=True,
+        expected_migration_type="live",
+    ):
         model = self.fake_c_cluster.generate_scenario_1()
         self.m_c_model.return_value = model
         self.fake_metrics.model = model
@@ -193,13 +201,16 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         if expect_migration:
             self.assertEqual(1, len(self.strategy.solution.actions))
 
-            expected = {'action_type': 'migrate',
-                        'input_parameters': {
-                            'destination_node': n2.hostname,
-                            'source_node': n1.hostname,
-                            'migration_type': expected_migration_type,
-                            'resource_id': instance.uuid,
-                            'resource_name': instance.name}}
+            expected = {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'source_node': n1.hostname,
+                    'migration_type': expected_migration_type,
+                    'resource_id': instance.uuid,
+                    'resource_name': instance.name,
+                },
+            }
             self.assertEqual(expected, self.strategy.solution.actions[0])
         else:
             self.assertEqual(0, len(self.strategy.solution.actions))
@@ -211,12 +222,14 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         self._test_add_migration(element.InstanceState.PAUSED.value)
 
     def test_add_migration_with_error_state(self):
-        self._test_add_migration(element.InstanceState.ERROR.value,
-                                 expect_migration=False)
+        self._test_add_migration(
+            element.InstanceState.ERROR.value, expect_migration=False
+        )
 
     def test_add_migration_with_stopped_state(self):
-        self._test_add_migration(element.InstanceState.STOPPED.value,
-                                 expected_migration_type="cold")
+        self._test_add_migration(
+            element.InstanceState.STOPPED.value, expected_migration_type="cold"
+        )
 
     def test_is_overloaded(self):
         model = self.fake_c_cluster.generate_scenario_1()
@@ -255,10 +268,16 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         self.fake_metrics.model = model
         n = model.get_node_by_uuid('Node_0')
         self.strategy.add_action_enable_compute_node(n)
-        expected = [{'action_type': 'change_nova_service_state',
-                     'input_parameters': {'state': 'enabled',
-                                          'resource_id': 'Node_0',
-                                          'resource_name': 'hostname_0'}}]
+        expected = [
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'state': 'enabled',
+                    'resource_id': 'Node_0',
+                    'resource_name': 'hostname_0',
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_add_action_disable_node(self):
@@ -267,12 +286,17 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         self.fake_metrics.model = model
         n = model.get_node_by_uuid('Node_0')
         self.strategy.add_action_disable_node(n)
-        expected = [{'action_type': 'change_nova_service_state',
-                     'input_parameters': {
-                         'state': 'disabled',
-                         'disabled_reason': 'watcher_disabled',
-                         'resource_id': 'Node_0',
-                         'resource_name': 'hostname_0'}}]
+        expected = [
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_disabled',
+                    'resource_id': 'Node_0',
+                    'resource_name': 'hostname_0',
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_disable_unused_nodes(self):
@@ -290,12 +314,15 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         self.strategy.add_migration(instance, n1, n2)
 
         self.strategy.disable_unused_nodes()
-        expected = {'action_type': 'change_nova_service_state',
-                    'input_parameters': {
-                        'state': 'disabled',
-                        'disabled_reason': 'watcher_disabled',
-                        'resource_id': 'Node_0',
-                        'resource_name': 'hostname_0'}}
+        expected = {
+            'action_type': 'change_nova_service_state',
+            'input_parameters': {
+                'state': 'disabled',
+                'disabled_reason': 'watcher_disabled',
+                'resource_id': 'Node_0',
+                'resource_name': 'hostname_0',
+            },
+        }
         self.assertEqual(2, len(self.strategy.solution.actions))
         self.assertEqual(expected, self.strategy.solution.actions[1])
 
@@ -318,12 +345,18 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         instance = model.get_instance_by_uuid(instance_uuid)
         cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
         self.strategy.consolidation_phase(cc)
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {'destination_node': n2.hostname,
-                                          'source_node': n1.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': instance.uuid,
-                                          'resource_name': instance.name}}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'source_node': n1.hostname,
+                    'migration_type': 'live',
+                    'resource_id': instance.uuid,
+                    'resource_name': instance.name,
+                },
+            }
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
     def test_strategy(self):
@@ -337,39 +370,58 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         n1 = model.get_node_by_uuid('Node_0')
         self.strategy.get_relative_cluster_utilization = mock.MagicMock()
         self.strategy.do_execute()
-        n2_name = self.strategy.solution.actions[0][
-            'input_parameters']['destination_node']
+        n2_name = self.strategy.solution.actions[0]['input_parameters'][
+            'destination_node'
+        ]
         n2 = model.get_node_by_name(n2_name)
-        n3_uuid = self.strategy.solution.actions[2][
-            'input_parameters']['resource_id']
+        n3_uuid = self.strategy.solution.actions[2]['input_parameters'][
+            'resource_id'
+        ]
         n3 = model.get_node_by_uuid(n3_uuid)
-        n4_uuid = self.strategy.solution.actions[3][
-            'input_parameters']['resource_id']
+        n4_uuid = self.strategy.solution.actions[3]['input_parameters'][
+            'resource_id'
+        ]
         n4 = model.get_node_by_uuid(n4_uuid)
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {'destination_node': n2.hostname,
-                                          'source_node': n1.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': 'INSTANCE_3',
-                                          'resource_name': ''}},
-                    {'action_type': 'migrate',
-                     'input_parameters': {'destination_node': n2.hostname,
-                                          'source_node': n1.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': 'INSTANCE_1',
-                                          'resource_name': ''}},
-                    {'action_type': 'change_nova_service_state',
-                     'input_parameters': {'state': 'disabled',
-                                          'disabled_reason':
-                                          'watcher_disabled',
-                                          'resource_id': n3.uuid,
-                                          'resource_name': n3.hostname}},
-                    {'action_type': 'change_nova_service_state',
-                     'input_parameters': {'state': 'disabled',
-                                          'disabled_reason':
-                                          'watcher_disabled',
-                                          'resource_id': n4.uuid,
-                                          'resource_name': n4.hostname}}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'source_node': n1.hostname,
+                    'migration_type': 'live',
+                    'resource_id': 'INSTANCE_3',
+                    'resource_name': '',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'source_node': n1.hostname,
+                    'migration_type': 'live',
+                    'resource_id': 'INSTANCE_1',
+                    'resource_name': '',
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_disabled',
+                    'resource_id': n3.uuid,
+                    'resource_name': n3.hostname,
+                },
+            },
+            {
+                'action_type': 'change_nova_service_state',
+                'input_parameters': {
+                    'state': 'disabled',
+                    'disabled_reason': 'watcher_disabled',
+                    'resource_id': n4.uuid,
+                    'resource_name': n4.hostname,
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
 
         compute_nodes_count = len(self.strategy.get_available_compute_nodes())
@@ -382,7 +434,7 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
             mock_set_efficacy_indicators.assert_called_once_with(
                 compute_nodes_count=compute_nodes_count,
                 released_compute_nodes_count=number_of_released_nodes,
-                instance_migrations_count=number_of_migrations
+                instance_migrations_count=number_of_migrations,
             )
 
     def test_strategy2(self):
@@ -393,32 +445,52 @@ class TestVMWorkloadConsolidation(TestBaseStrategy):
         n2 = model.get_node_by_uuid('Node_1')
         cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
         self.strategy.offload_phase(cc)
-        expected = [{'action_type': 'migrate',
-                     'input_parameters': {'destination_node': n2.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': 'INSTANCE_6',
-                                          'resource_name': '',
-                                          'source_node': n1.hostname}},
-                    {'action_type': 'migrate',
-                     'input_parameters': {'destination_node': n2.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': 'INSTANCE_7',
-                                          'resource_name': '',
-                                          'source_node': n1.hostname}},
-                    {'action_type': 'migrate',
-                     'input_parameters': {'destination_node': n2.hostname,
-                                          'migration_type': 'live',
-                                          'resource_id': 'INSTANCE_8',
-                                          'resource_name': '',
-                                          'source_node': n1.hostname}}]
+        expected = [
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'migration_type': 'live',
+                    'resource_id': 'INSTANCE_6',
+                    'resource_name': '',
+                    'source_node': n1.hostname,
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'migration_type': 'live',
+                    'resource_id': 'INSTANCE_7',
+                    'resource_name': '',
+                    'source_node': n1.hostname,
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n2.hostname,
+                    'migration_type': 'live',
+                    'resource_id': 'INSTANCE_8',
+                    'resource_name': '',
+                    'source_node': n1.hostname,
+                },
+            },
+        ]
         self.assertEqual(expected, self.strategy.solution.actions)
         self.strategy.consolidation_phase(cc)
-        expected.append({'action_type': 'migrate',
-                         'input_parameters': {'destination_node': n1.hostname,
-                                              'migration_type': 'live',
-                                              'resource_id': 'INSTANCE_7',
-                                              'resource_name': '',
-                                              'source_node': n2.hostname}})
+        expected.append(
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'destination_node': n1.hostname,
+                    'migration_type': 'live',
+                    'resource_id': 'INSTANCE_7',
+                    'resource_name': '',
+                    'source_node': n2.hostname,
+                },
+            }
+        )
         self.assertEqual(expected, self.strategy.solution.actions)
         self.strategy.optimize_solution()
         del expected[3]
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_balance.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_balance.py
index 37271f1aa..ff8d95d45 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_balance.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_balance.py
@@ -30,11 +30,14 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestWorkloadBalance(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics,
+            },
+        )
     ]
 
     def setUp(self):
@@ -43,20 +46,28 @@ class TestWorkloadBalance(TestBaseStrategy):
         self.fake_metrics = self.fake_datasource_cls()
 
         p_datasource = mock.patch.object(
-            strategies.WorkloadBalance, "datasource_backend",
-            new_callable=mock.PropertyMock)
+            strategies.WorkloadBalance,
+            "datasource_backend",
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         self.m_datasource.return_value = mock.Mock(
-            statistic_aggregation=self.fake_metrics.mock_get_statistics_wb)
+            statistic_aggregation=self.fake_metrics.mock_get_statistics_wb
+        )
         self.strategy = strategies.WorkloadBalance(
-            config=mock.Mock(datasource=self.datasource))
+            config=mock.Mock(datasource=self.datasource)
+        )
         self.strategy.input_parameters = utils.Struct()
-        self.strategy.input_parameters.update({'metrics': 'instance_cpu_usage',
-                                               'threshold': 25.0,
-                                               'period': 300,
-                                               'granularity': 300})
+        self.strategy.input_parameters.update(
+            {
+                'metrics': 'instance_cpu_usage',
+                'threshold': 25.0,
+                'period': 300,
+                'granularity': 300,
+            }
+        )
         self.strategy.threshold = 25.0
         self.strategy._period = 300
         self.strategy._meter = 'instance_cpu_usage'
@@ -86,10 +97,12 @@ class TestWorkloadBalance(TestBaseStrategy):
         self.m_c_model.return_value = model
         n1, n2, avg, w_map = self.strategy.group_hosts_by_cpu_or_ram_util()
         instance_to_mig = self.strategy.choose_instance_to_migrate(
-            n1, avg, w_map)
+            n1, avg, w_map
+        )
         self.assertEqual(instance_to_mig[0].uuid, 'Node_0')
-        self.assertEqual(instance_to_mig[1].uuid,
-                         "73b09e16-35b7-4922-804e-e8f5d9b740fc")
+        self.assertEqual(
+            instance_to_mig[1].uuid, "73b09e16-35b7-4922-804e-e8f5d9b740fc"
+        )
 
     def test_choose_instance_notfound(self):
         model = self.fake_c_cluster.generate_scenario_6_with_2_nodes()
@@ -98,7 +111,8 @@ class TestWorkloadBalance(TestBaseStrategy):
         instances = model.get_all_instances()
         [model.remove_instance(inst) for inst in instances.values()]
         instance_to_mig = self.strategy.choose_instance_to_migrate(
-            n1, avg, w_map)
+            n1, avg, w_map
+        )
         self.assertIsNone(instance_to_mig)
 
     @mock.patch.object(workload_balance.LOG, 'debug', autospec=True)
@@ -106,27 +120,45 @@ class TestWorkloadBalance(TestBaseStrategy):
         model = self.fake_c_cluster.generate_scenario_6_with_2_nodes()
         self.m_c_model.return_value = model
         self.strategy.datasource = mock.MagicMock(
-            statistic_aggregation=self.fake_metrics.mock_get_statistics_wb)
+            statistic_aggregation=self.fake_metrics.mock_get_statistics_wb
+        )
         n1, n2, avg, w_map = self.strategy.group_hosts_by_cpu_or_ram_util()
         instance_to_mig = self.strategy.choose_instance_to_migrate(
-            n1, avg, w_map)
+            n1, avg, w_map
+        )
         dest_hosts = self.strategy.filter_destination_hosts(
-            n2, instance_to_mig[1], avg, w_map)
+            n2, instance_to_mig[1], avg, w_map
+        )
         self.assertEqual(len(dest_hosts), 1)
         self.assertEqual(dest_hosts[0]['compute_node'].uuid, 'Node_1')
         expected_calls = [
-            mock.call('Host usage for %s: %s is %s. '
-                      'Higher than threshold %s: %s',
-                      'Node_0', 'host_cpu_usage_percent', 32.5, 25.0, True),
-            mock.call('Host usage for %s: %s is %s. '
-                      'Higher than threshold %s: %s',
-                      'Node_1', 'host_cpu_usage_percent', 7.5, 25.0, False),
-            mock.call('Host %s evaluated as destination for %s. '
-                      'Host usage for cpu would be %s.'
-                      'The threshold is: %s. selected: %s',
-                      'hostname_1',
-                      '73b09e16-35b7-4922-804e-e8f5d9b740fc',
-                      20.0, 25.0, True)]
+            mock.call(
+                'Host usage for %s: %s is %s. Higher than threshold %s: %s',
+                'Node_0',
+                'host_cpu_usage_percent',
+                32.5,
+                25.0,
+                True,
+            ),
+            mock.call(
+                'Host usage for %s: %s is %s. Higher than threshold %s: %s',
+                'Node_1',
+                'host_cpu_usage_percent',
+                7.5,
+                25.0,
+                False,
+            ),
+            mock.call(
+                'Host %s evaluated as destination for %s. '
+                'Host usage for cpu would be %s.'
+                'The threshold is: %s. selected: %s',
+                'hostname_1',
+                '73b09e16-35b7-4922-804e-e8f5d9b740fc',
+                20.0,
+                25.0,
+                True,
+            ),
+        ]
         mock_debug.assert_has_calls(expected_calls, any_order=True)
 
     @mock.patch.object(workload_balance.LOG, 'debug', autospec=True)
@@ -136,34 +168,51 @@ class TestWorkloadBalance(TestBaseStrategy):
         self.strategy._meter = 'instance_ram_usage'
         self.strategy.threshold = 30.0
         self.strategy.datasource = mock.MagicMock(
-            statistic_aggregation=self.fake_metrics.mock_get_statistics_wb)
+            statistic_aggregation=self.fake_metrics.mock_get_statistics_wb
+        )
         n1, n2, avg, w_map = self.strategy.group_hosts_by_cpu_or_ram_util()
         instance_to_mig = self.strategy.choose_instance_to_migrate(
-            n1, avg, w_map)
+            n1, avg, w_map
+        )
         dest_hosts = self.strategy.filter_destination_hosts(
-            n2, instance_to_mig[1], avg, w_map)
+            n2, instance_to_mig[1], avg, w_map
+        )
         self.assertEqual(len(dest_hosts), 1)
         self.assertEqual(dest_hosts[0]['compute_node'].uuid, 'Node_1')
         expected_calls = [
-            mock.call('Host usage for %s: %s is %s. '
-                      'Higher than threshold %s: %s',
-                      'Node_0', 'host_ram_usage_percent',
-                      37.121212121212125, 30.0, True),
-            mock.call('Host usage for %s: %s is %s. '
-                      'Higher than threshold %s: %s',
-                      'Node_1', 'host_ram_usage_percent',
-                      18.181818181818183, 30.0, False),
-            mock.call('Host %s evaluated as destination for %s. '
-                      'Host usage for ram would be %s.'
-                      'The threshold is: %s. selected: %s',
-                      'hostname_1',
-                      '73b09e16-35b7-4922-804e-e8f5d9b740fc',
-                      25.0, 30.0, True)]
+            mock.call(
+                'Host usage for %s: %s is %s. Higher than threshold %s: %s',
+                'Node_0',
+                'host_ram_usage_percent',
+                37.121212121212125,
+                30.0,
+                True,
+            ),
+            mock.call(
+                'Host usage for %s: %s is %s. Higher than threshold %s: %s',
+                'Node_1',
+                'host_ram_usage_percent',
+                18.181818181818183,
+                30.0,
+                False,
+            ),
+            mock.call(
+                'Host %s evaluated as destination for %s. '
+                'Host usage for ram would be %s.'
+                'The threshold is: %s. selected: %s',
+                'hostname_1',
+                '73b09e16-35b7-4922-804e-e8f5d9b740fc',
+                25.0,
+                30.0,
+                True,
+            ),
+        ]
         mock_debug.assert_has_calls(expected_calls, any_order=True)
 
     def test_execute_no_workload(self):
-        model = self.fake_c_cluster.\
-            generate_scenario_4_with_1_node_no_instance()
+        model = (
+            self.fake_c_cluster.generate_scenario_4_with_1_node_no_instance()
+        )
         self.m_c_model.return_value = model
         solution = self.strategy.execute()
         self.assertEqual([], solution.actions)
@@ -173,7 +222,8 @@ class TestWorkloadBalance(TestBaseStrategy):
         self.m_c_model.return_value = model
         solution = self.strategy.execute()
         actions_counter = collections.Counter(
-            [action.get('action_type') for action in solution.actions])
+            [action.get('action_type') for action in solution.actions]
+        )
 
         num_migrations = actions_counter.get("migrate", 0)
         self.assertEqual(num_migrations, 1)
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_stabilization.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_stabilization.py
index 88ee55858..27d8459c4 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_stabilization.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_workload_stabilization.py
@@ -28,11 +28,14 @@ from watcher.tests.unit.decision_engine.strategy.strategies.test_base import (
 
 
 class TestWorkloadStabilization(TestBaseStrategy):
-
     scenarios = [
-        ("Gnocchi",
-         {"datasource": "gnocchi",
-          "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics}),
+        (
+            "Gnocchi",
+            {
+                "datasource": "gnocchi",
+                "fake_datasource_cls": gnocchi_metrics.FakeGnocchiMetrics,
+            },
+        )
     ]
 
     def setUp(self):
@@ -42,61 +45,91 @@ class TestWorkloadStabilization(TestBaseStrategy):
         self.fake_metrics = self.fake_datasource_cls()
 
         self.hosts_load_assert = {
-            'Node_0': {'instance_cpu_usage': 0.07,
-                       'instance_ram_usage': 7.0, 'vcpus': 40},
-            'Node_1': {'instance_cpu_usage': 0.07,
-                       'instance_ram_usage': 5, 'vcpus': 40},
-            'Node_2': {'instance_cpu_usage': 0.8,
-                       'instance_ram_usage': 29, 'vcpus': 40},
-            'Node_3': {'instance_cpu_usage': 0.05,
-                       'instance_ram_usage': 8, 'vcpus': 40},
-            'Node_4': {'instance_cpu_usage': 0.05,
-                       'instance_ram_usage': 4, 'vcpus': 40}}
+            'Node_0': {
+                'instance_cpu_usage': 0.07,
+                'instance_ram_usage': 7.0,
+                'vcpus': 40,
+            },
+            'Node_1': {
+                'instance_cpu_usage': 0.07,
+                'instance_ram_usage': 5,
+                'vcpus': 40,
+            },
+            'Node_2': {
+                'instance_cpu_usage': 0.8,
+                'instance_ram_usage': 29,
+                'vcpus': 40,
+            },
+            'Node_3': {
+                'instance_cpu_usage': 0.05,
+                'instance_ram_usage': 8,
+                'vcpus': 40,
+            },
+            'Node_4': {
+                'instance_cpu_usage': 0.05,
+                'instance_ram_usage': 4,
+                'vcpus': 40,
+            },
+        }
 
-        p_osc = mock.patch.object(
-            clients, "OpenStackClients")
+        p_osc = mock.patch.object(clients, "OpenStackClients")
         self.m_osc = p_osc.start()
         self.addCleanup(p_osc.stop)
 
         p_datasource = mock.patch.object(
-            strategies.WorkloadStabilization, "datasource_backend",
-            new_callable=mock.PropertyMock)
+            strategies.WorkloadStabilization,
+            "datasource_backend",
+            new_callable=mock.PropertyMock,
+        )
         self.m_datasource = p_datasource.start()
         self.addCleanup(p_datasource.stop)
 
         self.m_datasource.return_value = mock.Mock(
-            statistic_aggregation=self.fake_metrics.mock_get_statistics)
+            statistic_aggregation=self.fake_metrics.mock_get_statistics
+        )
 
         self.strategy = strategies.WorkloadStabilization(
-            config=mock.Mock(datasource=self.datasource))
+            config=mock.Mock(datasource=self.datasource)
+        )
         self.strategy.input_parameters = utils.Struct()
         self.strategy.input_parameters.update(
-            {'metrics': ["instance_cpu_usage", "instance_ram_usage"],
-             'thresholds': {"instance_cpu_usage": 0.2,
-                            "instance_ram_usage": 0.2},
-             'weights': {"instance_cpu_usage_weight": 1.0,
-                         "instance_ram_usage_weight": 1.0},
-             'instance_metrics':
-                 {"instance_cpu_usage": "host_cpu_usage",
-                  "instance_ram_usage": "host_ram_usage"},
-             'host_choice': 'retry',
-             'retry_count': 1,
-             'periods': {
-                 "instance": 720,
-                 "compute_node": 600,
-                 "node": 0},
-             'aggregation_method': {
-                 "instance": "mean",
-                 "compute_node": "mean",
-                 "node": ''}})
+            {
+                'metrics': ["instance_cpu_usage", "instance_ram_usage"],
+                'thresholds': {
+                    "instance_cpu_usage": 0.2,
+                    "instance_ram_usage": 0.2,
+                },
+                'weights': {
+                    "instance_cpu_usage_weight": 1.0,
+                    "instance_ram_usage_weight": 1.0,
+                },
+                'instance_metrics': {
+                    "instance_cpu_usage": "host_cpu_usage",
+                    "instance_ram_usage": "host_ram_usage",
+                },
+                'host_choice': 'retry',
+                'retry_count': 1,
+                'periods': {"instance": 720, "compute_node": 600, "node": 0},
+                'aggregation_method': {
+                    "instance": "mean",
+                    "compute_node": "mean",
+                    "node": '',
+                },
+            }
+        )
         self.strategy.metrics = ["instance_cpu_usage", "instance_ram_usage"]
-        self.strategy.thresholds = {"instance_cpu_usage": 0.2,
-                                    "instance_ram_usage": 0.2}
-        self.strategy.weights = {"instance_cpu_usage_weight": 1.0,
-                                 "instance_ram_usage_weight": 1.0}
+        self.strategy.thresholds = {
+            "instance_cpu_usage": 0.2,
+            "instance_ram_usage": 0.2,
+        }
+        self.strategy.weights = {
+            "instance_cpu_usage_weight": 1.0,
+            "instance_ram_usage_weight": 1.0,
+        }
         self.strategy.instance_metrics = {
             "instance_cpu_usage": "host_cpu_usage",
-            "instance_ram_usage": "host_ram_usage"}
+            "instance_ram_usage": "host_ram_usage",
+        }
         self.strategy.host_choice = 'retry'
         self.strategy.retry_count = 1
         self.strategy.periods = {
@@ -119,63 +152,82 @@ class TestWorkloadStabilization(TestBaseStrategy):
             "d000ef1f-dc19-4982-9383-087498bfde03"
         )
         instance_0_dict = {
-            'uuid': 'd000ef1f-dc19-4982-9383-087498bfde03', 'vcpus': 10,
-            'instance_cpu_usage': 0.07, 'instance_ram_usage': 2}
+            'uuid': 'd000ef1f-dc19-4982-9383-087498bfde03',
+            'vcpus': 10,
+            'instance_cpu_usage': 0.07,
+            'instance_ram_usage': 2,
+        }
         self.assertEqual(
-            instance_0_dict, self.strategy.get_instance_load(instance0))
+            instance_0_dict, self.strategy.get_instance_load(instance0)
+        )
 
     def test_get_instance_load_with_no_metrics(self):
-        model = self.fake_c_cluster.\
-            generate_scenario_1_with_1_node_unavailable()
+        model = (
+            self.fake_c_cluster.generate_scenario_1_with_1_node_unavailable()
+        )
         self.m_c_model.return_value = model
         lost_instance = model.get_instance_by_uuid("LOST_INSTANCE")
         self.assertIsNone(self.strategy.get_instance_load(lost_instance))
 
     def test_normalize_hosts_load(self):
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
-        fake_hosts = {'Node_0': {'instance_cpu_usage': 0.07,
-                                 'instance_ram_usage': 7},
-                      'Node_1': {'instance_cpu_usage': 0.05,
-                                 'instance_ram_usage': 5}}
-        normalized_hosts = {'Node_0':
-                            {'instance_cpu_usage': 0.07,
-                             'instance_ram_usage': 0.05303030303030303},
-                            'Node_1':
-                            {'instance_cpu_usage': 0.05,
-                             'instance_ram_usage': 0.03787878787878788}}
+        fake_hosts = {
+            'Node_0': {'instance_cpu_usage': 0.07, 'instance_ram_usage': 7},
+            'Node_1': {'instance_cpu_usage': 0.05, 'instance_ram_usage': 5},
+        }
+        normalized_hosts = {
+            'Node_0': {
+                'instance_cpu_usage': 0.07,
+                'instance_ram_usage': 0.05303030303030303,
+            },
+            'Node_1': {
+                'instance_cpu_usage': 0.05,
+                'instance_ram_usage': 0.03787878787878788,
+            },
+        }
         self.assertEqual(
-            normalized_hosts,
-            self.strategy.normalize_hosts_load(fake_hosts))
+            normalized_hosts, self.strategy.normalize_hosts_load(fake_hosts)
+        )
 
     def test_get_available_nodes(self):
-        self.m_c_model.return_value = self.fake_c_cluster. \
-            generate_scenario_9_with_3_active_plus_1_disabled_nodes()
+        self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_9_with_3_active_plus_1_disabled_nodes()  # noqa: E501
         self.assertEqual(3, len(self.strategy.get_available_nodes()))
 
     def test_get_hosts_load(self):
-        self.m_c_model.return_value = self.fake_c_cluster.\
-            generate_scenario_1()
-        self.assertEqual(self.strategy.get_hosts_load(),
-                         self.hosts_load_assert)
+        self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
+        self.assertEqual(
+            self.strategy.get_hosts_load(), self.hosts_load_assert
+        )
 
     def test_get_hosts_load_with_node_missing(self):
-        self.m_c_model.return_value = \
-            self.fake_c_cluster.\
-            generate_scenario_1_with_1_node_unavailable()
-        self.assertEqual(self.hosts_load_assert,
-                         self.strategy.get_hosts_load())
+        self.m_c_model.return_value = (
+            self.fake_c_cluster.generate_scenario_1_with_1_node_unavailable()
+        )
+        self.assertEqual(
+            self.hosts_load_assert, self.strategy.get_hosts_load()
+        )
 
     def test_get_sd(self):
         test_cpu_sd = 0.296
         test_ram_sd = 9.3
         self.assertEqual(
-            round(self.strategy.get_sd(
-                self.hosts_load_assert, 'instance_cpu_usage'), 3),
-            test_cpu_sd)
+            round(
+                self.strategy.get_sd(
+                    self.hosts_load_assert, 'instance_cpu_usage'
+                ),
+                3,
+            ),
+            test_cpu_sd,
+        )
         self.assertEqual(
-            round(self.strategy.get_sd(
-                self.hosts_load_assert, 'instance_ram_usage'), 1),
-            test_ram_sd)
+            round(
+                self.strategy.get_sd(
+                    self.hosts_load_assert, 'instance_ram_usage'
+                ),
+                1,
+            ),
+            test_ram_sd,
+        )
 
     def test_calculate_weighted_sd(self):
         sd_case = [0.5, 0.75]
@@ -190,48 +242,49 @@ class TestWorkloadStabilization(TestBaseStrategy):
         src_node = model.get_node_by_uuid("Node_2")
         dst_node = model.get_node_by_uuid("Node_1")
         result = self.strategy.calculate_migration_case(
-            self.hosts_load_assert, instance,
-            src_node, dst_node)[-1][dst_node.uuid]
+            self.hosts_load_assert, instance, src_node, dst_node
+        )[-1][dst_node.uuid]
         result['instance_cpu_usage'] = round(result['instance_cpu_usage'], 3)
-        self.assertEqual(result, {'instance_cpu_usage': 0.095,
-                                  'instance_ram_usage': 21.0,
-                                  'vcpus': 40})
+        self.assertEqual(
+            result,
+            {
+                'instance_cpu_usage': 0.095,
+                'instance_ram_usage': 21.0,
+                'vcpus': 40,
+            },
+        )
 
     def test_simulate_migrations(self):
         model = self.fake_c_cluster.generate_scenario_1()
         self.m_c_model.return_value = model
         self.strategy.host_choice = 'fullsearch'
         self.assertEqual(
-            10,
-            len(self.strategy.simulate_migrations(self.hosts_load_assert)))
+            10, len(self.strategy.simulate_migrations(self.hosts_load_assert))
+        )
 
     def test_simulate_migrations_with_all_instances_exclude(self):
-        model = \
-            self.fake_c_cluster.\
-            generate_scenario_1_with_all_instances_exclude()
+        model = self.fake_c_cluster.generate_scenario_1_with_all_instances_exclude()  # noqa: E501
         self.m_c_model.return_value = model
         self.strategy.host_choice = 'fullsearch'
         self.assertEqual(
-            0,
-            len(self.strategy.simulate_migrations(self.hosts_load_assert)))
+            0, len(self.strategy.simulate_migrations(self.hosts_load_assert))
+        )
 
     def test_check_threshold(self):
-
         # sd for 0.05, 0.05, 0.07, 0.07, 0.8
         test_cpu_sd = 0.296
 
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
-        self.strategy.thresholds = {'instance_cpu_usage': 0.25,
-                                    'instance_ram_usage': 0.2}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.25,
+            'instance_ram_usage': 0.2,
+        }
 
         self.strategy.simulate_migrations = mock.Mock(return_value=True)
         self.assertTrue(self.strategy.check_threshold())
-        self.assertEqual(
-            round(self.strategy.sd_before_audit, 3),
-            test_cpu_sd)
+        self.assertEqual(round(self.strategy.sd_before_audit, 3), test_cpu_sd)
 
     def test_check_threshold_cpu(self):
-
         test_cpu_sd = 0.296
 
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
@@ -240,30 +293,29 @@ class TestWorkloadStabilization(TestBaseStrategy):
 
         self.strategy.simulate_migrations = mock.Mock(return_value=True)
         self.assertTrue(self.strategy.check_threshold())
-        self.assertEqual(
-            round(self.strategy.sd_before_audit, 3),
-            test_cpu_sd)
+        self.assertEqual(round(self.strategy.sd_before_audit, 3), test_cpu_sd)
 
     def test_check_threshold_ram(self):
-
         # sd for 4,5,7,8, 29 MB used in 132MB total memory hosts
         test_ram_sd = 0.071
 
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
         self.strategy.metrics = ["instance_ram_usage"]
-        self.strategy.thresholds = {'instance_cpu_usage': 0.25,
-                                    'instance_ram_usage': 0.05}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.25,
+            'instance_ram_usage': 0.05,
+        }
 
         self.strategy.simulate_migrations = mock.Mock(return_value=True)
         self.assertTrue(self.strategy.check_threshold())
-        self.assertEqual(
-            round(self.strategy.sd_before_audit, 3),
-            test_ram_sd)
+        self.assertEqual(round(self.strategy.sd_before_audit, 3), test_ram_sd)
 
     def test_check_threshold_fail(self):
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
-        self.strategy.thresholds = {'instance_cpu_usage': 0.3,
-                                    'instance_ram_usage': 0.2}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.3,
+            'instance_ram_usage': 0.2,
+        }
         self.strategy.simulate_migrations = mock.Mock(return_value=True)
         self.assertFalse(self.strategy.check_threshold())
 
@@ -277,20 +329,27 @@ class TestWorkloadStabilization(TestBaseStrategy):
     def test_check_threshold_ram_fail(self):
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
         self.strategy.metrics = ["instance_ram_usage"]
-        self.strategy.thresholds = {'instance_cpu_usage': 0.25,
-                                    'instance_ram_usage': 0.1}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.25,
+            'instance_ram_usage': 0.1,
+        }
         self.strategy.simulate_migrations = mock.Mock(return_value=True)
         self.assertFalse(self.strategy.check_threshold())
 
     def test_execute_one_migration(self):
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
-        self.strategy.thresholds = {'instance_cpu_usage': 0.001,
-                                    'instance_ram_usage': 0.2}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.001,
+            'instance_ram_usage': 0.2,
+        }
         self.strategy.simulate_migrations = mock.Mock(
             return_value=[
-                {'instance': 'd040ef1f-dc19-4982-9383-087498bfde03',
-                 's_host': 'Node_2',
-                 'host': 'Node_1'}]
+                {
+                    'instance': 'd040ef1f-dc19-4982-9383-087498bfde03',
+                    's_host': 'Node_2',
+                    'host': 'Node_1',
+                }
+            ]
         )
         with mock.patch.object(self.strategy, 'migrate') as mock_migration:
             self.strategy.do_execute()
@@ -300,16 +359,23 @@ class TestWorkloadStabilization(TestBaseStrategy):
 
     def test_execute_multiply_migrations(self):
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
-        self.strategy.thresholds = {'instance_cpu_usage': 0.00001,
-                                    'instance_ram_usage': 0.0001}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.00001,
+            'instance_ram_usage': 0.0001,
+        }
         self.strategy.simulate_migrations = mock.Mock(
             return_value=[
-                {'instance': 'd040ef1f-dc19-4982-9383-087498bfde03',
-                 's_host': 'Node_2',
-                 'host': 'Node_1'},
-                {'instance': 'd030ef1f-dc19-4982-9383-087498bfde03',
-                 's_host': 'Node_2',
-                 'host': 'Node_3'}]
+                {
+                    'instance': 'd040ef1f-dc19-4982-9383-087498bfde03',
+                    's_host': 'Node_2',
+                    'host': 'Node_1',
+                },
+                {
+                    'instance': 'd030ef1f-dc19-4982-9383-087498bfde03',
+                    's_host': 'Node_2',
+                    'host': 'Node_3',
+                },
+            ]
         )
         with mock.patch.object(self.strategy, 'migrate') as mock_migrate:
             self.strategy.do_execute()
@@ -317,8 +383,10 @@ class TestWorkloadStabilization(TestBaseStrategy):
 
     def test_execute_nothing_to_migrate(self):
         self.m_c_model.return_value = self.fake_c_cluster.generate_scenario_1()
-        self.strategy.thresholds = {'instance_cpu_usage': 0.042,
-                                    'instance_ram_usage': 0.0001}
+        self.strategy.thresholds = {
+            'instance_cpu_usage': 0.042,
+            'instance_ram_usage': 0.0001,
+        }
         self.strategy.simulate_migrations = mock.Mock(return_value=False)
         self.strategy.instance_migrations_count = 0
         with mock.patch.object(self.strategy, 'migrate') as mock_migrate:
@@ -328,20 +396,21 @@ class TestWorkloadStabilization(TestBaseStrategy):
     def test_parameter_backwards_compat(self):
         # Set the deprecated node values to a none default value
         self.strategy.input_parameters.update(
-            {'periods': {
-                "instance": 720,
-                "compute_node": 600,
-                "node": 500
-            }, 'aggregation_method': {
-                "instance": "mean",
-                "compute_node": "mean",
-                "node": 'min'}})
+            {
+                'periods': {"instance": 720, "compute_node": 600, "node": 500},
+                'aggregation_method': {
+                    "instance": "mean",
+                    "compute_node": "mean",
+                    "node": 'min',
+                },
+            }
+        )
 
         # Pre execute method handles backwards compatibility of parameters
         self.strategy.pre_execute()
 
         # assert that the compute_node values are updated to the those of node
         self.assertEqual(
-            'min', self.strategy.aggregation_method['compute_node'])
-        self.assertEqual(
-            500, self.strategy.periods['compute_node'])
+            'min', self.strategy.aggregation_method['compute_node']
+        )
+        self.assertEqual(500, self.strategy.periods['compute_node'])
diff --git a/watcher/tests/unit/decision_engine/strategy/strategies/test_zone_migration.py b/watcher/tests/unit/decision_engine/strategy/strategies/test_zone_migration.py
index e8da4379a..ae21674c5 100644
--- a/watcher/tests/unit/decision_engine/strategy/strategies/test_zone_migration.py
+++ b/watcher/tests/unit/decision_engine/strategy/strategies/test_zone_migration.py
@@ -33,7 +33,6 @@ volume_uuid_mapping = faker_cluster_state.volume_uuid_mapping
 
 
 class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
-
     def setUp(self):
         super().setUp()
 
@@ -41,8 +40,10 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.fake_s_cluster = faker_cluster_state.FakerStorageModelCollector()
 
         p_s_model = mock.patch.object(
-            strategies.ZoneMigration, "storage_model",
-            new_callable=mock.PropertyMock)
+            strategies.ZoneMigration,
+            "storage_model",
+            new_callable=mock.PropertyMock,
+        )
         self.m_s_model = p_s_model.start()
         self.addCleanup(p_s_model.stop)
 
@@ -54,41 +55,49 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.input_parameters = {
             "storage_pools": [
-                {"src_pool": "src1@back1#pool1",
-                 "dst_pool": "dst1@back1#pool1",
-                 "src_type": "type1", "dst_type": "type1"},
-                {"src_pool": "src2@back1#pool1",
-                 "dst_pool": "dst2@back2#pool1",
-                 "src_type": "type2", "dst_type": "type3"}
+                {
+                    "src_pool": "src1@back1#pool1",
+                    "dst_pool": "dst1@back1#pool1",
+                    "src_type": "type1",
+                    "dst_type": "type1",
+                },
+                {
+                    "src_pool": "src2@back1#pool1",
+                    "dst_pool": "dst2@back2#pool1",
+                    "src_type": "type2",
+                    "dst_type": "type3",
+                },
             ],
             "compute_nodes": [
                 {"src_node": "src1", "dst_node": "dst1"},
-                {"src_node": "src2", "dst_node": "dst2"}
+                {"src_node": "src2", "dst_node": "dst2"},
             ],
             "parallel_per_node": 2,
             "parallel_per_pool": 2,
             "parallel_total": 6,
-            "with_attached_volume": False
+            "with_attached_volume": False,
         }
 
-        self.strategy = strategies.ZoneMigration(
-            config=mock.Mock())
+        self.strategy = strategies.ZoneMigration(config=mock.Mock())
         self.strategy.input_parameters = self.input_parameters
 
         self.m_osc = self.useFixture(
             fixtures.MockPatch(
-                "watcher.common.clients.OpenStackClients",
-                autospec=True)).mock.return_value
+                "watcher.common.clients.OpenStackClients", autospec=True
+            )
+        ).mock.return_value
 
         self.m_n_helper = self.useFixture(
             fixtures.MockPatch(
-                "watcher.common.nova_helper.NovaHelper",
-                autospec=False)).mock.return_value
+                "watcher.common.nova_helper.NovaHelper", autospec=False
+            )
+        ).mock.return_value
 
         self.m_c_helper = self.useFixture(
             fixtures.MockPatch(
-                "watcher.common.cinder_helper.CinderHelper",
-                autospec=False)).mock.return_value
+                "watcher.common.cinder_helper.CinderHelper", autospec=False
+            )
+        ).mock.return_value
 
     @staticmethod
     def fake_volume(**kwargs):
@@ -100,8 +109,11 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         setattr(volume, 'os-vol-tenant-attr:tenant_id', tenant_id)
         setattr(volume, 'os-vol-host-attr:host', kwargs.get('host'))
         setattr(volume, 'size', kwargs.get('size', '1'))
-        setattr(volume, 'created_at',
-                kwargs.get('created_at', '1977-01-01T00:00:00'))
+        setattr(
+            volume,
+            'created_at',
+            kwargs.get('created_at', '1977-01-01T00:00:00'),
+        )
         setattr(volume, 'attachments', kwargs.get('attachments', []))
         volume.volume_type = kwargs.get('volume_type', 'type1')
 
@@ -126,7 +138,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -135,7 +147,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src2",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -144,7 +156,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src3",
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -170,7 +182,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d8f0ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -187,8 +199,8 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         # Create a test volume without an known id
         # so we expect it to not be in the model
         volume_on_src1 = self.fake_volume(
-            host="src1@back1#pool1",
-            name="volume_1")
+            host="src1@back1#pool1", name="volume_1"
+        )
 
         # Mock cinder helper to return our tets volume
         self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
@@ -198,15 +210,21 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertEqual([], volumes)
 
     def test_get_volumes(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src3@back2#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back2#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
@@ -222,25 +240,37 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertNotIn(volume_on_src3, volumes)
 
     def test_get_volumes_no_src_type(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src3@back2#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back2#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
             volume_on_src3,
         ]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "dst_type": "type1"},
-            {"src_pool": "src2@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "dst_type": "type3"}
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src2@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "dst_type": "type3",
+            },
         ]
 
         volumes = self.strategy.get_volumes()
@@ -252,20 +282,28 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertNotIn(volume_on_src3, volumes)
 
     def test_get_volumes_different_types_different_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          volume_type="type2",
-                                          name="volume_0")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            volume_type="type2",
+            name="volume_0",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
@@ -295,20 +333,28 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertNotIn(volume_on_src2, volumes)
 
     def test_get_volumes_different_types_same_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          volume_type="type3",
-                                          name="volume_0")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            volume_type="type3",
+            name="volume_0",
+        )
         self.m_c_helper.get_volume_list.return_value = {
             volume_on_src1,
             volume_on_src2,
@@ -337,25 +383,41 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertNotIn(volume_on_src2, volumes)
 
     def test_get_volumes_all_types_in_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          volume_type="type2",
-                                          name="volume_4")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            volume_type="type2",
+            name="volume_4",
+        )
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "src_type": "type2", "dst_type": "type3"}
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "src_type": "type2",
+                "dst_type": "type3",
+            },
         ]
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
@@ -376,23 +438,39 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertIn(volume_on_src2, volumes)
 
     def test_get_volumes_type_in_all_pools(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          name="volume_0")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            name="volume_0",
+        )
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
-            {"src_pool": "src2@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "src_type": "type1", "dst_type": "type3"}
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src2@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "src_type": "type1",
+                "dst_type": "type3",
+            },
         ]
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
@@ -413,20 +491,26 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertIn(volume_on_src2, volumes)
 
     def test_get_volumes_select_no_volumes(self):
-        volume_on_src1 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src3@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
+        volume_on_src1 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
-            volume_on_src3
+            volume_on_src3,
         ]
 
         volumes = self.strategy.get_volumes()
@@ -438,24 +522,40 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertEqual(len(volumes), 0)
 
     def test_get_volumes_duplicated_input(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          volume_type="type2",
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          name="volume_4")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            volume_type="type2",
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            name="volume_4",
+        )
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src2@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
-            {"src_pool": "src2@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "src_type": "type1", "dst_type": "type3"}
+            {
+                "src_pool": "src2@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src2@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "src_type": "type1",
+                "dst_type": "type3",
+            },
         ]
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
@@ -490,22 +590,23 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
         )
-        self.m_n_helper.get_instance_list.return_value = [
-            instance_on_src1,
-        ]
+        self.m_n_helper.get_instance_list.return_value = [instance_on_src1]
 
         self.m_c_helper.get_volume_list.return_value = []
 
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("live", 0))
         global_efficacy_value = solution.global_efficacy[0].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
@@ -515,14 +616,12 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
         )
-        self.m_n_helper.get_instance_list.return_value = [
-            instance_on_src1,
-        ]
+        self.m_n_helper.get_instance_list.return_value = [instance_on_src1]
         self.m_c_helper.get_volume_list.return_value = []
         self.input_parameters["compute_nodes"] = [{"src_node": "src1"}]
         solution = self.strategy.execute()
@@ -542,74 +641,86 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
         )
-        self.m_n_helper.get_instance_list.return_value = [
-            instance_on_src1,
-        ]
+        self.m_n_helper.get_instance_list.return_value = [instance_on_src1]
 
         self.m_c_helper.get_volume_list.return_value = []
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("cold", 0))
         global_efficacy_value = solution.global_efficacy[1].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volume(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src1,
-        ]
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
 
         self.m_n_helper.get_instance_list.return_value = []
 
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("migrate", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volume_no_dst_type(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src1,
-        ]
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
 
         self.m_n_helper.get_instance_list.return_value = []
 
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1",
-             "src_type": "type1", "dst_pool": "dst1@back1#pool1"},
+            {
+                "src_pool": "src1@back1#pool1",
+                "src_type": "type1",
+                "dst_pool": "dst1@back1#pool1",
+            }
         ]
 
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("migrate", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volume_no_dst_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src1,
-
-            ]
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
+            {
+                "src_pool": "src1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            }
         ]
         self.m_n_helper.get_instance_list.return_value = []
         solution = self.strategy.execute()
@@ -618,26 +729,29 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertEqual(len(solution.actions), 0)
 
     def test_execute_migrate_volume_dst_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src1,
-
-            ]
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1",
-             "src_type": "type1",
-             "dst_pool": "back2",
-             "dst_type": "type1"},
-
-            ]
+            {
+                "src_pool": "src1@back1#pool1",
+                "src_type": "type1",
+                "dst_pool": "back2",
+                "dst_type": "type1",
+            }
+        ]
         self.m_n_helper.get_instance_list.return_value = []
         solution = self.strategy.execute()
         # check that there is one volume migration proposed
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("migrate", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
@@ -647,33 +761,32 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
         )
         vol_attach = [{"server_id": instance_on_src1.uuid}]
-        self.m_n_helper.get_instance_list.return_value = [
-            instance_on_src1,
-        ]
+        self.m_n_helper.get_instance_list.return_value = [instance_on_src1]
         self.m_n_helper.find_instance.return_value = instance_on_src1
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1",
-                                          status="in-use",
-                                          attachments=vol_attach)
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src1,
-            ]
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+            status="in-use",
+            attachments=vol_attach,
+        )
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1",
-             "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
-            ]
-        self.input_parameters["compute_nodes"] = None
-        self.m_n_helper.get_instance_list.return_value = [
-            instance_on_src1,
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            }
         ]
+        self.input_parameters["compute_nodes"] = None
+        self.m_n_helper.get_instance_list.return_value = [instance_on_src1]
         self.input_parameters["with_attached_volume"] = True
 
         # check that the solution contains one volume migration and no
@@ -681,48 +794,56 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
         self.assertEqual(len(solution.actions), 1)
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions]
-            )
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(0, migration_types.get("live", 0))
         self.assertEqual(1, migration_types.get("migrate", 0))
 
     def test_execute_retype_volume(self):
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src2
-        ]
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src2]
 
         self.m_n_helper.get_instance_list.return_value = []
 
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("retype", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_swap_volume(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
         volume_on_src1.status = "in-use"
-        self.m_c_helper.get_volume_list.return_value = [
-            volume_on_src1,
-        ]
+        self.m_c_helper.get_volume_list.return_value = [volume_on_src1]
 
         self.m_n_helper.get_instance_list.return_value = []
 
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         # watcher no longer implements swap. it is now an
         # alias for migrate.
         self.assertEqual(0, migration_types.get("swap", 0))
@@ -731,25 +852,37 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volumes_no_src_type(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src3@back2#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back2#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
-            volume_on_src3
+            volume_on_src3,
         ]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "dst_type": "type1"},
-            {"src_pool": "src2@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "dst_type": "type3"}
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src2@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "dst_type": "type3",
+            },
         ]
         self.m_n_helper.get_instance_list.return_value = []
 
@@ -757,35 +890,44 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.assertEqual(2, len(solution.actions))
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
-        self.assertEqual(1,
-                         migration_types.get("migrate", 0))
-        self.assertEqual(1,
-                         migration_types.get("retype", 0))
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
+        self.assertEqual(1, migration_types.get("migrate", 0))
+        self.assertEqual(1, migration_types.get("retype", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volumes_different_types_different_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          volume_type="type2",
-                                          name="volume_0")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            volume_type="type2",
+            name="volume_0",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
             volume_on_src3,
-            volume_on_src4
+            volume_on_src4,
         ]
         self.m_n_helper.get_instance_list.return_value = []
 
@@ -793,140 +935,191 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.assertEqual(2, len(solution.actions))
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
-        self.assertEqual(1,
-                         migration_types.get("migrate", 0))
-        self.assertEqual(1,
-                         migration_types.get("retype", 0))
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
+        self.assertEqual(1, migration_types.get("migrate", 0))
+        self.assertEqual(1, migration_types.get("retype", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volumes_different_types_same_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          volume_type="type3",
-                                          name="volume_0")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            volume_type="type3",
+            name="volume_0",
+        )
 
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
             volume_on_src3,
-            volume_on_src4
+            volume_on_src4,
         ]
         self.m_n_helper.get_instance_list.return_value = []
         solution = self.strategy.execute()
 
         self.assertEqual(2, len(solution.actions))
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
-        self.assertEqual(2,
-                         migration_types.get("migrate", 0))
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
+        self.assertEqual(2, migration_types.get("migrate", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volumes_all_types_in_pool(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          volume_type="type2",
-                                          name="volume_4")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            volume_type="type2",
+            name="volume_4",
+        )
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "src_type": "type2", "dst_type": "type3"}
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "src_type": "type2",
+                "dst_type": "type3",
+            },
         ]
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
             volume_on_src3,
-            volume_on_src4
+            volume_on_src4,
         ]
         self.m_n_helper.get_instance_list.return_value = []
         solution = self.strategy.execute()
 
         self.assertEqual(2, len(solution.actions))
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
-        self.assertEqual(1,
-                         migration_types.get("migrate", 0))
-        self.assertEqual(1,
-                         migration_types.get("retype", 0))
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
+        self.assertEqual(1, migration_types.get("migrate", 0))
+        self.assertEqual(1, migration_types.get("retype", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(50, global_efficacy_value)
 
     def test_execute_migrate_volumes_type_in_all_pools(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
-        volume_on_src4 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_0"],
-                                          name="volume_0")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
+        volume_on_src4 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_0"],
+            name="volume_0",
+        )
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
-            {"src_pool": "src2@back1#pool1", "dst_pool": "dst2@back2#pool1",
-             "src_type": "type1", "dst_type": "type3"}
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            },
+            {
+                "src_pool": "src2@back1#pool1",
+                "dst_pool": "dst2@back2#pool1",
+                "src_type": "type1",
+                "dst_type": "type3",
+            },
         ]
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
             volume_on_src3,
-            volume_on_src4
+            volume_on_src4,
         ]
         self.m_n_helper.get_instance_list.return_value = []
         solution = self.strategy.execute()
 
         self.assertEqual(4, len(solution.actions))
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
-        self.assertEqual(2,
-                         migration_types.get("migrate", 0))
-        self.assertEqual(2,
-                         migration_types.get("retype", 0))
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
+        self.assertEqual(2, migration_types.get("migrate", 0))
+        self.assertEqual(2, migration_types.get("retype", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
 
     def test_execute_migrate_volumes_select_no_volumes(self):
-        volume_on_src1 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src3@back1#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
+        volume_on_src1 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
@@ -941,7 +1134,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -950,7 +1143,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src2",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -965,8 +1158,11 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(2, migration_types.get("live", 0))
         global_efficacy_value = solution.global_efficacy[0].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
@@ -978,7 +1174,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -987,7 +1183,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1002,19 +1198,26 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("live", 0))
         global_efficacy_value = solution.global_efficacy[0].get('value', 0)
         self.assertEqual(50.0, global_efficacy_value)
 
     def test_execute_migrate_volume_parallel(self):
-        volume_on_src1_1 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_1"],
-                                            name="volume_1")
-        volume_on_src1_2 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_2"],
-                                            name="volume_2")
+        volume_on_src1_1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src1_2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1_1,
             volume_on_src1_2,
@@ -1025,8 +1228,11 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(2, migration_types.get("migrate", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(100, global_efficacy_value)
@@ -1034,12 +1240,16 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
     def test_execute_parallel_per_pool(self):
         self.input_parameters["parallel_per_pool"] = 1
 
-        volume_on_src1_1 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_1"],
-                                            name="volume_1")
-        volume_on_src1_2 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_2"],
-                                            name="volume_2")
+        volume_on_src1_1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src1_2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1_1,
             volume_on_src1_2,
@@ -1050,8 +1260,11 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("migrate", 0))
         global_efficacy_value = solution.global_efficacy[2].get('value', 0)
         self.assertEqual(50.0, global_efficacy_value)
@@ -1060,15 +1273,21 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.input_parameters["parallel_total"] = 1
         self.input_parameters["parallel_per_pool"] = 1
 
-        volume_on_src1_1 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_1"],
-                                            name="volume_1")
-        volume_on_src1_2 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_2"],
-                                            name="volume_2")
-        volume_on_src2_1 = self.fake_volume(host="src2@back1#pool1",
-                                            id=volume_uuid_mapping["volume_3"],
-                                            name="volume_3")
+        volume_on_src1_1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src1_2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src2_1 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1_1,
             volume_on_src1_2,
@@ -1080,8 +1299,11 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
 
         migration_types = collections.Counter(
-            [action.get('input_parameters')['migration_type']
-             for action in solution.actions])
+            [
+                action.get('input_parameters')['migration_type']
+                for action in solution.actions
+            ]
+        )
         self.assertEqual(1, migration_types.get("migrate", 0))
 
     def test_execute_mixed_instances_volumes(self):
@@ -1089,7 +1311,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1098,7 +1320,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src2",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2_2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1108,15 +1330,21 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             instance_on_src2_2,
         ]
 
-        volume_on_src1_1 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_1"],
-                                            name="volume_1")
-        volume_on_src1_2 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_2"],
-                                            name="volume_2")
-        volume_on_src2_1 = self.fake_volume(host="src2@back1#pool1",
-                                            id=volume_uuid_mapping["volume_3"],
-                                            name="volume_3")
+        volume_on_src1_1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src1_2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src2_1 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1_1,
             volume_on_src1_2,
@@ -1124,61 +1352,84 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         ]
 
         self.input_parameters["compute_nodes"] = [
-            {"src_node": "src1", "dst_node": "dst1"},
+            {"src_node": "src1", "dst_node": "dst1"}
         ]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            }
         ]
 
         solution = self.strategy.execute()
 
         # Check volume migrations
         action_types = collections.Counter(
-            [action['action_type']
-             for action in solution.actions])
+            [action['action_type'] for action in solution.actions]
+        )
         expected_vmigrations = [
-            {'action_type': 'volume_migrate',
-             'input_parameters':
-                {'migration_type': 'migrate',
-                 'destination_node': 'dst1@back1#pool1',
-                 'resource_name': 'volume_1',
-                 'resource_id': '74454247-a064-4b34-8f43-89337987720e'}},
-            {'action_type': 'volume_migrate',
-             'input_parameters':
-                {'migration_type': 'migrate',
-                 'destination_node': 'dst1@back1#pool1',
-                 'resource_name': 'volume_2',
-                 'resource_id': 'a16c811e-2521-4fd3-8779-6a94ccb3be73'}}
+            {
+                'action_type': 'volume_migrate',
+                'input_parameters': {
+                    'migration_type': 'migrate',
+                    'destination_node': 'dst1@back1#pool1',
+                    'resource_name': 'volume_1',
+                    'resource_id': '74454247-a064-4b34-8f43-89337987720e',
+                },
+            },
+            {
+                'action_type': 'volume_migrate',
+                'input_parameters': {
+                    'migration_type': 'migrate',
+                    'destination_node': 'dst1@back1#pool1',
+                    'resource_name': 'volume_2',
+                    'resource_id': 'a16c811e-2521-4fd3-8779-6a94ccb3be73',
+                },
+            },
         ]
         expected_vm_migrations = [
-            {'action_type': 'migrate',
-             'input_parameters':
-                {'migration_type': 'live',
-                 'source_node': 'src1',
-                 'destination_node': 'dst1',
-                 'resource_name': 'INSTANCE_1',
-                 'resource_id': 'd010ef1f-dc19-4982-9383-087498bfde03'}}
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'source_node': 'src1',
+                    'destination_node': 'dst1',
+                    'resource_name': 'INSTANCE_1',
+                    'resource_id': 'd010ef1f-dc19-4982-9383-087498bfde03',
+                },
+            }
+        ]
+        migrated_volumes = [
+            action
+            for action in solution.actions
+            if action['action_type'] == 'volume_migrate'
         ]
-        migrated_volumes = [action
-                            for action in solution.actions
-                            if action['action_type'] == 'volume_migrate']
         self.assertEqual(2, action_types.get("volume_migrate", 0))
         self.assertEqual(expected_vmigrations, migrated_volumes)
 
         self.assertEqual(1, action_types.get("migrate", 0))
-        migrated_vms = [action
-                        for action in solution.actions
-                        if action['action_type'] == 'migrate']
+        migrated_vms = [
+            action
+            for action in solution.actions
+            if action['action_type'] == 'migrate'
+        ]
         self.assertEqual(expected_vm_migrations, migrated_vms)
 
         # All the detached volumes in the pool should be migrated
-        volume_indicator = [item['value'] for item in solution.global_efficacy
-                            if item['name'] == "volume_migrate_ratio"][0]
+        volume_indicator = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "volume_migrate_ratio"
+        ][0]
         self.assertEqual(100, volume_indicator)
         # All the instances in src1 should be migrated
-        live_ind = [item['value'] for item in solution.global_efficacy
-                    if item['name'] == "live_instance_migrate_ratio"][0]
+        live_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "live_instance_migrate_ratio"
+        ][0]
         self.assertEqual(100, live_ind)
         # check that the live migration is the third action, after all
         # volume migrations, since with_attached_volume=False in this test
@@ -1190,7 +1441,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1199,7 +1450,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src2",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2_2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1208,7 +1459,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1216,18 +1467,24 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.m_n_helper.get_instance_list.return_value = [
             instance_on_src1_1,
             instance_on_src2_2,
-            instance_on_src1_3
+            instance_on_src1_3,
         ]
 
-        volume_on_src1_1 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_1"],
-                                            name="volume_1")
-        volume_on_src1_2 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_2"],
-                                            name="volume_2")
-        volume_on_src2_1 = self.fake_volume(host="src2@back1#pool1",
-                                            id=volume_uuid_mapping["volume_3"],
-                                            name="volume_3")
+        volume_on_src1_1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src1_2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src2_1 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1_1,
             volume_on_src1_2,
@@ -1235,17 +1492,23 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         ]
 
         volume_on_src1_1.status = 'in-use'
-        volume_on_src1_1.attachments = [{
-            "server_id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "attachment_id": "attachment1"
-        }]
+        volume_on_src1_1.attachments = [
+            {
+                "server_id": "d010ef1f-dc19-4982-9383-087498bfde03",
+                "attachment_id": "attachment1",
+            }
+        ]
 
         self.input_parameters["compute_nodes"] = [
-            {"src_node": "src1", "dst_node": "dst1"},
+            {"src_node": "src1", "dst_node": "dst1"}
         ]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            }
         ]
         self.input_parameters["with_attached_volume"] = True
 
@@ -1254,46 +1517,62 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
         # Check migrations
         action_types = collections.Counter(
-            [action['action_type']
-             for action in solution.actions])
+            [action['action_type'] for action in solution.actions]
+        )
         expected_vol_migrations = [
-            {'action_type': 'volume_migrate',
-             'input_parameters':
-                {'migration_type': 'migrate',
-                 'destination_node': 'dst1@back1#pool1',
-                 'resource_name': 'volume_1',
-                 'resource_id': '74454247-a064-4b34-8f43-89337987720e'}},
-            {'action_type': 'volume_migrate',
-             'input_parameters':
-                {'migration_type': 'migrate',
-                 'destination_node': 'dst1@back1#pool1',
-                 'resource_name': 'volume_2',
-                 'resource_id': 'a16c811e-2521-4fd3-8779-6a94ccb3be73'}}
+            {
+                'action_type': 'volume_migrate',
+                'input_parameters': {
+                    'migration_type': 'migrate',
+                    'destination_node': 'dst1@back1#pool1',
+                    'resource_name': 'volume_1',
+                    'resource_id': '74454247-a064-4b34-8f43-89337987720e',
+                },
+            },
+            {
+                'action_type': 'volume_migrate',
+                'input_parameters': {
+                    'migration_type': 'migrate',
+                    'destination_node': 'dst1@back1#pool1',
+                    'resource_name': 'volume_2',
+                    'resource_id': 'a16c811e-2521-4fd3-8779-6a94ccb3be73',
+                },
+            },
         ]
         expected_vm_migrations = [
-            {'action_type': 'migrate',
-             'input_parameters':
-                {'migration_type': 'live',
-                 'source_node': 'src1',
-                 'destination_node': 'dst1',
-                 'resource_name': 'INSTANCE_3',
-                 'resource_id': 'd030ef1f-dc19-4982-9383-087498bfde03'}},
-            {'action_type': 'migrate',
-             'input_parameters':
-                {'migration_type': 'live',
-                 'source_node': 'src1',
-                 'destination_node': 'dst1',
-                 'resource_name': 'INSTANCE_1',
-                 'resource_id': 'd010ef1f-dc19-4982-9383-087498bfde03'}}
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'source_node': 'src1',
+                    'destination_node': 'dst1',
+                    'resource_name': 'INSTANCE_3',
+                    'resource_id': 'd030ef1f-dc19-4982-9383-087498bfde03',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'source_node': 'src1',
+                    'destination_node': 'dst1',
+                    'resource_name': 'INSTANCE_1',
+                    'resource_id': 'd010ef1f-dc19-4982-9383-087498bfde03',
+                },
+            },
+        ]
+        migrated_volumes = [
+            action
+            for action in solution.actions
+            if action['action_type'] == 'volume_migrate'
         ]
-        migrated_volumes = [action
-                            for action in solution.actions
-                            if action['action_type'] == 'volume_migrate']
         self.assertEqual(2, action_types.get("volume_migrate", 0))
         self.assertEqual(expected_vol_migrations, migrated_volumes)
-        migrated_vms = [action
-                        for action in solution.actions
-                        if action['action_type'] == 'migrate']
+        migrated_vms = [
+            action
+            for action in solution.actions
+            if action['action_type'] == 'migrate'
+        ]
         self.assertEqual(2, action_types.get("migrate", 0))
         self.assertEqual(expected_vm_migrations, migrated_vms)
 
@@ -1304,16 +1583,25 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertEqual(second_action['migration_type'], 'live')
 
         # All the detached volumes in the pool should be migrated
-        volume_mig_ind = [item['value'] for item in solution.global_efficacy
-                          if item['name'] == "volume_migrate_ratio"][0]
+        volume_mig_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "volume_migrate_ratio"
+        ][0]
         self.assertEqual(100, volume_mig_ind)
         # All the attached volumes in the pool should be swapped
-        volume_swap_ind = [item['value'] for item in solution.global_efficacy
-                           if item['name'] == "volume_update_ratio"][0]
+        volume_swap_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "volume_update_ratio"
+        ][0]
         self.assertEqual(100, volume_swap_ind)
         # All the instances in src1 should be migrated
-        live_ind = [item['value'] for item in solution.global_efficacy
-                    if item['name'] == "live_instance_migrate_ratio"][0]
+        live_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "live_instance_migrate_ratio"
+        ][0]
         self.assertEqual(100, live_ind)
 
     def test_execute_mixed_instances_volumes_with_attached_not_found(self):
@@ -1328,7 +1616,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1337,7 +1625,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src2",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2_2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1346,7 +1634,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1_3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1354,18 +1642,24 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.m_n_helper.get_instance_list.return_value = [
             instance_on_src1_1,
             instance_on_src2_2,
-            instance_on_src1_3
+            instance_on_src1_3,
         ]
 
-        volume_on_src1_1 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_1"],
-                                            name="volume_1")
-        volume_on_src1_2 = self.fake_volume(host="src1@back1#pool1",
-                                            id=volume_uuid_mapping["volume_2"],
-                                            name="volume_2")
-        volume_on_src2_1 = self.fake_volume(host="src2@back1#pool1",
-                                            id=volume_uuid_mapping["volume_3"],
-                                            name="volume_3")
+        volume_on_src1_1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src1_2 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+        )
+        volume_on_src2_1 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1_1,
             volume_on_src1_2,
@@ -1373,17 +1667,23 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         ]
 
         volume_on_src1_1.status = 'in-use'
-        volume_on_src1_1.attachments = [{
-            "server_id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "attachment_id": "attachment1"
-        }]
+        volume_on_src1_1.attachments = [
+            {
+                "server_id": "d010ef1f-dc19-4982-9383-087498bfde03",
+                "attachment_id": "attachment1",
+            }
+        ]
 
         self.input_parameters["compute_nodes"] = [
-            {"src_node": "src1", "dst_node": "dst1"},
+            {"src_node": "src1", "dst_node": "dst1"}
         ]
         self.input_parameters["storage_pools"] = [
-            {"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
-             "src_type": "type1", "dst_type": "type1"},
+            {
+                "src_pool": "src1@back1#pool1",
+                "dst_pool": "dst1@back1#pool1",
+                "src_type": "type1",
+                "dst_type": "type1",
+            }
         ]
         self.input_parameters["with_attached_volume"] = True
 
@@ -1395,46 +1695,62 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         solution = self.strategy.execute()
         # Check migrations
         action_types = collections.Counter(
-            [action['action_type']
-             for action in solution.actions])
+            [action['action_type'] for action in solution.actions]
+        )
         expected_vol_migrations = [
-            {'action_type': 'volume_migrate',
-             'input_parameters':
-                {'migration_type': 'migrate',
-                 'destination_node': 'dst1@back1#pool1',
-                 'resource_name': 'volume_1',
-                 'resource_id': '74454247-a064-4b34-8f43-89337987720e'}},
-            {'action_type': 'volume_migrate',
-             'input_parameters':
-                {'migration_type': 'migrate',
-                 'destination_node': 'dst1@back1#pool1',
-                 'resource_name': 'volume_2',
-                 'resource_id': 'a16c811e-2521-4fd3-8779-6a94ccb3be73'}}
+            {
+                'action_type': 'volume_migrate',
+                'input_parameters': {
+                    'migration_type': 'migrate',
+                    'destination_node': 'dst1@back1#pool1',
+                    'resource_name': 'volume_1',
+                    'resource_id': '74454247-a064-4b34-8f43-89337987720e',
+                },
+            },
+            {
+                'action_type': 'volume_migrate',
+                'input_parameters': {
+                    'migration_type': 'migrate',
+                    'destination_node': 'dst1@back1#pool1',
+                    'resource_name': 'volume_2',
+                    'resource_id': 'a16c811e-2521-4fd3-8779-6a94ccb3be73',
+                },
+            },
         ]
         expected_vm_migrations = [
-            {'action_type': 'migrate',
-             'input_parameters':
-                {'migration_type': 'live',
-                 'source_node': 'src1',
-                 'destination_node': 'dst1',
-                 'resource_name': 'INSTANCE_1',
-                 'resource_id': 'd010ef1f-dc19-4982-9383-087498bfde03'}},
-            {'action_type': 'migrate',
-             'input_parameters':
-                {'migration_type': 'live',
-                 'source_node': 'src1',
-                 'destination_node': 'dst1',
-                 'resource_name': 'INSTANCE_3',
-                 'resource_id': 'd030ef1f-dc19-4982-9383-087498bfde03'}}
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'source_node': 'src1',
+                    'destination_node': 'dst1',
+                    'resource_name': 'INSTANCE_1',
+                    'resource_id': 'd010ef1f-dc19-4982-9383-087498bfde03',
+                },
+            },
+            {
+                'action_type': 'migrate',
+                'input_parameters': {
+                    'migration_type': 'live',
+                    'source_node': 'src1',
+                    'destination_node': 'dst1',
+                    'resource_name': 'INSTANCE_3',
+                    'resource_id': 'd030ef1f-dc19-4982-9383-087498bfde03',
+                },
+            },
+        ]
+        migrated_volumes = [
+            action
+            for action in solution.actions
+            if action['action_type'] == 'volume_migrate'
         ]
-        migrated_volumes = [action
-                            for action in solution.actions
-                            if action['action_type'] == 'volume_migrate']
         self.assertEqual(2, action_types.get("volume_migrate", 0))
         self.assertEqual(expected_vol_migrations, migrated_volumes)
-        migrated_vms = [action
-                        for action in solution.actions
-                        if action['action_type'] == 'migrate']
+        migrated_vms = [
+            action
+            for action in solution.actions
+            if action['action_type'] == 'migrate'
+        ]
         self.assertEqual(2, action_types.get("migrate", 0))
         self.assertEqual(expected_vm_migrations, migrated_vms)
 
@@ -1445,30 +1761,38 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.assertEqual(second_action['migration_type'], 'live')
 
         # All the detached volumes in the pool should be migrated
-        volume_mig_ind = [item['value'] for item in solution.global_efficacy
-                          if item['name'] == "volume_migrate_ratio"][0]
+        volume_mig_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "volume_migrate_ratio"
+        ][0]
         self.assertEqual(100, volume_mig_ind)
         # All the attached volumes in the pool should be swapped
-        volume_swap_ind = [item['value'] for item in solution.global_efficacy
-                           if item['name'] == "volume_update_ratio"][0]
+        volume_swap_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "volume_update_ratio"
+        ][0]
         self.assertEqual(100, volume_swap_ind)
         # All the instances in src1 should be migrated
-        live_ind = [item['value'] for item in solution.global_efficacy
-                    if item['name'] == "live_instance_migrate_ratio"][0]
+        live_ind = [
+            item['value']
+            for item in solution.global_efficacy
+            if item['name'] == "live_instance_migrate_ratio"
+        ][0]
         self.assertEqual(100, live_ind)
 
     def test_instance_migration_exists(self):
-
         fake_actions = [
             {'action_type': 'migrate', 'resource_id': 'instance1'},
             {'action_type': 'some_other_action', 'resource_id': 'instance2'},
-            {'action_type': 'migrate', 'resource_id': 'instance3'}
+            {'action_type': 'migrate', 'resource_id': 'instance3'},
         ]
 
         for action in fake_actions:
             self.strategy.solution.add_action(
-                action['action_type'],
-                resource_id=action['resource_id'])
+                action['action_type'], resource_id=action['resource_id']
+            )
         self.assertTrue(self.strategy._instance_migration_exists('instance1'))
         self.assertTrue(self.strategy._instance_migration_exists('instance3'))
         self.assertFalse(self.strategy._instance_migration_exists('instance2'))
@@ -1484,15 +1808,21 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_node": ["compute1", "compute2"],
             "compute": ["cpu_num"],
             "storage_pool": ["pool1", "pool2"],
-            "storage": ["size"]
+            "storage": ["size"],
         }
         filters = self.strategy.get_priority_filter_list()
-        self.assertIn(strategies.zone_migration.ComputeHostSortFilter,
-                      map(lambda l: l.__class__, filters))  # noqa: E741
-        self.assertIn(strategies.zone_migration.StorageHostSortFilter,
-                      map(lambda l: l.__class__, filters))  # noqa: E741
-        self.assertIn(strategies.zone_migration.ProjectSortFilter,
-                      map(lambda l: l.__class__, filters))  # noqa: E741
+        self.assertIn(
+            strategies.zone_migration.ComputeHostSortFilter,
+            map(lambda l: l.__class__, filters),  # noqa: E741
+        )
+        self.assertIn(
+            strategies.zone_migration.StorageHostSortFilter,
+            map(lambda l: l.__class__, filters),  # noqa: E741
+        )
+        self.assertIn(
+            strategies.zone_migration.ProjectSortFilter,
+            map(lambda l: l.__class__, filters),  # noqa: E741
+        )
 
     # ComputeHostSortFilter #
 
@@ -1501,7 +1831,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src1",
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1510,7 +1840,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src2",
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1519,7 +1849,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "compute_host": "src3",
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1532,27 +1862,32 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_c_helper.get_volume_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "compute_node": ["src1", "src2"],
-        }
+        self.input_parameters["priority"] = {"compute_node": ["src1", "src2"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get('instance'),
-                         [instance_on_src1, instance_on_src2])
+        self.assertEqual(
+            targets.get('instance'), [instance_on_src1, instance_on_src2]
+        )
 
     # StorageHostSortFilter #
 
     def test_filtered_targets_storage_pools(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1")
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2")
-        volume_on_src3 = self.fake_volume(host="src3@back2#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back2#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
@@ -1562,12 +1897,13 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
         self.m_n_helper.get_instance_list.return_value = []
 
         self.input_parameters["priority"] = {
-            "storage_pool": ["src1@back1#pool1", "src2@back1#pool1"],
+            "storage_pool": ["src1@back1#pool1", "src2@back1#pool1"]
         }
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get("volume"),
-                         [volume_on_src1, volume_on_src2])
+        self.assertEqual(
+            targets.get("volume"), [volume_on_src1, volume_on_src2]
+        )
 
     # ProjectSortFilter #
 
@@ -1577,7 +1913,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
             "project_id": "pj2",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1587,7 +1923,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
             "project_id": "pj1",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1597,7 +1933,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
             "project_id": "pj3",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1610,19 +1946,25 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_c_helper.get_volume_list.return_value = []
 
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1",
-                                          project_id="pj2")
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          name="volume_2",
-                                          volume_type="type2",
-                                          project_id="pj1")
-        volume_on_src3 = self.fake_volume(host="src3@back2#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3",
-                                          project_id="pj3")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+            project_id="pj2",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            name="volume_2",
+            volume_type="type2",
+            project_id="pj1",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back2#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+            project_id="pj3",
+        )
 
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
@@ -1630,28 +1972,35 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             volume_on_src3,
         ]
 
-        self.input_parameters["priority"] = {
-            "project": ["pj1"],
-        }
+        self.input_parameters["priority"] = {"project": ["pj1"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get('instance'),
-                         [instance_on_src2, instance_on_src1])
-        self.assertEqual(targets.get('volume'),
-                         [volume_on_src2, volume_on_src1])
-        self.assertEqual(targets,
-                         {"instance": [instance_on_src2, instance_on_src1],
-                          "volume": [volume_on_src2, volume_on_src1]})
+        self.assertEqual(
+            targets.get('instance'), [instance_on_src2, instance_on_src1]
+        )
+        self.assertEqual(
+            targets.get('volume'), [volume_on_src2, volume_on_src1]
+        )
+        self.assertEqual(
+            targets,
+            {
+                "instance": [instance_on_src2, instance_on_src1],
+                "volume": [volume_on_src2, volume_on_src1],
+            },
+        )
 
     # ComputeSpecSortFilter #
 
     def test_filtered_targets_instance_mem_size(self):
         flavor_64 = self.create_openstacksdk_flavor(
-            id="1", ram="64", vcpus=1, disk=1)
+            id="1", ram="64", vcpus=1, disk=1
+        )
         flavor_128 = self.create_openstacksdk_flavor(
-            id="2", ram=128, vcpus=1, disk=1)
+            id="2", ram=128, vcpus=1, disk=1
+        )
         flavor_512 = self.create_openstacksdk_flavor(
-            id="3", ram=512, vcpus=1, disk=1)
+            id="3", ram=512, vcpus=1, disk=1
+        )
         self.m_n_helper.get_flavor_list.return_value = [
             flavor_64,
             flavor_128,
@@ -1663,7 +2012,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "1"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1673,7 +2022,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "2"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1683,7 +2032,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "3"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1696,21 +2045,23 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_c_helper.get_volume_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "compute": ["mem_size"],
-        }
+        self.input_parameters["priority"] = {"compute": ["mem_size"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get('instance'),
-                         [instance_on_src2, instance_on_src1])
+        self.assertEqual(
+            targets.get('instance'), [instance_on_src2, instance_on_src1]
+        )
 
     def test_filtered_targets_instance_vcpu_num(self):
         flavor_1 = self.create_openstacksdk_flavor(
-            id="1", ram=1, vcpus=1, disk=1)
+            id="1", ram=1, vcpus=1, disk=1
+        )
         flavor_2 = self.create_openstacksdk_flavor(
-            id="2", ram=1, vcpus=2, disk=1)
+            id="2", ram=1, vcpus=2, disk=1
+        )
         flavor_3 = self.create_openstacksdk_flavor(
-            id="3", ram=1, vcpus=3, disk=1)
+            id="3", ram=1, vcpus=3, disk=1
+        )
         self.m_n_helper.get_flavor_list.return_value = [
             flavor_1,
             flavor_2,
@@ -1722,7 +2073,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "1"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1732,7 +2083,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "2"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1742,7 +2093,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "3"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1755,21 +2106,23 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_c_helper.get_volume_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "compute": ["vcpu_num"],
-        }
+        self.input_parameters["priority"] = {"compute": ["vcpu_num"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get('instance'),
-                         [instance_on_src2, instance_on_src1])
+        self.assertEqual(
+            targets.get('instance'), [instance_on_src2, instance_on_src1]
+        )
 
     def test_filtered_targets_instance_disk_size(self):
         flavor_1 = self.create_openstacksdk_flavor(
-            id="1", ram=1, vcpus=1, disk=1)
+            id="1", ram=1, vcpus=1, disk=1
+        )
         flavor_2 = self.create_openstacksdk_flavor(
-            id="2", ram=1, vcpus=1, disk=2)
+            id="2", ram=1, vcpus=1, disk=2
+        )
         flavor_3 = self.create_openstacksdk_flavor(
-            id="3", ram=1, vcpus=1, disk=3)
+            id="3", ram=1, vcpus=1, disk=3
+        )
         self.m_n_helper.get_flavor_list.return_value = [
             flavor_1,
             flavor_2,
@@ -1781,7 +2134,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "1"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1791,7 +2144,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "2"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1801,7 +2154,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
             "flavor": {"id": "3"},
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1814,13 +2167,12 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_c_helper.get_volume_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "compute": ["disk_size"],
-        }
+        self.input_parameters["priority"] = {"compute": ["disk_size"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get('instance'),
-                         [instance_on_src2, instance_on_src1])
+        self.assertEqual(
+            targets.get('instance'), [instance_on_src2, instance_on_src1]
+        )
 
     def test_filtered_targets_instance_created_at(self):
         server_info = {
@@ -1828,7 +2180,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_1",
             "id": "d010ef1f-dc19-4982-9383-087498bfde03",
             "created_at": "2017-10-30T00:00:00",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src1 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1838,7 +2190,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_2",
             "id": "d020ef1f-dc19-4982-9383-087498bfde03",
             "created_at": "1977-03-29T03:03:03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src2 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1848,7 +2200,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             "name": "INSTANCE_3",
             "id": "d030ef1f-dc19-4982-9383-087498bfde03",
             "created_at": "1977-03-29T03:03:03",
-            "vm_state": "active"
+            "vm_state": "active",
         }
         instance_on_src3 = nova_helper.Server.from_openstacksdk(
             self.create_openstacksdk_server(**server_info)
@@ -1861,13 +2213,12 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_c_helper.get_volume_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "compute": ["created_at"],
-        }
+        self.input_parameters["priority"] = {"compute": ["created_at"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get('instance'),
-                         [instance_on_src2, instance_on_src1])
+        self.assertEqual(
+            targets.get('instance'), [instance_on_src2, instance_on_src1]
+        )
 
     # StorageSpecSortFilter #
 
@@ -1876,18 +2227,21 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             host="src1@back1#pool1",
             size="1",
             id=volume_uuid_mapping["volume_1"],
-            name="volume_1")
+            name="volume_1",
+        )
         volume_on_src2 = self.fake_volume(
             host="src2@back1#pool1",
             size="2",
             id=volume_uuid_mapping["volume_2"],
             volume_type="type2",
-            name="volume_2")
+            name="volume_2",
+        )
         volume_on_src3 = self.fake_volume(
             host="src3@back2#pool1",
             size="3",
             id=volume_uuid_mapping["volume_3"],
-            name="volume_3")
+            name="volume_3",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
@@ -1896,28 +2250,33 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_n_helper.get_instance_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "storage": ["size"]
-        }
+        self.input_parameters["priority"] = {"storage": ["size"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get("volume"),
-                         [volume_on_src2, volume_on_src1])
+        self.assertEqual(
+            targets.get("volume"), [volume_on_src2, volume_on_src1]
+        )
 
     def test_filtered_targets_storage_created_at(self):
-        volume_on_src1 = self.fake_volume(host="src1@back1#pool1",
-                                          id=volume_uuid_mapping["volume_1"],
-                                          name="volume_1",
-                                          created_at="2017-10-30T00:00:00")
-        volume_on_src2 = self.fake_volume(host="src2@back1#pool1",
-                                          id=volume_uuid_mapping["volume_2"],
-                                          volume_type="type2",
-                                          name="volume_2",
-                                          created_at="1977-03-29T03:03:03")
-        volume_on_src3 = self.fake_volume(host="src3@back2#pool1",
-                                          id=volume_uuid_mapping["volume_3"],
-                                          name="volume_3",
-                                          created_at="1977-03-29T03:03:03")
+        volume_on_src1 = self.fake_volume(
+            host="src1@back1#pool1",
+            id=volume_uuid_mapping["volume_1"],
+            name="volume_1",
+            created_at="2017-10-30T00:00:00",
+        )
+        volume_on_src2 = self.fake_volume(
+            host="src2@back1#pool1",
+            id=volume_uuid_mapping["volume_2"],
+            volume_type="type2",
+            name="volume_2",
+            created_at="1977-03-29T03:03:03",
+        )
+        volume_on_src3 = self.fake_volume(
+            host="src3@back2#pool1",
+            id=volume_uuid_mapping["volume_3"],
+            name="volume_3",
+            created_at="1977-03-29T03:03:03",
+        )
         self.m_c_helper.get_volume_list.return_value = [
             volume_on_src1,
             volume_on_src2,
@@ -1926,13 +2285,12 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
 
         self.m_n_helper.get_instance_list.return_value = []
 
-        self.input_parameters["priority"] = {
-            "storage": ["created_at"]
-        }
+        self.input_parameters["priority"] = {"storage": ["created_at"]}
 
         targets = self.strategy.filtered_targets()
-        self.assertEqual(targets.get("volume"),
-                         [volume_on_src2, volume_on_src1])
+        self.assertEqual(
+            targets.get("volume"), [volume_on_src2, volume_on_src1]
+        )
 
     def test_get_dst_pool_and_type_matching_src_pool_type(self):
         self.input_parameters["storage_pools"] = [
@@ -1943,8 +2301,9 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             },
             {
                 "src_pool": "src1@back1#pool1",
-                "src_type": "type2", "dst_type": "type3"
-            }
+                "src_type": "type2",
+                "dst_type": "type3",
+            },
         ]
         pool = "src1@back1#pool1"
         src_type = "type1"
@@ -1961,10 +2320,7 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
                 "src_type": "type1",
                 "dst_pool": "dst1@back1#pool1",
             },
-            {
-                "src_pool": "src1@back1#pool1",
-                "dst_pool": "dst2@back2#pool2"
-            }
+            {"src_pool": "src1@back1#pool1", "dst_pool": "dst2@back2#pool2"},
         ]
         pool = "src1@back1#pool1"
         src_type = "type1"
@@ -2002,8 +2358,9 @@ class TestZoneMigration(test_utils.NovaResourcesMixin, TestBaseStrategy):
             },
             {
                 "src_pool": "src1@back1#pool1",
-                "src_type": "type2", "dst_type": "type3"
-            }
+                "src_type": "type2",
+                "dst_type": "type3",
+            },
         ]
         pool = "src1@back1#pool1"
         src_type = "type2"
diff --git a/watcher/tests/unit/decision_engine/test_gmr.py b/watcher/tests/unit/decision_engine/test_gmr.py
index 93ab8d392..b2f12ec03 100644
--- a/watcher/tests/unit/decision_engine/test_gmr.py
+++ b/watcher/tests/unit/decision_engine/test_gmr.py
@@ -23,13 +23,14 @@ from watcher.tests.unit import base
 
 
 class TestGmrPlugin(base.TestCase):
-
     @mock.patch.object(manager.CollectorManager, "get_collectors")
     def test_show_models(self, m_get_collectors):
         m_to_string = mock.Mock(return_value="<TESTMODEL />")
         m_get_collectors.return_value = {
             "test_model": mock.Mock(
-                cluster_data_model=mock.Mock(to_string=m_to_string))}
+                cluster_data_model=mock.Mock(to_string=m_to_string)
+            )
+        }
         output = gmr.show_models()
         self.assertEqual(1, m_to_string.call_count)
         self.assertIn("<TESTMODEL />", output)
diff --git a/watcher/tests/unit/decision_engine/test_rpcapi.py b/watcher/tests/unit/decision_engine/test_rpcapi.py
index 159d8537e..d6a736d61 100644
--- a/watcher/tests/unit/decision_engine/test_rpcapi.py
+++ b/watcher/tests/unit/decision_engine/test_rpcapi.py
@@ -24,7 +24,6 @@ from watcher.tests.unit import base
 
 
 class TestDecisionEngineAPI(base.TestCase):
-
     api = rpcapi.DecisionEngineAPI()
 
     def test_get_api_version(self):
@@ -32,35 +31,40 @@ class TestDecisionEngineAPI(base.TestCase):
             expected_context = self.context
             self.api.check_api_version(expected_context)
             mock_call.assert_called_once_with(
-                expected_context, 'check_api_version',
-                api_version=rpcapi.DecisionEngineAPI().api_version)
+                expected_context,
+                'check_api_version',
+                api_version=rpcapi.DecisionEngineAPI().api_version,
+            )
 
     def test_execute_audit_throw_exception(self):
         audit_uuid = "uuid"
-        self.assertRaises(exception.InvalidUuidOrName,
-                          self.api.trigger_audit,
-                          audit_uuid)
+        self.assertRaises(
+            exception.InvalidUuidOrName, self.api.trigger_audit, audit_uuid
+        )
 
     def test_execute_audit_without_error(self):
         with mock.patch.object(om.RPCClient, 'cast') as mock_cast:
             audit_uuid = utils.generate_uuid()
             self.api.trigger_audit(self.context, audit_uuid)
             mock_cast.assert_called_once_with(
-                self.context, 'trigger_audit', audit_uuid=audit_uuid)
+                self.context, 'trigger_audit', audit_uuid=audit_uuid
+            )
 
     def test_get_strategy_info(self):
         with mock.patch.object(om.RPCClient, 'call') as mock_call:
             self.api.get_strategy_info(self.context, "dummy")
             mock_call.assert_called_once_with(
-                self.context, 'get_strategy_info', strategy_name="dummy")
+                self.context, 'get_strategy_info', strategy_name="dummy"
+            )
 
     def test_get_data_model_info(self):
         with mock.patch.object(om.RPCClient, 'call') as mock_call:
             self.api.get_data_model_info(
-                self.context,
-                data_model_type='compute',
-                audit=None)
+                self.context, data_model_type='compute', audit=None
+            )
             mock_call.assert_called_once_with(
-                self.context, 'get_data_model_info',
+                self.context,
+                'get_data_model_info',
                 data_model_type='compute',
-                audit=None)
+                audit=None,
+            )
diff --git a/watcher/tests/unit/decision_engine/test_scheduling.py b/watcher/tests/unit/decision_engine/test_scheduling.py
index bd7e9de92..a9b181fc6 100644
--- a/watcher/tests/unit/decision_engine/test_scheduling.py
+++ b/watcher/tests/unit/decision_engine/test_scheduling.py
@@ -35,21 +35,25 @@ from watcher.tests.unit.objects import utils as obj_utils
 
 
 class TestCancelOngoingAudits(db_base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_audit_notifications = mock.patch.object(
-            notifications, 'audit', autospec=True)
+            notifications, 'audit', autospec=True
+        )
         self.m_audit_notifications = p_audit_notifications.start()
         self.addCleanup(p_audit_notifications.stop)
 
         self.goal = obj_utils.create_test_goal(
-            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name())
+            self.context, id=1, name=dummy_strategy.DummyStrategy.get_name()
+        )
         self.strategy = obj_utils.create_test_strategy(
-            self.context, name=dummy_strategy.DummyStrategy.get_name(),
-            goal_id=self.goal.id)
+            self.context,
+            name=dummy_strategy.DummyStrategy.get_name(),
+            goal_id=self.goal.id,
+        )
         audit_template = obj_utils.create_test_audit_template(
-            self.context, strategy_id=self.strategy.id)
+            self.context, strategy_id=self.strategy.id
+        )
         self.audit = obj_utils.create_test_audit(
             self.context,
             id=999,
@@ -60,7 +64,8 @@ class TestCancelOngoingAudits(db_base.DbTestCase):
             audit_type=objects.audit.AuditType.ONESHOT.value,
             goal=self.goal,
             hostname='hostname1',
-            state=objects.audit.State.ONGOING)
+            state=objects.audit.State.ONGOING,
+        )
         cfg.CONF.set_override("host", "hostname1")
 
     @mock.patch.object(objects.audit.Audit, 'save')
@@ -78,22 +83,24 @@ class TestCancelOngoingAudits(db_base.DbTestCase):
 @mock.patch.object(objects.audit.Audit, 'save')
 @mock.patch.object(objects.audit.Audit, 'list')
 class TestDecisionEngineSchedulingService(base.TestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_keystone = self.useFixture(watcher_fixtures.KeystoneClient())
 
+    @mock.patch.object(default_loading.ClusterDataModelCollectorLoader, 'load')
     @mock.patch.object(
-        default_loading.ClusterDataModelCollectorLoader, 'load')
-    @mock.patch.object(
-        default_loading.ClusterDataModelCollectorLoader, 'list_available')
+        default_loading.ClusterDataModelCollectorLoader, 'list_available'
+    )
     @mock.patch.object(background.BackgroundScheduler, 'start')
-    def test_start_de_scheduling_service(self, m_start, m_list_available,
-                                         m_load, m_list, m_save):
+    def test_start_de_scheduling_service(
+        self, m_start, m_list_available, m_load, m_list, m_save
+    ):
         m_list_available.return_value = {
-            'fake': faker_cluster_state.FakerModelCollector}
+            'fake': faker_cluster_state.FakerModelCollector
+        }
         fake_collector = faker_cluster_state.FakerModelCollector(
-            config=mock.Mock(period=777))
+            config=mock.Mock(period=777)
+        )
         m_load.return_value = fake_collector
 
         scheduler = scheduling.DecisionEngineSchedulingService()
diff --git a/watcher/tests/unit/decision_engine/test_service.py b/watcher/tests/unit/decision_engine/test_service.py
index 2428b0f3f..834482bc1 100644
--- a/watcher/tests/unit/decision_engine/test_service.py
+++ b/watcher/tests/unit/decision_engine/test_service.py
@@ -22,28 +22,38 @@ from watcher.decision_engine.audit import continuous as c_handler
 from watcher.tests.unit import base
 
 
-@mock.patch.object(service_monitor.DecisionEngineMonitor, '__init__',
-                   return_value=None)
-@mock.patch.object(scheduling.DecisionEngineSchedulingService, '__init__',
-                   return_value=None)
+@mock.patch.object(
+    service_monitor.DecisionEngineMonitor, '__init__', return_value=None
+)
+@mock.patch.object(
+    scheduling.DecisionEngineSchedulingService, '__init__', return_value=None
+)
 @mock.patch.object(watcher_service.Service, '__init__', return_value=None)
 class TestDecisionEngineService(base.TestCase):
-
     @mock.patch.object(service_monitor.DecisionEngineMonitor, 'start')
     @mock.patch.object(c_handler.ContinuousAuditHandler, 'start')
     @mock.patch.object(scheduling.DecisionEngineSchedulingService, 'start')
     @mock.patch.object(watcher_service.Service, 'start')
-    def test_decision_engine_service_start(self, svc_start, sch_start,
-                                           cont_audit_start, svc_mon_start,
-                                           svc_init, sch_init, svc_mon_init):
+    def test_decision_engine_service_start(
+        self,
+        svc_start,
+        sch_start,
+        cont_audit_start,
+        svc_mon_start,
+        svc_init,
+        sch_init,
+        svc_mon_init,
+    ):
         de_service = service.DecisionEngineService()
         de_service.start()
         # Creates an DecisionEngineSchedulingService instance
-        self.assertIsInstance(de_service.bg_scheduler,
-                              scheduling.DecisionEngineSchedulingService)
+        self.assertIsInstance(
+            de_service.bg_scheduler, scheduling.DecisionEngineSchedulingService
+        )
         # Creates a DecisionEngineMonitor instance
-        self.assertIsInstance(de_service.service_monitor,
-                              service_monitor.DecisionEngineMonitor)
+        self.assertIsInstance(
+            de_service.service_monitor, service_monitor.DecisionEngineMonitor
+        )
 
         svc_start.assert_called()
         sch_start.assert_called()
@@ -53,9 +63,15 @@ class TestDecisionEngineService(base.TestCase):
     @mock.patch.object(service_monitor.DecisionEngineMonitor, 'stop')
     @mock.patch.object(scheduling.DecisionEngineSchedulingService, 'stop')
     @mock.patch.object(watcher_service.Service, 'stop')
-    def test_decision_engine_service_stop(self, svc_stop, sch_stop,
-                                          svc_mon_stop, svc_init, sch_init,
-                                          svc_mon_init):
+    def test_decision_engine_service_stop(
+        self,
+        svc_stop,
+        sch_stop,
+        svc_mon_stop,
+        svc_init,
+        sch_init,
+        svc_mon_init,
+    ):
         de_service = service.DecisionEngineService()
         de_service.stop()
 
@@ -66,9 +82,15 @@ class TestDecisionEngineService(base.TestCase):
     @mock.patch.object(service_monitor.DecisionEngineMonitor, 'wait')
     @mock.patch.object(scheduling.DecisionEngineSchedulingService, 'wait')
     @mock.patch.object(watcher_service.Service, 'wait')
-    def test_decision_engine_service_wait(self, svc_wait, sch_wait,
-                                          svc_mon_wait, svc_init, sch_init,
-                                          svc_mon_init):
+    def test_decision_engine_service_wait(
+        self,
+        svc_wait,
+        sch_wait,
+        svc_mon_wait,
+        svc_init,
+        sch_init,
+        svc_mon_init,
+    ):
         de_service = service.DecisionEngineService()
         de_service.wait()
 
@@ -79,9 +101,15 @@ class TestDecisionEngineService(base.TestCase):
     @mock.patch.object(service_monitor.DecisionEngineMonitor, 'reset')
     @mock.patch.object(scheduling.DecisionEngineSchedulingService, 'reset')
     @mock.patch.object(watcher_service.Service, 'reset')
-    def test_decision_engine_service_reset(self, svc_reset, sch_reset,
-                                           svc_mon_reset, svc_init, sch_init,
-                                           svc_mon_init):
+    def test_decision_engine_service_reset(
+        self,
+        svc_reset,
+        sch_reset,
+        svc_mon_reset,
+        svc_init,
+        sch_init,
+        svc_mon_init,
+    ):
         de_service = service.DecisionEngineService()
         de_service.reset()
 
diff --git a/watcher/tests/unit/decision_engine/test_service_monitor.py b/watcher/tests/unit/decision_engine/test_service_monitor.py
index e719d8c3a..5280da65c 100644
--- a/watcher/tests/unit/decision_engine/test_service_monitor.py
+++ b/watcher/tests/unit/decision_engine/test_service_monitor.py
@@ -32,7 +32,6 @@ from watcher.tests.unit.db import utils
 
 
 class TestDecisionEngineMonitor(base.TestCase):
-
     @mock.patch.object(background.BackgroundScheduler, 'start')
     def test_start_service_monitoring_service(self, m_start):
         scheduler = service_monitor.DecisionEngineMonitor()
@@ -59,39 +58,41 @@ class TestDecisionEngineMonitor(base.TestCase):
 
 
 class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
-
     def setUp(self):
         super().setUp()
-        fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow())
+        fake_service = utils.get_test_service(created_at=timeutils.utcnow())
         self.fake_service = objects.Service(**fake_service)
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(service, 'send_service_update')
     @mock.patch.object(objects.Audit, 'list')
-    def test_monitor_not_send_notification_on_active(self, m_audit_list,
-                                                     m_send_notif,
-                                                     m_service_list,
-                                                     m_get_service_status):
+    def test_monitor_not_send_notification_on_active(
+        self, m_audit_list, m_send_notif, m_service_list, m_get_service_status
+    ):
         # Create two decision-engine services
         fake_de_service1 = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         fake_de_service2 = utils.get_test_service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         fake_de_service_obj1 = objects.Service(**fake_de_service1)
         fake_de_service_obj2 = objects.Service(**fake_de_service2)
 
         m_service_list.return_value = [
-            fake_de_service_obj1, fake_de_service_obj2]
+            fake_de_service_obj1,
+            fake_de_service_obj2,
+        ]
 
         # First call: both ACTIVE in first and second call
         m_get_service_status.side_effect = [
             objects.service.ServiceStatus.ACTIVE,  # service1 first call
             objects.service.ServiceStatus.ACTIVE,  # service2 first call
             objects.service.ServiceStatus.ACTIVE,  # service1 second call
-            objects.service.ServiceStatus.ACTIVE   # service2 second call
+            objects.service.ServiceStatus.ACTIVE,  # service2 second call
         ]
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -100,37 +101,48 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         with mock.patch.object(service_monitor.CONF, 'host', 'host2'):
             # First call: both ACTIVE
             monitor.monitor_services_status(self.context)
-            self.assertEqual(monitor.services_status, {
-                fake_de_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-                fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-            })
+            self.assertEqual(
+                monitor.services_status,
+                {
+                    fake_de_service_obj1.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                    fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                },
+            )
             # Second call: both ACTIVE
             monitor.monitor_services_status(self.context)
-            self.assertEqual(monitor.services_status, {
-                fake_de_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-                fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-            })
+            self.assertEqual(
+                monitor.services_status,
+                {
+                    fake_de_service_obj1.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                    fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                },
+            )
 
         m_send_notif.assert_not_called()
         m_audit_list.assert_not_called()
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(service, 'send_service_update')
-    def test_monitor_send_notification_on_failure(self, m_send_notif,
-                                                  m_service_list,
-                                                  m_get_service_status):
+    def test_monitor_send_notification_on_failure(
+        self, m_send_notif, m_service_list, m_get_service_status
+    ):
         # Create two decision-engine services
         fake_de_service1 = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         fake_de_service2 = utils.get_test_service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         fake_de_service_obj1 = objects.Service(**fake_de_service1)
         fake_de_service_obj2 = objects.Service(**fake_de_service2)
 
         m_service_list.return_value = [
-            fake_de_service_obj1, fake_de_service_obj2]
+            fake_de_service_obj1,
+            fake_de_service_obj2,
+        ]
 
         # First call: both ACTIVE
         # Second call: service1 FAILED, service2 ACTIVE
@@ -138,7 +150,7 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             objects.service.ServiceStatus.ACTIVE,  # service1 first call
             objects.service.ServiceStatus.ACTIVE,  # service2 first call
             objects.service.ServiceStatus.FAILED,  # service1 second call
-            objects.service.ServiceStatus.ACTIVE   # service2 second call
+            objects.service.ServiceStatus.ACTIVE,  # service2 second call
         ]
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -148,39 +160,49 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         with mock.patch.object(service_monitor.CONF, 'host', 'host2'):
             # First call: both ACTIVE
             monitor.monitor_services_status(self.context)
-            self.assertEqual(monitor.services_status, {
-                fake_de_service_obj1.id: objects.service.ServiceStatus.ACTIVE,
-                fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-            })
+            self.assertEqual(
+                monitor.services_status,
+                {
+                    fake_de_service_obj1.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                    fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                },
+            )
             # Second call: service1 FAILED, service2 ACTIVE
             monitor.monitor_services_status(self.context)
-            self.assertEqual(monitor.services_status, {
-                fake_de_service_obj1.id: objects.service.ServiceStatus.FAILED,
-                fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE
-            })
+            self.assertEqual(
+                monitor.services_status,
+                {
+                    fake_de_service_obj1.id: objects.service.ServiceStatus.FAILED,  # noqa: E501
+                    fake_de_service_obj2.id: objects.service.ServiceStatus.ACTIVE,  # noqa: E501
+                },
+            )
 
         m_send_notif.assert_called_once_with(
-            self.context, fake_de_service_obj1,
-            state=objects.service.ServiceStatus.FAILED)
+            self.context,
+            fake_de_service_obj1,
+            state=objects.service.ServiceStatus.FAILED,
+        )
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(objects.Audit, 'list')
     @mock.patch.object(service, 'send_service_update')
     def test_monitor_migrate_audits_when_decision_engine_fails(
-            self, m_send_notif, m_audit_list, m_service_list,
-            m_get_service_status):
-
+        self, m_send_notif, m_audit_list, m_service_list, m_get_service_status
+    ):
         # Create test services
         failed_de_service = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         active_de_service = utils.get_test_service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
 
         m_service_list.return_value = [
             objects.Service(**failed_de_service),
-            objects.Service(**active_de_service)
+            objects.Service(**active_de_service),
         ]
 
         # First call: both ACTIVE
@@ -189,7 +211,7 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             objects.service.ServiceStatus.ACTIVE,  # service1 first call
             objects.service.ServiceStatus.ACTIVE,  # service2 first call
             objects.service.ServiceStatus.FAILED,  # service1 second call
-            objects.service.ServiceStatus.ACTIVE   # service2 second call
+            objects.service.ServiceStatus.ACTIVE,  # service2 second call
         ]
 
         # Create test continuous audit on the failed host
@@ -197,7 +219,7 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             id=1,
             audit_type=objects.audit.AuditType.CONTINUOUS.value,
             state=objects.audit.State.ONGOING,
-            hostname='host1'
+            hostname='host1',
         )
         audit_obj = objects.Audit(self.context, **fake_audit)
         m_audit_list.return_value = [audit_obj]
@@ -208,43 +230,58 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         with mock.patch.object(service_monitor.CONF, 'host', 'host2'):
             # First call: both ACTIVE
             monitor.monitor_services_status(self.context)
-            self.assertEqual(monitor.services_status, {
-                failed_de_service['id']: objects.service.ServiceStatus.ACTIVE,
-                active_de_service['id']: objects.service.ServiceStatus.ACTIVE
-            })
+            self.assertEqual(
+                monitor.services_status,
+                {
+                    failed_de_service[
+                        'id'
+                    ]: objects.service.ServiceStatus.ACTIVE,
+                    active_de_service[
+                        'id'
+                    ]: objects.service.ServiceStatus.ACTIVE,
+                },
+            )
             # Mock the audit.save() method
             with mock.patch.object(audit_obj, 'save') as m_save:
                 # Second call: service1 FAILED, service2 ACTIVE
                 monitor.monitor_services_status(self.context)
 
-            self.assertEqual(monitor.services_status, {
-                failed_de_service['id']: objects.service.ServiceStatus.FAILED,
-                active_de_service['id']: objects.service.ServiceStatus.ACTIVE
-            })
+            self.assertEqual(
+                monitor.services_status,
+                {
+                    failed_de_service[
+                        'id'
+                    ]: objects.service.ServiceStatus.FAILED,
+                    active_de_service[
+                        'id'
+                    ]: objects.service.ServiceStatus.ACTIVE,
+                },
+            )
 
         # Verify audit was migrated to the active SERVICE
         m_save.assert_called_once_with()
         self.assertEqual(active_de_service['host'], audit_obj.hostname)
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(objects.Audit, 'list')
     @mock.patch.object(service, 'send_service_update')
     def test_monitor_no_migration_when_no_active_services(
-            self, m_send_notif, m_audit_list, m_service_list,
-            m_get_service_status):
-
+        self, m_send_notif, m_audit_list, m_service_list, m_get_service_status
+    ):
         # Create test service that fails
         failed_de_service = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
 
         m_service_list.return_value = [objects.Service(**failed_de_service)]
 
         # First call returns ACTIVE, second call returns FAILED
         m_get_service_status.side_effect = [
             objects.service.ServiceStatus.ACTIVE,
-            objects.service.ServiceStatus.FAILED
+            objects.service.ServiceStatus.FAILED,
         ]
 
         # Create test continuous audit
@@ -252,7 +289,7 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             id=1,
             audit_type=objects.audit.AuditType.CONTINUOUS.value,
             state=objects.audit.State.ONGOING,
-            hostname='host1'
+            hostname='host1',
         )
         audit_obj = objects.Audit(self.context, **fake_audit)
         m_audit_list.return_value = [audit_obj]
@@ -273,29 +310,35 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
                 m_save.assert_not_called()
                 self.assertEqual('host1', audit_obj.hostname)
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(service, 'send_service_update')
     @mock.patch.object(objects.Audit, 'list')
-    def test_nonleader_not_send_notification_on_failure(self, m_audit_list,
-                                                        m_send_notif,
-                                                        m_service_list,
-                                                        m_get_service_status):
+    def test_nonleader_not_send_notification_on_failure(
+        self, m_audit_list, m_send_notif, m_service_list, m_get_service_status
+    ):
         # Create three decision-engine services
         fake_de_service1 = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         fake_de_service2 = utils.get_test_service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         fake_de_service3 = utils.get_test_service(
-            id=3, name='watcher-decision-engine', host='host3')
+            id=3, name='watcher-decision-engine', host='host3'
+        )
 
         fake_de_service_obj1 = objects.Service(**fake_de_service1)
         fake_de_service_obj2 = objects.Service(**fake_de_service2)
         fake_de_service_obj3 = objects.Service(**fake_de_service3)
 
         m_service_list.return_value = [
-            fake_de_service_obj1, fake_de_service_obj2, fake_de_service_obj3]
+            fake_de_service_obj1,
+            fake_de_service_obj2,
+            fake_de_service_obj3,
+        ]
 
         # First call: all ACTIVE
         # Second call: service1 FAILED, service2 ACTIVE, service3 ACTIVE
@@ -304,8 +347,8 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             objects.service.ServiceStatus.ACTIVE,  # service2 first call
             objects.service.ServiceStatus.ACTIVE,  # service3 first call
             objects.service.ServiceStatus.FAILED,  # service1 second call
-            objects.service.ServiceStatus.ACTIVE,   # service2 second call
-            objects.service.ServiceStatus.ACTIVE   # service3 second call
+            objects.service.ServiceStatus.ACTIVE,  # service2 second call
+            objects.service.ServiceStatus.ACTIVE,  # service3 second call
         ]
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -321,27 +364,30 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         m_send_notif.assert_not_called()
         m_audit_list.assert_not_called()
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     @mock.patch.object(objects.Audit, 'list')
     @mock.patch.object(service, 'send_service_update')
     def test_nonleader_monitor_not_migrate_audits_when_decision_engine_fails(
-            self, m_send_notif, m_audit_list, m_service_list,
-            m_get_service_status):
-
+        self, m_send_notif, m_audit_list, m_service_list, m_get_service_status
+    ):
         # Create test services
         failed_de_service = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         active_de_service2 = utils.get_test_service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         active_de_service3 = utils.get_test_service(
-            id=3, name='watcher-decision-engine', host='host3')
+            id=3, name='watcher-decision-engine', host='host3'
+        )
 
         m_service_list.return_value = [
             objects.Service(**failed_de_service),
             objects.Service(**active_de_service2),
-            objects.Service(**active_de_service3)
+            objects.Service(**active_de_service3),
         ]
 
         # First call: all ACTIVE
@@ -352,7 +398,7 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             objects.service.ServiceStatus.ACTIVE,  # service3 first call
             objects.service.ServiceStatus.FAILED,  # service1 second call
             objects.service.ServiceStatus.ACTIVE,  # service2 second call
-            objects.service.ServiceStatus.ACTIVE   # service3 second call
+            objects.service.ServiceStatus.ACTIVE,  # service3 second call
         ]
 
         # Create test continuous audit on the failed host
@@ -360,7 +406,7 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
             id=1,
             audit_type=objects.audit.AuditType.CONTINUOUS.value,
             state=objects.audit.State.ONGOING,
-            hostname='host1'
+            hostname='host1',
         )
         audit_obj = objects.Audit(self.context, **fake_audit)
         m_audit_list.return_value = [audit_obj]
@@ -383,14 +429,13 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
     @freezegun.freeze_time("2016-10-18T09:52:05.219414")
     def test_get_service_status_up(self):
         fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow(),
-            last_seen_up=timeutils.utcnow())
+            created_at=timeutils.utcnow(), last_seen_up=timeutils.utcnow()
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.DecisionEngineMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.ACTIVE, status)
 
@@ -398,14 +443,13 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
     def test_get_service_status_down(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            last_seen_up=past)
+            created_at=past, last_seen_up=past
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.DecisionEngineMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -413,15 +457,13 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
     def test_get_service_status_down_last_seen_up_none(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            updated_at=past,
-            last_seen_up=None)
+            created_at=past, updated_at=past, last_seen_up=None
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.DecisionEngineMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -429,15 +471,13 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
     def test_get_service_status_down_updated_at_none(self):
         past = timeutils.utcnow() - datetime.timedelta(seconds=120)
         fake_service = utils.get_test_service(
-            created_at=past,
-            updated_at=None,
-            last_seen_up=None)
+            created_at=past, updated_at=None, last_seen_up=None
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.DecisionEngineMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.FAILED, status)
 
@@ -446,13 +486,13 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         """Test that string timestamps are properly converted."""
         fake_service = utils.get_test_service(
             created_at=timeutils.utcnow(),
-            last_seen_up="2016-10-18T09:52:05.219414")
+            last_seen_up="2016-10-18T09:52:05.219414",
+        )
         test_service = objects.Service(self.context, **fake_service)
         test_service.create()
 
         monitor = service_monitor.DecisionEngineMonitor()
-        status = monitor.get_service_status(self.context,
-                                            test_service.id)
+        status = monitor.get_service_status(self.context, test_service.id)
 
         self.assertEqual(objects.service.ServiceStatus.ACTIVE, status)
 
@@ -466,48 +506,55 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         # Add a service status
         monitor.services_status[1] = objects.service.ServiceStatus.ACTIVE
         self.assertEqual(
-            {1: objects.service.ServiceStatus.ACTIVE},
-            monitor.services_status
+            {1: objects.service.ServiceStatus.ACTIVE}, monitor.services_status
         )
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     def test_get_services_status_without_services_in_list(
-            self, mock_get_list, mock_service_status):
+        self, mock_get_list, mock_service_status
+    ):
         scheduler = service_monitor.DecisionEngineMonitor()
         mock_get_list.return_value = []
         services_status = scheduler.get_services_status(mock.ANY)
         self.assertEqual([], services_status)
         mock_service_status.assert_not_called()
 
-    @mock.patch.object(service_monitor.DecisionEngineMonitor,
-                       'get_service_status')
+    @mock.patch.object(
+        service_monitor.DecisionEngineMonitor, 'get_service_status'
+    )
     @mock.patch.object(objects.Service, 'list')
     def test_get_services_status_with_services_in_list(
-            self, m_service_list, m_get_service_status):
+        self, m_service_list, m_get_service_status
+    ):
         """get_services_status returns only the decision-engine services."""
         # Create various services
         de_service1 = utils.get_test_service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         de_service2 = utils.get_test_service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         api_service = utils.get_test_service(
-            id=3, name='watcher-api', host='host3')
+            id=3, name='watcher-api', host='host3'
+        )
         applier_service = utils.get_test_service(
-            id=4, name='watcher-applier', host='host4')
+            id=4, name='watcher-applier', host='host4'
+        )
 
         m_service_list.return_value = [
             objects.Service(**de_service1),
             objects.Service(**de_service2),
             objects.Service(**api_service),
-            objects.Service(**applier_service)
+            objects.Service(**applier_service),
         ]
         m_get_service_status.side_effect = [
             objects.service.ServiceStatus.ACTIVE,
             objects.service.ServiceStatus.FAILED,
             objects.service.ServiceStatus.ACTIVE,
-            objects.service.ServiceStatus.ACTIVE
+            objects.service.ServiceStatus.ACTIVE,
         ]
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -520,11 +567,13 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
                 case 'host1':
                     self.assertEqual('watcher-decision-engine', wservice.name)
                     self.assertEqual(
-                        objects.service.ServiceStatus.ACTIVE, wservice.state)
+                        objects.service.ServiceStatus.ACTIVE, wservice.state
+                    )
                 case 'host2':
                     self.assertEqual('watcher-decision-engine', wservice.name)
                     self.assertEqual(
-                        objects.service.ServiceStatus.FAILED, wservice.state)
+                        objects.service.ServiceStatus.FAILED, wservice.state
+                    )
                 case _:
                     self.fail(f'Unexpected host: {wservice.host}')
 
@@ -533,9 +582,11 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         # Prepare three ongoing audits with the same failed host
         uuid_prefix = common_utils.generate_uuid()[:-1]
         audits = [
-            objects.Audit(context=self.context,
-                          uuid=f'{uuid_prefix}{i}',
-                          hostname='failed-host')
+            objects.Audit(
+                context=self.context,
+                uuid=f'{uuid_prefix}{i}',
+                hostname='failed-host',
+            )
             for i in range(3)
         ]
 
@@ -561,9 +612,11 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         # Prepare audits with distinct failed hosts to validate payload
         uuid_prefix = common_utils.generate_uuid()[:-1]
         audits = [
-            objects.Audit(context=self.context,
-                          uuid=f'{uuid_prefix}{i}',
-                          hostname=f'failed-{i}')
+            objects.Audit(
+                context=self.context,
+                uuid=f'{uuid_prefix}{i}',
+                hostname=f'failed-{i}',
+            )
             for i in range(2)
         ]
 
@@ -586,8 +639,9 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         self.assertEqual(f'{uuid_prefix}0', payload0['audit'])
         self.assertEqual('host1', payload0['host'])
         self.assertEqual('failed-0', payload0['failed_host'])
-        self.assertEqual(objects.service.ServiceStatus.FAILED,
-                         payload0['state'])
+        self.assertEqual(
+            objects.service.ServiceStatus.FAILED, payload0['state']
+        )
 
         # Second audit migrated to host2
         args1, _ = calls[1]
@@ -595,14 +649,16 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         self.assertEqual(f'{uuid_prefix}1', payload1['audit'])
         self.assertEqual('host2', payload1['host'])
         self.assertEqual('failed-1', payload1['failed_host'])
-        self.assertEqual(objects.service.ServiceStatus.FAILED,
-                         payload1['state'])
+        self.assertEqual(
+            objects.service.ServiceStatus.FAILED, payload1['state']
+        )
 
     def test_am_i_leader_with_single_active_service(self):
         """Test leader election with single active service."""
         # Create service objects with state attribute
         service1 = objects.Service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.ACTIVE
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -622,13 +678,16 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         # Create service objects with state attribute
         # sorted order: host1, host2, host3
         service1 = objects.Service(
-            id=1, name='watcher-decision-engine', host='host2')
+            id=1, name='watcher-decision-engine', host='host2'
+        )
         service1.state = objects.service.ServiceStatus.ACTIVE
         service2 = objects.Service(
-            id=2, name='watcher-decision-engine', host='host1')
+            id=2, name='watcher-decision-engine', host='host1'
+        )
         service2.state = objects.service.ServiceStatus.ACTIVE
         service3 = objects.Service(
-            id=3, name='watcher-decision-engine', host='host3')
+            id=3, name='watcher-decision-engine', host='host3'
+        )
         service3.state = objects.service.ServiceStatus.ACTIVE
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -650,10 +709,12 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         """Test leader election ignores failed services."""
         # Create service objects with mixed states
         service1 = objects.Service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.FAILED
         service2 = objects.Service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         service2.state = objects.service.ServiceStatus.ACTIVE
 
         monitor = service_monitor.DecisionEngineMonitor()
@@ -671,10 +732,12 @@ class TestDecisionEngineMonitorFunctions(db_base.DbTestCase):
         """Test leader election when no services are active."""
         # Create service objects with all failed states
         service1 = objects.Service(
-            id=1, name='watcher-decision-engine', host='host1')
+            id=1, name='watcher-decision-engine', host='host1'
+        )
         service1.state = objects.service.ServiceStatus.FAILED
         service2 = objects.Service(
-            id=2, name='watcher-decision-engine', host='host2')
+            id=2, name='watcher-decision-engine', host='host2'
+        )
         service2.state = objects.service.ServiceStatus.FAILED
 
         monitor = service_monitor.DecisionEngineMonitor()
diff --git a/watcher/tests/unit/decision_engine/test_sync.py b/watcher/tests/unit/decision_engine/test_sync.py
index 28ff54915..546235a61 100644
--- a/watcher/tests/unit/decision_engine/test_sync.py
+++ b/watcher/tests/unit/decision_engine/test_sync.py
@@ -28,42 +28,47 @@ from watcher.tests.unit.decision_engine import fake_strategies
 
 
 class TestSyncer(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.ctx = context.make_context()
 
         # This mock simulates the strategies discovery done in discover()
-        self.m_available_strategies = mock.Mock(return_value={
-            fake_strategies.FakeDummy1Strategy1.get_name():
-                fake_strategies.FakeDummy1Strategy1,
-            fake_strategies.FakeDummy1Strategy2.get_name():
-                fake_strategies.FakeDummy1Strategy2,
-            fake_strategies.FakeDummy2Strategy3.get_name():
-                fake_strategies.FakeDummy2Strategy3,
-            fake_strategies.FakeDummy2Strategy4.get_name():
-                fake_strategies.FakeDummy2Strategy4,
-        })
+        self.m_available_strategies = mock.Mock(
+            return_value={
+                fake_strategies.FakeDummy1Strategy1.get_name(): fake_strategies.FakeDummy1Strategy1,  # noqa: E501
+                fake_strategies.FakeDummy1Strategy2.get_name(): fake_strategies.FakeDummy1Strategy2,  # noqa: E501
+                fake_strategies.FakeDummy2Strategy3.get_name(): fake_strategies.FakeDummy2Strategy3,  # noqa: E501
+                fake_strategies.FakeDummy2Strategy4.get_name(): fake_strategies.FakeDummy2Strategy4,  # noqa: E501
+            }
+        )
 
-        self.m_available_goals = mock.Mock(return_value={
-            fake_goals.FakeDummy1.get_name(): fake_goals.FakeDummy1,
-            fake_goals.FakeDummy2.get_name(): fake_goals.FakeDummy2,
-        })
+        self.m_available_goals = mock.Mock(
+            return_value={
+                fake_goals.FakeDummy1.get_name(): fake_goals.FakeDummy1,
+                fake_goals.FakeDummy2.get_name(): fake_goals.FakeDummy2,
+            }
+        )
 
         self.goal1_spec = fake_goals.FakeDummy1(
-            config=mock.Mock()).get_efficacy_specification()
+            config=mock.Mock()
+        ).get_efficacy_specification()
         self.goal2_spec = fake_goals.FakeDummy2(
-            config=mock.Mock()).get_efficacy_specification()
+            config=mock.Mock()
+        ).get_efficacy_specification()
 
         p_goals_load = mock.patch.object(
-            default.DefaultGoalLoader, 'load',
-            side_effect=lambda goal: self.m_available_goals()[goal]())
+            default.DefaultGoalLoader,
+            'load',
+            side_effect=lambda goal: self.m_available_goals()[goal](),
+        )
         p_goals = mock.patch.object(
-            default.DefaultGoalLoader, 'list_available',
-            self.m_available_goals)
+            default.DefaultGoalLoader, 'list_available', self.m_available_goals
+        )
         p_strategies = mock.patch.object(
-            default.DefaultStrategyLoader, 'list_available',
-            self.m_available_strategies)
+            default.DefaultStrategyLoader,
+            'list_available',
+            self.m_available_strategies,
+        )
 
         p_goals.start()
         p_goals_load.start()
@@ -77,20 +82,22 @@ class TestSyncer(base.DbTestCase):
     @staticmethod
     def _find_created_modified_unmodified_ids(before, after):
         created = {
-            a_item.id: a_item for a_item in after
+            a_item.id: a_item
+            for a_item in after
             if a_item.uuid not in (b_item.uuid for b_item in before)
         }
 
         modified = {
-            a_item.id: a_item for a_item in after
-            if a_item.as_dict() not in (
-                b_items.as_dict() for b_items in before)
+            a_item.id: a_item
+            for a_item in after
+            if a_item.as_dict()
+            not in (b_items.as_dict() for b_items in before)
         }
 
         unmodified = {
-            a_item.id: a_item for a_item in after
-            if a_item.as_dict() in (
-                b_items.as_dict() for b_items in before)
+            a_item.id: a_item
+            for a_item in after
+            if a_item.as_dict() in (b_items.as_dict() for b_items in before)
         }
 
         return created, modified, unmodified
@@ -105,10 +112,20 @@ class TestSyncer(base.DbTestCase):
     @mock.patch.object(objects.Goal, "create")
     @mock.patch.object(objects.Goal, "list")
     def test_sync_empty_db(
-            self, m_g_list, m_g_create, m_g_save, m_g_soft_delete,
-            m_g_get_by_name, m_s_list, m_s_create, m_s_save, m_s_soft_delete):
+        self,
+        m_g_list,
+        m_g_create,
+        m_g_save,
+        m_g_soft_delete,
+        m_g_get_by_name,
+        m_s_list,
+        m_s_create,
+        m_s_save,
+        m_s_soft_delete,
+    ):
         m_g_get_by_name.side_effect = [
-            objects.Goal(self.ctx, id=i) for i in range(1, 10)]
+            objects.Goal(self.ctx, id=i) for i in range(1, 10)
+        ]
         m_g_list.return_value = []
         m_s_list.return_value = []
 
@@ -132,15 +149,31 @@ class TestSyncer(base.DbTestCase):
     @mock.patch.object(objects.Goal, "create")
     @mock.patch.object(objects.Goal, "list")
     def test_sync_with_existing_goal(
-            self, m_g_list, m_g_create, m_g_save, m_g_soft_delete,
-            m_g_get_by_name, m_s_list, m_s_create, m_s_save, m_s_soft_delete):
+        self,
+        m_g_list,
+        m_g_create,
+        m_g_save,
+        m_g_soft_delete,
+        m_g_get_by_name,
+        m_s_list,
+        m_s_create,
+        m_s_save,
+        m_s_soft_delete,
+    ):
         m_g_get_by_name.side_effect = [
-            objects.Goal(self.ctx, id=i) for i in range(1, 10)]
+            objects.Goal(self.ctx, id=i) for i in range(1, 10)
+        ]
         m_g_list.return_value = [
-            objects.Goal(self.ctx, id=1, uuid=utils.generate_uuid(),
-                         name="dummy_1", display_name="Dummy 1",
-                         efficacy_specification=(
-                             self.goal1_spec.serialize_indicators_specs()))
+            objects.Goal(
+                self.ctx,
+                id=1,
+                uuid=utils.generate_uuid(),
+                name="dummy_1",
+                display_name="Dummy 1",
+                efficacy_specification=(
+                    self.goal1_spec.serialize_indicators_specs()
+                ),
+            )
         ]
         m_s_list.return_value = []
 
@@ -164,20 +197,41 @@ class TestSyncer(base.DbTestCase):
     @mock.patch.object(objects.Goal, "create")
     @mock.patch.object(objects.Goal, "list")
     def test_sync_with_existing_strategy(
-            self, m_g_list, m_g_create, m_g_save, m_g_soft_delete,
-            m_g_get_by_name, m_s_list, m_s_create, m_s_save, m_s_soft_delete):
+        self,
+        m_g_list,
+        m_g_create,
+        m_g_save,
+        m_g_soft_delete,
+        m_g_get_by_name,
+        m_s_list,
+        m_s_create,
+        m_s_save,
+        m_s_soft_delete,
+    ):
         m_g_get_by_name.side_effect = [
-            objects.Goal(self.ctx, id=i) for i in range(1, 10)]
+            objects.Goal(self.ctx, id=i) for i in range(1, 10)
+        ]
         m_g_list.return_value = [
-            objects.Goal(self.ctx, id=1, uuid=utils.generate_uuid(),
-                         name="dummy_1", display_name="Dummy 1",
-                         efficacy_specification=(
-                             self.goal1_spec.serialize_indicators_specs()))
+            objects.Goal(
+                self.ctx,
+                id=1,
+                uuid=utils.generate_uuid(),
+                name="dummy_1",
+                display_name="Dummy 1",
+                efficacy_specification=(
+                    self.goal1_spec.serialize_indicators_specs()
+                ),
+            )
         ]
         m_s_list.return_value = [
-            objects.Strategy(self.ctx, id=1, name="strategy_1",
-                             goal_id=1, display_name="Strategy 1",
-                             parameters_spec='{}')
+            objects.Strategy(
+                self.ctx,
+                id=1,
+                name="strategy_1",
+                goal_id=1,
+                display_name="Strategy 1",
+                parameters_spec='{}',
+            )
         ]
         self.syncer.sync()
 
@@ -199,15 +253,30 @@ class TestSyncer(base.DbTestCase):
     @mock.patch.object(objects.Goal, "create")
     @mock.patch.object(objects.Goal, "list")
     def test_sync_with_modified_goal(
-            self, m_g_list, m_g_create, m_g_save, m_g_soft_delete,
-            m_g_get_by_name, m_s_list, m_s_create, m_s_save, m_s_soft_delete):
+        self,
+        m_g_list,
+        m_g_create,
+        m_g_save,
+        m_g_soft_delete,
+        m_g_get_by_name,
+        m_s_list,
+        m_s_create,
+        m_s_save,
+        m_s_soft_delete,
+    ):
         m_g_get_by_name.side_effect = [
-            objects.Goal(self.ctx, id=i) for i in range(1, 10)]
-        m_g_list.return_value = [objects.Goal(
-            self.ctx, id=1, uuid=utils.generate_uuid(),
-            name="dummy_2", display_name="original",
-            efficacy_specification=self.goal2_spec.serialize_indicators_specs()
-        )]
+            objects.Goal(self.ctx, id=i) for i in range(1, 10)
+        ]
+        m_g_list.return_value = [
+            objects.Goal(
+                self.ctx,
+                id=1,
+                uuid=utils.generate_uuid(),
+                name="dummy_2",
+                display_name="original",
+                efficacy_specification=self.goal2_spec.serialize_indicators_specs(),
+            )
+        ]
         m_s_list.return_value = []
         self.syncer.sync()
 
@@ -229,20 +298,41 @@ class TestSyncer(base.DbTestCase):
     @mock.patch.object(objects.Goal, "create")
     @mock.patch.object(objects.Goal, "list")
     def test_sync_with_modified_strategy(
-            self, m_g_list, m_g_create, m_g_save, m_g_soft_delete,
-            m_g_get_by_name, m_s_list, m_s_create, m_s_save, m_s_soft_delete):
+        self,
+        m_g_list,
+        m_g_create,
+        m_g_save,
+        m_g_soft_delete,
+        m_g_get_by_name,
+        m_s_list,
+        m_s_create,
+        m_s_save,
+        m_s_soft_delete,
+    ):
         m_g_get_by_name.side_effect = [
-            objects.Goal(self.ctx, id=i) for i in range(1, 10)]
+            objects.Goal(self.ctx, id=i) for i in range(1, 10)
+        ]
         m_g_list.return_value = [
-            objects.Goal(self.ctx, id=1, uuid=utils.generate_uuid(),
-                         name="dummy_1", display_name="Dummy 1",
-                         efficacy_specification=(
-                             self.goal1_spec.serialize_indicators_specs()))
+            objects.Goal(
+                self.ctx,
+                id=1,
+                uuid=utils.generate_uuid(),
+                name="dummy_1",
+                display_name="Dummy 1",
+                efficacy_specification=(
+                    self.goal1_spec.serialize_indicators_specs()
+                ),
+            )
         ]
         m_s_list.return_value = [
-            objects.Strategy(self.ctx, id=1, name="strategy_1",
-                             goal_id=1, display_name="original",
-                             parameters_spec='{}')
+            objects.Strategy(
+                self.ctx,
+                id=1,
+                name="strategy_1",
+                goal_id=1,
+                display_name="original",
+                parameters_spec='{}',
+            )
         ]
         self.syncer.sync()
 
@@ -262,38 +352,66 @@ class TestSyncer(base.DbTestCase):
 
         # Should stay unmodified after sync()
         goal1 = objects.Goal(
-            self.ctx, id=1, uuid=utils.generate_uuid(),
-            name="dummy_1", display_name="Dummy 1",
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name="dummy_1",
+            display_name="Dummy 1",
             efficacy_specification=(
-                self.goal1_spec.serialize_indicators_specs()))
+                self.goal1_spec.serialize_indicators_specs()
+            ),
+        )
         # Should be modified by the sync()
         goal2 = objects.Goal(
-            self.ctx, id=2, uuid=utils.generate_uuid(),
-            name="dummy_2", display_name="Original",
-            efficacy_specification=self.goal2_spec.serialize_indicators_specs()
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name="dummy_2",
+            display_name="Original",
+            efficacy_specification=self.goal2_spec.serialize_indicators_specs(),
         )
         goal1.create()
         goal2.create()
 
         # Should stay unmodified after sync()
         strategy1 = objects.Strategy(
-            self.ctx, id=1, name="strategy_1", uuid=utils.generate_uuid(),
-            display_name="Strategy 1", goal_id=goal1.id)
+            self.ctx,
+            id=1,
+            name="strategy_1",
+            uuid=utils.generate_uuid(),
+            display_name="Strategy 1",
+            goal_id=goal1.id,
+        )
         # Should be modified after sync() because its related goal has been
         # modified
         strategy2 = objects.Strategy(
-            self.ctx, id=2, name="strategy_2", uuid=utils.generate_uuid(),
-            display_name="Strategy 2", goal_id=goal2.id)
+            self.ctx,
+            id=2,
+            name="strategy_2",
+            uuid=utils.generate_uuid(),
+            display_name="Strategy 2",
+            goal_id=goal2.id,
+        )
         # Should be modified after sync() because its strategy name has been
         # modified
         strategy3 = objects.Strategy(
-            self.ctx, id=3, name="strategy_3", uuid=utils.generate_uuid(),
-            display_name="Original", goal_id=goal1.id)
+            self.ctx,
+            id=3,
+            name="strategy_3",
+            uuid=utils.generate_uuid(),
+            display_name="Original",
+            goal_id=goal1.id,
+        )
         # Should be modified after sync() because both its related goal
         # and its strategy name have been modified
         strategy4 = objects.Strategy(
-            self.ctx, id=4, name="strategy_4", uuid=utils.generate_uuid(),
-            display_name="Original", goal_id=goal2.id)
+            self.ctx,
+            id=4,
+            name="strategy_4",
+            uuid=utils.generate_uuid(),
+            display_name="Original",
+            goal_id=goal2.id,
+        )
         strategy1.create()
         strategy2.create()
         strategy3.create()
@@ -304,23 +422,43 @@ class TestSyncer(base.DbTestCase):
 
         # Should stay unmodified after sync()
         audit_template1 = objects.AuditTemplate(
-            self.ctx, id=1, name="Synced AT1", uuid=utils.generate_uuid(),
-            goal_id=goal1.id, strategy_id=strategy1.id)
+            self.ctx,
+            id=1,
+            name="Synced AT1",
+            uuid=utils.generate_uuid(),
+            goal_id=goal1.id,
+            strategy_id=strategy1.id,
+        )
         # Should be modified by the sync() because its associated goal
         # has been modified (compared to the defined fake goals)
         audit_template2 = objects.AuditTemplate(
-            self.ctx, id=2, name="Synced AT2", uuid=utils.generate_uuid(),
-            goal_id=goal2.id, strategy_id=strategy2.id)
+            self.ctx,
+            id=2,
+            name="Synced AT2",
+            uuid=utils.generate_uuid(),
+            goal_id=goal2.id,
+            strategy_id=strategy2.id,
+        )
         # Should be modified by the sync() because its associated strategy
         # has been modified (compared to the defined fake strategies)
         audit_template3 = objects.AuditTemplate(
-            self.ctx, id=3, name="Synced AT3", uuid=utils.generate_uuid(),
-            goal_id=goal1.id, strategy_id=strategy3.id)
+            self.ctx,
+            id=3,
+            name="Synced AT3",
+            uuid=utils.generate_uuid(),
+            goal_id=goal1.id,
+            strategy_id=strategy3.id,
+        )
         # Modified because of both because its associated goal and associated
         # strategy should be modified
         audit_template4 = objects.AuditTemplate(
-            self.ctx, id=4, name="Synced AT4", uuid=utils.generate_uuid(),
-            goal_id=goal2.id, strategy_id=strategy4.id)
+            self.ctx,
+            id=4,
+            name="Synced AT4",
+            uuid=utils.generate_uuid(),
+            goal_id=goal2.id,
+            strategy_id=strategy4.id,
+        )
         audit_template1.create()
         audit_template2.create()
         audit_template3.create()
@@ -328,32 +466,56 @@ class TestSyncer(base.DbTestCase):
 
         # Should stay unmodified after sync()
         audit1 = objects.Audit(
-            self.ctx, id=1, uuid=utils.generate_uuid(), name='audit_1',
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name='audit_1',
             audit_type=objects.audit.AuditType.ONESHOT.value,
             state=objects.audit.State.PENDING,
-            goal_id=goal1.id, strategy_id=strategy1.id, auto_trigger=False)
+            goal_id=goal1.id,
+            strategy_id=strategy1.id,
+            auto_trigger=False,
+        )
         # Should be modified by the sync() because its associated goal
         # has been modified (compared to the defined fake goals)
         audit2 = objects.Audit(
-            self.ctx, id=2, uuid=utils.generate_uuid(), name='audit_2',
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name='audit_2',
             audit_type=objects.audit.AuditType.ONESHOT.value,
             state=objects.audit.State.PENDING,
-            goal_id=goal2.id, strategy_id=strategy2.id, auto_trigger=False)
+            goal_id=goal2.id,
+            strategy_id=strategy2.id,
+            auto_trigger=False,
+        )
         # Should be modified by the sync() because its associated strategy
         # has been modified (compared to the defined fake strategies)
         audit3 = objects.Audit(
-            self.ctx, id=3, uuid=utils.generate_uuid(), name='audit_3',
+            self.ctx,
+            id=3,
+            uuid=utils.generate_uuid(),
+            name='audit_3',
             audit_type=objects.audit.AuditType.ONESHOT.value,
             state=objects.audit.State.PENDING,
-            goal_id=goal1.id, strategy_id=strategy3.id, auto_trigger=False)
+            goal_id=goal1.id,
+            strategy_id=strategy3.id,
+            auto_trigger=False,
+        )
         # Modified because of both because its associated goal and associated
         # strategy should be modified (compared to the defined fake
         # goals/strategies)
         audit4 = objects.Audit(
-            self.ctx, id=4, uuid=utils.generate_uuid(), name='audit_4',
+            self.ctx,
+            id=4,
+            uuid=utils.generate_uuid(),
+            name='audit_4',
             audit_type=objects.audit.AuditType.ONESHOT.value,
             state=objects.audit.State.PENDING,
-            goal_id=goal2.id, strategy_id=strategy4.id, auto_trigger=False)
+            goal_id=goal2.id,
+            strategy_id=strategy4.id,
+            auto_trigger=False,
+        )
 
         audit1.create()
         audit2.create()
@@ -362,27 +524,47 @@ class TestSyncer(base.DbTestCase):
 
         # Should stay unmodified after sync()
         action_plan1 = objects.ActionPlan(
-            self.ctx, id=1, uuid=utils.generate_uuid(),
-            audit_id=audit1.id, strategy_id=strategy1.id,
-            state='DOESNOTMATTER', global_efficacy=[])
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            audit_id=audit1.id,
+            strategy_id=strategy1.id,
+            state='DOESNOTMATTER',
+            global_efficacy=[],
+        )
         # Stale after syncing because the goal of the audit has been modified
         # (compared to the defined fake goals)
         action_plan2 = objects.ActionPlan(
-            self.ctx, id=2, uuid=utils.generate_uuid(),
-            audit_id=audit2.id, strategy_id=strategy2.id,
-            state='DOESNOTMATTER', global_efficacy=[])
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            audit_id=audit2.id,
+            strategy_id=strategy2.id,
+            state='DOESNOTMATTER',
+            global_efficacy=[],
+        )
         # Stale after syncing because the strategy has been modified
         # (compared to the defined fake strategies)
         action_plan3 = objects.ActionPlan(
-            self.ctx, id=3, uuid=utils.generate_uuid(),
-            audit_id=audit3.id, strategy_id=strategy3.id,
-            state='DOESNOTMATTER', global_efficacy=[])
+            self.ctx,
+            id=3,
+            uuid=utils.generate_uuid(),
+            audit_id=audit3.id,
+            strategy_id=strategy3.id,
+            state='DOESNOTMATTER',
+            global_efficacy=[],
+        )
         # Stale after syncing because both the strategy and the related audit
         # have been modified (compared to the defined fake goals/strategies)
         action_plan4 = objects.ActionPlan(
-            self.ctx, id=4, uuid=utils.generate_uuid(),
-            audit_id=audit4.id, strategy_id=strategy4.id,
-            state='DOESNOTMATTER', global_efficacy=[])
+            self.ctx,
+            id=4,
+            uuid=utils.generate_uuid(),
+            audit_id=audit4.id,
+            strategy_id=strategy4.id,
+            state='DOESNOTMATTER',
+            global_efficacy=[],
+        )
 
         action_plan1.create()
         action_plan2.create()
@@ -421,42 +603,56 @@ class TestSyncer(base.DbTestCase):
         self.assertEqual(4, len(after_audits))
         self.assertEqual(4, len(after_action_plans))
 
-        self.assertEqual(
-            {"dummy_1", "dummy_2"},
-            {g.name for g in after_goals})
+        self.assertEqual({"dummy_1", "dummy_2"}, {g.name for g in after_goals})
         self.assertEqual(
             {"strategy_1", "strategy_2", "strategy_3", "strategy_4"},
-            {s.name for s in after_strategies})
+            {s.name for s in after_strategies},
+        )
 
         created_goals, modified_goals, unmodified_goals = (
             self._find_created_modified_unmodified_ids(
-                before_goals, after_goals))
+                before_goals, after_goals
+            )
+        )
 
         created_strategies, modified_strategies, unmodified_strategies = (
             self._find_created_modified_unmodified_ids(
-                before_strategies, after_strategies))
+                before_strategies, after_strategies
+            )
+        )
 
-        (created_audit_templates, modified_audit_templates,
-         unmodified_audit_templates) = (
-             self._find_created_modified_unmodified_ids(
-                 before_audit_templates, after_audit_templates))
+        (
+            created_audit_templates,
+            modified_audit_templates,
+            unmodified_audit_templates,
+        ) = self._find_created_modified_unmodified_ids(
+            before_audit_templates, after_audit_templates
+        )
 
         created_audits, modified_audits, unmodified_audits = (
             self._find_created_modified_unmodified_ids(
-                before_audits, after_audits))
+                before_audits, after_audits
+            )
+        )
 
-        (created_action_plans, modified_action_plans,
-         unmodified_action_plans) = (
-             self._find_created_modified_unmodified_ids(
-                 before_action_plans, after_action_plans))
+        (
+            created_action_plans,
+            modified_action_plans,
+            unmodified_action_plans,
+        ) = self._find_created_modified_unmodified_ids(
+            before_action_plans, after_action_plans
+        )
 
         dummy_1_spec = jsonutils.loads(
-            self.goal1_spec.serialize_indicators_specs())
+            self.goal1_spec.serialize_indicators_specs()
+        )
         dummy_2_spec = jsonutils.loads(
-            self.goal2_spec.serialize_indicators_specs())
+            self.goal2_spec.serialize_indicators_specs()
+        )
         self.assertEqual(
             [dummy_1_spec, dummy_2_spec],
-            [g.efficacy_specification for g in after_goals])
+            [g.efficacy_specification for g in after_goals],
+        )
 
         self.assertEqual(1, len(created_goals))
         self.assertEqual(3, len(created_strategies))
@@ -467,26 +663,31 @@ class TestSyncer(base.DbTestCase):
 
         self.assertNotEqual(
             {strategy2.id, strategy3.id, strategy4.id},
-            set(modified_strategies))
+            set(modified_strategies),
+        )
         self.assertEqual({strategy1.id}, set(unmodified_strategies))
 
         self.assertEqual(
             {audit_template2.id, audit_template3.id, audit_template4.id},
-            set(modified_audit_templates))
-        self.assertEqual({audit_template1.id},
-                         set(unmodified_audit_templates))
+            set(modified_audit_templates),
+        )
+        self.assertEqual({audit_template1.id}, set(unmodified_audit_templates))
 
         self.assertEqual(
-            {audit2.id, audit3.id, audit4.id},
-            set(modified_audits))
+            {audit2.id, audit3.id, audit4.id}, set(modified_audits)
+        )
         self.assertEqual({audit1.id}, set(unmodified_audits))
 
         self.assertEqual(
             {action_plan2.id, action_plan3.id, action_plan4.id},
-            set(modified_action_plans))
+            set(modified_action_plans),
+        )
         self.assertTrue(
-            all(ap.state == objects.action_plan.State.CANCELLED
-                for ap in modified_action_plans.values()))
+            all(
+                ap.state == objects.action_plan.State.CANCELLED
+                for ap in modified_action_plans.values()
+            )
+        )
         self.assertEqual({action_plan1.id}, set(unmodified_action_plans))
 
     def test_end2end_sync_goals_with_removed_goal_and_strategy(self):
@@ -494,42 +695,62 @@ class TestSyncer(base.DbTestCase):
 
         # We simulate the fact that we removed 2 strategies
         self.m_available_strategies.return_value = {
-            fake_strategies.FakeDummy1Strategy1.get_name():
-                fake_strategies.FakeDummy1Strategy1
+            fake_strategies.FakeDummy1Strategy1.get_name(): fake_strategies.FakeDummy1Strategy1  # noqa: E501
         }
         # We simulate the fact that we removed the dummy_2 goal
         self.m_available_goals.return_value = {
-            fake_goals.FakeDummy1.get_name(): fake_goals.FakeDummy1,
+            fake_goals.FakeDummy1.get_name(): fake_goals.FakeDummy1
         }
         # Should stay unmodified after sync()
         goal1 = objects.Goal(
-            self.ctx, id=1, uuid=utils.generate_uuid(),
-            name="dummy_1", display_name="Dummy 1",
-            efficacy_specification=self.goal1_spec.serialize_indicators_specs()
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name="dummy_1",
+            display_name="Dummy 1",
+            efficacy_specification=self.goal1_spec.serialize_indicators_specs(),
         )
         # To be removed by the sync()
         goal2 = objects.Goal(
-            self.ctx, id=2, uuid=utils.generate_uuid(),
-            name="dummy_2", display_name="Dummy 2",
-            efficacy_specification=self.goal2_spec.serialize_indicators_specs()
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name="dummy_2",
+            display_name="Dummy 2",
+            efficacy_specification=self.goal2_spec.serialize_indicators_specs(),
         )
         goal1.create()
         goal2.create()
 
         # Should stay unmodified after sync()
         strategy1 = objects.Strategy(
-            self.ctx, id=1, name="strategy_1", uuid=utils.generate_uuid(),
-            display_name="Strategy 1", goal_id=goal1.id)
+            self.ctx,
+            id=1,
+            name="strategy_1",
+            uuid=utils.generate_uuid(),
+            display_name="Strategy 1",
+            goal_id=goal1.id,
+        )
         # To be removed by the sync() because strategy entry point does not
         # exist anymore
         strategy2 = objects.Strategy(
-            self.ctx, id=2, name="strategy_2", uuid=utils.generate_uuid(),
-            display_name="Strategy 2", goal_id=goal1.id)
+            self.ctx,
+            id=2,
+            name="strategy_2",
+            uuid=utils.generate_uuid(),
+            display_name="Strategy 2",
+            goal_id=goal1.id,
+        )
         # To be removed by the sync() because the goal has been soft deleted
         # and because the strategy entry point does not exist anymore
         strategy3 = objects.Strategy(
-            self.ctx, id=3, name="strategy_3", uuid=utils.generate_uuid(),
-            display_name="Original", goal_id=goal2.id)
+            self.ctx,
+            id=3,
+            name="strategy_3",
+            uuid=utils.generate_uuid(),
+            display_name="Original",
+            goal_id=goal2.id,
+        )
         strategy1.create()
         strategy2.create()
         strategy3.create()
@@ -540,42 +761,74 @@ class TestSyncer(base.DbTestCase):
         # The strategy of this audit template will be dereferenced
         # as it does not exist anymore
         audit_template1 = objects.AuditTemplate(
-            self.ctx, id=1, name="Synced AT1", uuid=utils.generate_uuid(),
-            goal_id=goal1.id, strategy_id=strategy1.id)
+            self.ctx,
+            id=1,
+            name="Synced AT1",
+            uuid=utils.generate_uuid(),
+            goal_id=goal1.id,
+            strategy_id=strategy1.id,
+        )
         # Stale after syncing because the goal has been soft deleted
         audit_template2 = objects.AuditTemplate(
-            self.ctx, id=2, name="Synced AT2", uuid=utils.generate_uuid(),
-            goal_id=goal2.id, strategy_id=strategy2.id)
+            self.ctx,
+            id=2,
+            name="Synced AT2",
+            uuid=utils.generate_uuid(),
+            goal_id=goal2.id,
+            strategy_id=strategy2.id,
+        )
 
         audit_template1.create()
         audit_template2.create()
 
         # Should stay unmodified after sync()
         audit1 = objects.Audit(
-            self.ctx, id=1, uuid=utils.generate_uuid(), name='audit_1',
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name='audit_1',
             audit_type=objects.audit.AuditType.ONESHOT.value,
             state=objects.audit.State.PENDING,
-            goal_id=goal1.id, strategy_id=strategy1.id, auto_trigger=False)
+            goal_id=goal1.id,
+            strategy_id=strategy1.id,
+            auto_trigger=False,
+        )
         # Stale after syncing because the goal has been soft deleted
         audit2 = objects.Audit(
-            self.ctx, id=2, uuid=utils.generate_uuid(), name='audit_2',
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name='audit_2',
             audit_type=objects.audit.AuditType.ONESHOT.value,
             state=objects.audit.State.PENDING,
-            goal_id=goal2.id, strategy_id=strategy2.id, auto_trigger=False)
+            goal_id=goal2.id,
+            strategy_id=strategy2.id,
+            auto_trigger=False,
+        )
         audit1.create()
         audit2.create()
 
         # Stale after syncing because its related strategy has been be
         # soft deleted
         action_plan1 = objects.ActionPlan(
-            self.ctx, id=1, uuid=utils.generate_uuid(),
-            audit_id=audit1.id, strategy_id=strategy1.id,
-            state='DOESNOTMATTER', global_efficacy=[])
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            audit_id=audit1.id,
+            strategy_id=strategy1.id,
+            state='DOESNOTMATTER',
+            global_efficacy=[],
+        )
         # Stale after syncing because its related goal has been soft deleted
         action_plan2 = objects.ActionPlan(
-            self.ctx, id=2, uuid=utils.generate_uuid(),
-            audit_id=audit2.id, strategy_id=strategy2.id,
-            state='DOESNOTMATTER', global_efficacy=[])
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            audit_id=audit2.id,
+            strategy_id=strategy2.id,
+            state='DOESNOTMATTER',
+            global_efficacy=[],
+        )
 
         action_plan1.create()
         action_plan2.create()
@@ -611,76 +864,101 @@ class TestSyncer(base.DbTestCase):
         self.assertEqual(2, len(after_audit_templates))
         self.assertEqual(2, len(after_audits))
         self.assertEqual(2, len(after_action_plans))
-        self.assertEqual(
-            {"dummy_1"},
-            {g.name for g in after_goals})
-        self.assertEqual(
-            {"strategy_1"},
-            {s.name for s in after_strategies})
+        self.assertEqual({"dummy_1"}, {g.name for g in after_goals})
+        self.assertEqual({"strategy_1"}, {s.name for s in after_strategies})
 
         created_goals, modified_goals, unmodified_goals = (
             self._find_created_modified_unmodified_ids(
-                before_goals, after_goals))
+                before_goals, after_goals
+            )
+        )
 
         created_strategies, modified_strategies, unmodified_strategies = (
             self._find_created_modified_unmodified_ids(
-                before_strategies, after_strategies))
+                before_strategies, after_strategies
+            )
+        )
 
-        (created_audit_templates, modified_audit_templates,
-         unmodified_audit_templates) = (
-             self._find_created_modified_unmodified_ids(
-                 before_audit_templates, after_audit_templates))
+        (
+            created_audit_templates,
+            modified_audit_templates,
+            unmodified_audit_templates,
+        ) = self._find_created_modified_unmodified_ids(
+            before_audit_templates, after_audit_templates
+        )
 
         created_audits, modified_audits, unmodified_audits = (
             self._find_created_modified_unmodified_ids(
-                before_audits, after_audits))
+                before_audits, after_audits
+            )
+        )
 
-        (created_action_plans, modified_action_plans,
-         unmodified_action_plans) = (
-             self._find_created_modified_unmodified_ids(
-                 before_action_plans, after_action_plans))
+        (
+            created_action_plans,
+            modified_action_plans,
+            unmodified_action_plans,
+        ) = self._find_created_modified_unmodified_ids(
+            before_action_plans, after_action_plans
+        )
 
         self.assertEqual(0, len(created_goals))
         self.assertEqual(0, len(created_strategies))
         self.assertEqual(0, len(created_audits))
         self.assertEqual(0, len(created_action_plans))
 
-        self.assertEqual({audit_template2.id},
-                         set(modified_audit_templates))
-        self.assertEqual({audit_template1.id},
-                         set(unmodified_audit_templates))
+        self.assertEqual({audit_template2.id}, set(modified_audit_templates))
+        self.assertEqual({audit_template1.id}, set(unmodified_audit_templates))
 
         self.assertEqual({audit2.id}, set(modified_audits))
         self.assertEqual({audit1.id}, set(unmodified_audits))
 
         self.assertEqual({action_plan2.id}, set(modified_action_plans))
         self.assertTrue(
-            all(ap.state == objects.action_plan.State.CANCELLED
-                for ap in modified_action_plans.values()))
+            all(
+                ap.state == objects.action_plan.State.CANCELLED
+                for ap in modified_action_plans.values()
+            )
+        )
         self.assertEqual({action_plan1.id}, set(unmodified_action_plans))
 
     def test_sync_strategies_with_removed_goal(self):
         # ### Setup ### #
 
         goal1 = objects.Goal(
-            self.ctx, id=1, uuid=utils.generate_uuid(),
-            name="dummy_1", display_name="Dummy 1",
-            efficacy_specification=self.goal1_spec.serialize_indicators_specs()
+            self.ctx,
+            id=1,
+            uuid=utils.generate_uuid(),
+            name="dummy_1",
+            display_name="Dummy 1",
+            efficacy_specification=self.goal1_spec.serialize_indicators_specs(),
         )
         goal2 = objects.Goal(
-            self.ctx, id=2, uuid=utils.generate_uuid(),
-            name="dummy_2", display_name="Dummy 2",
-            efficacy_specification=self.goal2_spec.serialize_indicators_specs()
+            self.ctx,
+            id=2,
+            uuid=utils.generate_uuid(),
+            name="dummy_2",
+            display_name="Dummy 2",
+            efficacy_specification=self.goal2_spec.serialize_indicators_specs(),
         )
         goal1.create()
         goal2.create()
 
         strategy1 = objects.Strategy(
-            self.ctx, id=1, name="strategy_1", uuid=utils.generate_uuid(),
-            display_name="Strategy 1", goal_id=goal1.id)
+            self.ctx,
+            id=1,
+            name="strategy_1",
+            uuid=utils.generate_uuid(),
+            display_name="Strategy 1",
+            goal_id=goal1.id,
+        )
         strategy2 = objects.Strategy(
-            self.ctx, id=2, name="strategy_2", uuid=utils.generate_uuid(),
-            display_name="Strategy 2", goal_id=goal2.id)
+            self.ctx,
+            id=2,
+            name="strategy_2",
+            uuid=utils.generate_uuid(),
+            display_name="Strategy 2",
+            goal_id=goal2.id,
+        )
         strategy1.create()
         strategy2.create()
         # to be removed by some reasons
@@ -705,9 +983,8 @@ class TestSyncer(base.DbTestCase):
         self.assertEqual(2, len(before_strategies))
         self.assertEqual(2, len(after_goals))
         self.assertEqual(4, len(after_strategies))
-        self.assertEqual(
-            {"dummy_1", "dummy_2"},
-            {g.name for g in after_goals})
+        self.assertEqual({"dummy_1", "dummy_2"}, {g.name for g in after_goals})
         self.assertEqual(
             {"strategy_1", "strategy_2", "strategy_3", "strategy_4"},
-            {s.name for s in after_strategies})
+            {s.name for s in after_strategies},
+        )
diff --git a/watcher/tests/unit/notifications/test_action_notification.py b/watcher/tests/unit/notifications/test_action_notification.py
index b2f75d379..d34045a28 100644
--- a/watcher/tests/unit/notifications/test_action_notification.py
+++ b/watcher/tests/unit/notifications/test_action_notification.py
@@ -27,7 +27,6 @@ from watcher.tests.unit.objects import utils
 
 @freezegun.freeze_time('2016-10-18T09:52:05.219414')
 class TestActionNotification(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_get_notifier = mock.patch.object(rpc, 'get_notifier')
@@ -42,28 +41,40 @@ class TestActionNotification(base.DbTestCase):
         m_get_notifier.side_effect = fake_get_notifier
         self.goal = utils.create_test_goal(mock.Mock())
         self.strategy = utils.create_test_strategy(mock.Mock())
-        self.audit = utils.create_test_audit(mock.Mock(),
-                                             strategy_id=self.strategy.id)
+        self.audit = utils.create_test_audit(
+            mock.Mock(), strategy_id=self.strategy.id
+        )
         self.action_plan = utils.create_test_action_plan(mock.Mock())
 
     def test_send_invalid_action_plan(self):
         action_plan = utils.get_test_action_plan(
-            mock.Mock(), state='DOESNOTMATTER', audit_id=1)
+            mock.Mock(), state='DOESNOTMATTER', audit_id=1
+        )
 
         self.assertRaises(
             exception.InvalidActionPlan,
             notifications.action_plan.send_update,
-            mock.MagicMock(), action_plan, host='node0')
+            mock.MagicMock(),
+            action_plan,
+            host='node0',
+        )
 
     def test_send_action_update(self):
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.ONGOING,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id,
-            status_message="Test status message")
+            mock.Mock(),
+            state=objects.action.State.ONGOING,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+            status_message="Test status message",
+        )
         notifications.action.send_update(
-            mock.MagicMock(), action, host='node0',
-            old_state=objects.action.State.PENDING)
+            mock.MagicMock(),
+            action,
+            host='node0',
+            old_state=objects.action.State.PENDING,
+        )
 
         # The 1st notification is because we created the object.
         # The 2nd notification is because we created the action plan object.
@@ -79,10 +90,7 @@ class TestActionNotification(base.DbTestCase):
                 'watcher_object.name': 'ActionUpdatePayload',
                 'watcher_object.data': {
                     'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                    'input_parameters': {
-                        'param2': 2,
-                        'param1': 1
-                    },
+                    'input_parameters': {'param2': 2, 'param1': 1},
                     'created_at': '2016-10-18T09:52:05Z',
                     'updated_at': None,
                     'state_update': {
@@ -92,8 +100,8 @@ class TestActionNotification(base.DbTestCase):
                         'watcher_object.data': {
                             'old_state': 'PENDING',
                             'state': 'ONGOING',
-                            'status_message': 'Test status message'
-                        }
+                            'status_message': 'Test status message',
+                        },
                     },
                     'state': 'ONGOING',
                     'action_plan': {
@@ -107,29 +115,34 @@ class TestActionNotification(base.DbTestCase):
                             'updated_at': None,
                             'state': 'ONGOING',
                             'audit_uuid': '10a47dd1-4874-4298'
-                                          '-91cf-eff046dbdb8d',
+                            '-91cf-eff046dbdb8d',
                             'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                             '-b75b-1e96878730e3',
+                            '-b75b-1e96878730e3',
                             'deleted_at': None,
-                            'status_message': None
-                        }
+                            'status_message': None,
+                        },
                     },
                     'parents': [],
                     'action_type': 'nop',
                     'deleted_at': None,
-                    'status_message': 'Test status message'
-                }
+                    'status_message': 'Test status message',
+                },
             },
-            payload
+            payload,
         )
 
     def test_send_action_plan_create(self):
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.PENDING,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id)
-        notifications.action.send_create(mock.MagicMock(), action,
-                                         host='node0')
+            mock.Mock(),
+            state=objects.action.State.PENDING,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+        )
+        notifications.action.send_create(
+            mock.MagicMock(), action, host='node0'
+        )
 
         self.assertEqual(4, self.m_notifier.info.call_count)
         notification = self.m_notifier.info.call_args[1]
@@ -143,10 +156,7 @@ class TestActionNotification(base.DbTestCase):
                 'watcher_object.name': 'ActionCreatePayload',
                 'watcher_object.data': {
                     'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                    'input_parameters': {
-                        'param2': 2,
-                        'param1': 1
-                    },
+                    'input_parameters': {'param2': 2, 'param1': 1},
                     'created_at': '2016-10-18T09:52:05Z',
                     'updated_at': None,
                     'state': 'PENDING',
@@ -161,29 +171,34 @@ class TestActionNotification(base.DbTestCase):
                             'updated_at': None,
                             'state': 'ONGOING',
                             'audit_uuid': '10a47dd1-4874-4298'
-                                          '-91cf-eff046dbdb8d',
+                            '-91cf-eff046dbdb8d',
                             'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                             '-b75b-1e96878730e3',
+                            '-b75b-1e96878730e3',
                             'deleted_at': None,
-                            'status_message': None
-                        }
+                            'status_message': None,
+                        },
                     },
                     'parents': [],
                     'action_type': 'nop',
                     'deleted_at': None,
-                    'status_message': None
-                }
+                    'status_message': None,
+                },
             },
-            payload
+            payload,
         )
 
     def test_send_action_delete(self):
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.DELETED,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id)
-        notifications.action.send_delete(mock.MagicMock(), action,
-                                         host='node0')
+            mock.Mock(),
+            state=objects.action.State.DELETED,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+        )
+        notifications.action.send_delete(
+            mock.MagicMock(), action, host='node0'
+        )
 
         # The 1st notification is because we created the audit object.
         # The 2nd notification is because we created the action plan object.
@@ -199,10 +214,7 @@ class TestActionNotification(base.DbTestCase):
                 'watcher_object.name': 'ActionDeletePayload',
                 'watcher_object.data': {
                     'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                    'input_parameters': {
-                        'param2': 2,
-                        'param1': 1
-                    },
+                    'input_parameters': {'param2': 2, 'param1': 1},
                     'created_at': '2016-10-18T09:52:05Z',
                     'updated_at': None,
                     'state': 'DELETED',
@@ -217,29 +229,34 @@ class TestActionNotification(base.DbTestCase):
                             'updated_at': None,
                             'state': 'ONGOING',
                             'audit_uuid': '10a47dd1-4874-4298'
-                                          '-91cf-eff046dbdb8d',
+                            '-91cf-eff046dbdb8d',
                             'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                             '-b75b-1e96878730e3',
+                            '-b75b-1e96878730e3',
                             'deleted_at': None,
-                            'status_message': None
-                        }
+                            'status_message': None,
+                        },
                     },
                     'parents': [],
                     'action_type': 'nop',
                     'deleted_at': None,
-                    'status_message': None
-                }
+                    'status_message': None,
+                },
             },
-            payload
+            payload,
         )
 
     def test_send_action_execution(self):
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.PENDING,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id)
+            mock.Mock(),
+            state=objects.action.State.PENDING,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+        )
         notifications.action.send_execution_notification(
-            mock.MagicMock(), action, 'execution', phase='start', host='node0')
+            mock.MagicMock(), action, 'execution', phase='start', host='node0'
+        )
 
         # The 1st notification is because we created the audit object.
         # The 2nd notification is because we created the action plan object.
@@ -256,10 +273,7 @@ class TestActionNotification(base.DbTestCase):
                     'watcher_object.name': 'ActionExecutionPayload',
                     'watcher_object.data': {
                         'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                        'input_parameters': {
-                            'param2': 2,
-                            'param1': 1
-                        },
+                        'input_parameters': {'param2': 2, 'param1': 1},
                         'created_at': '2016-10-18T09:52:05Z',
                         'fault': None,
                         'updated_at': None,
@@ -275,38 +289,47 @@ class TestActionNotification(base.DbTestCase):
                                 'updated_at': None,
                                 'state': 'ONGOING',
                                 'audit_uuid': '10a47dd1-4874-4298'
-                                              '-91cf-eff046dbdb8d',
+                                '-91cf-eff046dbdb8d',
                                 'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                                 '-b75b-1e96878730e3',
+                                '-b75b-1e96878730e3',
                                 'deleted_at': None,
-                                'status_message': None
-                            }
+                                'status_message': None,
+                            },
                         },
                         'parents': [],
                         'action_type': 'nop',
                         'deleted_at': None,
-                        'status_message': None
-                    }
-                }
+                        'status_message': None,
+                    },
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_action_execution_with_error(self):
         self.action_plan.status_message = 'Action plan status message'
         self.action_plan.save()
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.FAILED,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id,
-            status_message='Action status message')
+            mock.Mock(),
+            state=objects.action.State.FAILED,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+            status_message='Action status message',
+        )
         try:
             # This is to load the exception in sys.exc_info()
             raise exception.WatcherException("TEST")
         except exception.WatcherException:
             notifications.action.send_execution_notification(
-                mock.MagicMock(), action, 'execution', phase='error',
-                host='node0', priority='error')
+                mock.MagicMock(),
+                action,
+                'execution',
+                phase='error',
+                host='node0',
+                priority='error',
+            )
 
         self.assertEqual(1, self.m_notifier.error.call_count)
         notification = self.m_notifier.error.call_args[1]
@@ -320,24 +343,23 @@ class TestActionNotification(base.DbTestCase):
                     'watcher_object.name': 'ActionExecutionPayload',
                     'watcher_object.data': {
                         'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                        'input_parameters': {
-                            'param2': 2,
-                            'param1': 1
-                        },
+                        'input_parameters': {'param2': 2, 'param1': 1},
                         'created_at': '2016-10-18T09:52:05Z',
                         'fault': {
                             'watcher_object.data': {
                                 'exception': 'WatcherException',
                                 'exception_message': 'TEST',
                                 'function_name': (
-                                    'test_send_action_execution_with_error'),
+                                    'test_send_action_execution_with_error'
+                                ),
                                 'module_name': (
                                     'watcher.tests.unit.notifications.'
-                                    'test_action_notification')
+                                    'test_action_notification'
+                                ),
                             },
                             'watcher_object.name': 'ExceptionPayload',
                             'watcher_object.namespace': 'watcher',
-                            'watcher_object.version': '1.0'
+                            'watcher_object.version': '1.0',
                         },
                         'updated_at': None,
                         'state': 'FAILED',
@@ -352,30 +374,35 @@ class TestActionNotification(base.DbTestCase):
                                 'updated_at': '2016-10-18T09:52:05Z',
                                 'state': 'ONGOING',
                                 'audit_uuid': '10a47dd1-4874-4298'
-                                              '-91cf-eff046dbdb8d',
+                                '-91cf-eff046dbdb8d',
                                 'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                                 '-b75b-1e96878730e3',
+                                '-b75b-1e96878730e3',
                                 'deleted_at': None,
-                                'status_message': 'Action plan status message'
-                            }
+                                'status_message': 'Action plan status message',
+                            },
                         },
                         'parents': [],
                         'action_type': 'nop',
                         'deleted_at': None,
-                        'status_message': 'Action status message'
-                    }
-                }
+                        'status_message': 'Action status message',
+                    },
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_action_cancel(self):
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.PENDING,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id)
+            mock.Mock(),
+            state=objects.action.State.PENDING,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+        )
         notifications.action.send_cancel_notification(
-            mock.MagicMock(), action, 'cancel', phase='start', host='node0')
+            mock.MagicMock(), action, 'cancel', phase='start', host='node0'
+        )
 
         # The 1st notification is because we created the audit object.
         # The 2nd notification is because we created the action plan object.
@@ -392,10 +419,7 @@ class TestActionNotification(base.DbTestCase):
                     'watcher_object.name': 'ActionCancelPayload',
                     'watcher_object.data': {
                         'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                        'input_parameters': {
-                            'param2': 2,
-                            'param1': 1
-                        },
+                        'input_parameters': {'param2': 2, 'param1': 1},
                         'created_at': '2016-10-18T09:52:05Z',
                         'fault': None,
                         'updated_at': None,
@@ -411,36 +435,45 @@ class TestActionNotification(base.DbTestCase):
                                 'updated_at': None,
                                 'state': 'ONGOING',
                                 'audit_uuid': '10a47dd1-4874-4298'
-                                              '-91cf-eff046dbdb8d',
+                                '-91cf-eff046dbdb8d',
                                 'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                                 '-b75b-1e96878730e3',
+                                '-b75b-1e96878730e3',
                                 'deleted_at': None,
-                                'status_message': None
-                            }
+                                'status_message': None,
+                            },
                         },
                         'parents': [],
                         'action_type': 'nop',
                         'deleted_at': None,
-                        'status_message': None
-                    }
-                }
+                        'status_message': None,
+                    },
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_action_cancel_with_error(self):
         action = utils.create_test_action(
-            mock.Mock(), state=objects.action.State.FAILED,
-            action_type='nop', input_parameters={'param1': 1, 'param2': 2},
-            parents=[], action_plan_id=self.action_plan.id)
+            mock.Mock(),
+            state=objects.action.State.FAILED,
+            action_type='nop',
+            input_parameters={'param1': 1, 'param2': 2},
+            parents=[],
+            action_plan_id=self.action_plan.id,
+        )
 
         try:
             # This is to load the exception in sys.exc_info()
             raise exception.WatcherException("TEST")
         except exception.WatcherException:
             notifications.action.send_cancel_notification(
-                mock.MagicMock(), action, 'cancel', phase='error',
-                host='node0', priority='error')
+                mock.MagicMock(),
+                action,
+                'cancel',
+                phase='error',
+                host='node0',
+                priority='error',
+            )
 
         self.assertEqual(1, self.m_notifier.error.call_count)
         notification = self.m_notifier.error.call_args[1]
@@ -454,24 +487,23 @@ class TestActionNotification(base.DbTestCase):
                     'watcher_object.name': 'ActionCancelPayload',
                     'watcher_object.data': {
                         'uuid': '10a47dd1-4874-4298-91cf-eff046dbdb8d',
-                        'input_parameters': {
-                            'param2': 2,
-                            'param1': 1
-                        },
+                        'input_parameters': {'param2': 2, 'param1': 1},
                         'created_at': '2016-10-18T09:52:05Z',
                         'fault': {
                             'watcher_object.data': {
                                 'exception': 'WatcherException',
                                 'exception_message': 'TEST',
                                 'function_name': (
-                                    'test_send_action_cancel_with_error'),
+                                    'test_send_action_cancel_with_error'
+                                ),
                                 'module_name': (
                                     'watcher.tests.unit.notifications.'
-                                    'test_action_notification')
+                                    'test_action_notification'
+                                ),
                             },
                             'watcher_object.name': 'ExceptionPayload',
                             'watcher_object.namespace': 'watcher',
-                            'watcher_object.version': '1.0'
+                            'watcher_object.version': '1.0',
                         },
                         'updated_at': None,
                         'state': 'FAILED',
@@ -486,19 +518,19 @@ class TestActionNotification(base.DbTestCase):
                                 'updated_at': None,
                                 'state': 'ONGOING',
                                 'audit_uuid': '10a47dd1-4874-4298'
-                                              '-91cf-eff046dbdb8d',
+                                '-91cf-eff046dbdb8d',
                                 'strategy_uuid': 'cb3d0b58-4415-4d90'
-                                                 '-b75b-1e96878730e3',
+                                '-b75b-1e96878730e3',
                                 'deleted_at': None,
-                                'status_message': None
-                            }
+                                'status_message': None,
+                            },
                         },
                         'parents': [],
                         'action_type': 'nop',
                         'deleted_at': None,
-                        'status_message': None
-                    }
-                }
+                        'status_message': None,
+                    },
+                },
             },
-            notification
+            notification,
         )
diff --git a/watcher/tests/unit/notifications/test_action_plan_notification.py b/watcher/tests/unit/notifications/test_action_plan_notification.py
index aa9ca31de..857ff5701 100644
--- a/watcher/tests/unit/notifications/test_action_plan_notification.py
+++ b/watcher/tests/unit/notifications/test_action_plan_notification.py
@@ -27,7 +27,6 @@ from watcher.tests.unit.objects import utils
 
 @freezegun.freeze_time('2016-10-18T09:52:05.219414')
 class TestActionPlanNotification(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_get_notifier = mock.patch.object(rpc, 'get_notifier')
@@ -46,22 +45,33 @@ class TestActionPlanNotification(base.DbTestCase):
 
     def test_send_invalid_action_plan(self):
         action_plan = utils.get_test_action_plan(
-            mock.Mock(), state='DOESNOTMATTER', audit_id=1)
+            mock.Mock(), state='DOESNOTMATTER', audit_id=1
+        )
 
         self.assertRaises(
             exception.InvalidActionPlan,
             notifications.action_plan.send_update,
-            mock.MagicMock(), action_plan, host='node0')
+            mock.MagicMock(),
+            action_plan,
+            host='node0',
+        )
 
     def test_send_action_plan_update(self):
         action_plan = utils.create_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.ONGOING,
-            audit_id=self.audit.id, strategy_id=self.strategy.id,
-            audit=self.audit, strategy=self.strategy,
-            status_message="Test status message")
+            mock.Mock(),
+            state=objects.action_plan.State.ONGOING,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+            audit=self.audit,
+            strategy=self.strategy,
+            status_message="Test status message",
+        )
         notifications.action_plan.send_update(
-            mock.MagicMock(), action_plan, host='node0',
-            old_state=objects.action_plan.State.PENDING)
+            mock.MagicMock(),
+            action_plan,
+            host='node0',
+            old_state=objects.action_plan.State.PENDING,
+        )
 
         # The 1st notification is because we created the object.
         # The 2nd notification is because we created the action plan object.
@@ -87,9 +97,9 @@ class TestActionPlanNotification(base.DbTestCase):
                             "parameters_spec": {},
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test strategy",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "StrategyPayload"
+                        "watcher_object.name": "StrategyPayload",
                     },
                     "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     "audit_uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
@@ -103,18 +113,19 @@ class TestActionPlanNotification(base.DbTestCase):
                             "name": "My Audit",
                             "strategy_uuid": None,
                             "goal_uuid": (
-                                "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                            ),
                             "deleted_at": None,
                             "scope": [],
                             "state": "PENDING",
                             "updated_at": None,
                             "created_at": "2016-10-18T09:52:05Z",
                             "audit_type": "ONESHOT",
-                            "status_message": None
+                            "status_message": None,
                         },
                         "watcher_object.name": "TerseAuditPayload",
                         "watcher_object.namespace": "watcher",
-                        "watcher_object.version": "1.3"
+                        "watcher_object.version": "1.3",
                     },
                     "deleted_at": None,
                     "state": "ONGOING",
@@ -129,21 +140,26 @@ class TestActionPlanNotification(base.DbTestCase):
                             "state": "ONGOING",
                             "status_message": "Test status message",
                         },
-                        "watcher_object.name": "ActionPlanStateUpdatePayload"
+                        "watcher_object.name": "ActionPlanStateUpdatePayload",
                     },
                 },
-                "watcher_object.name": "ActionPlanUpdatePayload"
+                "watcher_object.name": "ActionPlanUpdatePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_action_plan_create(self):
         action_plan = utils.get_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.PENDING,
-            audit_id=self.audit.id, strategy_id=self.strategy.id,
-            audit=self.audit.as_dict(), strategy=self.strategy.as_dict())
+            mock.Mock(),
+            state=objects.action_plan.State.PENDING,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+            audit=self.audit.as_dict(),
+            strategy=self.strategy.as_dict(),
+        )
         notifications.action_plan.send_create(
-            mock.MagicMock(), action_plan, host='node0')
+            mock.MagicMock(), action_plan, host='node0'
+        )
 
         self.assertEqual(2, self.m_notifier.info.call_count)
         notification = self.m_notifier.info.call_args[1]
@@ -167,9 +183,9 @@ class TestActionPlanNotification(base.DbTestCase):
                             "parameters_spec": {},
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test strategy",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "StrategyPayload"
+                        "watcher_object.name": "StrategyPayload",
                     },
                     "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     "audit_uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
@@ -183,18 +199,19 @@ class TestActionPlanNotification(base.DbTestCase):
                             "name": "My Audit",
                             "strategy_uuid": None,
                             "goal_uuid": (
-                                "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                            ),
                             "deleted_at": None,
                             "scope": [],
                             "state": "PENDING",
                             "updated_at": None,
                             "created_at": "2016-10-18T09:52:05Z",
                             "audit_type": "ONESHOT",
-                            "status_message": None
+                            "status_message": None,
                         },
                         "watcher_object.name": "TerseAuditPayload",
                         "watcher_object.namespace": "watcher",
-                        "watcher_object.version": "1.3"
+                        "watcher_object.version": "1.3",
                     },
                     "deleted_at": None,
                     "state": "PENDING",
@@ -202,17 +219,21 @@ class TestActionPlanNotification(base.DbTestCase):
                     "updated_at": None,
                     "created_at": None,
                 },
-                "watcher_object.name": "ActionPlanCreatePayload"
+                "watcher_object.name": "ActionPlanCreatePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_action_plan_delete(self):
         action_plan = utils.create_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.DELETED,
-            audit_id=self.audit.id, strategy_id=self.strategy.id)
+            mock.Mock(),
+            state=objects.action_plan.State.DELETED,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+        )
         notifications.action_plan.send_delete(
-            mock.MagicMock(), action_plan, host='node0')
+            mock.MagicMock(), action_plan, host='node0'
+        )
 
         # The 1st notification is because we created the audit object.
         # The 2nd notification is because we created the action plan object.
@@ -238,9 +259,9 @@ class TestActionPlanNotification(base.DbTestCase):
                             "parameters_spec": {},
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test strategy",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "StrategyPayload"
+                        "watcher_object.name": "StrategyPayload",
                     },
                     "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     "audit_uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
@@ -254,18 +275,19 @@ class TestActionPlanNotification(base.DbTestCase):
                             "name": "My Audit",
                             "strategy_uuid": None,
                             "goal_uuid": (
-                                "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                            ),
                             "deleted_at": None,
                             "scope": [],
                             "state": "PENDING",
                             "updated_at": None,
                             "created_at": "2016-10-18T09:52:05Z",
                             "audit_type": "ONESHOT",
-                            "status_message": None
+                            "status_message": None,
                         },
                         "watcher_object.name": "TerseAuditPayload",
                         "watcher_object.namespace": "watcher",
-                        "watcher_object.version": "1.3"
+                        "watcher_object.version": "1.3",
                     },
                     "deleted_at": None,
                     "state": "DELETED",
@@ -273,19 +295,27 @@ class TestActionPlanNotification(base.DbTestCase):
                     "updated_at": None,
                     "created_at": "2016-10-18T09:52:05Z",
                 },
-                "watcher_object.name": "ActionPlanDeletePayload"
+                "watcher_object.name": "ActionPlanDeletePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_action_plan_action(self):
         action_plan = utils.create_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.ONGOING,
-            audit_id=self.audit.id, strategy_id=self.strategy.id,
-            audit=self.audit, strategy=self.strategy)
+            mock.Mock(),
+            state=objects.action_plan.State.ONGOING,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+            audit=self.audit,
+            strategy=self.strategy,
+        )
         notifications.action_plan.send_action_notification(
-            mock.MagicMock(), action_plan, host='node0',
-            action='execution', phase='start')
+            mock.MagicMock(),
+            action_plan,
+            host='node0',
+            action='execution',
+            phase='start',
+        )
 
         # The 1st notification is because we created the audit object.
         # The 2nd notification is because we created the action plan object.
@@ -315,21 +345,23 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "name": "My Audit",
                                 "strategy_uuid": None,
                                 "goal_uuid": (
-                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                                ),
                                 "deleted_at": None,
                                 "scope": [],
                                 "state": "PENDING",
                                 "updated_at": None,
                                 "created_at": "2016-10-18T09:52:05Z",
                                 "audit_type": "ONESHOT",
-                                "status_message": None
-                            }
+                                "status_message": None,
+                            },
                         },
                         "global_efficacy": [],
                         "state": "ONGOING",
                         "status_message": None,
                         "strategy_uuid": (
-                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"),
+                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                        ),
                         "strategy": {
                             "watcher_object.data": {
                                 "created_at": "2016-10-18T09:52:05Z",
@@ -338,36 +370,45 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "name": "TEST",
                                 "parameters_spec": {},
                                 "updated_at": None,
-                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3",
                             },
                             "watcher_object.name": "StrategyPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "updated_at": None,
-                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061"
+                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     },
                     "watcher_object.name": "ActionPlanActionPayload",
                     "watcher_object.namespace": "watcher",
-                    "watcher_object.version": "1.2"
-                }
+                    "watcher_object.version": "1.2",
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_action_plan_action_with_error(self):
         action_plan = utils.create_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.ONGOING,
-            audit_id=self.audit.id, strategy_id=self.strategy.id,
-            audit=self.audit, strategy=self.strategy)
+            mock.Mock(),
+            state=objects.action_plan.State.ONGOING,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+            audit=self.audit,
+            strategy=self.strategy,
+        )
 
         try:
             # This is to load the exception in sys.exc_info()
             raise exception.WatcherException("TEST")
         except exception.WatcherException:
             notifications.action_plan.send_action_notification(
-                mock.MagicMock(), action_plan, host='node0',
-                action='execution', priority='error', phase='error')
+                mock.MagicMock(),
+                action_plan,
+                host='node0',
+                action='execution',
+                priority='error',
+                phase='error',
+            )
 
         self.assertEqual(1, self.m_notifier.error.call_count)
         notification = self.m_notifier.error.call_args[1]
@@ -384,14 +425,15 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "exception": "WatcherException",
                                 "exception_message": "TEST",
                                 "function_name": (
-                                    "test_send_action_plan_action_with_error"),
+                                    "test_send_action_plan_action_with_error"
+                                ),
                                 "module_name": "watcher.tests.unit."
-                                               "notifications."
-                                               "test_action_plan_notification"
+                                "notifications."
+                                "test_action_plan_notification",
                             },
                             "watcher_object.name": "ExceptionPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "audit_uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
                         "audit": {
@@ -404,24 +446,26 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "name": "My Audit",
                                 "strategy_uuid": None,
                                 "goal_uuid": (
-                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                                ),
                                 "deleted_at": None,
                                 "scope": [],
                                 "state": "PENDING",
                                 "updated_at": None,
                                 "created_at": "2016-10-18T09:52:05Z",
                                 "audit_type": "ONESHOT",
-                                "status_message": None
+                                "status_message": None,
                             },
                             "watcher_object.name": "TerseAuditPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.3"
+                            "watcher_object.version": "1.3",
                         },
                         "global_efficacy": [],
                         "state": "ONGOING",
                         "status_message": None,
                         "strategy_uuid": (
-                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"),
+                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                        ),
                         "strategy": {
                             "watcher_object.data": {
                                 "created_at": "2016-10-18T09:52:05Z",
@@ -430,31 +474,39 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "name": "TEST",
                                 "parameters_spec": {},
                                 "updated_at": None,
-                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3",
                             },
                             "watcher_object.name": "StrategyPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "updated_at": None,
-                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061"
+                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     },
                     "watcher_object.name": "ActionPlanActionPayload",
                     "watcher_object.namespace": "watcher",
-                    "watcher_object.version": "1.2"
-                }
+                    "watcher_object.version": "1.2",
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_action_plan_cancel(self):
         action_plan = utils.create_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.ONGOING,
-            audit_id=self.audit.id, strategy_id=self.strategy.id,
-            audit=self.audit, strategy=self.strategy)
+            mock.Mock(),
+            state=objects.action_plan.State.ONGOING,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+            audit=self.audit,
+            strategy=self.strategy,
+        )
         notifications.action_plan.send_cancel_notification(
-            mock.MagicMock(), action_plan, host='node0',
-            action='cancel', phase='start')
+            mock.MagicMock(),
+            action_plan,
+            host='node0',
+            action='cancel',
+            phase='start',
+        )
 
         # The 1st notification is because we created the audit object.
         # The 2nd notification is because we created the action plan object.
@@ -483,21 +535,23 @@ class TestActionPlanNotification(base.DbTestCase):
                                 'name': 'My Audit',
                                 "strategy_uuid": None,
                                 "goal_uuid": (
-                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                                ),
                                 "deleted_at": None,
                                 "scope": [],
                                 "state": "PENDING",
                                 "updated_at": None,
                                 "created_at": "2016-10-18T09:52:05Z",
                                 "audit_type": "ONESHOT",
-                                "status_message": None
-                            }
+                                "status_message": None,
+                            },
                         },
                         "global_efficacy": [],
                         "state": "ONGOING",
                         "status_message": None,
                         "strategy_uuid": (
-                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"),
+                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                        ),
                         "strategy": {
                             "watcher_object.data": {
                                 "created_at": "2016-10-18T09:52:05Z",
@@ -506,36 +560,45 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "name": "TEST",
                                 "parameters_spec": {},
                                 "updated_at": None,
-                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3",
                             },
                             "watcher_object.name": "StrategyPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "updated_at": None,
-                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061"
+                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     },
                     "watcher_object.name": "ActionPlanCancelPayload",
                     "watcher_object.namespace": "watcher",
-                    "watcher_object.version": "1.2"
-                }
+                    "watcher_object.version": "1.2",
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_action_plan_cancel_with_error(self):
         action_plan = utils.create_test_action_plan(
-            mock.Mock(), state=objects.action_plan.State.ONGOING,
-            audit_id=self.audit.id, strategy_id=self.strategy.id,
-            audit=self.audit, strategy=self.strategy)
+            mock.Mock(),
+            state=objects.action_plan.State.ONGOING,
+            audit_id=self.audit.id,
+            strategy_id=self.strategy.id,
+            audit=self.audit,
+            strategy=self.strategy,
+        )
 
         try:
             # This is to load the exception in sys.exc_info()
             raise exception.WatcherException("TEST")
         except exception.WatcherException:
             notifications.action_plan.send_cancel_notification(
-                mock.MagicMock(), action_plan, host='node0',
-                action='cancel', priority='error', phase='error')
+                mock.MagicMock(),
+                action_plan,
+                host='node0',
+                action='cancel',
+                priority='error',
+                phase='error',
+            )
 
         self.assertEqual(1, self.m_notifier.error.call_count)
         notification = self.m_notifier.error.call_args[1]
@@ -552,14 +615,15 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "exception": "WatcherException",
                                 "exception_message": "TEST",
                                 "function_name": (
-                                    "test_send_action_plan_cancel_with_error"),
+                                    "test_send_action_plan_cancel_with_error"
+                                ),
                                 "module_name": "watcher.tests.unit."
-                                               "notifications."
-                                               "test_action_plan_notification"
+                                "notifications."
+                                "test_action_plan_notification",
                             },
                             "watcher_object.name": "ExceptionPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "audit_uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
                         "audit": {
@@ -572,24 +636,26 @@ class TestActionPlanNotification(base.DbTestCase):
                                 'name': 'My Audit',
                                 "strategy_uuid": None,
                                 "goal_uuid": (
-                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"),
+                                    "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                                ),
                                 "deleted_at": None,
                                 "scope": [],
                                 "state": "PENDING",
                                 "updated_at": None,
                                 "created_at": "2016-10-18T09:52:05Z",
                                 "audit_type": "ONESHOT",
-                                "status_message": None
+                                "status_message": None,
                             },
                             "watcher_object.name": "TerseAuditPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.3"
+                            "watcher_object.version": "1.3",
                         },
                         "global_efficacy": [],
                         "state": "ONGOING",
                         "status_message": None,
                         "strategy_uuid": (
-                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"),
+                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                        ),
                         "strategy": {
                             "watcher_object.data": {
                                 "created_at": "2016-10-18T09:52:05Z",
@@ -598,19 +664,19 @@ class TestActionPlanNotification(base.DbTestCase):
                                 "name": "TEST",
                                 "parameters_spec": {},
                                 "updated_at": None,
-                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3",
                             },
                             "watcher_object.name": "StrategyPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "updated_at": None,
-                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061"
+                        "uuid": "76be87bd-3422-43f9-93a0-e85a577e3061",
                     },
                     "watcher_object.name": "ActionPlanCancelPayload",
                     "watcher_object.namespace": "watcher",
-                    "watcher_object.version": "1.2"
-                }
+                    "watcher_object.version": "1.2",
+                },
             },
-            notification
+            notification,
         )
diff --git a/watcher/tests/unit/notifications/test_audit_notification.py b/watcher/tests/unit/notifications/test_audit_notification.py
index 5979ee752..1b2d796b6 100644
--- a/watcher/tests/unit/notifications/test_audit_notification.py
+++ b/watcher/tests/unit/notifications/test_audit_notification.py
@@ -27,7 +27,6 @@ from watcher.tests.unit.objects import utils
 
 @freezegun.freeze_time('2016-10-18T09:52:05.219414')
 class TestAuditNotification(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_get_notifier = mock.patch.object(rpc, 'get_notifier')
@@ -45,21 +44,33 @@ class TestAuditNotification(base.DbTestCase):
 
     def test_send_invalid_audit(self):
         audit = utils.get_test_audit(
-            mock.Mock(), interval=None, state='DOESNOTMATTER', goal_id=1)
+            mock.Mock(), interval=None, state='DOESNOTMATTER', goal_id=1
+        )
 
         self.assertRaises(
             exception.InvalidAudit,
             notifications.audit.send_update,
-            mock.MagicMock(), audit, host='node0')
+            mock.MagicMock(),
+            audit,
+            host='node0',
+        )
 
     def test_send_audit_update_with_strategy(self):
         audit = utils.create_test_audit(
-            mock.Mock(), interval=None, state=objects.audit.State.ONGOING,
-            goal_id=self.goal.id, strategy_id=self.strategy.id,
-            goal=self.goal, strategy=self.strategy)
+            mock.Mock(),
+            interval=None,
+            state=objects.audit.State.ONGOING,
+            goal_id=self.goal.id,
+            strategy_id=self.strategy.id,
+            goal=self.goal,
+            strategy=self.strategy,
+        )
         notifications.audit.send_update(
-            mock.MagicMock(), audit, host='node0',
-            old_state=objects.audit.State.PENDING)
+            mock.MagicMock(),
+            audit,
+            host='node0',
+            old_state=objects.audit.State.PENDING,
+        )
 
         # The 1st notification is because we created the object.
         self.assertEqual(2, self.m_notifier.info.call_count)
@@ -86,9 +97,9 @@ class TestAuditNotification(base.DbTestCase):
                             "parameters_spec": {},
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test strategy",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "StrategyPayload"
+                        "watcher_object.name": "StrategyPayload",
                     },
                     "parameters": {},
                     "uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
@@ -104,9 +115,9 @@ class TestAuditNotification(base.DbTestCase):
                             "efficacy_specification": [],
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test goal",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "GoalPayload"
+                        "watcher_object.name": "GoalPayload",
                     },
                     "deleted_at": None,
                     "scope": [],
@@ -119,26 +130,33 @@ class TestAuditNotification(base.DbTestCase):
                         "watcher_object.data": {
                             "old_state": "PENDING",
                             "state": "ONGOING",
-                            "status_message": None
+                            "status_message": None,
                         },
-                        "watcher_object.name": "AuditStateUpdatePayload"
+                        "watcher_object.name": "AuditStateUpdatePayload",
                     },
                     "audit_type": "ONESHOT",
-                    "status_message": None
+                    "status_message": None,
                 },
-                "watcher_object.name": "AuditUpdatePayload"
+                "watcher_object.name": "AuditUpdatePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_audit_update_without_strategy(self):
         audit = utils.get_test_audit(
-            mock.Mock(), interval=None, state=objects.audit.State.ONGOING,
-            goal_id=self.goal.id, goal=self.goal,
-            status_message='Fake message')
+            mock.Mock(),
+            interval=None,
+            state=objects.audit.State.ONGOING,
+            goal_id=self.goal.id,
+            goal=self.goal,
+            status_message='Fake message',
+        )
         notifications.audit.send_update(
-            mock.MagicMock(), audit, host='node0',
-            old_state=objects.audit.State.PENDING)
+            mock.MagicMock(),
+            audit,
+            host='node0',
+            old_state=objects.audit.State.PENDING,
+        )
 
         self.assertEqual(1, self.m_notifier.info.call_count)
         notification = self.m_notifier.info.call_args[1]
@@ -167,9 +185,9 @@ class TestAuditNotification(base.DbTestCase):
                             "efficacy_specification": [],
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test goal",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "GoalPayload"
+                        "watcher_object.name": "GoalPayload",
                     },
                     "strategy_uuid": None,
                     "strategy": None,
@@ -184,25 +202,29 @@ class TestAuditNotification(base.DbTestCase):
                         "watcher_object.data": {
                             "old_state": "PENDING",
                             "state": "ONGOING",
-                            "status_message": "Fake message"
+                            "status_message": "Fake message",
                         },
-                        "watcher_object.name": "AuditStateUpdatePayload"
+                        "watcher_object.name": "AuditStateUpdatePayload",
                     },
                     "audit_type": "ONESHOT",
-                    "status_message": "Fake message"
+                    "status_message": "Fake message",
                 },
-                "watcher_object.name": "AuditUpdatePayload"
+                "watcher_object.name": "AuditUpdatePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_audit_create(self):
         audit = utils.get_test_audit(
-            mock.Mock(), interval=None, state=objects.audit.State.PENDING,
-            goal_id=self.goal.id, strategy_id=self.strategy.id,
-            goal=self.goal.as_dict(), strategy=self.strategy.as_dict())
-        notifications.audit.send_create(
-            mock.MagicMock(), audit, host='node0')
+            mock.Mock(),
+            interval=None,
+            state=objects.audit.State.PENDING,
+            goal_id=self.goal.id,
+            strategy_id=self.strategy.id,
+            goal=self.goal.as_dict(),
+            strategy=self.strategy.as_dict(),
+        )
+        notifications.audit.send_create(mock.MagicMock(), audit, host='node0')
 
         self.assertEqual(1, self.m_notifier.info.call_count)
         notification = self.m_notifier.info.call_args[1]
@@ -228,9 +250,9 @@ class TestAuditNotification(base.DbTestCase):
                             "parameters_spec": {},
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test strategy",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "StrategyPayload"
+                        "watcher_object.name": "StrategyPayload",
                     },
                     "parameters": {},
                     "uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
@@ -246,9 +268,9 @@ class TestAuditNotification(base.DbTestCase):
                             "efficacy_specification": [],
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test goal",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "GoalPayload"
+                        "watcher_object.name": "GoalPayload",
                     },
                     "deleted_at": None,
                     "scope": [],
@@ -256,19 +278,22 @@ class TestAuditNotification(base.DbTestCase):
                     "updated_at": None,
                     "created_at": None,
                     "audit_type": "ONESHOT",
-                    "status_message": None
+                    "status_message": None,
                 },
-                "watcher_object.name": "AuditCreatePayload"
+                "watcher_object.name": "AuditCreatePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_audit_delete(self):
         audit = utils.create_test_audit(
-            mock.Mock(), interval=None, state=objects.audit.State.DELETED,
-            goal_id=self.goal.id, strategy_id=self.strategy.id)
-        notifications.audit.send_delete(
-            mock.MagicMock(), audit, host='node0')
+            mock.Mock(),
+            interval=None,
+            state=objects.audit.State.DELETED,
+            goal_id=self.goal.id,
+            strategy_id=self.strategy.id,
+        )
+        notifications.audit.send_delete(mock.MagicMock(), audit, host='node0')
 
         # The 1st notification is because we created the object.
         self.assertEqual(2, self.m_notifier.info.call_count)
@@ -295,9 +320,9 @@ class TestAuditNotification(base.DbTestCase):
                             "parameters_spec": {},
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test strategy",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "StrategyPayload"
+                        "watcher_object.name": "StrategyPayload",
                     },
                     "parameters": {},
                     "uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
@@ -313,9 +338,9 @@ class TestAuditNotification(base.DbTestCase):
                             "efficacy_specification": [],
                             "created_at": "2016-10-18T09:52:05Z",
                             "display_name": "test goal",
-                            "deleted_at": None
+                            "deleted_at": None,
                         },
-                        "watcher_object.name": "GoalPayload"
+                        "watcher_object.name": "GoalPayload",
                     },
                     "deleted_at": None,
                     "scope": [],
@@ -323,21 +348,30 @@ class TestAuditNotification(base.DbTestCase):
                     "updated_at": None,
                     "created_at": "2016-10-18T09:52:05Z",
                     "audit_type": "ONESHOT",
-                    "status_message": None
+                    "status_message": None,
                 },
-                "watcher_object.name": "AuditDeletePayload"
+                "watcher_object.name": "AuditDeletePayload",
             },
-            payload
+            payload,
         )
 
     def test_send_audit_action(self):
         audit = utils.create_test_audit(
-            mock.Mock(), interval=None, state=objects.audit.State.ONGOING,
-            goal_id=self.goal.id, strategy_id=self.strategy.id,
-            goal=self.goal, strategy=self.strategy)
+            mock.Mock(),
+            interval=None,
+            state=objects.audit.State.ONGOING,
+            goal_id=self.goal.id,
+            strategy_id=self.strategy.id,
+            goal=self.goal,
+            strategy=self.strategy,
+        )
         notifications.audit.send_action_notification(
-            mock.MagicMock(), audit, host='node0',
-            action='strategy', phase='start')
+            mock.MagicMock(),
+            audit,
+            host='node0',
+            action='strategy',
+            phase='start',
+        )
 
         # The 1st notification is because we created the object.
         self.assertEqual(2, self.m_notifier.info.call_count)
@@ -363,11 +397,11 @@ class TestAuditNotification(base.DbTestCase):
                                 "efficacy_specification": [],
                                 "name": "TEST",
                                 "updated_at": None,
-                                "uuid": "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                                "uuid": "f7ad87ae-4298-91cf-93a0-f35a852e3652",
                             },
                             "watcher_object.name": "GoalPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "interval": None,
                         "next_run_time": None,
@@ -377,7 +411,8 @@ class TestAuditNotification(base.DbTestCase):
                         "scope": [],
                         "state": "ONGOING",
                         "strategy_uuid": (
-                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"),
+                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                        ),
                         "strategy": {
                             "watcher_object.data": {
                                 "created_at": "2016-10-18T09:52:05Z",
@@ -386,37 +421,47 @@ class TestAuditNotification(base.DbTestCase):
                                 "name": "TEST",
                                 "parameters_spec": {},
                                 "updated_at": None,
-                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3",
                             },
                             "watcher_object.name": "StrategyPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "updated_at": None,
                         "uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
-                        "status_message": None
+                        "status_message": None,
                     },
                     "watcher_object.name": "AuditActionPayload",
                     "watcher_object.namespace": "watcher",
-                    "watcher_object.version": "1.2"
-                }
+                    "watcher_object.version": "1.2",
+                },
             },
-            notification
+            notification,
         )
 
     def test_send_audit_action_with_error(self):
         audit = utils.create_test_audit(
-            mock.Mock(), interval=None, state=objects.audit.State.ONGOING,
-            goal_id=self.goal.id, strategy_id=self.strategy.id,
-            goal=self.goal, strategy=self.strategy)
+            mock.Mock(),
+            interval=None,
+            state=objects.audit.State.ONGOING,
+            goal_id=self.goal.id,
+            strategy_id=self.strategy.id,
+            goal=self.goal,
+            strategy=self.strategy,
+        )
 
         try:
             # This is to load the exception in sys.exc_info()
             raise exception.WatcherException("TEST")
         except exception.WatcherException:
             notifications.audit.send_action_notification(
-                mock.MagicMock(), audit, host='node0',
-                action='strategy', priority='error', phase='error')
+                mock.MagicMock(),
+                audit,
+                host='node0',
+                action='strategy',
+                priority='error',
+                phase='error',
+            )
 
         self.assertEqual(1, self.m_notifier.error.call_count)
         notification = self.m_notifier.error.call_args[1]
@@ -434,14 +479,15 @@ class TestAuditNotification(base.DbTestCase):
                                 "exception": "WatcherException",
                                 "exception_message": "TEST",
                                 "function_name": (
-                                    "test_send_audit_action_with_error"),
+                                    "test_send_audit_action_with_error"
+                                ),
                                 "module_name": "watcher.tests.unit."
-                                               "notifications."
-                                               "test_audit_notification"
+                                "notifications."
+                                "test_audit_notification",
                             },
                             "watcher_object.name": "ExceptionPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "goal_uuid": "f7ad87ae-4298-91cf-93a0-f35a852e3652",
                         "goal": {
@@ -452,11 +498,11 @@ class TestAuditNotification(base.DbTestCase):
                                 "efficacy_specification": [],
                                 "name": "TEST",
                                 "updated_at": None,
-                                "uuid": "f7ad87ae-4298-91cf-93a0-f35a852e3652"
+                                "uuid": "f7ad87ae-4298-91cf-93a0-f35a852e3652",
                             },
                             "watcher_object.name": "GoalPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "interval": None,
                         "next_run_time": None,
@@ -466,7 +512,8 @@ class TestAuditNotification(base.DbTestCase):
                         "scope": [],
                         "state": "ONGOING",
                         "strategy_uuid": (
-                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"),
+                            "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                        ),
                         "strategy": {
                             "watcher_object.data": {
                                 "created_at": "2016-10-18T09:52:05Z",
@@ -475,20 +522,20 @@ class TestAuditNotification(base.DbTestCase):
                                 "name": "TEST",
                                 "parameters_spec": {},
                                 "updated_at": None,
-                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3"
+                                "uuid": "cb3d0b58-4415-4d90-b75b-1e96878730e3",
                             },
                             "watcher_object.name": "StrategyPayload",
                             "watcher_object.namespace": "watcher",
-                            "watcher_object.version": "1.0"
+                            "watcher_object.version": "1.0",
                         },
                         "updated_at": None,
                         "uuid": "10a47dd1-4874-4298-91cf-eff046dbdb8d",
-                        "status_message": None
+                        "status_message": None,
                     },
                     "watcher_object.name": "AuditActionPayload",
                     "watcher_object.namespace": "watcher",
-                    "watcher_object.version": "1.2"
-                }
+                    "watcher_object.version": "1.2",
+                },
             },
-            notification
+            notification,
         )
diff --git a/watcher/tests/unit/notifications/test_notification.py b/watcher/tests/unit/notifications/test_notification.py
index 44e4e7f00..2a47e0a60 100644
--- a/watcher/tests/unit/notifications/test_notification.py
+++ b/watcher/tests/unit/notifications/test_notification.py
@@ -28,7 +28,6 @@ from watcher.tests.unit.objects import test_objects
 
 
 class TestNotificationBase(testbase.TestCase):
-
     @base.WatcherObjectRegistry.register_if(False)
     class TestObject(base.WatcherObject):
         VERSION = '1.0'
@@ -50,7 +49,7 @@ class TestNotificationBase(testbase.TestCase):
         fields = {
             'extra_field': wfields.StringField(),  # filled by ctor
             'field_1': wfields.StringField(),  # filled by the schema
-            'field_2': wfields.IntegerField(),   # filled by the schema
+            'field_2': wfields.IntegerField(),  # filled by the schema
         }
 
         def populate_schema(self, source_field):
@@ -58,11 +57,12 @@ class TestNotificationBase(testbase.TestCase):
 
     @base.WatcherObjectRegistry.register_if(False)
     class TestNotificationPayloadEmptySchema(
-            notificationbase.NotificationPayloadBase):
+        notificationbase.NotificationPayloadBase
+    ):
         VERSION = '1.0'
 
         fields = {
-            'extra_field': wfields.StringField(),  # filled by ctor
+            'extra_field': wfields.StringField()  # filled by ctor
         }
 
     @notificationbase.notification_sample('test-update-1.json')
@@ -70,16 +70,15 @@ class TestNotificationBase(testbase.TestCase):
     @base.WatcherObjectRegistry.register_if(False)
     class TestNotification(notificationbase.NotificationBase):
         VERSION = '1.0'
-        fields = {
-            'payload': wfields.ObjectField('TestNotificationPayload')
-        }
+        fields = {'payload': wfields.ObjectField('TestNotificationPayload')}
 
     @base.WatcherObjectRegistry.register_if(False)
     class TestNotificationEmptySchema(notificationbase.NotificationBase):
         VERSION = '1.0'
         fields = {
             'payload': wfields.ObjectField(
-                'TestNotificationPayloadEmptySchema')
+                'TestNotificationPayloadEmptySchema'
+            )
         }
 
     expected_payload = {
@@ -87,41 +86,51 @@ class TestNotificationBase(testbase.TestCase):
         'watcher_object.data': {
             'extra_field': 'test string',
             'field_1': 'test1',
-            'field_2': 42},
+            'field_2': 42,
+        },
         'watcher_object.version': '1.0',
-        'watcher_object.namespace': 'watcher'}
+        'watcher_object.namespace': 'watcher',
+    }
 
     def setUp(self):
         super().setUp()
 
-        self.my_obj = self.TestObject(field_1='test1',
-                                      field_2=42,
-                                      not_important_field=13)
+        self.my_obj = self.TestObject(
+            field_1='test1', field_2=42, not_important_field=13
+        )
 
-        self.payload = self.TestNotificationPayload(
-            extra_field='test string')
+        self.payload = self.TestNotificationPayload(extra_field='test string')
         self.payload.populate_schema(source_field=self.my_obj)
 
         self.notification = self.TestNotification(
             event_type=notificationbase.EventType(
                 object='test_object',
                 action=wfields.NotificationAction.UPDATE,
-                phase=wfields.NotificationPhase.START),
+                phase=wfields.NotificationPhase.START,
+            ),
             publisher=notificationbase.NotificationPublisher(
-                host='fake-host', binary='watcher-fake'),
+                host='fake-host', binary='watcher-fake'
+            ),
             priority=wfields.NotificationPriority.INFO,
-            payload=self.payload)
+            payload=self.payload,
+        )
 
-    def _verify_notification(self, mock_notifier, mock_context,
-                             expected_event_type,
-                             expected_payload):
+    def _verify_notification(
+        self,
+        mock_notifier,
+        mock_context,
+        expected_event_type,
+        expected_payload,
+    ):
         mock_notifier.prepare.assert_called_once_with(
-            publisher_id='watcher-fake:fake-host')
+            publisher_id='watcher-fake:fake-host'
+        )
         mock_notify = mock_notifier.prepare.return_value.info
         self.assertTrue(mock_notify.called)
         self.assertEqual(mock_notify.call_args[0][0], mock_context)
-        self.assertEqual(mock_notify.call_args[1]['event_type'],
-                         expected_event_type)
+        self.assertEqual(
+            mock_notify.call_args[1]['event_type'], expected_event_type
+        )
         actual_payload = mock_notify.call_args[1]['payload']
         self.assertEqual(expected_payload, actual_payload)
 
@@ -135,7 +144,8 @@ class TestNotificationBase(testbase.TestCase):
             mock_notifier,
             mock_context,
             expected_event_type='test_object.update.start',
-            expected_payload=self.expected_payload)
+            expected_payload=self.expected_payload,
+        )
 
     @mock.patch.object(rpc, 'NOTIFIER')
     def test_no_emit_notifs_disabled(self, mock_notifier):
@@ -146,11 +156,14 @@ class TestNotificationBase(testbase.TestCase):
             event_type=notificationbase.EventType(
                 object='test_object',
                 action=wfields.NotificationAction.UPDATE,
-                phase=wfields.NotificationPhase.START),
+                phase=wfields.NotificationPhase.START,
+            ),
             publisher=notificationbase.NotificationPublisher(
-                host='fake-host', binary='watcher-fake'),
+                host='fake-host', binary='watcher-fake'
+            ),
             priority=wfields.NotificationPriority.INFO,
-            payload=self.payload)
+            payload=self.payload,
+        )
 
         mock_context = mock.Mock()
         notif.emit(mock_context)
@@ -166,11 +179,14 @@ class TestNotificationBase(testbase.TestCase):
             event_type=notificationbase.EventType(
                 object='test_object',
                 action=wfields.NotificationAction.UPDATE,
-                phase=wfields.NotificationPhase.START),
+                phase=wfields.NotificationPhase.START,
+            ),
             publisher=notificationbase.NotificationPublisher(
-                host='fake-host', binary='watcher-fake'),
+                host='fake-host', binary='watcher-fake'
+            ),
             priority=wfields.NotificationPriority.INFO,
-            payload=self.payload)
+            payload=self.payload,
+        )
 
         mock_context = mock.Mock()
         notif.emit(mock_context)
@@ -181,12 +197,14 @@ class TestNotificationBase(testbase.TestCase):
     def test_emit_event_type_without_phase(self, mock_notifier):
         noti = self.TestNotification(
             event_type=notificationbase.EventType(
-                object='test_object',
-                action=wfields.NotificationAction.UPDATE),
+                object='test_object', action=wfields.NotificationAction.UPDATE
+            ),
             publisher=notificationbase.NotificationPublisher(
-                host='fake-host', binary='watcher-fake'),
+                host='fake-host', binary='watcher-fake'
+            ),
             priority=wfields.NotificationPriority.INFO,
-            payload=self.payload)
+            payload=self.payload,
+        )
 
         mock_context = mock.Mock()
         mock_context.to_dict.return_value = {}
@@ -196,38 +214,46 @@ class TestNotificationBase(testbase.TestCase):
             mock_notifier,
             mock_context,
             expected_event_type='test_object.update',
-            expected_payload=self.expected_payload)
+            expected_payload=self.expected_payload,
+        )
 
     @mock.patch.object(rpc, 'NOTIFIER')
     def test_not_possible_to_emit_if_not_populated(self, mock_notifier):
         non_populated_payload = self.TestNotificationPayload(
-            extra_field='test string')
+            extra_field='test string'
+        )
         noti = self.TestNotification(
             event_type=notificationbase.EventType(
-                object='test_object',
-                action=wfields.NotificationAction.UPDATE),
+                object='test_object', action=wfields.NotificationAction.UPDATE
+            ),
             publisher=notificationbase.NotificationPublisher(
-                host='fake-host', binary='watcher-fake'),
+                host='fake-host', binary='watcher-fake'
+            ),
             priority=wfields.NotificationPriority.INFO,
-            payload=non_populated_payload)
+            payload=non_populated_payload,
+        )
 
         mock_context = mock.Mock()
-        self.assertRaises(exception.NotificationPayloadError,
-                          noti.emit, mock_context)
+        self.assertRaises(
+            exception.NotificationPayloadError, noti.emit, mock_context
+        )
         self.assertFalse(mock_notifier.called)
 
     @mock.patch.object(rpc, 'NOTIFIER')
     def test_empty_schema(self, mock_notifier):
         non_populated_payload = self.TestNotificationPayloadEmptySchema(
-            extra_field='test string')
+            extra_field='test string'
+        )
         noti = self.TestNotificationEmptySchema(
             event_type=notificationbase.EventType(
-                object='test_object',
-                action=wfields.NotificationAction.UPDATE),
+                object='test_object', action=wfields.NotificationAction.UPDATE
+            ),
             publisher=notificationbase.NotificationPublisher(
-                host='fake-host', binary='watcher-fake'),
+                host='fake-host', binary='watcher-fake'
+            ),
             priority=wfields.NotificationPriority.INFO,
-            payload=non_populated_payload)
+            payload=non_populated_payload,
+        )
 
         mock_context = mock.Mock()
         mock_context.to_dict.return_value = {}
@@ -241,7 +267,9 @@ class TestNotificationBase(testbase.TestCase):
                 'watcher_object.name': 'TestNotificationPayloadEmptySchema',
                 'watcher_object.data': {'extra_field': 'test string'},
                 'watcher_object.version': '1.0',
-                'watcher_object.namespace': 'watcher'})
+                'watcher_object.namespace': 'watcher',
+            },
+        )
 
     def test_sample_decorator(self):
         self.assertEqual(2, len(self.TestNotification.samples))
@@ -295,8 +323,7 @@ expected_notification_fingerprints = {
     'ServiceUpdateNotification': '1.0-9b69de0724fda8310d05e18418178866',
     'ServicePayload': '1.0-9c5a9bc51e6606e0ec3cf95baf698f4f',
     'ServiceStatusUpdatePayload': '1.0-1a1b606bf14a2c468800c2b010801ce5',
-    'ServiceUpdatePayload': '1.0-e0e9812a45958974693a723a2c820c3f'
-
+    'ServiceUpdatePayload': '1.0-e0e9812a45958974693a723a2c820c3f',
 }
 
 
@@ -307,20 +334,27 @@ class TestNotificationObjectVersions(testbase.TestCase):
 
     def test_versions(self):
         checker = fixture.ObjectVersionChecker(
-            test_objects.get_watcher_objects())
+            test_objects.get_watcher_objects()
+        )
         expected_notification_fingerprints.update(
-            test_objects.expected_object_fingerprints)
+            test_objects.expected_object_fingerprints
+        )
         expected, actual = checker.test_hashes(
-            expected_notification_fingerprints)
-        self.assertEqual(expected, actual,
-                         'Some notification objects have changed; please make '
-                         'sure the versions have been bumped, and then update '
-                         'their hashes here.')
+            expected_notification_fingerprints
+        )
+        self.assertEqual(
+            expected,
+            actual,
+            'Some notification objects have changed; please make '
+            'sure the versions have been bumped, and then update '
+            'their hashes here.',
+        )
 
     def test_notification_payload_version_depends_on_the_schema(self):
         @base.WatcherObjectRegistry.register_if(False)
         class TestNotificationPayload(
-                notificationbase.NotificationPayloadBase):
+            notificationbase.NotificationPayloadBase
+        ):
             VERSION = '1.0'
 
             SCHEMA = {
@@ -331,15 +365,15 @@ class TestNotificationObjectVersions(testbase.TestCase):
             fields = {
                 'extra_field': wfields.StringField(),  # filled by ctor
                 'field_1': wfields.StringField(),  # filled by the schema
-                'field_2': wfields.IntegerField(),   # filled by the schema
+                'field_2': wfields.IntegerField(),  # filled by the schema
             }
 
         checker = fixture.ObjectVersionChecker(
-            {'TestNotificationPayload': (TestNotificationPayload,)})
+            {'TestNotificationPayload': (TestNotificationPayload,)}
+        )
 
         old_hash = checker.get_hashes(extra_data_func=get_extra_data)
-        TestNotificationPayload.SCHEMA['field_3'] = ('source_field',
-                                                     'field_3')
+        TestNotificationPayload.SCHEMA['field_3'] = ('source_field', 'field_3')
         new_hash = checker.get_hashes(extra_data_func=get_extra_data)
 
         self.assertNotEqual(old_hash, new_hash)
@@ -351,8 +385,7 @@ def get_extra_data(obj_class):
     # Get the SCHEMA items to add to the fingerprint
     # if we are looking at a notification
     if issubclass(obj_class, notificationbase.NotificationPayloadBase):
-        schema_data = collections.OrderedDict(
-            sorted(obj_class.SCHEMA.items()))
+        schema_data = collections.OrderedDict(sorted(obj_class.SCHEMA.items()))
 
         extra_data += (schema_data,)
 
diff --git a/watcher/tests/unit/notifications/test_service_notifications.py b/watcher/tests/unit/notifications/test_service_notifications.py
index 6ca2b6fce..5cd1ecfe4 100644
--- a/watcher/tests/unit/notifications/test_service_notifications.py
+++ b/watcher/tests/unit/notifications/test_service_notifications.py
@@ -29,7 +29,6 @@ from watcher.tests.unit.objects import utils
 
 @freezegun.freeze_time('2016-10-18T09:52:05.219414')
 class TestActionPlanNotification(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_get_notifier = mock.patch.object(rpc, 'get_notifier')
@@ -44,34 +43,35 @@ class TestActionPlanNotification(base.DbTestCase):
         m_get_notifier.side_effect = fake_get_notifier
 
     def test_service_failed(self):
-        service = utils.get_test_service(mock.Mock(),
-                                         created_at=timeutils.utcnow())
+        service = utils.get_test_service(
+            mock.Mock(), created_at=timeutils.utcnow()
+        )
         state = w_service.ServiceStatus.FAILED
-        notifications.service.send_service_update(mock.MagicMock(),
-                                                  service,
-                                                  state,
-                                                  host='node0')
+        notifications.service.send_service_update(
+            mock.MagicMock(), service, state, host='node0'
+        )
         notification = self.m_notifier.warning.call_args[1]
         payload = notification['payload']
         self.assertEqual("infra-optim:node0", self.m_notifier.publisher_id)
-        self.assertDictEqual({
-            'watcher_object.data': {
-                'last_seen_up': '2016-09-22T08:32:06Z',
-                'name': 'watcher-service',
-                'sevice_host': 'controller',
-                'status_update': {
-                    'watcher_object.data': {
-                        'old_state': 'ACTIVE',
-                        'state': 'FAILED'
+        self.assertDictEqual(
+            {
+                'watcher_object.data': {
+                    'last_seen_up': '2016-09-22T08:32:06Z',
+                    'name': 'watcher-service',
+                    'sevice_host': 'controller',
+                    'status_update': {
+                        'watcher_object.data': {
+                            'old_state': 'ACTIVE',
+                            'state': 'FAILED',
+                        },
+                        'watcher_object.name': 'ServiceStatusUpdatePayload',
+                        'watcher_object.namespace': 'watcher',
+                        'watcher_object.version': '1.0',
                     },
-                    'watcher_object.name': 'ServiceStatusUpdatePayload',
-                    'watcher_object.namespace': 'watcher',
-                    'watcher_object.version': '1.0'
-                }
+                },
+                'watcher_object.name': 'ServiceUpdatePayload',
+                'watcher_object.namespace': 'watcher',
+                'watcher_object.version': '1.0',
             },
-            'watcher_object.name': 'ServiceUpdatePayload',
-            'watcher_object.namespace': 'watcher',
-            'watcher_object.version': '1.0'
-        },
-            payload
+            payload,
         )
diff --git a/watcher/tests/unit/objects/test_action.py b/watcher/tests/unit/objects/test_action.py
index 0749801d4..98709568c 100644
--- a/watcher/tests/unit/objects/test_action.py
+++ b/watcher/tests/unit/objects/test_action.py
@@ -29,36 +29,52 @@ from watcher.tests.unit.db import utils
 
 
 class TestActionObject(base.DbTestCase):
-
     action_plan_id = 2
 
     scenarios = [
-        ('non_eager', dict(
-            eager=False,
-            fake_action=utils.get_test_action(
-                action_plan_id=action_plan_id))),
-        ('eager_with_non_eager_load', dict(
-            eager=True,
-            fake_action=utils.get_test_action(
-                action_plan_id=action_plan_id))),
-        ('eager_with_eager_load', dict(
-            eager=True,
-            fake_action=utils.get_test_action(
-                action_plan_id=action_plan_id,
-                action_plan=utils.get_test_action_plan(id=action_plan_id)))),
+        (
+            'non_eager',
+            dict(
+                eager=False,
+                fake_action=utils.get_test_action(
+                    action_plan_id=action_plan_id
+                ),
+            ),
+        ),
+        (
+            'eager_with_non_eager_load',
+            dict(
+                eager=True,
+                fake_action=utils.get_test_action(
+                    action_plan_id=action_plan_id
+                ),
+            ),
+        ),
+        (
+            'eager_with_eager_load',
+            dict(
+                eager=True,
+                fake_action=utils.get_test_action(
+                    action_plan_id=action_plan_id,
+                    action_plan=utils.get_test_action_plan(id=action_plan_id),
+                ),
+            ),
+        ),
     ]
 
     def setUp(self):
         super().setUp()
 
         p_action_notifications = mock.patch.object(
-            notifications, 'action_plan', autospec=True)
+            notifications, 'action_plan', autospec=True
+        )
         self.m_action_notifications = p_action_notifications.start()
         self.addCleanup(p_action_notifications.stop)
         self.m_send_update = self.m_action_notifications.send_update
 
         self.fake_action_plan = utils.create_test_action_plan(
-            id=self.action_plan_id)
+            id=self.action_plan_id
+        )
 
     def eager_action_assert(self, action):
         if self.eager:
@@ -67,11 +83,15 @@ class TestActionObject(base.DbTestCase):
                 super(objects.ActionPlan, objects.ActionPlan).fields
             ).symmetric_difference(objects.ActionPlan.fields)
             db_data = {
-                k: v for k, v in self.fake_action_plan.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in self.fake_action_plan.as_dict().items()
+                if k in fields_to_check
+            }
             object_data = {
-                k: v for k, v in action.action_plan.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in action.action_plan.as_dict().items()
+                if k in fields_to_check
+            }
             self.assertEqual(db_data, object_data)
 
     @mock.patch.object(db_api.Connection, 'get_action_by_id')
@@ -80,7 +100,8 @@ class TestActionObject(base.DbTestCase):
         action_id = self.fake_action['id']
         action = objects.Action.get(self.context, action_id, eager=self.eager)
         mock_get_action.assert_called_once_with(
-            self.context, action_id, eager=self.eager)
+            self.context, action_id, eager=self.eager
+        )
         self.assertEqual(self.context, action._context)
         self.eager_action_assert(action)
         self.assertEqual(0, self.m_send_update.call_count)
@@ -91,14 +112,19 @@ class TestActionObject(base.DbTestCase):
         uuid = self.fake_action['uuid']
         action = objects.Action.get(self.context, uuid, eager=self.eager)
         mock_get_action.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual(self.context, action._context)
         self.assertEqual(0, self.m_send_update.call_count)
 
     def test_get_bad_id_and_uuid(self):
-        self.assertRaises(exception.InvalidIdentity,
-                          objects.Action.get, self.context, 'not-a-uuid',
-                          eager=self.eager)
+        self.assertRaises(
+            exception.InvalidIdentity,
+            objects.Action.get,
+            self.context,
+            'not-a-uuid',
+            eager=self.eager,
+        )
 
     @mock.patch.object(db_api.Connection, 'get_action_list')
     def test_list(self, mock_get_list):
@@ -116,45 +142,61 @@ class TestActionObject(base.DbTestCase):
     @mock.patch.object(objects.Audit, 'get')
     @mock.patch.object(db_api.Connection, 'update_action')
     @mock.patch.object(db_api.Connection, 'get_action_by_uuid')
-    def test_save(self, mock_get_action, mock_update_action, mock_get_audit,
-                  mock_get_strategy):
+    def test_save(
+        self,
+        mock_get_action,
+        mock_update_action,
+        mock_get_audit,
+        mock_get_strategy,
+    ):
         mock_get_action.return_value = self.fake_action
         fake_saved_action = self.fake_action.copy()
         mock_get_audit.return_value = mock.PropertyMock(
-            uuid=c_utils.generate_uuid())
+            uuid=c_utils.generate_uuid()
+        )
         mock_get_strategy.return_value = mock.PropertyMock(
-            uuid=c_utils.generate_uuid())
+            uuid=c_utils.generate_uuid()
+        )
         fake_saved_action['updated_at'] = timeutils.utcnow()
         mock_update_action.return_value = fake_saved_action
         uuid = self.fake_action['uuid']
         action = objects.Action.get_by_uuid(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         action.state = objects.action.State.SUCCEEDED
         if not self.eager:
-            self.assertRaises(exception.EagerlyLoadedActionRequired,
-                              action.save)
+            self.assertRaises(
+                exception.EagerlyLoadedActionRequired, action.save
+            )
         else:
             action.save()
 
         expected_update_at = fake_saved_action['updated_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
 
         mock_get_action.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         mock_update_action.assert_called_once_with(
-            uuid, {'state': objects.action.State.SUCCEEDED})
+            uuid, {'state': objects.action.State.SUCCEEDED}
+        )
         self.assertEqual(self.context, action._context)
         self.assertEqual(expected_update_at, action.updated_at)
         self.assertEqual(0, self.m_send_update.call_count)
 
     @mock.patch.object(db_api.Connection, 'get_action_by_uuid')
     def test_refresh(self, mock_get_action):
-        returns = [dict(self.fake_action, state="first state"),
-                   dict(self.fake_action, state="second state")]
+        returns = [
+            dict(self.fake_action, state="first state"),
+            dict(self.fake_action, state="second state"),
+        ]
         mock_get_action.side_effect = returns
         uuid = self.fake_action['uuid']
-        expected = [mock.call(self.context, uuid, eager=self.eager),
-                    mock.call(self.context, uuid, eager=self.eager)]
+        expected = [
+            mock.call(self.context, uuid, eager=self.eager),
+            mock.call(self.context, uuid, eager=self.eager),
+        ]
         action = objects.Action.get(self.context, uuid, eager=self.eager)
         self.assertEqual("first state", action.state)
         action.refresh(eager=self.eager)
@@ -166,15 +208,14 @@ class TestActionObject(base.DbTestCase):
 
 
 class TestCreateDeleteActionObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_strategy = utils.create_test_strategy(name="DUMMY")
         self.fake_audit = utils.create_test_audit()
         self.fake_action_plan = utils.create_test_action_plan()
         self.fake_action = utils.get_test_action(
-            created_at=timeutils.utcnow(),
-            status_message="Fake status message")
+            created_at=timeutils.utcnow(), status_message="Fake status message"
+        )
 
     @mock.patch.object(db_api.Connection, 'create_action')
     def test_create(self, mock_create_action):
@@ -183,7 +224,8 @@ class TestCreateDeleteActionObject(base.DbTestCase):
         action.create()
         expected_action = self.fake_action.copy()
         expected_action['created_at'] = expected_action['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         mock_create_action.assert_called_once_with(expected_action)
         self.assertEqual(self.context, action._context)
         self.assertEqual("Fake status message", action.status_message)
@@ -193,9 +235,14 @@ class TestCreateDeleteActionObject(base.DbTestCase):
     @mock.patch.object(db_api.Connection, 'update_action')
     @mock.patch.object(db_api.Connection, 'soft_delete_action')
     @mock.patch.object(db_api.Connection, 'get_action_by_uuid')
-    def test_soft_delete(self, mock_get_action,
-                         mock_soft_delete_action, mock_update_action,
-                         mock_send_update, mock_send_delete):
+    def test_soft_delete(
+        self,
+        mock_get_action,
+        mock_soft_delete_action,
+        mock_update_action,
+        mock_send_update,
+        mock_send_delete,
+    ):
         mock_get_action.return_value = self.fake_action
         fake_deleted_action = self.fake_action.copy()
         fake_deleted_action['deleted_at'] = timeutils.utcnow()
@@ -204,19 +251,23 @@ class TestCreateDeleteActionObject(base.DbTestCase):
 
         expected_action = fake_deleted_action.copy()
         expected_action['created_at'] = expected_action['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         expected_action['deleted_at'] = expected_action['deleted_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         del expected_action['action_plan']
 
         uuid = self.fake_action['uuid']
         action = objects.Action.get_by_uuid(self.context, uuid)
         action.soft_delete()
         mock_get_action.assert_called_once_with(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         mock_soft_delete_action.assert_called_once_with(uuid)
         mock_update_action.assert_called_once_with(
-            uuid, {'state': objects.action.State.DELETED})
+            uuid, {'state': objects.action.State.DELETED}
+        )
         self.assertEqual(self.context, action._context)
         self.assertEqual(expected_action, action.as_dict())
 
@@ -229,6 +280,7 @@ class TestCreateDeleteActionObject(base.DbTestCase):
         action.destroy()
 
         mock_get_action.assert_called_once_with(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         mock_destroy_action.assert_called_once_with(uuid)
         self.assertEqual(self.context, action._context)
diff --git a/watcher/tests/unit/objects/test_action_description.py b/watcher/tests/unit/objects/test_action_description.py
index 0902664be..91bedd645 100644
--- a/watcher/tests/unit/objects/test_action_description.py
+++ b/watcher/tests/unit/objects/test_action_description.py
@@ -26,20 +26,22 @@ from watcher.tests.unit.db import utils
 
 
 class TestActionDescriptionObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_action_desc = utils.get_test_action_desc(
-            created_at=timeutils.utcnow())
+            created_at=timeutils.utcnow()
+        )
 
     @mock.patch.object(db_api.Connection, 'get_action_description_by_id')
     def test_get_by_id(self, mock_get_action_desc):
         action_desc_id = self.fake_action_desc['id']
         mock_get_action_desc.return_value = self.fake_action_desc
         action_desc = objects.ActionDescription.get(
-            self.context, action_desc_id)
+            self.context, action_desc_id
+        )
         mock_get_action_desc.assert_called_once_with(
-            self.context, action_desc_id)
+            self.context, action_desc_id
+        )
         self.assertEqual(self.context, action_desc._context)
 
     @mock.patch.object(db_api.Connection, 'get_action_description_list')
@@ -55,12 +57,14 @@ class TestActionDescriptionObject(base.DbTestCase):
     def test_create(self, mock_create_action_desc):
         mock_create_action_desc.return_value = self.fake_action_desc
         action_desc = objects.ActionDescription(
-            self.context, **self.fake_action_desc)
+            self.context, **self.fake_action_desc
+        )
 
         action_desc.create()
         expected_action_desc = self.fake_action_desc.copy()
         expected_action_desc['created_at'] = expected_action_desc[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
 
         mock_create_action_desc.assert_called_once_with(expected_action_desc)
         self.assertEqual(self.context, action_desc._context)
@@ -79,17 +83,19 @@ class TestActionDescriptionObject(base.DbTestCase):
 
         mock_get_action_desc.assert_called_once_with(self.context, _id)
         mock_update_action_desc.assert_called_once_with(
-            _id, {'description': 'This is a test'})
+            _id, {'description': 'This is a test'}
+        )
         self.assertEqual(self.context, action_desc._context)
 
     @mock.patch.object(db_api.Connection, 'get_action_description_by_id')
     def test_refresh(self, mock_get_action_desc):
-        returns = [dict(self.fake_action_desc, description="Test message1"),
-                   dict(self.fake_action_desc, description="Test message2")]
+        returns = [
+            dict(self.fake_action_desc, description="Test message1"),
+            dict(self.fake_action_desc, description="Test message2"),
+        ]
         mock_get_action_desc.side_effect = returns
         _id = self.fake_action_desc['id']
-        expected = [mock.call(self.context, _id),
-                    mock.call(self.context, _id)]
+        expected = [mock.call(self.context, _id), mock.call(self.context, _id)]
         action_desc = objects.ActionDescription.get(self.context, _id)
         self.assertEqual("Test message1", action_desc.description)
         action_desc.refresh()
@@ -107,9 +113,11 @@ class TestActionDescriptionObject(base.DbTestCase):
 
         expected_action_desc = fake_deleted_action_desc.copy()
         expected_action_desc['created_at'] = expected_action_desc[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         expected_action_desc['deleted_at'] = expected_action_desc[
-            'deleted_at'].replace(tzinfo=datetime.timezone.utc)
+            'deleted_at'
+        ].replace(tzinfo=datetime.timezone.utc)
 
         _id = self.fake_action_desc['id']
         action_desc = objects.ActionDescription.get(self.context, _id)
diff --git a/watcher/tests/unit/objects/test_action_plan.py b/watcher/tests/unit/objects/test_action_plan.py
index b7aa9a1bc..d65e4def9 100644
--- a/watcher/tests/unit/objects/test_action_plan.py
+++ b/watcher/tests/unit/objects/test_action_plan.py
@@ -33,45 +33,61 @@ CONF = conf.CONF
 
 
 class TestActionPlanObject(base.DbTestCase):
-
     audit_id = 2
     strategy_id = 2
 
     scenarios = [
-        ('non_eager', dict(
-            eager=False,
-            fake_action_plan=utils.get_test_action_plan(
-                created_at=timeutils.utcnow(),
-                audit_id=audit_id,
-                strategy_id=strategy_id))),
-        ('eager_with_non_eager_load', dict(
-            eager=True,
-            fake_action_plan=utils.get_test_action_plan(
-                created_at=timeutils.utcnow(),
-                audit_id=audit_id,
-                strategy_id=strategy_id))),
-        ('eager_with_eager_load', dict(
-            eager=True,
-            fake_action_plan=utils.get_test_action_plan(
-                created_at=timeutils.utcnow(),
-                strategy_id=strategy_id,
-                strategy=utils.get_test_strategy(id=strategy_id),
-                audit_id=audit_id,
-                audit=utils.get_test_audit(id=audit_id)))),
+        (
+            'non_eager',
+            dict(
+                eager=False,
+                fake_action_plan=utils.get_test_action_plan(
+                    created_at=timeutils.utcnow(),
+                    audit_id=audit_id,
+                    strategy_id=strategy_id,
+                ),
+            ),
+        ),
+        (
+            'eager_with_non_eager_load',
+            dict(
+                eager=True,
+                fake_action_plan=utils.get_test_action_plan(
+                    created_at=timeutils.utcnow(),
+                    audit_id=audit_id,
+                    strategy_id=strategy_id,
+                ),
+            ),
+        ),
+        (
+            'eager_with_eager_load',
+            dict(
+                eager=True,
+                fake_action_plan=utils.get_test_action_plan(
+                    created_at=timeutils.utcnow(),
+                    strategy_id=strategy_id,
+                    strategy=utils.get_test_strategy(id=strategy_id),
+                    audit_id=audit_id,
+                    audit=utils.get_test_audit(id=audit_id),
+                ),
+            ),
+        ),
     ]
 
     def setUp(self):
         super().setUp()
 
         p_action_plan_notifications = mock.patch.object(
-            notifications, 'action_plan', autospec=True)
+            notifications, 'action_plan', autospec=True
+        )
         self.m_action_plan_notifications = p_action_plan_notifications.start()
         self.addCleanup(p_action_plan_notifications.stop)
         self.m_send_update = self.m_action_plan_notifications.send_update
 
         self.fake_audit = utils.create_test_audit(id=self.audit_id)
         self.fake_strategy = utils.create_test_strategy(
-            id=self.strategy_id, name="DUMMY")
+            id=self.strategy_id, name="DUMMY"
+        )
 
     def eager_load_action_plan_assert(self, action_plan):
         if self.eager:
@@ -80,11 +96,15 @@ class TestActionPlanObject(base.DbTestCase):
                 super(objects.Audit, objects.Audit).fields
             ).symmetric_difference(objects.Audit.fields)
             db_data = {
-                k: v for k, v in self.fake_audit.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in self.fake_audit.as_dict().items()
+                if k in fields_to_check
+            }
             object_data = {
-                k: v for k, v in action_plan.audit.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in action_plan.audit.as_dict().items()
+                if k in fields_to_check
+            }
             self.assertEqual(db_data, object_data)
 
     @mock.patch.object(db_api.Connection, 'get_action_plan_by_id')
@@ -92,9 +112,11 @@ class TestActionPlanObject(base.DbTestCase):
         mock_get_action_plan.return_value = self.fake_action_plan
         action_plan_id = self.fake_action_plan['id']
         action_plan = objects.ActionPlan.get(
-            self.context, action_plan_id, eager=self.eager)
+            self.context, action_plan_id, eager=self.eager
+        )
         mock_get_action_plan.assert_called_once_with(
-            self.context, action_plan_id, eager=self.eager)
+            self.context, action_plan_id, eager=self.eager
+        )
         self.assertEqual(self.context, action_plan._context)
         self.eager_load_action_plan_assert(action_plan)
         self.assertEqual(0, self.m_send_update.call_count)
@@ -104,17 +126,23 @@ class TestActionPlanObject(base.DbTestCase):
         mock_get_action_plan.return_value = self.fake_action_plan
         uuid = self.fake_action_plan['uuid']
         action_plan = objects.ActionPlan.get(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         mock_get_action_plan.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual(self.context, action_plan._context)
         self.eager_load_action_plan_assert(action_plan)
         self.assertEqual(0, self.m_send_update.call_count)
 
     def test_get_bad_id_and_uuid(self):
-        self.assertRaises(exception.InvalidIdentity,
-                          objects.ActionPlan.get, self.context,
-                          'not-a-uuid', eager=self.eager)
+        self.assertRaises(
+            exception.InvalidIdentity,
+            objects.ActionPlan.get,
+            self.context,
+            'not-a-uuid',
+            eager=self.eager,
+        )
 
     @mock.patch.object(db_api.Connection, 'get_action_plan_list')
     def test_list(self, mock_get_list):
@@ -139,44 +167,59 @@ class TestActionPlanObject(base.DbTestCase):
         mock_update_action_plan.return_value = fake_saved_action_plan
 
         expected_action_plan = fake_saved_action_plan.copy()
-        expected_action_plan[
-            'created_at'] = expected_action_plan['created_at'].replace(
-                tzinfo=datetime.timezone.utc)
-        expected_action_plan[
-            'updated_at'] = expected_action_plan['updated_at'].replace(
-                tzinfo=datetime.timezone.utc)
+        expected_action_plan['created_at'] = expected_action_plan[
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
+        expected_action_plan['updated_at'] = expected_action_plan[
+            'updated_at'
+        ].replace(tzinfo=datetime.timezone.utc)
 
         uuid = self.fake_action_plan['uuid']
         action_plan = objects.ActionPlan.get_by_uuid(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         action_plan.state = objects.action_plan.State.SUCCEEDED
         action_plan.save()
 
         mock_get_action_plan.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         mock_update_action_plan.assert_called_once_with(
-            uuid, {'state': objects.action_plan.State.SUCCEEDED})
+            uuid, {'state': objects.action_plan.State.SUCCEEDED}
+        )
         self.assertEqual(self.context, action_plan._context)
         self.eager_load_action_plan_assert(action_plan)
         self.m_send_update.assert_called_once_with(
-            self.context, action_plan,
-            old_state=self.fake_action_plan['state'])
+            self.context, action_plan, old_state=self.fake_action_plan['state']
+        )
         self.assertEqual(
-            {k: v for k, v in expected_action_plan.items()
-             if k not in action_plan.object_fields},
-            {k: v for k, v in action_plan.as_dict().items()
-             if k not in action_plan.object_fields})
+            {
+                k: v
+                for k, v in expected_action_plan.items()
+                if k not in action_plan.object_fields
+            },
+            {
+                k: v
+                for k, v in action_plan.as_dict().items()
+                if k not in action_plan.object_fields
+            },
+        )
 
     @mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid')
     def test_refresh(self, mock_get_action_plan):
-        returns = [dict(self.fake_action_plan, state="first state"),
-                   dict(self.fake_action_plan, state="second state")]
+        returns = [
+            dict(self.fake_action_plan, state="first state"),
+            dict(self.fake_action_plan, state="second state"),
+        ]
         mock_get_action_plan.side_effect = returns
         uuid = self.fake_action_plan['uuid']
-        expected = [mock.call(self.context, uuid, eager=self.eager),
-                    mock.call(self.context, uuid, eager=self.eager)]
+        expected = [
+            mock.call(self.context, uuid, eager=self.eager),
+            mock.call(self.context, uuid, eager=self.eager),
+        ]
         action_plan = objects.ActionPlan.get(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual("first state", action_plan.state)
         action_plan.refresh(eager=self.eager)
         self.assertEqual("second state", action_plan.state)
@@ -186,12 +229,12 @@ class TestActionPlanObject(base.DbTestCase):
 
 
 class TestCreateDeleteActionPlanObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
 
         p_action_plan_notifications = mock.patch.object(
-            notifications, 'action_plan', autospec=True)
+            notifications, 'action_plan', autospec=True
+        )
         self.m_action_plan_notifications = p_action_plan_notifications.start()
         self.addCleanup(p_action_plan_notifications.stop)
         self.m_send_update = self.m_action_plan_notifications.send_update
@@ -199,17 +242,18 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
         self.fake_strategy = utils.create_test_strategy(name="DUMMY")
         self.fake_audit = utils.create_test_audit()
         self.fake_action_plan = utils.get_test_action_plan(
-            created_at=timeutils.utcnow())
+            created_at=timeutils.utcnow()
+        )
 
     @mock.patch.object(db_api.Connection, 'create_action_plan')
     def test_create(self, mock_create_action_plan):
         mock_create_action_plan.return_value = self.fake_action_plan
-        action_plan = objects.ActionPlan(
-            self.context, **self.fake_action_plan)
+        action_plan = objects.ActionPlan(self.context, **self.fake_action_plan)
         action_plan.create()
         expected_action_plan = self.fake_action_plan.copy()
         expected_action_plan['created_at'] = expected_action_plan[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         mock_create_action_plan.assert_called_once_with(expected_action_plan)
         self.assertEqual(self.context, action_plan._context)
 
@@ -221,12 +265,17 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
         get_efficacy_indicator_list=mock.DEFAULT,
         soft_delete_efficacy_indicator=mock.DEFAULT,
     )
-    def test_soft_delete(self, get_action_plan_by_uuid,
-                         soft_delete_action_plan, update_action_plan,
-                         get_efficacy_indicator_list,
-                         soft_delete_efficacy_indicator):
+    def test_soft_delete(
+        self,
+        get_action_plan_by_uuid,
+        soft_delete_action_plan,
+        update_action_plan,
+        get_efficacy_indicator_list,
+        soft_delete_efficacy_indicator,
+    ):
         efficacy_indicator = utils.get_test_efficacy_indicator(
-            action_plan_id=self.fake_action_plan['id'])
+            action_plan_id=self.fake_action_plan['id']
+        )
         uuid = self.fake_action_plan['uuid']
         m_get_action_plan = get_action_plan_by_uuid
         m_soft_delete_action_plan = soft_delete_action_plan
@@ -241,27 +290,38 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
         m_soft_delete_action_plan.return_value = fake_deleted_action_plan
         expected_action_plan = fake_deleted_action_plan.copy()
         expected_action_plan['created_at'] = expected_action_plan[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         expected_action_plan['deleted_at'] = expected_action_plan[
-            'deleted_at'].replace(tzinfo=datetime.timezone.utc)
+            'deleted_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         del expected_action_plan['audit']
         del expected_action_plan['strategy']
 
         m_get_efficacy_indicator_list.return_value = [efficacy_indicator]
         action_plan = objects.ActionPlan.get_by_uuid(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         action_plan.soft_delete()
 
         m_get_action_plan.assert_called_once_with(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         m_get_efficacy_indicator_list.assert_called_once_with(
-            self.context, filters={"action_plan_uuid": uuid},
-            limit=None, marker=None, sort_dir=None, sort_key=None)
+            self.context,
+            filters={"action_plan_uuid": uuid},
+            limit=None,
+            marker=None,
+            sort_dir=None,
+            sort_key=None,
+        )
         m_soft_delete_action_plan.assert_called_once_with(uuid)
         m_soft_delete_efficacy_indicator.assert_called_once_with(
-            efficacy_indicator['uuid'])
+            efficacy_indicator['uuid']
+        )
         m_update_action_plan.assert_called_once_with(
-            uuid, {'state': objects.action_plan.State.DELETED})
+            uuid, {'state': objects.action_plan.State.DELETED}
+        )
 
         self.assertEqual(self.context, action_plan._context)
         self.assertEqual(expected_action_plan, action_plan.as_dict())
@@ -273,14 +333,20 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
         get_efficacy_indicator_list=mock.DEFAULT,
         destroy_efficacy_indicator=mock.DEFAULT,
     )
-    def test_destroy(self, get_action_plan_by_uuid, destroy_action_plan,
-                     get_efficacy_indicator_list, destroy_efficacy_indicator):
+    def test_destroy(
+        self,
+        get_action_plan_by_uuid,
+        destroy_action_plan,
+        get_efficacy_indicator_list,
+        destroy_efficacy_indicator,
+    ):
         m_get_action_plan = get_action_plan_by_uuid
         m_destroy_action_plan = destroy_action_plan
         m_get_efficacy_indicator_list = get_efficacy_indicator_list
         m_destroy_efficacy_indicator = destroy_efficacy_indicator
         efficacy_indicator = utils.get_test_efficacy_indicator(
-            action_plan_id=self.fake_action_plan['id'])
+            action_plan_id=self.fake_action_plan['id']
+        )
         uuid = self.fake_action_plan['uuid']
         m_get_action_plan.return_value = self.fake_action_plan
         m_get_efficacy_indicator_list.return_value = [efficacy_indicator]
@@ -288,39 +354,49 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
         action_plan.destroy()
 
         m_get_action_plan.assert_called_once_with(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         m_get_efficacy_indicator_list.assert_called_once_with(
-            self.context, filters={"action_plan_uuid": uuid},
-            limit=None, marker=None, sort_dir=None, sort_key=None)
+            self.context,
+            filters={"action_plan_uuid": uuid},
+            limit=None,
+            marker=None,
+            sort_dir=None,
+            sort_key=None,
+        )
         m_destroy_action_plan.assert_called_once_with(uuid)
         m_destroy_efficacy_indicator.assert_called_once_with(
-            efficacy_indicator['uuid'])
+            efficacy_indicator['uuid']
+        )
         self.assertEqual(self.context, action_plan._context)
 
 
 @mock.patch.object(notifications.action_plan, 'send_update', mock.Mock())
 class TestStateManager(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.state_manager = objects.action_plan.StateManager()
 
     def test_check_expired(self):
-        CONF.set_default('action_plan_expiry', 0,
-                         group='watcher_decision_engine')
+        CONF.set_default(
+            'action_plan_expiry', 0, group='watcher_decision_engine'
+        )
         strategy_1 = utils.create_test_strategy(
-            uuid=common_utils.generate_uuid())
-        audit_1 = utils.create_test_audit(
-            uuid=common_utils.generate_uuid())
+            uuid=common_utils.generate_uuid()
+        )
+        audit_1 = utils.create_test_audit(uuid=common_utils.generate_uuid())
         action_plan_1 = utils.create_test_action_plan(
             state=objects.action_plan.State.RECOMMENDED,
             uuid=common_utils.generate_uuid(),
             audit_id=audit_1.id,
-            strategy_id=strategy_1.id)
+            strategy_id=strategy_1.id,
+        )
 
         self.state_manager.check_expired(self.context)
 
         action_plan = objects.action_plan.ActionPlan.get_by_uuid(
-            self.context, action_plan_1.uuid)
-        self.assertEqual(objects.action_plan.State.SUPERSEDED,
-                         action_plan.state)
+            self.context, action_plan_1.uuid
+        )
+        self.assertEqual(
+            objects.action_plan.State.SUPERSEDED, action_plan.state
+        )
diff --git a/watcher/tests/unit/objects/test_audit.py b/watcher/tests/unit/objects/test_audit.py
index 5b24b7793..3a845744e 100644
--- a/watcher/tests/unit/objects/test_audit.py
+++ b/watcher/tests/unit/objects/test_audit.py
@@ -31,35 +31,50 @@ from watcher.tests.unit.objects import utils as objutils
 
 
 class TestAuditObject(base.DbTestCase):
-
     goal_id = 2
 
     goal_data = utils.get_test_goal(
-        id=goal_id, uuid=w_utils.generate_uuid(), name="DUMMY")
+        id=goal_id, uuid=w_utils.generate_uuid(), name="DUMMY"
+    )
 
     scenarios = [
-        ('non_eager', dict(
-            eager=False,
-            fake_audit=utils.get_test_audit(
-                created_at=timeutils.utcnow(),
-                goal_id=goal_id))),
-        ('eager_with_non_eager_load', dict(
-            eager=True,
-            fake_audit=utils.get_test_audit(
-                created_at=timeutils.utcnow(),
-                goal_id=goal_id))),
-        ('eager_with_eager_load', dict(
-            eager=True,
-            fake_audit=utils.get_test_audit(
-                created_at=timeutils.utcnow(),
-                goal_id=goal_id, goal=goal_data))),
+        (
+            'non_eager',
+            dict(
+                eager=False,
+                fake_audit=utils.get_test_audit(
+                    created_at=timeutils.utcnow(), goal_id=goal_id
+                ),
+            ),
+        ),
+        (
+            'eager_with_non_eager_load',
+            dict(
+                eager=True,
+                fake_audit=utils.get_test_audit(
+                    created_at=timeutils.utcnow(), goal_id=goal_id
+                ),
+            ),
+        ),
+        (
+            'eager_with_eager_load',
+            dict(
+                eager=True,
+                fake_audit=utils.get_test_audit(
+                    created_at=timeutils.utcnow(),
+                    goal_id=goal_id,
+                    goal=goal_data,
+                ),
+            ),
+        ),
     ]
 
     def setUp(self):
         super().setUp()
 
         p_audit_notifications = mock.patch.object(
-            notifications, 'audit', autospec=True)
+            notifications, 'audit', autospec=True
+        )
         self.m_audit_notifications = p_audit_notifications.start()
         self.addCleanup(p_audit_notifications.stop)
         self.m_send_update = self.m_audit_notifications.send_update
@@ -72,11 +87,13 @@ class TestAuditObject(base.DbTestCase):
                 super(objects.Goal, objects.Goal).fields
             ).symmetric_difference(objects.Goal.fields)
             db_data = {
-                k: v for k, v in goal.as_dict().items()
-                if k in fields_to_check}
+                k: v for k, v in goal.as_dict().items() if k in fields_to_check
+            }
             object_data = {
-                k: v for k, v in audit.goal.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in audit.goal.as_dict().items()
+                if k in fields_to_check
+            }
             self.assertEqual(db_data, object_data)
 
     @mock.patch.object(db_api.Connection, 'get_audit_by_id')
@@ -85,7 +102,8 @@ class TestAuditObject(base.DbTestCase):
         audit_id = self.fake_audit['id']
         audit = objects.Audit.get(self.context, audit_id, eager=self.eager)
         mock_get_audit.assert_called_once_with(
-            self.context, audit_id, eager=self.eager)
+            self.context, audit_id, eager=self.eager
+        )
         self.assertEqual(self.context, audit._context)
         self.eager_load_audit_assert(audit, self.fake_goal)
         self.assertEqual(0, self.m_send_update.call_count)
@@ -96,23 +114,34 @@ class TestAuditObject(base.DbTestCase):
         uuid = self.fake_audit['uuid']
         audit = objects.Audit.get(self.context, uuid, eager=self.eager)
         mock_get_audit.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual(self.context, audit._context)
         self.eager_load_audit_assert(audit, self.fake_goal)
         self.assertEqual(0, self.m_send_update.call_count)
 
     def test_get_bad_id_and_uuid(self):
-        self.assertRaises(exception.InvalidIdentity,
-                          objects.Audit.get, self.context,
-                          'not-a-uuid', eager=self.eager)
+        self.assertRaises(
+            exception.InvalidIdentity,
+            objects.Audit.get,
+            self.context,
+            'not-a-uuid',
+            eager=self.eager,
+        )
 
     @mock.patch.object(db_api.Connection, 'get_audit_list')
     def test_list(self, mock_get_list):
         mock_get_list.return_value = [self.fake_audit]
         audits = objects.Audit.list(self.context, eager=self.eager)
         mock_get_list.assert_called_once_with(
-            self.context, eager=self.eager, filters=None, limit=None,
-            marker=None, sort_dir=None, sort_key=None)
+            self.context,
+            eager=self.eager,
+            filters=None,
+            limit=None,
+            marker=None,
+            sort_dir=None,
+            sort_key=None,
+        )
         self.assertEqual(1, len(audits))
         self.assertIsInstance(audits[0], objects.Audit)
         self.assertEqual(self.context, audits[0]._context)
@@ -131,9 +160,11 @@ class TestAuditObject(base.DbTestCase):
 
         expected_audit = fake_saved_audit.copy()
         expected_audit['created_at'] = expected_audit['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         expected_audit['updated_at'] = expected_audit['updated_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
 
         uuid = self.fake_audit['uuid']
         audit = objects.Audit.get_by_uuid(self.context, uuid, eager=self.eager)
@@ -141,28 +172,41 @@ class TestAuditObject(base.DbTestCase):
         audit.save()
 
         mock_get_audit.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         mock_update_audit.assert_called_once_with(
-            uuid, {'state': objects.audit.State.SUCCEEDED})
+            uuid, {'state': objects.audit.State.SUCCEEDED}
+        )
         self.assertEqual(self.context, audit._context)
         self.eager_load_audit_assert(audit, self.fake_goal)
         self.m_send_update.assert_called_once_with(
-            self.context, audit, old_state=self.fake_audit['state'])
+            self.context, audit, old_state=self.fake_audit['state']
+        )
         self.assertEqual(
-            {k: v for k, v in expected_audit.items()
-             if k not in audit.object_fields},
-            {k: v for k, v in audit.as_dict().items()
-             if k not in audit.object_fields})
+            {
+                k: v
+                for k, v in expected_audit.items()
+                if k not in audit.object_fields
+            },
+            {
+                k: v
+                for k, v in audit.as_dict().items()
+                if k not in audit.object_fields
+            },
+        )
 
     @mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
     def test_refresh(self, mock_get_audit):
-        returns = [dict(self.fake_audit, state="first state"),
-                   dict(self.fake_audit, state="second state")]
+        returns = [
+            dict(self.fake_audit, state="first state"),
+            dict(self.fake_audit, state="second state"),
+        ]
         mock_get_audit.side_effect = returns
         uuid = self.fake_audit['uuid']
         expected = [
             mock.call(self.context, uuid, eager=self.eager),
-            mock.call(self.context, uuid, eager=self.eager)]
+            mock.call(self.context, uuid, eager=self.eager),
+        ]
         audit = objects.Audit.get(self.context, uuid, eager=self.eager)
         self.assertEqual("first state", audit.state)
         audit.refresh(eager=self.eager)
@@ -173,11 +217,11 @@ class TestAuditObject(base.DbTestCase):
 
 
 class TestCreateDeleteAuditObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         p_audit_notifications = mock.patch.object(
-            notifications, 'audit', autospec=True)
+            notifications, 'audit', autospec=True
+        )
         self.m_audit_notifications = p_audit_notifications.start()
         self.addCleanup(p_audit_notifications.stop)
         self.m_send_update = self.m_audit_notifications.send_update
@@ -185,7 +229,8 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
         self.goal_id = 1
         self.goal = utils.create_test_goal(id=self.goal_id, name="DUMMY")
         self.fake_audit = utils.get_test_audit(
-            goal_id=self.goal_id, created_at=timeutils.utcnow())
+            goal_id=self.goal_id, created_at=timeutils.utcnow()
+        )
 
     @mock.patch.object(db_api.Connection, 'create_audit')
     def test_create(self, mock_create_audit):
@@ -194,15 +239,17 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
         audit.create()
         expected_audit = self.fake_audit.copy()
         expected_audit['created_at'] = expected_audit['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         mock_create_audit.assert_called_once_with(expected_audit)
         self.assertEqual(self.context, audit._context)
 
     @mock.patch.object(db_api.Connection, 'update_audit')
     @mock.patch.object(db_api.Connection, 'soft_delete_audit')
     @mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
-    def test_soft_delete(self, mock_get_audit,
-                         mock_soft_delete_audit, mock_update_audit):
+    def test_soft_delete(
+        self, mock_get_audit, mock_soft_delete_audit, mock_update_audit
+    ):
         mock_get_audit.return_value = self.fake_audit
         fake_deleted_audit = self.fake_audit.copy()
         fake_deleted_audit['deleted_at'] = timeutils.utcnow()
@@ -211,9 +258,11 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
 
         expected_audit = fake_deleted_audit.copy()
         expected_audit['created_at'] = expected_audit['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         expected_audit['deleted_at'] = expected_audit['deleted_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         del expected_audit['goal']
         del expected_audit['strategy']
 
@@ -228,29 +277,30 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
 
     @mock.patch.object(db_api.Connection, 'destroy_audit')
     @mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
-    def test_destroy(self, mock_get_audit,
-                     mock_destroy_audit):
+    def test_destroy(self, mock_get_audit, mock_destroy_audit):
         mock_get_audit.return_value = self.fake_audit
         uuid = self.fake_audit['uuid']
         audit = objects.Audit.get_by_uuid(self.context, uuid)
         audit.destroy()
-        mock_get_audit.assert_called_once_with(
-            self.context, uuid, eager=False)
+        mock_get_audit.assert_called_once_with(self.context, uuid, eager=False)
         mock_destroy_audit.assert_called_once_with(uuid)
         self.assertEqual(self.context, audit._context)
 
 
 class TestAuditObjectSendNotifications(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         goal_id = 1
         self.fake_goal = utils.create_test_goal(id=goal_id, name="DUMMY")
         self.fake_strategy = utils.create_test_strategy(
-            id=goal_id, name="DUMMY")
+            id=goal_id, name="DUMMY"
+        )
         self.fake_audit = utils.get_test_audit(
-            goal_id=goal_id, goal=utils.get_test_goal(id=goal_id),
-            strategy_id=self.fake_strategy.id, strategy=self.fake_strategy)
+            goal_id=goal_id,
+            goal=utils.get_test_goal(id=goal_id),
+            strategy_id=self.fake_strategy.id,
+            strategy=self.fake_strategy,
+        )
 
         p_get_notifier = mock.patch.object(rpc, 'get_notifier')
         self.m_get_notifier = p_get_notifier.start()
@@ -264,7 +314,8 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
         fake_audit = utils.get_test_audit(
             goal=self.fake_goal.as_dict(),
             strategy_id=self.fake_strategy.id,
-            strategy=self.fake_strategy.as_dict())
+            strategy=self.fake_strategy.as_dict(),
+        )
         m_get_audit.return_value = fake_audit
         fake_saved_audit = self.fake_audit.copy()
         fake_saved_audit['state'] = objects.audit.State.SUCCEEDED
@@ -276,8 +327,9 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
         audit.save()
 
         self.assertEqual(1, self.m_notifier.info.call_count)
-        self.assertEqual('audit.update',
-                         self.m_notifier.info.call_args[1]['event_type'])
+        self.assertEqual(
+            'audit.update', self.m_notifier.info.call_args[1]['event_type']
+        )
 
     @mock.patch.object(db_api.Connection, 'create_audit')
     def test_send_create_notification(self, m_create_audit):
@@ -287,29 +339,34 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
             goal_id=self.fake_goal.id,
             strategy_id=self.fake_strategy.id,
             goal=self.fake_goal.as_dict(),
-            strategy=self.fake_strategy.as_dict())
+            strategy=self.fake_strategy.as_dict(),
+        )
         m_create_audit.return_value = audit
         audit.create()
 
         self.assertEqual(1, self.m_notifier.info.call_count)
-        self.assertEqual('audit.create',
-                         self.m_notifier.info.call_args[1]['event_type'])
+        self.assertEqual(
+            'audit.create', self.m_notifier.info.call_args[1]['event_type']
+        )
 
     @mock.patch.object(db_api.Connection, 'update_audit')
     @mock.patch.object(db_api.Connection, 'soft_delete_audit')
     @mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
     def test_send_delete_notification(
-            self, m_get_audit, m_soft_delete_audit, m_update_audit):
+        self, m_get_audit, m_soft_delete_audit, m_update_audit
+    ):
         fake_audit = utils.get_test_audit(
             goal=self.fake_goal.as_dict(),
             strategy_id=self.fake_strategy.id,
-            strategy=self.fake_strategy.as_dict())
+            strategy=self.fake_strategy.as_dict(),
+        )
         m_get_audit.return_value = fake_audit
         fake_deleted_audit = self.fake_audit.copy()
         fake_deleted_audit['deleted_at'] = timeutils.utcnow()
         expected_audit = fake_deleted_audit.copy()
         expected_audit['deleted_at'] = expected_audit['deleted_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
 
         m_soft_delete_audit.return_value = fake_deleted_audit
         m_update_audit.return_value = fake_deleted_audit
@@ -320,7 +377,9 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
         self.assertEqual(2, self.m_notifier.info.call_count)
         self.assertEqual(
             'audit.update',
-            self.m_notifier.info.call_args_list[0][1]['event_type'])
+            self.m_notifier.info.call_args_list[0][1]['event_type'],
+        )
         self.assertEqual(
             'audit.delete',
-            self.m_notifier.info.call_args_list[1][1]['event_type'])
+            self.m_notifier.info.call_args_list[1][1]['event_type'],
+        )
diff --git a/watcher/tests/unit/objects/test_audit_template.py b/watcher/tests/unit/objects/test_audit_template.py
index b96ede94e..9d6ed8b2a 100644
--- a/watcher/tests/unit/objects/test_audit_template.py
+++ b/watcher/tests/unit/objects/test_audit_template.py
@@ -28,28 +28,42 @@ from watcher.tests.unit.db import utils
 
 
 class TestAuditTemplateObject(base.DbTestCase):
-
     goal_id = 1
 
     goal_data = utils.get_test_goal(
-        id=goal_id, uuid=w_utils.generate_uuid(), name="DUMMY")
+        id=goal_id, uuid=w_utils.generate_uuid(), name="DUMMY"
+    )
 
     scenarios = [
-        ('non_eager', dict(
-            eager=False,
-            fake_audit_template=utils.get_test_audit_template(
-                created_at=timeutils.utcnow(),
-                goal_id=goal_id))),
-        ('eager_with_non_eager_load', dict(
-            eager=True,
-            fake_audit_template=utils.get_test_audit_template(
-                created_at=timeutils.utcnow(),
-                goal_id=goal_id))),
-        ('eager_with_eager_load', dict(
-            eager=True,
-            fake_audit_template=utils.get_test_audit_template(
-                created_at=timeutils.utcnow(),
-                goal_id=goal_id, goal=goal_data))),
+        (
+            'non_eager',
+            dict(
+                eager=False,
+                fake_audit_template=utils.get_test_audit_template(
+                    created_at=timeutils.utcnow(), goal_id=goal_id
+                ),
+            ),
+        ),
+        (
+            'eager_with_non_eager_load',
+            dict(
+                eager=True,
+                fake_audit_template=utils.get_test_audit_template(
+                    created_at=timeutils.utcnow(), goal_id=goal_id
+                ),
+            ),
+        ),
+        (
+            'eager_with_eager_load',
+            dict(
+                eager=True,
+                fake_audit_template=utils.get_test_audit_template(
+                    created_at=timeutils.utcnow(),
+                    goal_id=goal_id,
+                    goal=goal_data,
+                ),
+            ),
+        ),
     ]
 
     def setUp(self):
@@ -63,11 +77,13 @@ class TestAuditTemplateObject(base.DbTestCase):
                 super(objects.Goal, objects.Goal).fields
             ).symmetric_difference(objects.Goal.fields)
             db_data = {
-                k: v for k, v in goal.as_dict().items()
-                if k in fields_to_check}
+                k: v for k, v in goal.as_dict().items() if k in fields_to_check
+            }
             object_data = {
-                k: v for k, v in audit_template.goal.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in audit_template.goal.as_dict().items()
+                if k in fields_to_check
+            }
             self.assertEqual(db_data, object_data)
 
     @mock.patch.object(db_api.Connection, 'get_audit_template_by_id')
@@ -75,9 +91,11 @@ class TestAuditTemplateObject(base.DbTestCase):
         mock_get_audit_template.return_value = self.fake_audit_template
         audit_template_id = self.fake_audit_template['id']
         audit_template = objects.AuditTemplate.get(
-            self.context, audit_template_id, eager=self.eager)
+            self.context, audit_template_id, eager=self.eager
+        )
         mock_get_audit_template.assert_called_once_with(
-            self.context, audit_template_id, eager=self.eager)
+            self.context, audit_template_id, eager=self.eager
+        )
         self.assertEqual(self.context, audit_template._context)
         self.eager_load_audit_template_assert(audit_template, self.fake_goal)
 
@@ -86,9 +104,11 @@ class TestAuditTemplateObject(base.DbTestCase):
         mock_get_audit_template.return_value = self.fake_audit_template
         uuid = self.fake_audit_template['uuid']
         audit_template = objects.AuditTemplate.get(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         mock_get_audit_template.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual(self.context, audit_template._context)
         self.eager_load_audit_template_assert(audit_template, self.fake_goal)
 
@@ -97,31 +117,45 @@ class TestAuditTemplateObject(base.DbTestCase):
         mock_get_audit_template.return_value = self.fake_audit_template
         name = self.fake_audit_template['name']
         audit_template = objects.AuditTemplate.get_by_name(
-            self.context, name, eager=self.eager)
+            self.context, name, eager=self.eager
+        )
         mock_get_audit_template.assert_called_once_with(
-            self.context, name, eager=self.eager)
+            self.context, name, eager=self.eager
+        )
         self.assertEqual(self.context, audit_template._context)
         self.eager_load_audit_template_assert(audit_template, self.fake_goal)
 
     def test_get_bad_id_and_uuid(self):
-        self.assertRaises(exception.InvalidIdentity,
-                          objects.AuditTemplate.get,
-                          self.context, 'not-a-uuid', eager=self.eager)
+        self.assertRaises(
+            exception.InvalidIdentity,
+            objects.AuditTemplate.get,
+            self.context,
+            'not-a-uuid',
+            eager=self.eager,
+        )
 
     @mock.patch.object(db_api.Connection, 'get_audit_template_list')
     def test_list(self, mock_get_list):
         mock_get_list.return_value = [self.fake_audit_template]
         audit_templates = objects.AuditTemplate.list(
-            self.context, eager=self.eager)
+            self.context, eager=self.eager
+        )
         mock_get_list.assert_called_once_with(
-            self.context, eager=self.eager, filters=None, limit=None,
-            marker=None, sort_dir=None, sort_key=None)
+            self.context,
+            eager=self.eager,
+            filters=None,
+            limit=None,
+            marker=None,
+            sort_dir=None,
+            sort_key=None,
+        )
         self.assertEqual(1, len(audit_templates))
         self.assertIsInstance(audit_templates[0], objects.AuditTemplate)
         self.assertEqual(self.context, audit_templates[0]._context)
         for audit_template in audit_templates:
             self.eager_load_audit_template_assert(
-                audit_template, self.fake_goal)
+                audit_template, self.fake_goal
+            )
 
     @mock.patch.object(db_api.Connection, 'update_audit_template')
     @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
@@ -132,27 +166,35 @@ class TestAuditTemplateObject(base.DbTestCase):
         mock_update_audit_template.return_value = fake_saved_audit_template
         uuid = self.fake_audit_template['uuid']
         audit_template = objects.AuditTemplate.get_by_uuid(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         audit_template.goal_id = self.fake_goal.id
         audit_template.save()
 
         mock_get_audit_template.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         mock_update_audit_template.assert_called_once_with(
-            uuid, {'goal_id': self.fake_goal.id})
+            uuid, {'goal_id': self.fake_goal.id}
+        )
         self.assertEqual(self.context, audit_template._context)
         self.eager_load_audit_template_assert(audit_template, self.fake_goal)
 
     @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
     def test_refresh(self, mock_get_audit_template):
-        returns = [dict(self.fake_audit_template, name="first name"),
-                   dict(self.fake_audit_template, name="second name")]
+        returns = [
+            dict(self.fake_audit_template, name="first name"),
+            dict(self.fake_audit_template, name="second name"),
+        ]
         mock_get_audit_template.side_effect = returns
         uuid = self.fake_audit_template['uuid']
-        expected = [mock.call(self.context, uuid, eager=self.eager),
-                    mock.call(self.context, uuid, eager=self.eager)]
+        expected = [
+            mock.call(self.context, uuid, eager=self.eager),
+            mock.call(self.context, uuid, eager=self.eager),
+        ]
         audit_template = objects.AuditTemplate.get(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual("first name", audit_template.name)
         audit_template.refresh(eager=self.eager)
         self.assertEqual("second name", audit_template.name)
@@ -162,11 +204,11 @@ class TestAuditTemplateObject(base.DbTestCase):
 
 
 class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_audit_template = utils.get_test_audit_template(
-            created_at=timeutils.utcnow())
+            created_at=timeutils.utcnow()
+        )
 
     @mock.patch.object(db_api.Connection, 'create_audit_template')
     def test_create(self, mock_create_audit_template):
@@ -174,19 +216,23 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
         self.fake_audit_template['goal_id'] = goal.id
         mock_create_audit_template.return_value = self.fake_audit_template
         audit_template = objects.AuditTemplate(
-            self.context, **self.fake_audit_template)
+            self.context, **self.fake_audit_template
+        )
         audit_template.create()
         expected_audit_template = self.fake_audit_template.copy()
         expected_audit_template['created_at'] = expected_audit_template[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         mock_create_audit_template.assert_called_once_with(
-            expected_audit_template)
+            expected_audit_template
+        )
         self.assertEqual(self.context, audit_template._context)
 
     @mock.patch.object(db_api.Connection, 'soft_delete_audit_template')
     @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
-    def test_soft_delete(self, m_get_audit_template,
-                         m_soft_delete_audit_template):
+    def test_soft_delete(
+        self, m_get_audit_template, m_soft_delete_audit_template
+    ):
         m_get_audit_template.return_value = self.fake_audit_template
         fake_deleted_audit_template = self.fake_audit_template.copy()
         fake_deleted_audit_template['deleted_at'] = timeutils.utcnow()
@@ -194,9 +240,11 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
 
         expected_audit_template = fake_deleted_audit_template.copy()
         expected_audit_template['created_at'] = expected_audit_template[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         expected_audit_template['deleted_at'] = expected_audit_template[
-            'deleted_at'].replace(tzinfo=datetime.timezone.utc)
+            'deleted_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         del expected_audit_template['goal']
         del expected_audit_template['strategy']
 
@@ -204,20 +252,23 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
         audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid)
         audit_template.soft_delete()
         m_get_audit_template.assert_called_once_with(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         m_soft_delete_audit_template.assert_called_once_with(uuid)
         self.assertEqual(self.context, audit_template._context)
         self.assertEqual(expected_audit_template, audit_template.as_dict())
 
     @mock.patch.object(db_api.Connection, 'destroy_audit_template')
     @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
-    def test_destroy(self, mock_get_audit_template,
-                     mock_destroy_audit_template):
+    def test_destroy(
+        self, mock_get_audit_template, mock_destroy_audit_template
+    ):
         mock_get_audit_template.return_value = self.fake_audit_template
         uuid = self.fake_audit_template['uuid']
         audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid)
         audit_template.destroy()
         mock_get_audit_template.assert_called_once_with(
-            self.context, uuid, eager=False)
+            self.context, uuid, eager=False
+        )
         mock_destroy_audit_template.assert_called_once_with(uuid)
         self.assertEqual(self.context, audit_template._context)
diff --git a/watcher/tests/unit/objects/test_efficacy_indicator.py b/watcher/tests/unit/objects/test_efficacy_indicator.py
index b219d6278..d77260aa2 100644
--- a/watcher/tests/unit/objects/test_efficacy_indicator.py
+++ b/watcher/tests/unit/objects/test_efficacy_indicator.py
@@ -23,127 +23,157 @@ from watcher.tests.unit.db import utils
 
 
 class TestEfficacyIndicatorObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_efficacy_indicator = utils.get_test_efficacy_indicator()
 
     def test_get_by_id(self):
         efficacy_indicator_id = self.fake_efficacy_indicator['id']
-        with mock.patch.object(self.dbapi, 'get_efficacy_indicator_by_id',
-                               autospec=True) as mock_get_efficacy_indicator:
+        with mock.patch.object(
+            self.dbapi, 'get_efficacy_indicator_by_id', autospec=True
+        ) as mock_get_efficacy_indicator:
             mock_get_efficacy_indicator.return_value = (
-                self.fake_efficacy_indicator)
+                self.fake_efficacy_indicator
+            )
             efficacy_indicator = objects.EfficacyIndicator.get(
-                self.context, efficacy_indicator_id)
+                self.context, efficacy_indicator_id
+            )
             mock_get_efficacy_indicator.assert_called_once_with(
-                self.context, efficacy_indicator_id)
+                self.context, efficacy_indicator_id
+            )
             self.assertEqual(self.context, efficacy_indicator._context)
 
     def test_get_by_uuid(self):
         uuid = self.fake_efficacy_indicator['uuid']
-        with mock.patch.object(self.dbapi, 'get_efficacy_indicator_by_uuid',
-                               autospec=True) as mock_get_efficacy_indicator:
+        with mock.patch.object(
+            self.dbapi, 'get_efficacy_indicator_by_uuid', autospec=True
+        ) as mock_get_efficacy_indicator:
             mock_get_efficacy_indicator.return_value = (
-                self.fake_efficacy_indicator)
+                self.fake_efficacy_indicator
+            )
             efficacy_indicator = objects.EfficacyIndicator.get(
-                self.context, uuid)
+                self.context, uuid
+            )
             mock_get_efficacy_indicator.assert_called_once_with(
-                self.context, uuid)
+                self.context, uuid
+            )
             self.assertEqual(self.context, efficacy_indicator._context)
 
     def test_get_bad_id_and_uuid(self):
         self.assertRaises(
             exception.InvalidIdentity,
-            objects.EfficacyIndicator.get, self.context, 'not-a-uuid')
+            objects.EfficacyIndicator.get,
+            self.context,
+            'not-a-uuid',
+        )
 
     def test_list(self):
-        with mock.patch.object(self.dbapi, 'get_efficacy_indicator_list',
-                               autospec=True) as mock_get_list:
+        with mock.patch.object(
+            self.dbapi, 'get_efficacy_indicator_list', autospec=True
+        ) as mock_get_list:
             mock_get_list.return_value = [self.fake_efficacy_indicator]
             efficacy_indicators = objects.EfficacyIndicator.list(self.context)
             self.assertEqual(1, mock_get_list.call_count)
             self.assertEqual(1, len(efficacy_indicators))
             self.assertIsInstance(
-                efficacy_indicators[0], objects.EfficacyIndicator)
+                efficacy_indicators[0], objects.EfficacyIndicator
+            )
             self.assertEqual(self.context, efficacy_indicators[0]._context)
 
     def test_create(self):
         with mock.patch.object(
-            self.dbapi, 'create_efficacy_indicator',
-            autospec=True
+            self.dbapi, 'create_efficacy_indicator', autospec=True
         ) as mock_create_efficacy_indicator:
             mock_create_efficacy_indicator.return_value = (
-                self.fake_efficacy_indicator)
+                self.fake_efficacy_indicator
+            )
             efficacy_indicator = objects.EfficacyIndicator(
-                self.context, **self.fake_efficacy_indicator)
+                self.context, **self.fake_efficacy_indicator
+            )
 
             efficacy_indicator.create()
             mock_create_efficacy_indicator.assert_called_once_with(
-                self.fake_efficacy_indicator)
+                self.fake_efficacy_indicator
+            )
             self.assertEqual(self.context, efficacy_indicator._context)
 
     def test_destroy(self):
         uuid = self.fake_efficacy_indicator['uuid']
         with mock.patch.object(
-            self.dbapi, 'get_efficacy_indicator_by_uuid',
-            autospec=True
+            self.dbapi, 'get_efficacy_indicator_by_uuid', autospec=True
         ) as mock_get_efficacy_indicator:
             mock_get_efficacy_indicator.return_value = (
-                self.fake_efficacy_indicator)
+                self.fake_efficacy_indicator
+            )
             with mock.patch.object(
-                self.dbapi, 'destroy_efficacy_indicator',
-                autospec=True
+                self.dbapi, 'destroy_efficacy_indicator', autospec=True
             ) as mock_destroy_efficacy_indicator:
                 efficacy_indicator = objects.EfficacyIndicator.get_by_uuid(
-                    self.context, uuid)
+                    self.context, uuid
+                )
                 efficacy_indicator.destroy()
                 mock_get_efficacy_indicator.assert_called_once_with(
-                    self.context, uuid)
+                    self.context, uuid
+                )
                 mock_destroy_efficacy_indicator.assert_called_once_with(uuid)
                 self.assertEqual(self.context, efficacy_indicator._context)
 
     def test_save(self):
         uuid = self.fake_efficacy_indicator['uuid']
         with mock.patch.object(
-            self.dbapi, 'get_efficacy_indicator_by_uuid',
-            autospec=True
+            self.dbapi, 'get_efficacy_indicator_by_uuid', autospec=True
         ) as mock_get_efficacy_indicator:
             mock_get_efficacy_indicator.return_value = (
-                self.fake_efficacy_indicator)
+                self.fake_efficacy_indicator
+            )
             with mock.patch.object(
-                self.dbapi, 'update_efficacy_indicator',
-                autospec=True
+                self.dbapi, 'update_efficacy_indicator', autospec=True
             ) as mock_update_efficacy_indicator:
                 efficacy_indicator = objects.EfficacyIndicator.get_by_uuid(
-                    self.context, uuid)
+                    self.context, uuid
+                )
                 efficacy_indicator.description = 'Indicator Description'
                 efficacy_indicator.save()
 
                 mock_get_efficacy_indicator.assert_called_once_with(
-                    self.context, uuid)
+                    self.context, uuid
+                )
                 mock_update_efficacy_indicator.assert_called_once_with(
-                    uuid, {'description': 'Indicator Description'})
+                    uuid, {'description': 'Indicator Description'}
+                )
                 self.assertEqual(self.context, efficacy_indicator._context)
 
     def test_refresh(self):
         uuid = self.fake_efficacy_indicator['uuid']
-        returns = [dict(self.fake_efficacy_indicator,
-                        description="first description"),
-                   dict(self.fake_efficacy_indicator,
-                        description="second description")]
-        expected = [mock.call(self.context, uuid),
-                    mock.call(self.context, uuid)]
-        with mock.patch.object(self.dbapi, 'get_efficacy_indicator_by_uuid',
-                               side_effect=returns,
-                               autospec=True) as mock_get_efficacy_indicator:
+        returns = [
+            dict(
+                self.fake_efficacy_indicator, description="first description"
+            ),
+            dict(
+                self.fake_efficacy_indicator, description="second description"
+            ),
+        ]
+        expected = [
+            mock.call(self.context, uuid),
+            mock.call(self.context, uuid),
+        ]
+        with mock.patch.object(
+            self.dbapi,
+            'get_efficacy_indicator_by_uuid',
+            side_effect=returns,
+            autospec=True,
+        ) as mock_get_efficacy_indicator:
             efficacy_indicator = objects.EfficacyIndicator.get(
-                self.context, uuid)
+                self.context, uuid
+            )
             self.assertEqual(
-                "first description", efficacy_indicator.description)
+                "first description", efficacy_indicator.description
+            )
             efficacy_indicator.refresh()
             self.assertEqual(
-                "second description", efficacy_indicator.description)
+                "second description", efficacy_indicator.description
+            )
             self.assertEqual(
-                expected, mock_get_efficacy_indicator.call_args_list)
+                expected, mock_get_efficacy_indicator.call_args_list
+            )
             self.assertEqual(self.context, efficacy_indicator._context)
diff --git a/watcher/tests/unit/objects/test_goal.py b/watcher/tests/unit/objects/test_goal.py
index 27c7d4b5f..115ac3d90 100644
--- a/watcher/tests/unit/objects/test_goal.py
+++ b/watcher/tests/unit/objects/test_goal.py
@@ -26,11 +26,9 @@ from watcher.tests.unit.db import utils
 
 
 class TestGoalObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
-        self.fake_goal = utils.get_test_goal(
-            created_at=timeutils.utcnow())
+        self.fake_goal = utils.get_test_goal(created_at=timeutils.utcnow())
 
     @mock.patch.object(db_api.Connection, 'get_goal_by_id')
     def test_get_by_id(self, mock_get_goal):
@@ -72,7 +70,8 @@ class TestGoalObject(base.DbTestCase):
         goal.create()
         expected_goal = self.fake_goal.copy()
         expected_goal['created_at'] = expected_goal['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         mock_create_goal.assert_called_once_with(expected_goal)
         self.assertEqual(self.context, goal._context)
 
@@ -83,8 +82,7 @@ class TestGoalObject(base.DbTestCase):
         mock_get_goal.return_value = self.fake_goal
         goal = objects.Goal.get_by_id(self.context, goal_id)
         goal.destroy()
-        mock_get_goal.assert_called_once_with(
-            self.context, goal_id)
+        mock_get_goal.assert_called_once_with(self.context, goal_id)
         mock_destroy_goal.assert_called_once_with(goal_id)
         self.assertEqual(self.context, goal._context)
 
@@ -103,7 +101,8 @@ class TestGoalObject(base.DbTestCase):
 
         mock_get_goal.assert_called_once_with(self.context, goal_uuid)
         mock_update_goal.assert_called_once_with(
-            goal_uuid, {'display_name': 'DUMMY'})
+            goal_uuid, {'display_name': 'DUMMY'}
+        )
         self.assertEqual(self.context, goal._context)
 
     @mock.patch.object(db_api.Connection, 'get_goal_by_uuid')
@@ -112,8 +111,10 @@ class TestGoalObject(base.DbTestCase):
         returns = [self.fake_goal, fake_goal2]
         mock_get_goal.side_effect = returns
         uuid = self.fake_goal['uuid']
-        expected = [mock.call(self.context, uuid),
-                    mock.call(self.context, uuid)]
+        expected = [
+            mock.call(self.context, uuid),
+            mock.call(self.context, uuid),
+        ]
         goal = objects.Goal.get(self.context, uuid)
         self.assertEqual("TEST", goal.name)
         goal.refresh()
@@ -131,9 +132,11 @@ class TestGoalObject(base.DbTestCase):
 
         expected_goal = fake_deleted_goal.copy()
         expected_goal['created_at'] = expected_goal['created_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
         expected_goal['deleted_at'] = expected_goal['deleted_at'].replace(
-            tzinfo=datetime.timezone.utc)
+            tzinfo=datetime.timezone.utc
+        )
 
         uuid = self.fake_goal['uuid']
         goal = objects.Goal.get_by_uuid(self.context, uuid)
diff --git a/watcher/tests/unit/objects/test_objects.py b/watcher/tests/unit/objects/test_objects.py
index 07361a295..cf19f71d2 100644
--- a/watcher/tests/unit/objects/test_objects.py
+++ b/watcher/tests/unit/objects/test_objects.py
@@ -32,13 +32,18 @@ gettext.install('watcher')
 
 
 @base.WatcherObjectRegistry.register
-class MyObj(base.WatcherPersistentObject, base.WatcherObject,
-            base.WatcherObjectDictCompat):
+class MyObj(
+    base.WatcherPersistentObject,
+    base.WatcherObject,
+    base.WatcherObjectDictCompat,
+):
     VERSION = '1.5'
 
-    fields = {'foo': fields.IntegerField(),
-              'bar': fields.StringField(),
-              'missing': fields.StringField()}
+    fields = {
+        'foo': fields.IntegerField(),
+        'bar': fields.StringField(),
+        'missing': fields.StringField(),
+    }
 
     def obj_load_attr(self, attrname):
         setattr(self, attrname, 'loaded!')
@@ -113,33 +118,44 @@ def things_temporarily_local():
 
 class _TestObject:
     def test_hydration_type_error(self):
-        primitive = {'watcher_object.name': 'MyObj',
-                     'watcher_object.namespace': 'watcher',
-                     'watcher_object.version': '1.5',
-                     'watcher_object.data': {'foo': 'a'}}
+        primitive = {
+            'watcher_object.name': 'MyObj',
+            'watcher_object.namespace': 'watcher',
+            'watcher_object.version': '1.5',
+            'watcher_object.data': {'foo': 'a'},
+        }
         self.assertRaises(ValueError, MyObj.obj_from_primitive, primitive)
 
     def test_hydration(self):
-        primitive = {'watcher_object.name': 'MyObj',
-                     'watcher_object.namespace': 'watcher',
-                     'watcher_object.version': '1.5',
-                     'watcher_object.data': {'foo': 1}}
+        primitive = {
+            'watcher_object.name': 'MyObj',
+            'watcher_object.namespace': 'watcher',
+            'watcher_object.version': '1.5',
+            'watcher_object.data': {'foo': 1},
+        }
         obj = MyObj.obj_from_primitive(primitive)
         self.assertEqual(1, obj.foo)
 
     def test_hydration_bad_ns(self):
-        primitive = {'watcher_object.name': 'MyObj',
-                     'watcher_object.namespace': 'foo',
-                     'watcher_object.version': '1.5',
-                     'watcher_object.data': {'foo': 1}}
-        self.assertRaises(object_exception.UnsupportedObjectError,
-                          MyObj.obj_from_primitive, primitive)
+        primitive = {
+            'watcher_object.name': 'MyObj',
+            'watcher_object.namespace': 'foo',
+            'watcher_object.version': '1.5',
+            'watcher_object.data': {'foo': 1},
+        }
+        self.assertRaises(
+            object_exception.UnsupportedObjectError,
+            MyObj.obj_from_primitive,
+            primitive,
+        )
 
     def test_dehydration(self):
-        expected = {'watcher_object.name': 'MyObj',
-                    'watcher_object.namespace': 'watcher',
-                    'watcher_object.version': '1.5',
-                    'watcher_object.data': {'foo': 1}}
+        expected = {
+            'watcher_object.name': 'MyObj',
+            'watcher_object.namespace': 'watcher',
+            'watcher_object.version': '1.5',
+            'watcher_object.data': {'foo': 1},
+        }
         obj = MyObj(self.context)
         obj.foo = 1
         obj.obj_reset_changes()
@@ -164,6 +180,7 @@ class _TestObject:
 
         def fail():
             obj.foo = 'a'
+
         self.assertRaises(ValueError, fail)
 
     def test_load(self):
@@ -172,26 +189,35 @@ class _TestObject:
 
     def test_load_in_base(self):
         @base.WatcherObjectRegistry.register_if(False)
-        class Foo(base.WatcherPersistentObject, base.WatcherObject,
-                  base.WatcherObjectDictCompat):
+        class Foo(
+            base.WatcherPersistentObject,
+            base.WatcherObject,
+            base.WatcherObjectDictCompat,
+        ):
             fields = {'foobar': fields.IntegerField()}
+
         obj = Foo(self.context)
 
         self.assertRaisesRegex(
-            NotImplementedError, "Cannot load 'foobar' in the base class",
-            getattr, obj, 'foobar')
+            NotImplementedError,
+            "Cannot load 'foobar' in the base class",
+            getattr,
+            obj,
+            'foobar',
+        )
 
     def test_loaded_in_primitive(self):
         obj = MyObj(self.context)
         obj.foo = 1
         obj.obj_reset_changes()
         self.assertEqual('loaded!', obj.bar)
-        expected = {'watcher_object.name': 'MyObj',
-                    'watcher_object.namespace': 'watcher',
-                    'watcher_object.version': '1.5',
-                    'watcher_object.changes': ['bar'],
-                    'watcher_object.data': {'foo': 1,
-                                            'bar': 'loaded!'}}
+        expected = {
+            'watcher_object.name': 'MyObj',
+            'watcher_object.namespace': 'watcher',
+            'watcher_object.version': '1.5',
+            'watcher_object.changes': ['bar'],
+            'watcher_object.data': {'foo': 1, 'bar': 'loaded!'},
+        }
         self.assertEqual(expected, obj.obj_to_primitive())
 
     def test_changes_in_primitive(self):
@@ -206,8 +232,12 @@ class _TestObject:
         self.assertEqual(set(), obj2.obj_what_changed())
 
     def test_unknown_objtype(self):
-        self.assertRaises(object_exception.UnsupportedObjectError,
-                          base.WatcherObject.obj_class_from_name, 'foo', '1.0')
+        self.assertRaises(
+            object_exception.UnsupportedObjectError,
+            base.WatcherObject.obj_class_from_name,
+            'foo',
+            '1.0',
+        )
 
     def test_with_alternate_context(self):
         ctxt1 = context.RequestContext('foo', 'foo')
@@ -219,8 +249,9 @@ class _TestObject:
     def test_orphaned_object(self):
         obj = MyObj.query(self.context)
         obj._context = None
-        self.assertRaises(object_exception.OrphanedObjectError,
-                          obj.update_test)
+        self.assertRaises(
+            object_exception.OrphanedObjectError, obj.update_test
+        )
 
     def test_changed_1(self):
         obj = MyObj.query(self.context)
@@ -274,22 +305,26 @@ class _TestObject:
         obj = MyObj(self.context)
         obj.created_at = dt
         obj.updated_at = dt
-        expected = {'watcher_object.name': 'MyObj',
-                    'watcher_object.namespace': 'watcher',
-                    'watcher_object.version': '1.5',
-                    'watcher_object.changes':
-                        ['created_at', 'updated_at'],
-                    'watcher_object.data':
-                        {'created_at': datatime.stringify(dt),
-                         'updated_at': datatime.stringify(dt),
-                         }
-                    }
+        expected = {
+            'watcher_object.name': 'MyObj',
+            'watcher_object.namespace': 'watcher',
+            'watcher_object.version': '1.5',
+            'watcher_object.changes': ['created_at', 'updated_at'],
+            'watcher_object.data': {
+                'created_at': datatime.stringify(dt),
+                'updated_at': datatime.stringify(dt),
+            },
+        }
         actual = obj.obj_to_primitive()
         # watcher_object.changes is built from a set and order is undefined
-        self.assertEqual(sorted(expected['watcher_object.changes']),
-                         sorted(actual['watcher_object.changes']))
-        del expected[
-            'watcher_object.changes'], actual['watcher_object.changes']
+        self.assertEqual(
+            sorted(expected['watcher_object.changes']),
+            sorted(actual['watcher_object.changes']),
+        )
+        del (
+            expected['watcher_object.changes'],
+            actual['watcher_object.changes'],
+        )
         self.assertEqual(expected, actual)
 
     def test_contains(self):
@@ -323,18 +358,22 @@ class _TestObject:
         self.assertRaises(AttributeError, obj.get, 'nothing', 3)
 
     def test_object_inheritance(self):
-        base_fields = (
-            list(base.WatcherObject.fields) +
-            list(base.WatcherPersistentObject.fields))
+        base_fields = list(base.WatcherObject.fields) + list(
+            base.WatcherPersistentObject.fields
+        )
         myobj_fields = ['foo', 'bar', 'missing'] + base_fields
         myobj3_fields = ['new_field']
         self.assertTrue(issubclass(WatcherTestSubclassedObject, MyObj))
         self.assertEqual(len(myobj_fields), len(MyObj.fields))
         self.assertEqual(set(myobj_fields), set(MyObj.fields.keys()))
-        self.assertEqual(len(myobj_fields) + len(myobj3_fields),
-                         len(WatcherTestSubclassedObject.fields))
-        self.assertEqual(set(myobj_fields) | set(myobj3_fields),
-                         set(WatcherTestSubclassedObject.fields.keys()))
+        self.assertEqual(
+            len(myobj_fields) + len(myobj3_fields),
+            len(WatcherTestSubclassedObject.fields),
+        )
+        self.assertEqual(
+            set(myobj_fields) | set(myobj3_fields),
+            set(WatcherTestSubclassedObject.fields.keys()),
+        )
 
     def test_get_changes(self):
         obj = MyObj(self.context)
@@ -348,8 +387,11 @@ class _TestObject:
 
     def test_obj_fields(self):
         @base.WatcherObjectRegistry.register_if(False)
-        class TestObj(base.WatcherPersistentObject, base.WatcherObject,
-                      base.WatcherObjectDictCompat):
+        class TestObj(
+            base.WatcherPersistentObject,
+            base.WatcherObject,
+            base.WatcherObjectDictCompat,
+        ):
             fields = {'foo': fields.IntegerField()}
             obj_extra_fields = ['bar']
 
@@ -358,16 +400,22 @@ class _TestObject:
                 return 'this is bar'
 
         obj = TestObj(self.context)
-        self.assertEqual({'created_at', 'updated_at', 'deleted_at',
-                          'foo', 'bar'},
-                         set(obj.obj_fields))
+        self.assertEqual(
+            {'created_at', 'updated_at', 'deleted_at', 'foo', 'bar'},
+            set(obj.obj_fields),
+        )
 
     def test_refresh_object(self):
         @base.WatcherObjectRegistry.register_if(False)
-        class TestObj(base.WatcherPersistentObject, base.WatcherObject,
-                      base.WatcherObjectDictCompat):
-            fields = {'foo': fields.IntegerField(),
-                      'bar': fields.StringField()}
+        class TestObj(
+            base.WatcherPersistentObject,
+            base.WatcherObject,
+            base.WatcherObjectDictCompat,
+        ):
+            fields = {
+                'foo': fields.IntegerField(),
+                'bar': fields.StringField(),
+            }
 
         obj = TestObj(self.context)
         current_obj = TestObj(self.context)
@@ -387,8 +435,11 @@ class _TestObject:
 
     def test_assign_value_without_DictCompat(self):
         class TestObj(base.WatcherObject):
-            fields = {'foo': fields.IntegerField(),
-                      'bar': fields.StringField()}
+            fields = {
+                'foo': fields.IntegerField(),
+                'bar': fields.StringField(),
+            }
+
         obj = TestObj(self.context)
         obj.foo = 10
         err_message = ''
@@ -397,8 +448,10 @@ class _TestObject:
         except TypeError as e:
             err_message = str(e)
         finally:
-            self.assertIn("'TestObj' object does not support item assignment",
-                          err_message)
+            self.assertIn(
+                "'TestObj' object does not support item assignment",
+                err_message,
+            )
 
 
 class TestObject(_LocalTest, _TestObject):
@@ -419,7 +472,7 @@ expected_object_fingerprints = {
     'ScoringEngine': '1.0-4abbe833544000728e17bd9e83f97576',
     'Service': '1.0-4b35b99ada9677a882c9de2b30212f35',
     'MyObj': '1.5-23c516d1e842f365f694e688d34e47c3',
-    'ActionDescription': '1.0-5761a3d16651046e7a0c357b57a6583e'
+    'ActionDescription': '1.0-5761a3d16651046e7a0c357b57a6583e',
 }
 
 
@@ -435,30 +488,33 @@ def get_watcher_objects():
     watcher_classes = {}
     for name in all_classes:
         objclasses = all_classes[name]
-        if (objclasses[0].OBJ_PROJECT_NAMESPACE !=
-                base.WatcherObject.OBJ_PROJECT_NAMESPACE):
+        if (
+            objclasses[0].OBJ_PROJECT_NAMESPACE
+            != base.WatcherObject.OBJ_PROJECT_NAMESPACE
+        ):
             continue
         watcher_classes[name] = objclasses
     return watcher_classes
 
 
 class TestObjectVersions(test_base.TestCase):
-
     def test_object_version_check(self):
         classes = base.WatcherObjectRegistry.obj_classes()
         checker = object_fixture.ObjectVersionChecker(obj_classes=classes)
         # Compute the difference between actual fingerprints and
         # expect fingerprints. expect = actual = {} if there is no change.
         expect, actual = checker.test_hashes(expected_object_fingerprints)
-        self.assertEqual(expect, actual,
-                         "Some objects fields or remotable methods have been "
-                         "modified. Please make sure the version of those "
-                         "objects have been bumped and then update "
-                         "expected_object_fingerprints with the new hashes. ")
+        self.assertEqual(
+            expect,
+            actual,
+            "Some objects fields or remotable methods have been "
+            "modified. Please make sure the version of those "
+            "objects have been bumped and then update "
+            "expected_object_fingerprints with the new hashes. ",
+        )
 
 
 class TestObjectSerializer(test_base.TestCase):
-
     def test_object_serialization(self):
         obj_ser = base.WatcherObjectSerializer()
         obj = MyObj(self.context)
@@ -483,12 +539,17 @@ class TestObjectSerializer(test_base.TestCase):
                 self.assertIsInstance(item, MyObj)
 
     @mock.patch('watcher.objects.base.WatcherObject.indirection_api')
-    def _test_deserialize_entity_newer(self, obj_version, backported_to,
-                                       mock_indirection_api,
-                                       my_version='1.6'):
+    def _test_deserialize_entity_newer(
+        self,
+        obj_version,
+        backported_to,
+        mock_indirection_api,
+        my_version='1.6',
+    ):
         obj_ser = base.WatcherObjectSerializer()
-        mock_indirection_api.object_backport_versions.return_value \
-            = 'backported'
+        mock_indirection_api.object_backport_versions.return_value = (
+            'backported'
+        )
 
         @base.WatcherObjectRegistry.register
         class MyTestObj(MyObj):
@@ -500,12 +561,14 @@ class TestObjectSerializer(test_base.TestCase):
         result = obj_ser.deserialize_entity(self.context, primitive)
         if backported_to is None:
             self.assertFalse(
-                mock_indirection_api.object_backport_versions.called)
+                mock_indirection_api.object_backport_versions.called
+            )
         else:
             self.assertEqual('backported', result)
             versions = object_base.obj_tree_get_versions('MyTestObj')
             mock_indirection_api.object_backport_versions.assert_called_with(
-                self.context, primitive, versions)
+                self.context, primitive, versions
+            )
 
     def test_deserialize_entity_newer_version_backports(self):
         "Test object with unsupported (newer) version"
@@ -529,7 +592,6 @@ class TestObjectSerializer(test_base.TestCase):
 
 
 class TestRegistry(test_base.TestCase):
-
     @mock.patch('watcher.objects.base.objects')
     def test_hook_chooses_newer_properly(self, mock_objects):
         mock_objects.MyObj.VERSION = MyObj.VERSION
diff --git a/watcher/tests/unit/objects/test_scoring_engine.py b/watcher/tests/unit/objects/test_scoring_engine.py
index fc24d812c..9fe463ec0 100644
--- a/watcher/tests/unit/objects/test_scoring_engine.py
+++ b/watcher/tests/unit/objects/test_scoring_engine.py
@@ -26,20 +26,22 @@ from watcher.tests.unit.db import utils
 
 
 class TestScoringEngineObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_scoring_engine = utils.get_test_scoring_engine(
-            created_at=timeutils.utcnow())
+            created_at=timeutils.utcnow()
+        )
 
     @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
     def test_get_by_id(self, mock_get_scoring_engine):
         scoring_engine_id = self.fake_scoring_engine['id']
         mock_get_scoring_engine.return_value = self.fake_scoring_engine
         scoring_engine = objects.ScoringEngine.get_by_id(
-            self.context, scoring_engine_id)
+            self.context, scoring_engine_id
+        )
         mock_get_scoring_engine.assert_called_once_with(
-            self.context, scoring_engine_id)
+            self.context, scoring_engine_id
+        )
         self.assertEqual(self.context, scoring_engine._context)
 
     @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid')
@@ -47,9 +49,9 @@ class TestScoringEngineObject(base.DbTestCase):
         se_uuid = self.fake_scoring_engine['uuid']
         mock_get_scoring_engine.return_value = self.fake_scoring_engine
         scoring_engine = objects.ScoringEngine.get_by_uuid(
-            self.context, se_uuid)
-        mock_get_scoring_engine.assert_called_once_with(
-            self.context, se_uuid)
+            self.context, se_uuid
+        )
+        mock_get_scoring_engine.assert_called_once_with(self.context, se_uuid)
         self.assertEqual(self.context, scoring_engine._context)
 
     @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid')
@@ -57,9 +59,11 @@ class TestScoringEngineObject(base.DbTestCase):
         scoring_engine_uuid = self.fake_scoring_engine['uuid']
         mock_get_scoring_engine.return_value = self.fake_scoring_engine
         scoring_engine = objects.ScoringEngine.get(
-            self.context, scoring_engine_uuid)
+            self.context, scoring_engine_uuid
+        )
         mock_get_scoring_engine.assert_called_once_with(
-            self.context, scoring_engine_uuid)
+            self.context, scoring_engine_uuid
+        )
         self.assertEqual(self.context, scoring_engine._context)
 
     @mock.patch.object(db_api.Connection, 'get_scoring_engine_list')
@@ -75,19 +79,23 @@ class TestScoringEngineObject(base.DbTestCase):
     def test_create(self, mock_create_scoring_engine):
         mock_create_scoring_engine.return_value = self.fake_scoring_engine
         scoring_engine = objects.ScoringEngine(
-            self.context, **self.fake_scoring_engine)
+            self.context, **self.fake_scoring_engine
+        )
         scoring_engine.create()
         expected_scoring_engine = self.fake_scoring_engine.copy()
         expected_scoring_engine['created_at'] = expected_scoring_engine[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         mock_create_scoring_engine.assert_called_once_with(
-            expected_scoring_engine)
+            expected_scoring_engine
+        )
         self.assertEqual(self.context, scoring_engine._context)
 
     @mock.patch.object(db_api.Connection, 'destroy_scoring_engine')
     @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
-    def test_destroy(self, mock_get_scoring_engine,
-                     mock_destroy_scoring_engine):
+    def test_destroy(
+        self, mock_get_scoring_engine, mock_destroy_scoring_engine
+    ):
         mock_get_scoring_engine.return_value = self.fake_scoring_engine
         _id = self.fake_scoring_engine['id']
         scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
@@ -111,18 +119,19 @@ class TestScoringEngineObject(base.DbTestCase):
 
         mock_get_scoring_engine.assert_called_once_with(self.context, uuid)
         mock_update_scoring_engine.assert_called_once_with(
-            uuid, {'description': 'UPDATED DESCRIPTION'})
+            uuid, {'description': 'UPDATED DESCRIPTION'}
+        )
         self.assertEqual(self.context, scoring_engine._context)
 
     @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
     def test_refresh(self, mock_get_scoring_engine):
         returns = [
             dict(self.fake_scoring_engine, description="first description"),
-            dict(self.fake_scoring_engine, description="second description")]
+            dict(self.fake_scoring_engine, description="second description"),
+        ]
         mock_get_scoring_engine.side_effect = returns
         _id = self.fake_scoring_engine['id']
-        expected = [mock.call(self.context, _id),
-                    mock.call(self.context, _id)]
+        expected = [mock.call(self.context, _id), mock.call(self.context, _id)]
         scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
         self.assertEqual("first description", scoring_engine.description)
         scoring_engine.refresh()
@@ -140,9 +149,11 @@ class TestScoringEngineObject(base.DbTestCase):
 
         expected_scoring_engine = fake_deleted_scoring_engine.copy()
         expected_scoring_engine['created_at'] = expected_scoring_engine[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         expected_scoring_engine['deleted_at'] = expected_scoring_engine[
-            'deleted_at'].replace(tzinfo=datetime.timezone.utc)
+            'deleted_at'
+        ].replace(tzinfo=datetime.timezone.utc)
 
         _id = self.fake_scoring_engine['id']
         scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
diff --git a/watcher/tests/unit/objects/test_service.py b/watcher/tests/unit/objects/test_service.py
index 2907ad9f6..aeabbe162 100644
--- a/watcher/tests/unit/objects/test_service.py
+++ b/watcher/tests/unit/objects/test_service.py
@@ -26,11 +26,11 @@ from watcher.tests.unit.db import utils
 
 
 class TestServiceObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_service = utils.get_test_service(
-            created_at=timeutils.utcnow())
+            created_at=timeutils.utcnow()
+        )
 
     @mock.patch.object(db_api.Connection, 'get_service_by_id')
     def test_get_by_id(self, mock_get_service):
@@ -57,7 +57,8 @@ class TestServiceObject(base.DbTestCase):
         service.create()
         expected_service = self.fake_service.copy()
         expected_service['created_at'] = expected_service[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
 
         mock_create_service.assert_called_once_with(expected_service)
         self.assertEqual(self.context, service._context)
@@ -76,17 +77,19 @@ class TestServiceObject(base.DbTestCase):
 
         mock_get_service.assert_called_once_with(self.context, _id)
         mock_update_service.assert_called_once_with(
-            _id, {'name': 'UPDATED NAME'})
+            _id, {'name': 'UPDATED NAME'}
+        )
         self.assertEqual(self.context, service._context)
 
     @mock.patch.object(db_api.Connection, 'get_service_by_id')
     def test_refresh(self, mock_get_service):
-        returns = [dict(self.fake_service, name="first name"),
-                   dict(self.fake_service, name="second name")]
+        returns = [
+            dict(self.fake_service, name="first name"),
+            dict(self.fake_service, name="second name"),
+        ]
         mock_get_service.side_effect = returns
         _id = self.fake_service['id']
-        expected = [mock.call(self.context, _id),
-                    mock.call(self.context, _id)]
+        expected = [mock.call(self.context, _id), mock.call(self.context, _id)]
         service = objects.Service.get(self.context, _id)
         self.assertEqual("first name", service.name)
         service.refresh()
@@ -104,9 +107,11 @@ class TestServiceObject(base.DbTestCase):
 
         expected_service = fake_deleted_service.copy()
         expected_service['created_at'] = expected_service[
-            'created_at'].replace(tzinfo=datetime.timezone.utc)
+            'created_at'
+        ].replace(tzinfo=datetime.timezone.utc)
         expected_service['deleted_at'] = expected_service[
-            'deleted_at'].replace(tzinfo=datetime.timezone.utc)
+            'deleted_at'
+        ].replace(tzinfo=datetime.timezone.utc)
 
         _id = self.fake_service['id']
         service = objects.Service.get(self.context, _id)
diff --git a/watcher/tests/unit/objects/test_strategy.py b/watcher/tests/unit/objects/test_strategy.py
index ab696f5b0..e4b0785cd 100644
--- a/watcher/tests/unit/objects/test_strategy.py
+++ b/watcher/tests/unit/objects/test_strategy.py
@@ -24,19 +24,32 @@ from watcher.tests.unit.db import utils
 
 
 class TestStrategyObject(base.DbTestCase):
-
     goal_id = 2
 
     scenarios = [
-        ('non_eager', dict(
-            eager=False, fake_strategy=utils.get_test_strategy(
-                goal_id=goal_id))),
-        ('eager_with_non_eager_load', dict(
-            eager=True, fake_strategy=utils.get_test_strategy(
-                goal_id=goal_id))),
-        ('eager_with_eager_load', dict(
-            eager=True, fake_strategy=utils.get_test_strategy(
-                goal_id=goal_id, goal=utils.get_test_goal(id=goal_id)))),
+        (
+            'non_eager',
+            dict(
+                eager=False,
+                fake_strategy=utils.get_test_strategy(goal_id=goal_id),
+            ),
+        ),
+        (
+            'eager_with_non_eager_load',
+            dict(
+                eager=True,
+                fake_strategy=utils.get_test_strategy(goal_id=goal_id),
+            ),
+        ),
+        (
+            'eager_with_eager_load',
+            dict(
+                eager=True,
+                fake_strategy=utils.get_test_strategy(
+                    goal_id=goal_id, goal=utils.get_test_goal(id=goal_id)
+                ),
+            ),
+        ),
     ]
 
     def setUp(self):
@@ -50,11 +63,15 @@ class TestStrategyObject(base.DbTestCase):
                 super(objects.Goal, objects.Goal).fields
             ).symmetric_difference(objects.Goal.fields)
             db_data = {
-                k: v for k, v in self.fake_goal.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in self.fake_goal.as_dict().items()
+                if k in fields_to_check
+            }
             object_data = {
-                k: v for k, v in strategy.goal.as_dict().items()
-                if k in fields_to_check}
+                k: v
+                for k, v in strategy.goal.as_dict().items()
+                if k in fields_to_check
+            }
             self.assertEqual(db_data, object_data)
 
     @mock.patch.object(db_api.Connection, 'get_strategy_by_id')
@@ -62,9 +79,11 @@ class TestStrategyObject(base.DbTestCase):
         strategy_id = self.fake_strategy['id']
         mock_get_strategy.return_value = self.fake_strategy
         strategy = objects.Strategy.get(
-            self.context, strategy_id, eager=self.eager)
+            self.context, strategy_id, eager=self.eager
+        )
         mock_get_strategy.assert_called_once_with(
-            self.context, strategy_id, eager=self.eager)
+            self.context, strategy_id, eager=self.eager
+        )
         self.assertEqual(self.context, strategy._context)
         self.eager_load_strategy_assert(strategy)
 
@@ -74,13 +93,18 @@ class TestStrategyObject(base.DbTestCase):
         mock_get_strategy.return_value = self.fake_strategy
         strategy = objects.Strategy.get(self.context, uuid, eager=self.eager)
         mock_get_strategy.assert_called_once_with(
-            self.context, uuid, eager=self.eager)
+            self.context, uuid, eager=self.eager
+        )
         self.assertEqual(self.context, strategy._context)
         self.eager_load_strategy_assert(strategy)
 
     def test_get_bad_uuid(self):
-        self.assertRaises(exception.InvalidIdentity,
-                          objects.Strategy.get, self.context, 'not-a-uuid')
+        self.assertRaises(
+            exception.InvalidIdentity,
+            objects.Strategy.get,
+            self.context,
+            'not-a-uuid',
+        )
 
     @mock.patch.object(db_api.Connection, 'get_strategy_list')
     def test_list(self, mock_get_list):
@@ -99,25 +123,32 @@ class TestStrategyObject(base.DbTestCase):
         _id = self.fake_strategy['id']
         mock_get_strategy.return_value = self.fake_strategy
         strategy = objects.Strategy.get_by_id(
-            self.context, _id, eager=self.eager)
+            self.context, _id, eager=self.eager
+        )
         strategy.name = 'UPDATED NAME'
         strategy.save()
 
         mock_get_strategy.assert_called_once_with(
-            self.context, _id, eager=self.eager)
+            self.context, _id, eager=self.eager
+        )
         mock_update_strategy.assert_called_once_with(
-            _id, {'name': 'UPDATED NAME'})
+            _id, {'name': 'UPDATED NAME'}
+        )
         self.assertEqual(self.context, strategy._context)
         self.eager_load_strategy_assert(strategy)
 
     @mock.patch.object(db_api.Connection, 'get_strategy_by_id')
     def test_refresh(self, mock_get_strategy):
         _id = self.fake_strategy['id']
-        returns = [dict(self.fake_strategy, name="first name"),
-                   dict(self.fake_strategy, name="second name")]
+        returns = [
+            dict(self.fake_strategy, name="first name"),
+            dict(self.fake_strategy, name="second name"),
+        ]
         mock_get_strategy.side_effect = returns
-        expected = [mock.call(self.context, _id, eager=self.eager),
-                    mock.call(self.context, _id, eager=self.eager)]
+        expected = [
+            mock.call(self.context, _id, eager=self.eager),
+            mock.call(self.context, _id, eager=self.eager),
+        ]
         strategy = objects.Strategy.get(self.context, _id, eager=self.eager)
         self.assertEqual("first name", strategy.name)
         strategy.refresh(eager=self.eager)
@@ -128,7 +159,6 @@ class TestStrategyObject(base.DbTestCase):
 
 
 class TestCreateDeleteStrategyObject(base.DbTestCase):
-
     def setUp(self):
         super().setUp()
         self.fake_goal = utils.create_test_goal()
@@ -150,7 +180,8 @@ class TestCreateDeleteStrategyObject(base.DbTestCase):
         strategy = objects.Strategy.get_by_id(self.context, _id)
         strategy.soft_delete()
         mock_get_strategy.assert_called_once_with(
-            self.context, _id, eager=False)
+            self.context, _id, eager=False
+        )
         mock_soft_delete.assert_called_once_with(_id)
         self.assertEqual(self.context, strategy._context)
 
@@ -162,6 +193,7 @@ class TestCreateDeleteStrategyObject(base.DbTestCase):
         strategy = objects.Strategy.get_by_id(self.context, _id)
         strategy.destroy()
         mock_get_strategy.assert_called_once_with(
-            self.context, _id, eager=False)
+            self.context, _id, eager=False
+        )
         mock_destroy_strategy.assert_called_once_with(_id)
         self.assertEqual(self.context, strategy._context)
diff --git a/watcher/tests/unit/test_threading.py b/watcher/tests/unit/test_threading.py
index 134b885ec..fe866f128 100644
--- a/watcher/tests/unit/test_threading.py
+++ b/watcher/tests/unit/test_threading.py
@@ -25,7 +25,6 @@ from watcher.tests.unit import base
 
 
 class TestDecisionEngineThreadPool(base.TestCase):
-
     def setUp(self):
         super().setUp()
 
@@ -39,15 +38,18 @@ class TestDecisionEngineThreadPool(base.TestCase):
         # is restored after these tests finish but the threadpool can still
         # be used as intended with its methods
         self.p_threadool = mock.patch.object(
-            threading, 'DecisionEngineThreadPool',
-            new=threading.DecisionEngineThreadPool)
+            threading,
+            'DecisionEngineThreadPool',
+            new=threading.DecisionEngineThreadPool,
+        )
         self.m_threadpool = self.p_threadool.start()
         self.addCleanup(self.p_threadool.stop)
 
         # bind unbound patched methods for python 2.7 compatibility
         # class methods can be used unbounded in Python 3.x
         self.m_threadpool.submit = self.m_threadpool.submit.__get__(
-            self.m_threadpool, threading.DecisionEngineThreadPool)
+            self.m_threadpool, threading.DecisionEngineThreadPool
+        )
 
         self.m_threadpool._threadpool = executor.get_futurist_pool_executor(1)
 
@@ -86,7 +88,8 @@ class TestDecisionEngineThreadPool(base.TestCase):
         # execute m_do_while_function for every future that completes
         # and block until all futures are completed
         self.m_threadpool.do_while_futures(
-            futures, self.m_do_while_function, 3, 4)
+            futures, self.m_do_while_function, 3, 4
+        )
 
         # assert that m_do_while_function was called
         self.m_do_while_function.assert_called_once_with(futures[0], 3, 4)
@@ -115,7 +118,8 @@ class TestDecisionEngineThreadPool(base.TestCase):
         # execute m_do_while_function for every future that completes
         # and block until all futures are completed
         self.m_threadpool.do_while_futures_modify(
-            futures, self.m_do_while_function, 3, 4)
+            futures, self.m_do_while_function, 3, 4
+        )
 
         # assert that m_do_while_function was called
         self.m_do_while_function.assert_called_once_with(future_ref, 3, 4)
@@ -127,8 +131,9 @@ class TestDecisionEngineThreadPool(base.TestCase):
         """Test that 10 tasks are all executed with the correct arguments"""
 
         # create a collection of 10 futures from submitted m_function tasks
-        futures = [self.m_threadpool.submit(
-            self.m_function, i, 2) for i in range(10)]
+        futures = [
+            self.m_threadpool.submit(self.m_function, i, 2) for i in range(10)
+        ]
 
         # assert that there are 10 submitted tasks
         self.assertEqual(10, len(futures))
@@ -136,15 +141,15 @@ class TestDecisionEngineThreadPool(base.TestCase):
         # execute m_do_while_function for every future that completes
         # and block until all futures are completed
         self.m_threadpool.do_while_futures(
-            futures, self.m_do_while_function, 3, 4)
+            futures, self.m_do_while_function, 3, 4
+        )
 
         # create list of 10 calls that should have occurred
         calls_submit = []
         for i in range(10):
             calls_submit.append(mock.call(i, 2))
         # test that the submit function has been called 10 times
-        self.m_function.assert_has_calls(
-            calls_submit, any_order=True)
+        self.m_function.assert_has_calls(calls_submit, any_order=True)
 
         # create list of 10 calls that should have occurred
         calls_do_while = []
@@ -152,17 +157,23 @@ class TestDecisionEngineThreadPool(base.TestCase):
             calls_do_while.append(mock.call(futures[i], 3, 4))
         # test that the passed do_while function has been called 10 times
         self.m_do_while_function.assert_has_calls(
-            calls_do_while, any_order=True)
+            calls_do_while, any_order=True
+        )
 
     def test_do_while_futures_modify_timeout(self):
         """Test the operation of the do_while_futures with a timeout"""
 
         # create a collection of futures from submitted m_function tasks
-        futures = [self.m_threadpool.submit(
-            TestDecisionEngineThreadPool.noop_function) for i in range(3)]
+        futures = [
+            self.m_threadpool.submit(
+                TestDecisionEngineThreadPool.noop_function
+            )
+            for i in range(3)
+        ]
 
         self.m_threadpool.do_while_futures_modify(
-            futures, self.m_do_while_function, futures_timeout=0)
+            futures, self.m_do_while_function, futures_timeout=0
+        )
 
         # At least one future should be running or cancelled
         self.assertGreater(len(futures), 0)
diff --git a/watcher/wsgi/api.py b/watcher/wsgi/api.py
index fb1f2ea95..32b75821b 100644
--- a/watcher/wsgi/api.py
+++ b/watcher/wsgi/api.py
@@ -10,6 +10,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 """WSGI application entry-point for Watcher API."""
+
 import threading
 
 from watcher.api import wsgi