← Back to branch summary

~blueyed/ubuntu/lucid/miro/merge-from-sid

« back to all changes in this revision

Viewing changes to portable/test/storedatabasetest.py

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Hahler
  • Date: 2010-02-20 02:34:26 UTC
  • mfrom: (1.2.9 upstream) (1.5.6 sid)
  • Revision ID: james.westby@ubuntu.com-20100220023426-779i9mv2gk8w84ui
Tags: 2.5.4-1ubuntu1
* Merge with Debian unstable, remaining changes: 
  - debian/patches/40_boost_python.patch:
    Drop, not needed to build on karmic
  - 100_catch_keyerror_in_update_items.patch: Catch exception
    caused by out of bounds array index.
  - 101_player_undefined_elapsed_time.patch: There are some cases 
    where the elapsed_time returned is undefined; use a current 
    time of 0 in this case when fast-forwarding.
  - 90_miro_boost_py26.patch: Fix build breakage due to boost dependency
    changes.
  - debian/control, debian/pyversions,
    Build with python 2.6 and xulrunner 1.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
portable/test/storedatabasetest.py
11
11
from miro import downloader
12
12
from miro import item
13
13
from miro import feed
 
14
from miro import folder
14
15
from miro import frontendstate
15
16
from miro import guide
16
17
from miro import schema
432
433
                "WHERE name='lee'")
433
434
        restored_lee = self.reload_object(self.lee)
434
435
        self.assertEqual(restored_lee.stuff, 'testing123')
 
436
        app.db.cursor.execute("SELECT stuff from human WHERE name='lee'")
 
437
        row = app.db.cursor.fetchone()
 
438
        self.assertEqual(row[0], "'testing123'")
435
439
 
436
440
    def test_repr_failure_no_handler(self):
