Format the coding style across the codebase using "black" and manual tweaks

The main benefit of this commit is that the use of double quotes
is now consistent.

tests/test_resolver/test_db.py

@@ -38,64 +38,63 @@ base_dir = os.path.join(os.path.dirname(__file__), "..")
 
 
 class TestDBModule:
-
     def setup_method(self):
         tests.reuse_component_init_data()
 
     def test_get_buildrequired_modulemds(self):
-        mmd = load_mmd_file(os.path.join(base_dir, 'staged_data', 'platform.yaml'))
-        mmd.set_stream('f30.1.3')
+        mmd = load_mmd_file(os.path.join(base_dir, "staged_data", "platform.yaml"))
+        mmd.set_stream("f30.1.3")
         import_mmd(db.session, mmd)
-        platform_f300103 = ModuleBuild.query.filter_by(stream='f30.1.3').one()
+        platform_f300103 = ModuleBuild.query.filter_by(stream="f30.1.3").one()
         mmd.set_name("testmodule")
         mmd.set_stream("master")
         mmd.set_version(20170109091357)
         mmd.set_context("123")
         build = ModuleBuild(
-            name='testmodule',
-            stream='master',
+            name="testmodule",
+            stream="master",
             version=20170109091357,
             state=5,
-            build_context='dd4de1c346dcf09ce77d38cd4e75094ec1c08ec3',
-            runtime_context='ec4de1c346dcf09ce77d38cd4e75094ec1c08ef7',
-            context='7c29193d',
-            koji_tag='module-testmodule-master-20170109091357-7c29193d',
-            scmurl='https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79',
+            build_context="dd4de1c346dcf09ce77d38cd4e75094ec1c08ec3",
+            runtime_context="ec4de1c346dcf09ce77d38cd4e75094ec1c08ef7",
+            context="7c29193d",
+            koji_tag="module-testmodule-master-20170109091357-7c29193d",
+            scmurl="https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79",
             batch=3,
-            owner='Dr. Pepper',
+            owner="Dr. Pepper",
             time_submitted=datetime(2018, 11, 15, 16, 8, 18),
             time_modified=datetime(2018, 11, 15, 16, 19, 35),
-            rebuild_strategy='changed-and-after',
-            modulemd=to_text_type(mmd.dumps())
+            rebuild_strategy="changed-and-after",
+            modulemd=to_text_type(mmd.dumps()),
         )
         build.buildrequires.append(platform_f300103)
         db.session.add(build)
         db.session.commit()
 
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
         result = resolver.get_buildrequired_modulemds(
             "testmodule", "master", platform_f300103.mmd().dup_nsvc())
         nsvcs = set([m.dup_nsvc() for m in result])
-        assert nsvcs == set(['testmodule:master:20170109091357:123'])
+        assert nsvcs == set(["testmodule:master:20170109091357:123"])
 
-    @pytest.mark.parametrize('stream_versions', [False, True])
+    @pytest.mark.parametrize("stream_versions", [False, True])
     def test_get_module_modulemds_stream_versions(self, stream_versions):
         tests.init_data(1, multiple_stream_versions=True)
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
         result = resolver.get_module_modulemds(
             "platform", "f29.1.0", stream_version_lte=stream_versions)
         nsvcs = set([mmd.dup_nsvc() for mmd in result])
         if stream_versions:
-            assert nsvcs == set(['platform:f29.1.0:3:00000000', 'platform:f29.0.0:3:00000000'])
+            assert nsvcs == set(["platform:f29.1.0:3:00000000", "platform:f29.0.0:3:00000000"])
         else:
-            assert nsvcs == set(['platform:f29.1.0:3:00000000'])
+            assert nsvcs == set(["platform:f29.1.0:3:00000000"])
 
-    @pytest.mark.parametrize('empty_buildrequires', [False, True])
+    @pytest.mark.parametrize("empty_buildrequires", [False, True])
     def test_get_module_build_dependencies(self, empty_buildrequires):
         """
         Tests that the buildrequires of testmodule are returned
         """
-        expected = set(['module-f28-build'])
+        expected = set(["module-f28-build"])
         module = models.ModuleBuild.query.get(2)
         if empty_buildrequires:
             expected = set()
@@ -104,14 +103,14 @@ class TestDBModule:
             # Wipe out the dependencies
             mmd.set_dependencies()
             xmd = glib.from_variant_dict(mmd.get_xmd())
