ed/toaster/fix-orm-tests

index d4d97ee..df9a2a9 100644
@@ -18,9 +18,6 @@ class LayerSourceVerifyInheritanceSaveLoad(TestCase):
         lils = LayerSource.objects.create(name = "a2", sourcetype = LayerSource.TYPE_LAYERINDEX, apiurl = "")
         imls = LayerSource.objects.create(name = "a3", sourcetype = LayerSource.TYPE_IMPORTED, apiurl = "")
 
-        import pprint
-        pprint.pprint([(x.__class__,vars(x)) for x in LayerSource.objects.all()])
-
         self.assertTrue(True in map(lambda x: isinstance(x, LocalLayerSource), LayerSource.objects.all()))
         self.assertTrue(True in map(lambda x: isinstance(x, LayerIndexLayerSource), LayerSource.objects.all()))
         self.assertTrue(True in map(lambda x: isinstance(x, ImportedLayerSource), LayerSource.objects.all()))

@@ -42,7 +39,6 @@ class LILSUpdateTestCase(TransactionTestCase):
     def test_update(self):
         layer_index_url = os.getenv("TTS_LAYER_INDEX")
         if layer_index_url == None:
-            print "Using layers.openembedded.org for layer index. override with TTS_LAYER_INDEX enviroment variable"
             layer_index_url = "http://layers.openembedded.org/"
 
         lils = LayerSource.objects.create(name = "b1", sourcetype = LayerSource.TYPE_LAYERINDEX, apiurl = layer_index_url + "layerindex/api/")

index df9a2a9..8bb5dec 100644
@@ -117,7 +117,7 @@ class LayerVersionEquivalenceTestCase(TestCase):
         # 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.assertTrue(equivalent_list == build_equivalent_list, "%s is not %s" % (equivalent_list, build_equivalent_list))
+        self.assertEqual(list(equivalent_list), list(build_equivalent_list))
 
 class ProjectLVSelectionTestCase(TestCase):
     def setUp(self):

index 8bb5dec..b0c01db 100644
@@ -6,28 +6,34 @@ from orm.models import Project, Build, Layer, Layer_Version, Branch, ProjectLaye
 from orm.models import Release, ReleaseLayerSourcePriority, BitbakeVersion
 
 from django.utils import timezone
+from django.db import IntegrityError
 
 import os
 
 # set TTS_LAYER_INDEX to the base url to use a different instance of the layer index
 
-# tests to verify inheritance for the LayerSource proxy-inheritance classes
 class LayerSourceVerifyInheritanceSaveLoad(TestCase):
+    """
+    Tests to verify inheritance for the LayerSource proxy-inheritance classes.
+    """
     def test_object_creation(self):
-        lls = LayerSource.objects.create(name = "a1", sourcetype = LayerSource.TYPE_LOCAL, apiurl = "")
-        lils = LayerSource.objects.create(name = "a2", sourcetype = LayerSource.TYPE_LAYERINDEX, apiurl = "")
-        imls = LayerSource.objects.create(name = "a3", sourcetype = LayerSource.TYPE_IMPORTED, apiurl = "")
+        """Test LayerSource object creation."""
+        for name, sourcetype in [("a1", LayerSource.TYPE_LOCAL),
+                                 ("a2", LayerSource.TYPE_LAYERINDEX),
+                                 ("a3", LayerSource.TYPE_IMPORTED)]:
+            LayerSource.objects.create(name=name, sourcetype=sourcetype)
 
-        self.assertTrue(True in map(lambda x: isinstance(x, LocalLayerSource), LayerSource.objects.all()))
-        self.assertTrue(True in map(lambda x: isinstance(x, LayerIndexLayerSource), LayerSource.objects.all()))
-        self.assertTrue(True in map(lambda x: isinstance(x, ImportedLayerSource), LayerSource.objects.all()))
+        objects = LayerSource.objects.all()
+        self.assertTrue(isinstance(objects[0], LocalLayerSource))
+        self.assertTrue(isinstance(objects[1], LayerIndexLayerSource))
+        self.assertTrue(isinstance(objects[2], ImportedLayerSource))
 
     def test_duplicate_error(self):
-        def duplicate():
-            LayerSource.objects.create(name = "a1", sourcetype = LayerSource.TYPE_LOCAL, apiurl = "")
-            LayerSource.objects.create(name = "a1", sourcetype = LayerSource.TYPE_LOCAL, apiurl = "")
-
-        self.assertRaises(Exception, duplicate)
+        """Test creation of duplicate LayerSource objects."""
+        stype = LayerSource.TYPE_LOCAL
+        LayerSource.objects.create(name="a1", sourcetype=stype)
+        with self.assertRaises(IntegrityError):
+            LayerSource.objects.create(name="a1", sourcetype=stype)
 
 
 class LILSUpdateTestCase(TransactionTestCase):

index b0c01db..3384f01 100644
@@ -37,22 +37,26 @@ class LayerSourceVerifyInheritanceSaveLoad(TestCase):
 
 
 class LILSUpdateTestCase(TransactionTestCase):
