From 202d808f890b03958cd6873486e6a37f3f437098 Mon Sep 17 00:00:00 2001 From: Alexandru DAMIAN Date: Mon, 2 Feb 2015 17:57:36 +0000 Subject: bitbake: toastergui: improvements in layer selection logic This patch clearers and bring fixes for the layer selection logic in order to enable information collected during build to be used in configuring projects, specifically targeting the recipes learned through the building process. The patch also adds tests to verify the layer selection logic. [YOCTO #7189] (Bitbake rev: f0faba8ef0f08c98ac4bddf5b3954d540820d215) Signed-off-by: Alexandru DAMIAN Signed-off-by: Richard Purdie --- bitbake/lib/toaster/orm/tests.py | 131 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 130 insertions(+), 1 deletion(-) (limited to 'bitbake/lib/toaster/orm/tests.py') diff --git a/bitbake/lib/toaster/orm/tests.py b/bitbake/lib/toaster/orm/tests.py index b965d8e50e..7b1b9633f9 100644 --- a/bitbake/lib/toaster/orm/tests.py +++ b/bitbake/lib/toaster/orm/tests.py @@ -2,6 +2,12 @@ from django.test import TestCase from orm.models import LocalLayerSource, LayerIndexLayerSource, ImportedLayerSource, LayerSource from orm.models import Branch +from orm.models import Project, Build, Layer, Layer_Version, Branch, ProjectLayer +from orm.models import Release, ReleaseLayerSourcePriority, BitbakeVersion + +from django.utils import timezone + +# tests to verify inheritance for the LayerSource proxy-inheritance classes class LayerSourceVerifyInheritanceSaveLoad(TestCase): def test_object_creation(self): lls = LayerSource.objects.create(name = "a1", sourcetype = LayerSource.TYPE_LOCAL, apiurl = "") @@ -23,7 +29,7 @@ class LayerSourceVerifyInheritanceSaveLoad(TestCase): self.assertRaises(Exception, duplicate) - +# test to verify the layer source update functionality for layerindex. edit to pass the URL to a layerindex application class LILSUpdateTestCase(TestCase): def test_update(self): lils = LayerSource.objects.create(name = "b1", sourcetype = LayerSource.TYPE_LAYERINDEX, apiurl = "http://adamian-desk.local:8080/layerindex/api/") @@ -34,3 +40,126 @@ class LILSUpdateTestCase(TestCase): # print vars(lils) #print map(lambda x: vars(x), Branch.objects.all()) + + # run asserts + self.assertTrue(lils.branch_set.all().count() > 0, "update() needs to fetch some branches") + + + +# 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) + + # 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 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) + + + # 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 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) + + 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) + + # 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.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) + + 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.assertTrue(equivalent_list == build_equivalent_list, "%s is not %s" % (equivalent_list, build_equivalent_list)) + +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 test_single_layersource(self): + compatible_layerversions = self.project.compatible_layerversions() + self.assertTrue(len(compatible_layerversions) == 1) + self.assertTrue(compatible_layerversions[0] == self.layerversion) + + + 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) + + # 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.layerversion) -- cgit v1.2.3-54-g00ecf