3 from db_test import DBDakTestCase
4 from base_test import fixture
6 from daklib.dbconn import *
7 from daklib.queue_install import package_to_suite
8 from daklib.queue import get_newest_source, get_suite_version_by_source, \
9 get_source_by_package_and_suite, get_suite_version_by_package
11 from sqlalchemy.orm.exc import MultipleResultsFound
15 'fake package class used for testing'
23 'fake Upload class used for testing'
25 def __init__(self, pkg):
28 class PackageTestCase(DBDakTestCase):
30 PackageTestCase checks the handling of source and binary packages in dak's
35 super(PackageTestCase, self).setUp()
37 # flush to make sure that the setup is correct
40 def test_suite_architecture(self):
41 # check the id for architectures source and all
42 self.assertEqual(1, self.arch['source'].arch_id)
43 self.assertEqual(2, self.arch['all'].arch_id)
44 # check the many to many relation between Suite and Architecture
45 self.assertEqual('source', self.suite['lenny'].architectures[0])
46 self.assertEqual(4, len(self.suite['lenny'].architectures))
47 self.assertEqual(3, len(self.arch['i386'].suites))
48 # check the function get_suite_architectures()
49 architectures = get_suite_architectures('lenny', session = self.session)
50 self.assertEqual(4, len(architectures))
51 self.assertTrue(self.arch['source'] in architectures)
52 self.assertTrue(self.arch['all'] in architectures)
53 self.assertTrue(self.arch['kfreebsd-i386'] not in architectures)
54 architectures = get_suite_architectures('sid', session = self.session)
55 self.assertEqual(5, len(architectures))
56 self.assertTrue(self.arch['kfreebsd-i386'] in architectures)
57 architectures = get_suite_architectures('lenny', skipsrc = True, session = self.session)
58 self.assertEqual(3, len(architectures))
59 self.assertTrue(self.arch['source'] not in architectures)
60 architectures = get_suite_architectures('lenny', skipall = True, session = self.session)
61 self.assertEqual(3, len(architectures))
62 self.assertTrue(self.arch['all'] not in architectures)
64 self.assertEqual(0, self.suite['lenny'].overrides.count())
66 def test_poolfiles(self):
68 Test the relation of the classes PoolFile and Location.
70 The code needs some explaination. The property Location.files is not a
71 list as in other relations because such a list would become rather
72 huge. It is a query object that can be queried, filtered, and iterated
73 as usual. But list like methods like append() and remove() are
74 supported as well which allows code like:
76 somelocation.files.append(somefile)
79 main = self.loc['main']
80 contrib = self.loc['contrib']
81 self.assertEqual(fixture('ftp/pool/'), main.path)
82 count = len(self.file.keys()) - 2
83 self.assertEqual(count, main.files.count())
84 self.assertEqual(2, contrib.files.count())
85 poolfile = main.files. \
86 filter(PoolFile.filename.like('%/hello/hello%')). \
87 order_by(PoolFile.filename)[0]
88 self.assertEqual('main/h/hello/hello_2.2-1.dsc', poolfile.filename)
89 self.assertEqual(main, poolfile.location)
91 self.assertEqual(poolfile, \
92 self.session.query(PoolFile).get(poolfile.file_id))
93 self.assertEqual(None, self.session.query(PoolFile).get(-1))
94 # test remove() and append()
95 main.files.remove(self.file['sl_3.03-16.dsc'])
96 contrib.files.append(self.file['sl_3.03-16.dsc'])
97 self.assertEqual(count - 1, main.files.count())
98 self.assertEqual(3, contrib.files.count())
100 self.assertEqual(fixture('ftp/pool/main/s/sl/sl_3.03-16.dsc'), \
101 self.file['sl_3.03-16.dsc'].fullpath)
102 # test check_poolfile()
103 self.assertEqual((True, self.file['sl_3.03-16.dsc']), \
104 check_poolfile('main/s/sl/sl_3.03-16.dsc', 0, '', \
105 contrib.location_id, self.session))
106 # test string value of 2nd argument
107 self.assertEqual((True, self.file['sl_3.03-16.dsc']), \
108 check_poolfile('main/s/sl/sl_3.03-16.dsc', '0', '', \
109 contrib.location_id, self.session))
110 self.assertEqual((False, None), \
111 check_poolfile('foobar', 0, '', contrib.location_id, self.session))
112 self.assertEqual((False, self.file['sl_3.03-16.dsc']), \
113 check_poolfile('main/s/sl/sl_3.03-16.dsc', 42, '', \
114 contrib.location_id, self.session))
115 self.assertEqual((False, self.file['sl_3.03-16.dsc']), \
116 check_poolfile('main/s/sl/sl_3.03-16.dsc', 0, 'deadbeef', \
117 contrib.location_id, self.session))
118 # test get_poolfile_like_name()
119 self.assertEqual([self.file['sl_3.03-16.dsc']], \
120 get_poolfile_like_name('sl_3.03-16.dsc', self.session))
121 self.assertEqual([], get_poolfile_like_name('foobar', self.session))
123 def test_maintainers(self):
125 tests relation between Maintainer and DBSource
127 TODO: add relations to changes_pending_source
130 maintainer = self.maintainer['maintainer']
131 self.assertEqual(maintainer,
132 self.session.query(Maintainer).get(maintainer.maintainer_id))
133 uploader = self.maintainer['uploader']
134 self.assertEqual(uploader,
135 self.session.query(Maintainer).get(uploader.maintainer_id))
136 lazyguy = self.maintainer['lazyguy']
137 self.assertEqual(lazyguy,
138 self.session.query(Maintainer).get(lazyguy.maintainer_id))
139 self.assertEqual(4, len(maintainer.maintains_sources))
140 self.assertTrue(self.source['hello_2.2-2'] in maintainer.maintains_sources)
141 self.assertEqual(maintainer.changed_sources, [])
142 self.assertEqual(uploader.maintains_sources, [])
143 self.assertEqual(4, len(uploader.changed_sources))
144 self.assertTrue(self.source['sl_3.03-16'] in uploader.changed_sources)
145 self.assertEqual(lazyguy.maintains_sources, [])
146 self.assertEqual(lazyguy.changed_sources, [])
148 def get_source_in_suite_fail(self):
150 This function throws the MultipleResultsFound exception because
151 get_source_in_suite is broken.
153 TODO: fix get_source_in_suite
156 return get_source_in_suite('hello', 'sid', self.session)
158 def test_sources(self):
159 'test relation between DBSource and PoolFile or Suite'
162 self.assertEqual(self.file['hello_2.2-2.dsc'], self.source['hello_2.2-2'].poolfile)
163 self.assertEqual(self.source['hello_2.2-2'], self.file['hello_2.2-2.dsc'].source)
164 self.assertEqual(None, self.file['python2.6_2.6.6-8.dsc'].source)
166 squeeze = self.session.query(Suite). \
167 filter(Suite.sources.contains(self.source['sl_3.03-16'])). \
168 order_by(Suite.suite_name)[1]
169 self.assertEqual(self.suite['squeeze'], squeeze)
170 self.assertEqual(1, squeeze.sources.count())
171 self.assertEqual(self.source['sl_3.03-16'], squeeze.sources[0])
172 sl = self.session.query(DBSource). \
173 filter(DBSource.suites.contains(self.suite['squeeze'])).one()
174 self.assertEqual(self.source['sl_3.03-16'], sl)
175 self.assertEqual(2, len(sl.suites))
176 self.assertTrue(self.suite['sid'] in sl.suites)
177 # test get_source_in_suite()
178 self.assertRaises(MultipleResultsFound, self.get_source_in_suite_fail)
179 self.assertEqual(None, \
180 get_source_in_suite('hello', 'squeeze', self.session))
181 self.assertEqual(self.source['sl_3.03-16'], \
182 get_source_in_suite('sl', 'sid', self.session))
183 # test get_suites_source_in()
184 self.assertEqual([self.suite['sid']], \
185 get_suites_source_in('hello', self.session))
186 self.assertEqual(2, len(get_suites_source_in('sl', self.session)))
187 self.assertTrue(self.suite['squeeze'] in \
188 get_suites_source_in('sl', self.session))
190 def test_add_dsc_to_db(self):
191 'tests function add_dsc_to_db()'
194 pkg.dsc['source'] = 'hello'
195 pkg.dsc['version'] = '2.2-3'
196 pkg.dsc['maintainer'] = self.maintainer['maintainer'].name
197 pkg.changes['changed-by'] = self.maintainer['uploader'].name
198 pkg.changes['fingerprint'] = 'deadbeef'
199 pkg.changes['distribution'] = { 'sid': '' }
200 pkg.files['hello_2.2-3.dsc'] = { \
202 'location id': self.loc['main'].location_id,
203 'files id': self.file['hello_2.2-3.dsc'].file_id }
206 (source, dsc_component, dsc_location_id, pfs) = \
207 add_dsc_to_db(upload, 'hello_2.2-3.dsc', self.session)
208 self.assertEqual('hello', source.source)
209 self.assertEqual('2.2-3', source.version)
210 self.assertEqual('sid', source.suites[0].suite_name)
211 self.assertEqual('main', dsc_component)
212 self.assertEqual(self.loc['main'].location_id, dsc_location_id)
213 self.assertEqual([], pfs)
215 def test_source_exists(self):
216 'test function source_exists()'
218 hello = self.source['hello_2.2-2']
219 self.assertTrue(source_exists(hello.source, hello.version, \
220 suites = ['sid'], session = self.session))
222 self.assertTrue(source_exists(hello.source, hello.version + '+b7', \
223 suites = ['sid'], session = self.session))
224 self.assertTrue(not source_exists(hello.source, hello.version, \
225 suites = ['lenny', 'squeeze'], session = self.session))
226 self.assertTrue(not source_exists(hello.source, hello.version, \
227 suites = ['lenny', 'sid'], session = self.session))
228 self.assertTrue(not source_exists(hello.source, hello.version, \
229 suites = ['sid', 'lenny'], session = self.session))
230 self.assertTrue(not source_exists(hello.source, '0815', \
231 suites = ['sid'], session = self.session))
233 self.assertTrue(source_exists(hello.source, hello.version, \
234 session = self.session))
236 def test_package_to_suite(self):
237 'test function package_to_suite()'
240 pkg.changes = { 'distribution': {} }
242 self.assertTrue(not package_to_suite(upload, 'sid', self.session))
243 pkg.changes['distribution'] = { 'sid': '' }
244 pkg.changes['architecture'] = { 'source': '' }
245 self.assertTrue(package_to_suite(upload, 'sid', self.session))
246 pkg.changes['architecture'] = {}
247 pkg.changes['source'] = self.source['hello_2.2-2'].source
248 pkg.changes['version'] = self.source['hello_2.2-2'].version
249 self.assertTrue(not package_to_suite(upload, 'sid', self.session))
250 pkg.changes['version'] = '42'
251 self.assertTrue(package_to_suite(upload, 'sid', self.session))
252 pkg.changes['source'] = 'foobar'
253 pkg.changes['version'] = self.source['hello_2.2-2'].version
254 self.assertTrue(package_to_suite(upload, 'sid', self.session))
255 pkg.changes['distribution'] = { 'lenny': '' }
256 self.assertTrue(package_to_suite(upload, 'lenny', self.session))
258 def test_get_newest_source(self):
259 'test function get_newest_source()'
262 daklib.queue.dm_suites = ['sid']
263 self.assertEqual(self.source['hello_2.2-2'], get_newest_source('hello', self.session))
264 self.assertEqual(None, get_newest_source('foobar', self.session))
266 def test_get_suite_version_by_source(self):
267 'test function get_suite_version_by_source()'
269 result = get_suite_version_by_source('hello', self.session)
270 self.assertEqual(2, len(result))
271 self.assertTrue(('sid', '2.2-1') in result)
272 self.assertTrue(('sid', '2.2-2') in result)
273 result = get_suite_version_by_source('sl', self.session)
274 self.assertEqual(2, len(result))
275 self.assertTrue(('squeeze', '3.03-16') in result)
276 self.assertTrue(('sid', '3.03-16') in result)
278 def test_binaries(self):
280 tests class DBBinary; TODO: test relation with Architecture, Maintainer,
281 PoolFile, and Fingerprint
284 # test Suite relation
285 self.assertEqual(3, self.suite['sid'].binaries.count())
286 self.assertTrue(self.binary['hello_2.2-1_i386'] in \
287 self.suite['sid'].binaries.all())
288 self.assertEqual(0, self.suite['lenny'].binaries.count())
289 # test DBSource relation
290 self.assertEqual(3, len(self.source['hello_2.2-1'].binaries))
291 self.assertTrue(self.binary['hello_2.2-1_i386'] in \
292 self.source['hello_2.2-1'].binaries)
293 self.assertEqual(0, len(self.source['hello_2.2-2'].binaries))
294 # test get_suites_binary_in()
295 self.assertEqual(2, len(get_suites_binary_in('hello', self.session)))
296 self.assertTrue(self.suite['sid'] in \
297 get_suites_binary_in('hello', self.session))
298 self.assertEqual(2, len(get_suites_binary_in('gnome-hello', self.session)))
299 self.assertTrue(self.suite['squeeze'] in \
300 get_suites_binary_in('gnome-hello', self.session))
301 self.assertEqual(0, len(get_suites_binary_in('sl', self.session)))
303 def test_add_deb_to_db(self):
304 'tests function add_deb_to_db()'
307 pkg.changes['fingerprint'] = 'deadbeef'
308 pkg.changes['distribution'] = { 'sid': '' }
309 pkg.files['hello_2.2-2_i386.deb'] = { \
312 'maintainer': self.maintainer['maintainer'].name,
313 'architecture': 'i386',
315 'pool name': 'main/h/hello/',
316 'location id': self.loc['main'].location_id,
317 'source package': 'hello',
318 'source version': '2.2-2',
320 'md5sum': 'deadbeef',
321 'sha1sum': 'deadbeef',
322 'sha256sum': 'deadbeef'}
324 bin, poolfile = add_deb_to_db(upload, 'hello_2.2-2_i386.deb', self.session)
325 self.session.refresh(poolfile)
326 self.session.refresh(poolfile.binary)
327 self.assertEqual('main/h/hello/hello_2.2-2_i386.deb', poolfile.filename)
328 self.assertEqual('hello', poolfile.binary.package)
329 self.assertEqual('2.2-2', poolfile.binary.version)
330 self.assertEqual(['sid'], poolfile.binary.suites)
331 self.assertEqual('Mr. Maintainer', poolfile.binary.maintainer.name)
332 self.assertEqual('i386', poolfile.binary.architecture.arch_string)
333 self.assertEqual('deb', poolfile.binary.binarytype)
334 self.assertEqual(self.loc['main'], poolfile.location)
335 self.assertEqual(self.source['hello_2.2-2'], poolfile.binary.source)
336 self.assertEqual(0, poolfile.filesize)
337 self.assertEqual('deadbeef', poolfile.md5sum)
338 self.assertEqual('deadbeef', poolfile.sha1sum)
339 self.assertEqual('deadbeef', poolfile.sha256sum)
341 def test_get_source_by_package_and_suite(self):
342 'test get_source_by_package_and_suite()'
344 query = get_source_by_package_and_suite('hello', 'sid', self.session)
345 self.assertEqual(self.source['hello_2.2-1'], query.one())
346 query = get_source_by_package_and_suite('gnome-hello', 'squeeze', self.session)
347 self.assertEqual(self.source['hello_2.2-1'], query.one())
348 query = get_source_by_package_and_suite('hello', 'hamm', self.session)
349 self.assertEqual(0, query.count())
350 query = get_source_by_package_and_suite('foobar', 'squeeze', self.session)
351 self.assertEqual(0, query.count())
353 def test_get_suite_version_by_package(self):
354 'test function get_suite_version_by_package()'
356 result = get_suite_version_by_package('hello', 'i386', self.session)
357 self.assertEqual(2, len(result))
358 self.assertTrue(('sid', '2.2-1') in result)
359 result = get_suite_version_by_package('hello', 'amd64', self.session)
360 self.assertEqual(0, len(result))
361 result = get_suite_version_by_package('python-hello', 'i386', self.session)
362 self.assertEqual([('squeeze', '2.2-1')], result)
363 result = get_suite_version_by_package('python-hello', 'amd64', self.session)
364 self.assertEqual([('squeeze', '2.2-1')], result)
366 def test_components(self):
367 'test class Component'
369 self.assertEqual([self.loc['main']], self.comp['main'].location)
370 self.assertEqual([self.loc['contrib']], self.comp['contrib'].location)
371 self.assertEqual(0, self.comp['main'].overrides.count())
373 def test_get_component_by_package_suite(self):
374 'test get_component_by_package_suite()'
376 result = get_component_by_package_suite('hello', ['sid'], \
377 session = self.session)
378 self.assertEqual('main', result)
379 result = get_component_by_package_suite('hello', ['hamm'], \
380 session = self.session)
381 self.assertEqual(None, result)
382 result = get_component_by_package_suite('foobar', ['sid'], \
383 session = self.session)
384 self.assertEqual(None, result)
385 # test that the newest version is returned
386 result = get_component_by_package_suite('gnome-hello', ['squeeze'], \
387 session = self.session)
388 self.assertEqual('main', result)
389 result = get_component_by_package_suite('gnome-hello', ['sid'], \
390 session = self.session)
391 self.assertEqual('contrib', result)
393 result = get_component_by_package_suite('hello', ['sid'], \
394 arch_list = ['i386'], session = self.session)
395 self.assertEqual('main', result)
396 result = get_component_by_package_suite('hello', ['sid'], \
397 arch_list = ['amd64'], session = self.session)
398 self.assertEqual(None, result)
400 if __name__ == '__main__':