-            xmd['mbs']['buildrequires'] = {}
+            xmd["mbs"]["buildrequires"] = {}
             mmd.set_xmd(glib.dict_values(xmd))
             module.modulemd = to_text_type(mmd.dumps())
             db.session.add(module)
             db.session.commit()
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
         result = resolver.get_module_build_dependencies(
-            'testmodule', 'master', '20170109091357', '78e4a6fd').keys()
+            "testmodule", "master", "20170109091357", "78e4a6fd").keys()
         assert set(result) == expected
 
     def test_get_module_build_dependencies_recursive(self):
@@ -121,126 +120,150 @@ class TestDBModule:
         # Add testmodule2 that requires testmodule
         module = models.ModuleBuild.query.get(3)
         mmd = module.mmd()
-        mmd.set_name('testmodule2')
+        mmd.set_name("testmodule2")
         mmd.set_version(20180123171545)
         requires = mmd.get_dependencies()[0].get_requires()
-        requires['testmodule'] = Modulemd.SimpleSet()
-        requires['testmodule'].add('master')
+        requires["testmodule"] = Modulemd.SimpleSet()
+        requires["testmodule"].add("master")
         mmd.get_dependencies()[0].set_requires(requires)
         xmd = glib.from_variant_dict(mmd.get_xmd())
-        xmd['mbs']['requires']['testmodule'] = {
-            'filtered_rpms': [],
-            'ref': '620ec77321b2ea7b0d67d82992dda3e1d67055b4',
-            'stream': 'master',
-            'version': '20180205135154'
+        xmd["mbs"]["requires"]["testmodule"] = {
+            "filtered_rpms": [],
+            "ref": "620ec77321b2ea7b0d67d82992dda3e1d67055b4",
+            "stream": "master",
+            "version": "20180205135154",
         }
         mmd.set_xmd(glib.dict_values(xmd))
         module.modulemd = to_text_type(mmd.dumps())
-        module.name = 'testmodule2'
+        module.name = "testmodule2"
         module.version = str(mmd.get_version())
-        module.koji_tag = 'module-ae2adf69caf0e1b6'
+        module.koji_tag = "module-ae2adf69caf0e1b6"
 
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
         result = resolver.get_module_build_dependencies(
-            'testmodule2', 'master', '20180123171545', 'c40c156c').keys()
-        assert set(result) == set(['module-f28-build'])
+            "testmodule2", "master", "20180123171545", "c40c156c").keys()
+        assert set(result) == set(["module-f28-build"])
 
-    @patch("module_build_service.config.Config.system",
-           new_callable=PropertyMock, return_value="test")
-    @patch("module_build_service.config.Config.mock_resultsdir",
-           new_callable=PropertyMock,
-           return_value=os.path.join(base_dir, 'staged_data', "local_builds"))
-    def test_get_module_build_dependencies_recursive_requires(
-            self, resultdir, conf_system):
+    @patch(
+        "module_build_service.config.Config.system", new_callable=PropertyMock, return_value="test"
+    )
+    @patch(
+        "module_build_service.config.Config.mock_resultsdir",
+        new_callable=PropertyMock,
+        return_value=os.path.join(base_dir, "staged_data", "local_builds"),
+    )
+    def test_get_module_build_dependencies_recursive_requires(self, resultdir, conf_system):
         """
         Tests that it returns the requires of the buildrequires recursively
         """
         with app.app_context():
             utils.load_local_builds(["platform", "parent", "child", "testmodule"])
 
-            build = models.ModuleBuild.local_modules(
-                db.session, "child", "master")
-            resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
+            build = models.ModuleBuild.local_modules(db.session, "child", "master")
+            resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
             result = resolver.get_module_build_dependencies(mmd=build[0].mmd()).keys()
 
-            local_path = os.path.join(base_dir, 'staged_data', "local_builds")
+            local_path = os.path.join(base_dir, "staged_data", "local_builds")
 