+    """Test Layer Source update."""
+
     def setUp(self):
-        # create release
-        bbv = BitbakeVersion.objects.create(name="master", giturl="git://git.openembedded.org/bitbake")
-        release = Release.objects.create(name="default-release", bitbake_version = bbv, branch_name = "master")
+        """Create release."""
+        bbv = BitbakeVersion.objects.create(\
+                  name="master", giturl="git://git.openembedded.org/bitbake")
+        Release.objects.create(name="default-release", bitbake_version=bbv,
+                               branch_name="master")
 
     def test_update(self):
-        layer_index_url = os.getenv("TTS_LAYER_INDEX")
-        if layer_index_url == None:
-            layer_index_url = "http://layers.openembedded.org/"
-
-        lils = LayerSource.objects.create(name = "b1", sourcetype = LayerSource.TYPE_LAYERINDEX, apiurl = layer_index_url + "layerindex/api/")
-        lils.update()
-
-        # run asserts
-        self.assertTrue(lils.branch_set.all().count() > 0, "update() needs to fetch some branches")
-
+        """Check if LayerSource.update can fetch branches."""
+        url = os.getenv("TTS_LAYER_INDEX",
+                        default="http://layers.openembedded.org/")
+
+        lsobj = LayerSource.objects.create(\
+                    name="b1", sourcetype=LayerSource.TYPE_LAYERINDEX,
+                    apiurl=url + "layerindex/api/")
+        lsobj.update()
+        self.assertTrue(lsobj.branch_set.all().count() > 0,
+                        "no branches fetched")
 
 
 # tests to verify layer_version priority selection

index 3384f01..75783ce 100644
@@ -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):

index 168bafa..6837038 100644
@@ -166,20 +166,3 @@ class ProjectLVSelectionTestCase(TestCase):
         self.assertTrue(len(compatible_layerversions) == 1)
         self.assertTrue(compatible_layerversions[0] == 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="testing")
-
-        # assign a lower priority for the second layer source
-        Release.objects.get(name="default-release").releaselayersourcepriority_set.create(layer_source = ls2, 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)
-
-         # expect two layer versions, in the priority order
-        equivalent_list = self.project.compatible_layerversions()
-        self.assertTrue(len(equivalent_list) == 2)
-        self.assertTrue(equivalent_list[0] == self.layerversion2)
-        self.assertTrue(equivalent_list[1] == self.lver)

index 75783ce..168bafa 100644
@@ -59,42 +59,45 @@ class LILSUpdateTestCase(TransactionTestCase):
                         "no branches fetched")
 
 
+def setup_lv_tests(self):
+    """Create required objects."""
+    # create layer source
+    self.lsrc = LayerSource.objects.create(name="dummy-layersource",
+                                           sourcetype=LayerSource.TYPE_LOCAL)
+    # create release
+    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=self.release, layer_source=self.lsrc, priority=1)
+
+    # create a layer version for the layer on the specified branch
+    self.layer = Layer.objects.create(name="meta-testlayer",
+                                      layer_source=self.lsrc)
+    self.branch = Branch.objects.create(name="master", layer_source=self.lsrc)
+    self.lver = Layer_Version.objects.create(\
+        layer=self.layer, layer_source=self.lsrc, up_branch=self.branch)
+
+    # 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)
+
 class LayerVersionEquivalenceTestCase(TestCase):
     """Verify Layer_Version priority selection."""
 
     def setUp(self):
-        """Create required objects."""
-        # create layer source
-        lsrc = LayerSource.objects.create(name="dummy-layersource",
-                                          sourcetype=LayerSource.TYPE_LOCAL)
-        # create release
-        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=self.release, layer_source=lsrc, priority=1)
-
-        # 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)
-
+        setup_lv_tests(self)
         # create spoof layer that should not appear in the search results
-        layer = Layer.objects.create(name="meta-notvalid", layer_source=lsrc)
-        Layer_Version.objects.create(layer=layer, layer_source=lsrc,
+        layer = Layer.objects.create(name="meta-notvalid",
+                                     layer_source=self.lsrc)
+        Layer_Version.objects.create(layer=layer, layer_source=self.lsrc,
                                      up_branch=self.branch)
 
-        # 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,

@@ -154,35 +157,14 @@ class LayerVersionEquivalenceTestCase(TestCase):
         self.assertEqual(list(equivqs), list(bequivqs))
 
 class ProjectLVSelectionTestCase(TestCase):
-    def setUp(self):
-        # create layer sources
-        ls = LayerSource.objects.create(name = "dummy-layersource", sourcetype = LayerSource.TYPE_LOCAL)
 
-        # create bitbake version
-        bbv = BitbakeVersion.objects.create(name="master", giturl="git://git.openembedded.org/bitbake")
-        # create release
-        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)
-
-        # 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 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)
+    def setUp(self):
+        setup_lv_tests(self)
 
     def test_single_layersource(self):
         compatible_layerversions = self.project.compatible_layerversions()
         self.assertTrue(len(compatible_layerversions) == 1)
