bitbake: toaster: reformat LayerVersionEquivalenceTestCase

Reformatted to increase readability and satisfy pylint.
Added docstings.
Shortened variable names.

(Bitbake rev: 01e6fb74b60b1a66873f33866a35bdf6b2f807bd)

Signed-off-by: Ed Bartosh <ed.bartosh@linux.intel.com>
Signed-off-by: Michael Wood <michael.g.wood@intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 74 insertions, 50 deletions

diff --git a/bitbake/lib/toaster/orm/tests.py b/bitbake/lib/toaster/orm/tests.py
index 3384f01c39..75783ceb82 100644
--- a/bitbake/lib/toaster/orm/tests.py
+++ b/bitbake/lib/toaster/orm/tests.py
@@ -59,75 +59,99 @@ class LILSUpdateTestCase(TransactionTestCase):
                         "no branches fetched")
 
 
-# tests to verify layer_version priority selection
 class LayerVersionEquivalenceTestCase(TestCase):
-    def setUp(self):
-        # create layer sources
-        ls = LayerSource.objects.create(name = "dummy-layersource", sourcetype = LayerSource.TYPE_LOCAL)
+    """Verify Layer_Version priority selection."""
 
-        # create bitbake version
-        bbv = BitbakeVersion.objects.create(name="master", giturl="git://git.openembedded.org/bitbake")
+    def setUp(self):
+        """Create required objects."""
+        # create layer source
+        lsrc = LayerSource.objects.create(name="dummy-layersource",
+                                          sourcetype=LayerSource.TYPE_LOCAL)
         # create release
-        release = Release.objects.create(name="default-release", bitbake_version = bbv, branch_name = "master")
+        bbv = BitbakeVersion.objects.create(\
+                  name="master", giturl="git://git.openembedded.org/bitbake")
+        self.release = Release.objects.create(name="default-release",
+                                              bitbake_version=bbv,
+                                              branch_name="master")
         # attach layer source to release
-        ReleaseLayerSourcePriority.objects.create(release = release, layer_source = ls, priority = 1)
+        ReleaseLayerSourcePriority.objects.create(\
+            release=self.release, layer_source=lsrc, priority=1)
 
-
-        # create layer attach
-        self.layer = Layer.objects.create(name="meta-testlayer", layer_source = ls)
-        # create branch
-        self.branch = Branch.objects.create(name="master", layer_source = ls)
-
-        # set a layer version for the layer on the specified branch
-        self.layerversion = Layer_Version.objects.create(layer = self.layer, layer_source = ls, up_branch = self.branch)
+        # create a layer version for the layer on the specified branch
+        self.layer = Layer.objects.create(name="meta-testlayer",
+                                          layer_source=lsrc)
+        self.branch = Branch.objects.create(name="master", layer_source=lsrc)
+        self.lver = Layer_Version.objects.create(\
+            layer=self.layer, layer_source=lsrc, up_branch=self.branch)
 
         # create spoof layer that should not appear in the search results
-        Layer_Version.objects.create(layer = Layer.objects.create(name="meta-notvalid", layer_source = ls), layer_source = ls, up_branch = self.branch)
+        layer = Layer.objects.create(name="meta-notvalid", layer_source=lsrc)
+        Layer_Version.objects.create(layer=layer, layer_source=lsrc,
+                                     up_branch=self.branch)
 
-
-        # create a project ...
-        self.project = Project.objects.create_project(name="test-project", release = release)
-        # ... and set it up with a single layer version
-        ProjectLayer.objects.create(project=  self.project, layercommit = self.layerversion)
+        # create project and project layer
+        self.project = Project.objects.create_project(name="test-project",
+                                                      release=self.release)
+        ProjectLayer.objects.create(project=self.project,
+                                    layercommit=self.lver)
 
     def test_single_layersource(self):
-        # when we have a single layer version, get_equivalents_wpriority() should return a list with just this layer_version
-        equivalent_list = self.layerversion.get_equivalents_wpriority(self.project)
-        self.assertTrue(len(equivalent_list) == 1)
-        self.assertTrue(equivalent_list[0] == self.layerversion)
+        """
+        When we have a single layer version,
+        get_equivalents_wpriority() should return a list with
+        just this layer_version.
+        """
+        equivqs = self.lver.get_equivalents_wpriority(self.project)
+        self.assertEqual(list(equivqs), [self.lver])
 
     def test_dual_layersource(self):