-            expected = [
-                os.path.join(
-                    local_path,
-                    'module-parent-master-20170816080815/results'),
-            ]
+            expected = [os.path.join(local_path, "module-parent-master-20170816080815/results")]
             assert set(result) == set(expected)
 
     def test_resolve_requires(self):
         build = models.ModuleBuild.query.get(2)
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
-        result = resolver.resolve_requires([":".join([
-            build.name, build.stream, build.version, build.context])])
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
+        result = resolver.resolve_requires(
+            [":".join([build.name, build.stream, build.version, build.context])]
+        )
 
         assert result == {
-            'testmodule': {
-                'stream': 'master', 'version': '20170109091357', 'context': u'78e4a6fd',
-                'ref': 'ff1ea79fc952143efeed1851aa0aa006559239ba',
-                'koji_tag': 'module-testmodule-master-20170109091357-78e4a6fd'
-            }}
+            "testmodule": {
+                "stream": "master",
+                "version": "20170109091357",
+                "context": u"78e4a6fd",
+                "ref": "ff1ea79fc952143efeed1851aa0aa006559239ba",
+                "koji_tag": "module-testmodule-master-20170109091357-78e4a6fd",
+            }
+        }
 
     def test_resolve_profiles(self):
         """
         Tests that the profiles get resolved recursively
         """
         mmd = models.ModuleBuild.query.get(2).mmd()
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
-        result = resolver.resolve_profiles(mmd, ('buildroot', 'srpm-buildroot'))
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
+        result = resolver.resolve_profiles(mmd, ("buildroot", "srpm-buildroot"))
         expected = {
-            'buildroot':
-                set(['unzip', 'tar', 'cpio', 'gawk', 'gcc', 'xz', 'sed',
-                     'findutils', 'util-linux', 'bash', 'info', 'bzip2',
-                     'grep', 'redhat-rpm-config', 'fedora-release',
-                     'diffutils', 'make', 'patch', 'shadow-utils', 'coreutils',
-                     'which', 'rpm-build', 'gzip', 'gcc-c++']),
-            'srpm-buildroot':
-                set(['shadow-utils', 'redhat-rpm-config', 'rpm-build',
-                     'fedora-release', 'fedpkg-minimal', 'gnupg2',
-                     'bash'])
+            "buildroot": set([
+                "unzip",
+                "tar",
+                "cpio",
+                "gawk",
+                "gcc",
+                "xz",
+                "sed",
+                "findutils",
+                "util-linux",
+                "bash",
+                "info",
+                "bzip2",
+                "grep",
+                "redhat-rpm-config",
+                "fedora-release",
+                "diffutils",
+                "make",
+                "patch",
+                "shadow-utils",
+                "coreutils",
+                "which",
+                "rpm-build",
+                "gzip",
+                "gcc-c++",
+            ]),
+            "srpm-buildroot": set([
+                "shadow-utils",
+                "redhat-rpm-config",
+                "rpm-build",
+                "fedora-release",
+                "fedpkg-minimal",
+                "gnupg2",
+                "bash",
+            ]),
         }
         assert result == expected
 
-    @patch("module_build_service.config.Config.system",
-           new_callable=PropertyMock, return_value="test")
-    @patch("module_build_service.config.Config.mock_resultsdir",
-           new_callable=PropertyMock,
-           return_value=os.path.join(base_dir, 'staged_data', "local_builds"))
+    @patch(
+        "module_build_service.config.Config.system", new_callable=PropertyMock, return_value="test"
+    )
+    @patch(
+        "module_build_service.config.Config.mock_resultsdir",
+        new_callable=PropertyMock,
+        return_value=os.path.join(base_dir, "staged_data", "local_builds"),
+    )
     def test_resolve_profiles_local_module(self, local_builds, conf_system):
         """
         Test that profiles get resolved recursively on local builds
         """
         with app.app_context():
-            utils.load_local_builds(['platform'])
+            utils.load_local_builds(["platform"])
             mmd = models.ModuleBuild.query.get(2).mmd()
-            resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='mbs')
-            result = resolver.resolve_profiles(mmd, ('buildroot', 'srpm-buildroot'))
-            expected = {
-                'buildroot':
-                    set(['foo']),
-                'srpm-buildroot':
-                    set(['bar'])
-            }
+            resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="mbs")
+            result = resolver.resolve_profiles(mmd, ("buildroot", "srpm-buildroot"))
+            expected = {"buildroot": set(["foo"]), "srpm-buildroot": set(["bar"])}
             assert result == expected
 
     def test_get_latest_with_virtual_stream(self):
         tests.init_data(1, multiple_stream_versions=True)
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
-        mmd = resolver.get_latest_with_virtual_stream('platform', 'f29')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
+        mmd = resolver.get_latest_with_virtual_stream("platform", "f29")
         assert mmd
-        assert mmd.get_stream() == 'f29.2.0'
+        assert mmd.get_stream() == "f29.2.0"
 
     def test_get_latest_with_virtual_stream_none(self):
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
-        mmd = resolver.get_latest_with_virtual_stream('platform', 'doesnotexist')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
+        mmd = resolver.get_latest_with_virtual_stream("platform", "doesnotexist")
         assert not mmd
 
     def test_get_module_count(self):
-        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')
-        count = resolver.get_module_count(name='platform', stream='f28')
+        resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")
+        count = resolver.get_module_count(name="platform", stream="f28")
         assert count == 1