-        self.assertTrue(compatible_layerversions[0] == self.layerversion)
+        self.assertTrue(compatible_layerversions[0] == self.lver)
 
 
     def test_dual_layersource(self):

@@ -200,4 +182,4 @@ class ProjectLVSelectionTestCase(TestCase):
         equivalent_list = self.project.compatible_layerversions()
         self.assertTrue(len(equivalent_list) == 2)
         self.assertTrue(equivalent_list[0] == self.layerversion2)
-        self.assertTrue(equivalent_list[1] == self.layerversion)
+        self.assertTrue(equivalent_list[1] == self.lver)

index 6837038..a57a62c 100644
@@ -162,7 +162,6 @@ class ProjectLVSelectionTestCase(TestCase):
         setup_lv_tests(self)
 
     def test_single_layersource(self):
-        compatible_layerversions = self.project.compatible_layerversions()
-        self.assertTrue(len(compatible_layerversions) == 1)
-        self.assertTrue(compatible_layerversions[0] == self.lver)
+        compat_lv = self.project.compatible_layerversions()
+        self.assertEqual(list(compat_lv), [self.lver])
 

index a57a62c..99f4fa0 100644
@@ -1,3 +1,26 @@
+#! /usr/bin/env python
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+#
+# BitBake Toaster Implementation
+#
+# Copyright (C) 2013-2015 Intel Corporation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+"""Test cases for Toaster ORM."""
+
 from django.test import TestCase, TransactionTestCase
 from orm.models import LocalLayerSource, LayerIndexLayerSource, ImportedLayerSource, LayerSource
 from orm.models import Branch

index 99f4fa0..5246909 100644
@@ -118,8 +118,9 @@ class LayerVersionEquivalenceTestCase(TestCase):
         # create spoof layer that should not appear in the search results
         layer = Layer.objects.create(name="meta-notvalid",
                                      layer_source=self.lsrc)
-        Layer_Version.objects.create(layer=layer, layer_source=self.lsrc,
-                                     up_branch=self.branch)
+        self.lver2 = Layer_Version.objects.create(layer=layer,
+                                                  layer_source=self.lsrc,
+                                                  up_branch=self.branch)
 
     def test_single_layersource(self):
         """

@@ -179,12 +180,11 @@ class LayerVersionEquivalenceTestCase(TestCase):
 
         self.assertEqual(list(equivqs), list(bequivqs))
 
-class ProjectLVSelectionTestCase(TestCase):
-
-    def setUp(self):
-        setup_lv_tests(self)
-
-    def test_single_layersource(self):
+    def test_compatible_layerversions(self):
+        """
+        When we have a 2 layer versions, compatible_layerversions()
+        should return a queryset with both.
+        """
         compat_lv = self.project.compatible_layerversions()
-        self.assertEqual(list(compat_lv), [self.lver])
+        self.assertEqual(list(compat_lv), [self.lver, self.lver2])
 

index 5246909..783aea8 100644
@@ -81,40 +81,37 @@ class LILSUpdateTestCase(TransactionTestCase):
         self.assertTrue(lsobj.branch_set.all().count() > 0,
                         "no branches fetched")
 
-
-def setup_lv_tests(self):
-    """Create required objects."""
-    # create layer source
-    self.lsrc = LayerSource.objects.create(name="dummy-layersource",
-                                           sourcetype=LayerSource.TYPE_LOCAL)
-    # create release
-    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=self.release, layer_source=self.lsrc, priority=1)
-
-    # create a layer version for the layer on the specified branch
-    self.layer = Layer.objects.create(name="meta-testlayer",
-                                      layer_source=self.lsrc)
-    self.branch = Branch.objects.create(name="master", layer_source=self.lsrc)
-    self.lver = Layer_Version.objects.create(\
-        layer=self.layer, layer_source=self.lsrc, up_branch=self.branch)
-
-    # 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)
-
 class LayerVersionEquivalenceTestCase(TestCase):
     """Verify Layer_Version priority selection."""
 
     def setUp(self):
-        setup_lv_tests(self)
+        """Create required objects."""
+        # create layer source
+        self.lsrc = LayerSource.objects.create(name="dummy-layersource",
+                                               sourcetype=LayerSource.TYPE_LOCAL)
+        # create release
+        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=self.release, layer_source=self.lsrc, priority=1)
+
+        # create a layer version for the layer on the specified branch
+        self.layer = Layer.objects.create(name="meta-testlayer",
+                                          layer_source=self.lsrc)
+        self.branch = Branch.objects.create(name="master", layer_source=self.lsrc)
+        self.lver = Layer_Version.objects.create(\
+            layer=self.layer, layer_source=self.lsrc, up_branch=self.branch)
+
+        # 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)
+
         # create spoof layer that should not appear in the search results
         layer = Layer.objects.create(name="meta-notvalid",
                                      layer_source=self.lsrc)