437
441
        app.db.cursor.execute("UPDATE pcf_programmer SET stuff='{baddata' "
465
469
        self.theme_hist = theme.ThemeHistory()
466
470
        self.widgets_frontend_state = frontendstate.WidgetsFrontendState()
467
471
 
 
472
    def check_fixed_value(self, obj, column_name, value, disk_value=None):
 
473
        obj = self.reload_object(obj)
 
474
        self.assertEquals(getattr(obj, column_name), value)
 
475
        # make sure the values stored on disk are correct as well
 
476
        if disk_value is None:
 
477
            disk_value = value
 
478
        obj_schema = app.db._schema_map[obj.__class__]
 
479
        app.db.cursor.execute("SELECT %s FROM %s WHERE id=?" % (column_name,
 
480
            obj_schema.table_name), (obj.id,))
 
481
        row = app.db.cursor.fetchone()
 
482
        for name, schema_item in obj_schema.fields:
 
483
            if name == column_name:
 
484
                break
 
485
        sql_value = app.db._converter.to_sql(obj_schema, column_name,
 
486
                schema_item, disk_value)
 
487
        self.assertEqual(row[0], sql_value)
 
488
 
468
489
    def test_corrupt_status(self):
469
490
        app.db.cursor.execute("UPDATE remote_downloader "
470
491
                "SET status='{baddata' WHERE id=?", (self.downloader.id,))
471
 
        reloaded = self.reload_object(self.downloader)
472
492
        # setup_restored sets some values for status, so we will have more
473
493
        # than an empty dict
474
 
        self.assertEquals(reloaded.status,
475
 
                {'rate': 0, 'upRate': 0, 'eta': 0})
 
494
        self.check_fixed_value(self.downloader, 'status',
 
495
                {'rate': 0, 'upRate': 0, 'eta': 0}, disk_value={})
476
496
 
477
497
    def test_corrupt_feedparser_output(self):
478
498
        app.db.cursor.execute("UPDATE item "
479
499
                "SET feedparser_output='{baddata' WHERE id=?", (self.item.id,))
480
 
        reloaded = self.reload_object(self.item)
481
 
        self.assertEquals(reloaded.feedparser_output, {})
 
500
        self.check_fixed_value(self.item, 'feedparser_output', {})
482
501
 
483
502
    def test_corrupt_etag(self):
484
503
        app.db.cursor.execute("UPDATE rss_multi_feed_impl "
485
504
                "SET etag='{baddata' WHERE ufeed_id=?", (self.feed.id,))
486
 
        reloaded = self.reload_object(self.feed.actualFeed)
487
 
        self.assertEquals(reloaded.etag, {})
 
505
        self.check_fixed_value(self.feed.actualFeed, 'etag', {})
488
506
 
489
507
    def test_corrupt_modified(self):
490
508
        app.db.cursor.execute("UPDATE rss_multi_feed_impl "
491
509
                "SET modified='{baddata' WHERE ufeed_id=?", (self.feed.id,))
492
 
        reloaded = self.reload_object(self.feed.actualFeed)
493
 
        self.assertEquals(reloaded.modified, {})
 
510
        self.check_fixed_value(self.feed.actualFeed, 'modified', {})
494
511
 
495
512
    def test_corrupt_tab_ids(self):
496
513
        app.db.cursor.execute("UPDATE taborder_order "
497
514
                "SET tab_ids='[1, 2; 3 ]' WHERE id=?", (self.tab_order.id,))
498
515
        reloaded = self.reload_object(self.tab_order)
 
516
        self.check_fixed_value(reloaded, 'tab_ids', [])
 
517
        # check that restore_tab_list() re-adds the tab ids
499
518
        reloaded.restore_tab_list()
500
 
        self.assertEquals(reloaded.tab_ids, [self.feed.id])
 
519
        self.check_fixed_value(reloaded, 'tab_ids', [self.feed.id])
501
520
 
502
521
    def test_corrupt_allowed_urls(self):
503
522
        app.db.cursor.execute("UPDATE channel_guide "
504
523
                "SET allowedURLs='[1, 2; 3 ]' WHERE id=?", (self.guide.id,))
505
 
        reloaded = self.reload_object(self.guide)
506
 
        self.assertEquals(reloaded.allowedURLs, [])
 
524
        self.check_fixed_value(self.guide, 'allowedURLs', [])
507
525
 
508
526
    def test_corrupt_past_themes(self):
509
527
        app.db.cursor.execute("UPDATE theme_history "
510
528
                "SET pastThemes='[1, 2; 3 ]' WHERE id=?", (self.theme_hist.id,))
511
 
        reloaded = self.reload_object(self.theme_hist)
512
 
        self.assertEquals(reloaded.pastThemes, [])
 
529
        self.check_fixed_value(self.theme_hist, 'pastThemes', [])
513
530
 
514
531
    def test_corrupt_list_view_displays(self):
515
532
        app.db.cursor.execute("UPDATE widgets_frontend_state "
516
533
                "SET list_view_displays='[1, 2; 3 ]' WHERE id=?",
517
534
                (self.widgets_frontend_state.id,))
518
 
        reloaded = self.reload_object(self.widgets_frontend_state)
519
 
        self.assertEquals(reloaded.list_view_displays, [])
 
535
        self.check_fixed_value(self.widgets_frontend_state,
 
536
                'list_view_displays', [])
520
537
 
521
538
    def test_corrupt_link_history(self):
522
539
        # TODO: should test ScraperFeedIpml.linkHistory, but it's not so easy
523
540
        # to create a ScraperFeedIpml in the unit tests.
524
541
        pass
525
542
 
 
543
class BadTabOrderTest(StoreDatabaseTest):
 
544
    # Test TabOrder objects with the wrong order
 
545
    def setUp(self):
 
546
        StoreDatabaseTest.setUp(self)
 
547
        self.f1 = feed.Feed(u"http://example.com/1")
 
548
        self.f2 = feed.Feed(u"http://example.com/2")
 
549
        self.folder = folder.ChannelFolder(u'test channel folder')
 
550
        self.tab_order = tabs.TabOrder(u'channel')
 
551
 
 
552
    def screw_with_tab_order(self, *tab_ids):
 
553
        app.db.cursor.execute("UPDATE taborder_order "
 
554
                "SET tab_ids=? WHERE id=?",
 
555
                (repr(list(tab_ids)), self.tab_order.id,))
 
556
 
 
557
    def check_order(self, *tab_ids):
 
558
        self.tab_order = self.reload_object(self.tab_order)
 
559
        self.tab_order.restore_tab_list()
 
560
        self.assertEqual(self.tab_order.tab_ids, list(tab_ids))
 
561
 
 
562
    def test_missing_tab_ids(self):
 
563
        self.screw_with_tab_order(self.f1.id, self.folder.id)
 
564
        self.check_order(self.f1.id, self.folder.id, self.f2.id)
 
565
 
 
566
    def test_missing_folder_ids(self):
 
567
        self.screw_with_tab_order(self.f1.id, self.f2.id)
 
568
        self.check_order(self.f1.id, self.f2.id, self.folder.id)
 
569
 
 
570
    def test_extra_tab_ids(self):
 
571
        self.screw_with_tab_order(self.f1.id, self.f2.id, self.folder.id, 123)
 
572
        self.check_order(self.f1.id, self.f2.id, self.folder.id)
 
573
 
 
574
    def test_order_wrong(self):
 
575
        self.f1.set_folder(self.folder)
 
576
        self.check_order(self.f2.id, self.folder.id, self.f1.id)
 
577
        # f1 should follow it's parent, check that we fix things if that's not
 
578
        # true
 
579
        self.screw_with_tab_order(self.f1.id, self.f2.id, self.folder.id)
 
580
        self.check_order(self.f2.id, self.folder.id, self.f1.id)
 
581
 
526
582
if __name__ == '__main__':
527
583
    unittest.main()