-        # if we have two layers with the same name, from different layer sources, we expect both layers in, in increasing priority of the layer source
-        ls2 = LayerSource.objects.create(name = "dummy-layersource2", sourcetype = LayerSource.TYPE_LOCAL, apiurl="test")
+        """
+        If we have two layers with the same name, from different layer sources,
+        we expect both layers in, in increasing priority of the layer source.
+        """
+        lsrc2 = LayerSource.objects.create(\
+                    name="dummy-layersource2",
+                    sourcetype=LayerSource.TYPE_LOCAL,
+                    apiurl="test")
 
         # assign a lower priority for the second layer source
-        Release.objects.get(name="default-release").releaselayersourcepriority_set.create(layer_source = ls2, priority = 2)
+        self.release.releaselayersourcepriority_set.create(layer_source=lsrc2,
+                                                           priority=2)
 
-        # create a new layer_version for a layer with the same name coming from the second layer source
-        self.layer2 = Layer.objects.create(name="meta-testlayer", layer_source = ls2)
-        self.layerversion2 = Layer_Version.objects.create(layer = self.layer2, layer_source = ls2, up_branch = self.branch)
+        # create a new layer_version for a layer with the same name
+        # coming from the second layer source
+        layer2 = Layer.objects.create(name="meta-testlayer",
+                                      layer_source=lsrc2)
+        lver2 = Layer_Version.objects.create(layer=layer2, layer_source=lsrc2,
+                                             up_branch=self.branch)
 
         # expect two layer versions, in the priority order
-        equivalent_list = self.layerversion.get_equivalents_wpriority(self.project)
-        self.assertTrue(len(equivalent_list) == 2)
-        self.assertTrue(equivalent_list[0] == self.layerversion2)
-        self.assertTrue(equivalent_list[1] == self.layerversion)
+        equivqs = self.lver.get_equivalents_wpriority(self.project)
+        self.assertEqual(list(equivqs), [lver2, self.lver])
 
     def test_build_layerversion(self):
-        # any layer version coming from the build should show up before any layer version coming from upstream
-        build = Build.objects.create(project = self.project, started_on = timezone.now(), completed_on = timezone.now())
-        self.layerversion_build = Layer_Version.objects.create(layer = self.layer, build = build, commit = "deadbeef")
-
-        # a build layerversion must be in the equivalence list for the original layerversion
-        equivalent_list = self.layerversion.get_equivalents_wpriority(self.project)
-        self.assertTrue(len(equivalent_list) == 2)
-        self.assertTrue(equivalent_list[0] == self.layerversion)
-        self.assertTrue(equivalent_list[1] == self.layerversion_build)
-
-        # getting the build layerversion equivalent list must return the same list as the original layer
-        build_equivalent_list = self.layerversion_build.get_equivalents_wpriority(self.project)
-
-        self.assertEqual(list(equivalent_list), list(build_equivalent_list))
+        """
+        Any layer version coming from the build should show up
+        before any layer version coming from upstream
+        """
+        build = Build.objects.create(project=self.project,
+                                     started_on=timezone.now(),
+                                     completed_on=timezone.now())
+        lvb = Layer_Version.objects.create(layer=self.layer, build=build,
+                                           commit="deadbeef")
+
+        # a build layerversion must be in the equivalence
+        # list for the original layerversion
+        equivqs = self.lver.get_equivalents_wpriority(self.project)
+        self.assertTrue(len(equivqs) == 2)
+        self.assertTrue(equivqs[0] == self.lver)
+        self.assertTrue(equivqs[1] == lvb)
+
+        # getting the build layerversion equivalent list must
+        # return the same list as the original layer
+        bequivqs = lvb.get_equivalents_wpriority(self.project)
+
+        self.assertEqual(list(equivqs), list(bequivqs))
 
 class ProjectLVSelectionTestCase(TestCase):
     def setUp(self):