1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
from django.test import TestCase, TransactionTestCase
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
from django.db import IntegrityError
import os
# set TTS_LAYER_INDEX to the base url to use a different instance of the layer index
class LayerSourceVerifyInheritanceSaveLoad(TestCase):
"""
Tests to verify inheritance for the LayerSource proxy-inheritance classes.
"""
def test_object_creation(self):
"""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)
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):
"""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):
"""Test Layer Source update."""
def setUp(self):
"""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):
"""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")
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 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)
def test_single_layersource(self):
"""
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.
"""
lsrc2 = LayerSource.objects.create(\
name="dummy-layersource2",
sourcetype=LayerSource.TYPE_LOCAL,
apiurl="test")
# assign a lower priority for the second layer source
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
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
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())
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):
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)
|
