← Back to branch summary

~ubuntu-branches/ubuntu/lucid/landscape-client/lucid

« back to all changes in this revision

Viewing changes to landscape/package/tests/test_store.py

  • Committer: Bazaar Package Importer
  • Author(s): Free Ekanayaka
  • Date: 2009-12-16 10:50:05 UTC
  • mfrom: (1.2.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: james.westby@ubuntu.com-20091216105005-bmki8i2of1dmcdkc
Tags: 1.4.0-0ubuntu0.9.10.0
https://launchpad.net/bugs/497351
https://launchpad.net/bugs/456124
https://launchpad.net/bugs/340843
https://launchpad.net/bugs/450629
https://launchpad.net/bugs/455217
https://launchpad.net/bugs/462543
https://launchpad.net/bugs/463321
* New upstream release (LP: #497351)

* Bug fixes:
  - Fix landscape daemons fail to start when too many groups are
    available (LP: #456124)
  - Fix landscape programs wake up far too much. (LP: #340843)
  - Fix Package manager fails with 'no such table: task' (LP #465846)
  - Fix test suite leaving temporary files around (LP #476418)
  - Fix the 1hr long wait for user data to be uploaded following a
    resynchronisation (LP #369000)

* Add support for Ubuntu release upgrades:
  - Add helper function to fetch many files at once (LP: #450629)
  - Handle release-upgrade messages in the packagemanager
    plugin (LP: #455217)
  - Add a release-upgrader task handler (LP: #462543)
  - Support upgrade-tool environment variables (LP: #463321)

* Add initial support for Smart package locking:
  - Detect and report changes about Smart package locks (#488108)

* Packaging fixes:
  - Turn unnecessary Pre-Depends on python-gobject into a regular Depends
  - If it's empty, remove /etc/landscape upon purge

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/package/tests/test_store.py
31
31
        self.store1.set_hash_ids(hash_ids)
32
32
        self.assertEquals(self.store1.get_hash_ids(), hash_ids)
33
33
 
 
34
    def test_wb_lazy_connection(self):
 
35
        """
 
36
        The connection to the sqlite database is created only when some query
 
37
        gets actually requsted.
 
38
        """
 
39
        self.assertEquals(self.store1._db, None)
 
40
        self.store1.get_hash_ids()
 
41
        self.assertTrue(isinstance(self.store1._db, sqlite3.Connection))
 
42
 
34
43
    def test_wb_transactional_commits(self):
 
44
        self.store1._db = sqlite3.connect(self.store1._filename)
35
45
        mock_db = self.mocker.replace(self.store1._db)
36
46
        mock_db.commit()
37
47
        self.mocker.replay()
38
48
        self.store1.set_hash_ids({})
39
49
 
40
50
    def test_wb_transactional_rolls_back(self):
 
51
        self.store1._db = sqlite3.connect(self.store1._filename)
41
52
        mock_db = self.mocker.replace(self.store1._db)
42
53
        mock_db.rollback()
43
54
        self.mocker.replay()
293
304
        self.store1.clear_installed()
294
305
        self.assertEquals(self.store2.get_installed(), [])
295
306
 
 
307
    def test_ensure_package_schema_with_new_tables(self):
 
308
        """
 
309
        The L{ensure_package_schema} function behaves correctly when new
 
310
        tables are added.
 
311
        """
 
312
        filename = self.makeFile()
 
313
        database = sqlite3.connect(filename)
 
314
        cursor = database.cursor()
 
315
        cursor.execute("CREATE TABLE available"
 
316
                       " (id INTEGER PRIMARY KEY)")
 
317
        cursor.execute("CREATE TABLE available_upgrade"
 
318
                       " (id INTEGER PRIMARY KEY)")
 
319
        cursor.execute("CREATE TABLE installed"
 
320
                       " (id INTEGER PRIMARY KEY)")
 
321
        cursor.execute("CREATE TABLE hash_id_request"
 
322
                       " (id INTEGER PRIMARY KEY, timestamp TIMESTAMP,"
 
323
                       " message_id INTEGER, hashes BLOB)")
 
324
        cursor.execute("CREATE TABLE task"
 
325
                       " (id INTEGER PRIMARY KEY, queue TEXT,"
 
326
                       " timestamp TIMESTAMP, data BLOB)")
 
327
        cursor.close()
 
328
        database.commit()
 
329
        database.close()
 
330
 
 
331
        store = PackageStore(filename)
 
332
        store.get_locked()
 
333
 
 
334
        database = sqlite3.connect(filename)
 
335
        cursor = database.cursor()
 
336
        for table in ["package_locks", "locked"]:
 
337
            query = "pragma table_info(%s)" % table
 
338
            result = cursor.execute(query).fetchall()
 
339
            self.assertTrue(len(result) > 0)
 
340
 
 
341
    def test_add_and_get_locked(self):
 
342
        """
 
343
        L{PackageStore.add_locked} adds the given ids to the table of locked
 
344
        packages and commits the changes.
 
345
        """
 
346
        self.store1.add_locked([1])
 
347
        self.assertEquals(self.store2.get_locked(), [1])
 
348
 
 
349
    def test_add_locked_conflicting(self):
 
350
        """Adding the same locked pacakge id twice is fine."""
 
351
        self.store1.add_locked([1])
 
352
        self.store1.add_locked([1])
 
353
        self.assertEquals(self.store2.get_locked(), [1])
 
354
 
 
355
    def test_remove_locked(self):
 
356
        """
 
357
        L{PackageStore.removed_locked} remove the given ids from the table
 
358
        of locked packages and commits the changes.
 
359
        """
 
360
        self.store1.add_locked([1, 2, 3, 4])
 
361
        self.store1.remove_locked([2, 3])
 
362
        self.assertEquals(self.store2.get_locked(), [1, 4])
 
363
 
 
364
    def test_remove_locked_non_existing(self):
 
365
        """
 
366
        Removing non-existing locked packages is fine.
 
367
        """
 
368
        self.store1.remove_locked([1])
 
369
        self.assertEquals(self.store2.get_locked(), [])
 
370
 
 
371
    def test_clear_locked(self):
 
372
        """
 
373
        L{PackageStore.clear_locked} clears the table of locked packages by
 
374
        removing all its package ids.
 
375
        """
 
376
        self.store1.add_locked([1, 2, 3, 4])
 
377
        self.store1.clear_locked()
 
378
        self.assertEquals(self.store2.get_locked(), [])
 
379
 
 
380
    def test_get_package_locks_with_no_lock(self):
 
381
        """
 
382
        L{PackageStore.get_package_locks} returns an empty list if no package
 
383
        locks are stored.
 
384
        """
 
385
        self.assertEquals(self.store1.get_package_locks(), [])
 
386
 
 
387
    def test_add_package_locks(self):
 
388
        """
 
389
        L{PackageStore.add_package_locks} adds a package lock to the store.
 
390
        """
 
391
        self.store1.add_package_locks([("name", "", "")])
 
392
        self.assertEquals(self.store2.get_package_locks(),
 
393
                          [("name", "", "")])
 
394
 
 
395
    def test_add_package_locks_idempotence(self):
 
396
        """
 
397
        The operation of adding a lock is idempotent.
 
398
        """
 
399
        self.store1.add_package_locks([("name", "", "")])
 
400
        self.store1.add_package_locks([("name", "", "")])
 
401
        self.assertEquals(self.store2.get_package_locks(),
 
402
                          [("name", "", "")])
 
403
 
 
404
    def test_add_package_locks_with_none(self):
 
405
        """
 
406
        If None, package locks relation and version values are automatically
 
407
        converted to empty strings.
 
408
        """
 
409
        self.store1.add_package_locks([("name", None, None)])
 
410
        self.assertEquals(self.store2.get_package_locks(),
 
411
                          [("name", "", "")])
 
412
 
 
413
    def test_add_package_locks_multiple_times(self):
 
414
        """
 
415
        L{PackageStore.add_package_locks} can be called multiple times and
 
416
        with multiple locks each time.
 
417
        """
 
418
        self.store1.add_package_locks([("name1", "", "")])
 
419
        self.store1.add_package_locks([("name2", "<", "0.2"),
 
420
                                       ("name3", "", "")])
 
421
        self.assertEquals(sorted(self.store2.get_package_locks()),
 
422
                          sorted([("name1", "", ""),
 
423
                                  ("name2", "<", "0.2"),
 
424
                                  ("name3", "", "")]))
 
425
 
 
426
    def test_add_package_locks_without_name(self):
 
427
        """
 
428
        It's not possible to add a package lock without a name.
 
429
        """
 
430
        self.assertRaises(sqlite3.IntegrityError,
 
431
                          self.store1.add_package_locks,
 
432
                          [(None, None, None)])
 
433
 
 
434
    def test_remove_package_locks(self):
 
435
        """
 
436
        L{PackageStore.remove_package_locks} removes a package lock from
 
437
        the store.
 
438
        """
 
439
        self.store1.add_package_locks([("name1", "", "")])
 
440
        self.store1.remove_package_locks([("name1", "", "")])
 
441
        self.assertEquals(self.store2.get_package_locks(), [])
 
442
 
 
443
    def test_remove_package_locks_multiple_times(self):
 
444
        """
 
445
        L{PackageStore.remove_package_locks} can be called multiple times and
 
446
        with multiple locks each time.
 
447
        """
 
448
        self.store1.add_package_locks([("name1", "", ""),
 
449
                                       ("name2", "<", "0.2"),
 
450
                                       ("name3", "", "")])
 
451
        self.store1.remove_package_locks([("name1", "", "")])
 
452
        self.store1.remove_package_locks([("name2", "<", "0.2"),
 
453
                                          ("name3", "", "")])
 
454
        self.assertEquals(self.store2.get_package_locks(), [])
 
455
 
 
456
    def test_remove_package_locks_without_matching_lock(self):
 
457
        """
 
458
        It's fine to remove a non-existent lock.
 
459
        """
 
460
        self.store1.remove_package_locks([("name", "", "")])
 
461
        self.assertEquals(self.store2.get_package_locks(), [])
 
462
 
 
463
    def test_clear_package_locks(self):
 
464
        """
 
465
        L{PackageStore.clear_package_locks} removes all package locks
 
466
        from the store.
 
467
        """
 
468
        self.store1.add_package_locks([("name1", "", ""),
 
469
                                       ("name2", "<", "0.2")])
 
470
        self.store1.clear_package_locks()
 
471
        self.assertEquals(self.store2.get_package_locks(), [])
 
472
 
296
473
    def test_add_hash_id_request(self):
297
474
        hashes = ("ha\x00sh1", "ha\x00sh2")
298
475
        request1 = self.store1.add_hash_id_request(hashes)