← Back to branch summary

~mvo/software-center/size-calculation-via-aptdaemon

« back to all changes in this revision

Viewing changes to tests/test_database.py

  • Committer: Michael Vogt
  • Date: 2012-06-25 09:52:58 UTC
  • mfrom: (2989.22.39 software-center)
  • Revision ID: michael.vogt@ubuntu.com-20120625095258-7m2j5d8rsfqe9u0p
merged trunk and resolved conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_database.py
1
 
#!/usr/bin/python
2
 
 
3
1
import apt
4
2
import os
5
3
import re
8
6
import unittest
9
7
import xapian
10
8
 
 
9
from gi.repository import GObject
11
10
from piston_mini_client import PistonResponseObject
12
11
from mock import Mock, patch
13
12
 
14
 
from testutils import setup_test_env
 
13
from tests.utils import (
 
14
    DATA_DIR,
 
15
    get_test_db,
 
16
    get_test_pkg_info,
 
17
    do_events,
 
18
    make_software_center_agent_subscription_dict,
 
19
    make_software_center_agent_app_dict,
 
20
    setup_test_env,
 
21
)
15
22
setup_test_env()
16
23
 
17
24
import softwarecenter.paths
 
25
import softwarecenter.distro
 
26
 
18
27
from softwarecenter.db.application import Application, AppDetails
19
28
from softwarecenter.db.database import StoreDatabase
20
29
from softwarecenter.db.enquire import AppEnquire
21
30
from softwarecenter.db.database import parse_axi_values_file
22
 
from softwarecenter.db.pkginfo import get_pkg_info
 
31
from softwarecenter.db.pkginfo import get_pkg_info, _Version
23
32
from softwarecenter.db.update import (
24
33
    make_doc_from_parser,
25
34
    update_from_app_install_data,
26
35
    update_from_var_lib_apt_lists,
27
36
    update_from_appstream_xml,
 
37
    update_from_json_string,
28
38
    update_from_software_center_agent,
29
39
    SCAPurchasedApplicationParser,
30
40
    SCAApplicationParser,
31
41
    )
32
 
from softwarecenter.distro import get_distro
 
42
from softwarecenter.db.utils import (
 
43
    get_installed_package_list,
 
44
    get_installed_apps_list,
 
45
)
33
46
from softwarecenter.enums import (
34
47
    XapianValues,
35
48
    PkgStates,
36
49
    )
37
 
from softwarecenter.testutils import (
38
 
    get_test_db,
39
 
    get_test_pkg_info,
40
 
    do_events,
41
 
    make_software_center_agent_subscription_dict,
42
 
    make_software_center_agent_app_dict,
43
 
    )
44
 
from softwarecenter.region import REGIONTAG
 
50
from softwarecenter.region import REGION_BLACKLIST_TAG, REGIONTAG
 
51
 
 
52
PKD_DIR = os.path.join(DATA_DIR, 'appdetails', 'var', 'lib', 'dpkg', 'status')
 
53
TEST_DB = os.path.join(DATA_DIR, "test.db")
 
54
 
45
55
 
46
56
class TestDatabase(unittest.TestCase):
47
57
    """ tests the store database """
48
58
 
49
59
    def setUp(self):
50
 
        apt.apt_pkg.config.set("Dir::State::status",
51
 
                               "./data/appdetails/var/lib/dpkg/status")
 
60
        apt.apt_pkg.config.set("Dir::State::status", PKD_DIR)
52
61
        self.cache = get_pkg_info()
53
62
        self.cache.open()
54
63
 
72
81
    def test_update_from_desktop_file(self):
73
82
        # ensure we index with german locales to test i18n
74
83
        os.environ["LANGUAGE"] = "de"
75
 
        db = xapian.WritableDatabase("./data/test.db",
 
84
        db = xapian.WritableDatabase(TEST_DB,
76
85
                                     xapian.DB_CREATE_OR_OVERWRITE)
77
 
        res = update_from_app_install_data(db, self.cache, datadir="./data/desktop")
 
86
        res = update_from_app_install_data(db, self.cache,
 
87
            datadir=os.path.join(DATA_DIR, "desktop"))
78
88
        self.assertTrue(res)
79
89
        self.assertEqual(db.get_doccount(), 5)
80
90
        # test if Name[de] was picked up
84
94
        self.assertEqual(i, 1)
85
95
 
86
96
    def test_update_from_appstream_xml(self):
87
 
        db = xapian.WritableDatabase("./data/test.db",
 
97
        db = xapian.WritableDatabase(TEST_DB,
88
98
                                     xapian.DB_CREATE_OR_OVERWRITE)
89
 
        res = update_from_appstream_xml(db, self.cache, "./data/app-info/")
 
99
        res = update_from_appstream_xml(db, self.cache,
 
100
            os.path.join(DATA_DIR, "app-info"))
90
101
        self.assertTrue(res)
91
102
        self.assertEqual(db.get_doccount(), 1)
92
103
        # FIXME: improve tests
93
104
        for p in db.postlist(""):
94
105
            doc = db.get_document(p.docid)
95
106
            for term in doc.termlist():
96
 
                print term, term.term
 
107
                self.assertIsInstance(term, xapian.TermListItem)
 
108
                self.assertIsInstance(term.term, basestring)
97
109
            for value in doc.values():
98
 
                print value, value.num, value.value
 
110
                self.assertIsInstance(value, xapian.ValueItem)
 
111
                self.assertIsInstance(value.num, long)
 
112
                self.assertIsInstance(value.value, basestring)
99
113
 
100
114
    def test_update_from_var_lib_apt_lists(self):
101
115
        # ensure we index with german locales to test i18n
102
116
        os.environ["LANGUAGE"] = "de"
103
 
        db = xapian.WritableDatabase("./data/test.db",
 
117
        db = xapian.WritableDatabase(TEST_DB,
104
118
                                     xapian.DB_CREATE_OR_OVERWRITE)
105
 
        res = update_from_var_lib_apt_lists(db, self.cache, listsdir="./data/app-info/")
 
119
        res = update_from_var_lib_apt_lists(db, self.cache,
 
120
            listsdir=os.path.join(DATA_DIR, "app-info"))
106
121
        self.assertTrue(res)
107
122
        self.assertEqual(db.get_doccount(), 1)
108
123
        # test if Name-de was picked up
123
138
        self.assertTrue(found_gettext_translation)
124
139
 
125
140
    def test_update_from_json_string(self):
126
 
        from softwarecenter.db.update import update_from_json_string
127
 
        db = xapian.WritableDatabase("./data/test.db",
 
141
        db = xapian.WritableDatabase(TEST_DB,
128
142
                                     xapian.DB_CREATE_OR_OVERWRITE)
129
143
        cache = apt.Cache()
130
 
        p = os.path.abspath("./data/app-info-json/apps.json")
 
144
        p = os.path.join(DATA_DIR, "app-info-json", "apps.json")
131
145
        res = update_from_json_string(db, cache, open(p).read(), origin=p)
132
146
        self.assertTrue(res)
133
147
        self.assertEqual(db.get_doccount(), 1)
134
148
 
135
149
    def test_build_from_software_center_agent(self):
136
 
        db = xapian.WritableDatabase("./data/test.db",
 
150
        db = xapian.WritableDatabase(TEST_DB,
137
151
                                     xapian.DB_CREATE_OR_OVERWRITE)
138
152
        cache = apt.Cache()
139
153
        # monkey patch distro to ensure we get data
140
 
        import softwarecenter.distro
141
154
        distro = softwarecenter.distro.get_distro()
142
155
        distro.get_codename = lambda: "natty"
143
156
        # we test against the real https://software-center.ubuntu.com here
166
179
        # staging does not have a valid cert
167
180
        os.environ["PISTON_MINI_CLIENT_DISABLE_SSL_VALIDATION"] = "1"
168
181
        cache = get_test_pkg_info()
169
 
        db = xapian.WritableDatabase("./data/test.db",
 
182
        db = xapian.WritableDatabase(TEST_DB,
170
183
                                     xapian.DB_CREATE_OR_OVERWRITE)
171
184
        res = update_from_software_center_agent(db, cache, ignore_cache=True)
172
185
        self.assertTrue(res)
184
197
        self.assertRaises(ValueError, AppDetails, db)
185
198
 
186
199
    def test_application_details(self):
187
 
        db = xapian.WritableDatabase("./data/test.db",
 
200
        db = xapian.WritableDatabase(TEST_DB,
188
201
                                     xapian.DB_CREATE_OR_OVERWRITE)
189
 
        res = update_from_app_install_data(db, self.cache, datadir="./data/desktop")
 
202
        res = update_from_app_install_data(db, self.cache,
 
203
            datadir=os.path.join(DATA_DIR, "desktop"))
190
204
        self.assertTrue(res)
191
 
        db = StoreDatabase("./data/test.db", self.cache)
 
205
        db = StoreDatabase(TEST_DB, self.cache)
192
206
        db.open(use_axi=False, use_agent=False)
193
207
        self.assertEqual(len(db), 5)
194
208
        # test details
243
257
        self.assertEqual(app.pkgname, 'linux-headers-'+os.uname()[2])
244
258
        # $distro
245
259
        details = app.get_details(db)
246
 
        distro = get_distro().get_codename()
 
260
        distro = softwarecenter.distro.get_distro().get_codename()
247
261
        self.assertEqual(app.request, 'channel=' + distro + '-partner')
248
 
    
 
262
 
249
263
    def ensure_installation_date_and_lazy_history_loading(self, appdetails):
250
264
        # we run two tests, the first is to ensure that we get a
251
265
        # result from installation_data immediately (at this point the
253
267
        self.assertEqual(appdetails.installation_date, None)
254
268
        # then we need to wait until the history is loaded in the idle
255
269
        # handler
256
 
        from gi.repository import GObject
257
270
        context = GObject.main_context_default()
258
271
        while context.pending():
259
272
            context.iteration()
262
275
        self.assertNotEqual(appdetails.installation_date, None)
263
276
 
264
277
    def test_package_states(self):
265
 
        db = xapian.WritableDatabase("./data/test.db",
 
278
        db = xapian.WritableDatabase(TEST_DB,
266
279
                                     xapian.DB_CREATE_OR_OVERWRITE)
267
 
        res = update_from_app_install_data(db, self.cache, datadir="./data/desktop")
 
280
        res = update_from_app_install_data(db, self.cache,
 
281
            datadir=os.path.join(DATA_DIR, "desktop"))
268
282
        self.assertTrue(res)
269
 
        db = StoreDatabase("./data/test.db", self.cache)
 
283
        db = StoreDatabase(TEST_DB, self.cache)
270
284
        db.open(use_axi=False)
271
285
        # test PkgStates.INSTALLED
272
286
        # FIXME: this will only work if software-center is installed
323
337
            last_time = doc.get_value(value_time)
324
338
 
325
339
    def test_for_purchase_apps_date_published(self):
326
 
        from softwarecenter.testutils import get_test_pkg_info
327
340
        #os.environ["SOFTWARE_CENTER_DEBUG_HTTP"] = "1"
328
341
        #os.environ["SOFTWARE_CENTER_AGENT_HOST"] = "http://sc.staging.ubuntu.com/"
329
342
        # staging does not have a valid cert
330
343
        os.environ["PISTON_MINI_CLIENT_DISABLE_SSL_VALIDATION"] = "1"
331
344
        cache = get_test_pkg_info()
332
 
        db = xapian.WritableDatabase("./data/test.db",
 
345
        db = xapian.WritableDatabase(TEST_DB,
333
346
                                     xapian.DB_CREATE_OR_OVERWRITE)
334
347
        res = update_from_software_center_agent(db, cache, ignore_cache=True)
335
348
        self.assertTrue(res)
366
379
 
367
380
    @patch("softwarecenter.db.application.get_region_cached")
368
381
    def test_region_requirements_satisfied(self, mock_region_discover):
369
 
        mock_region_discover.return_value = { 
 
382
        mock_region_discover.return_value = {
370
383
            'country' : 'Germany',
371
384
            'countrycode' : 'DE',
372
385
            }
414
427
        #db = StoreDatabase("/var/cache/software-center/xapian", self.cache)
415
428
        axi_values = parse_axi_values_file(fname)
416
429
        self.assertNotEqual(axi_values, {})
417
 
        print axi_values
 
430
        #print axi_values
418
431
 
419
432
    def test_appdetails(self):
420
 
        from softwarecenter.testutils import get_test_db
421
433
        db = get_test_db()
422
434
        # see "apt-cache show casper|grep ^Tag"
423
435
        details = AppDetails(db, application=Application("", "casper"))
443
455
class UtilsTestCase(unittest.TestCase):
444
456
 
445
457
    def test_utils_get_installed_package_list(self):
446
 
        from softwarecenter.db.utils import get_installed_package_list
447
458
        installed_pkgs = get_installed_package_list()
448
459
        self.assertTrue(len(installed_pkgs) > 0)
449
460
 
450
461
    def test_utils_get_installed_apps_list(self):
451
 
        from softwarecenter.db.utils import (
452
 
            get_installed_package_list,get_installed_apps_list)
453
462
        db = get_test_db()
454
463
        # installed pkgs
455
464
        installed_pkgs = get_installed_package_list()
469
478
    else:
470
479
        # If no supportod_series kwarg was provided, we ensure the
471
480
        # current series/arch is supported.
472
 
        distro = get_distro()
 
481
        distro = softwarecenter.distro.get_distro()
473
482
        subscription['application']['series'] = {
474
483
            distro.get_codename(): [distro.get_architecture()]
475
484
            }
486
495
 
487
496
 
488
497
class AppDetailsSCAApplicationParser(unittest.TestCase):
489
 
    
 
498
 
490
499
    def setUp(self):
491
500
        self.db = get_test_db()
492
501
 
508
517
        app_details = self._get_app_details_from_app_dict(app_dict)
509
518
        # ensure that archive.canonical.com archive roots are detected
510
519
        # as the partner channel
511
 
        dist = get_distro().get_codename()
 
520
        dist = softwarecenter.distro.get_distro().get_codename()
512
521
        self.assertEqual(app_details.channelname, "%s-partner" % dist)
513
 
    
 
522
 
514
523
    @patch('os.path.exists')
515
524
    def test_channel_detection_extras(self, mock):
516
525
        # we need to patch os.path.exists as "AppDetails.channelname" will
540
549
 
541
550
    @patch("softwarecenter.db.update.get_region_cached")
542
551
    def test_region_blacklist(self, get_region_cached_mock):
543
 
        from softwarecenter.region import REGION_BLACKLIST_TAG
544
552
        get_region_cached_mock.return_value = { "countrycode" : "es",
545
553
                                              }
546
554
        app_dict = make_software_center_agent_app_dict()
547
 
        app_dict["debtags"] = ["%s%s" % (REGION_BLACKLIST_TAG, "es"),
548
 
                              ]
 
555
        app_dict["debtags"] = ["%s%s" % (REGION_BLACKLIST_TAG, "es")]
549
556
        # see _get_app_details_from_app_dict
550
557
        item = PistonResponseObject.from_dict(app_dict)
551
558
        parser = SCAApplicationParser(item)
552
559
        doc = make_doc_from_parser(parser, self.db._aptcache)
553
560
        self.assertEqual(doc, None)
554
 
        
 
561
 
555
562
 
556
563
class AppDetailsPkgStateTestCase(unittest.TestCase):
557
564
 
559
566
    def setUpClass(cls):
560
567
        # Set these as class attributes as we don't modify either
561
568
        # during the tests.
562
 
        cls.distro = get_distro()
 
569
        cls.distro = softwarecenter.distro.get_distro()
563
570
        cls.db = get_test_db()
564
571
 
565
572
    def test_package_state_purchased_enable_repo(self):
619
626
            PkgStates.PURCHASED_BUT_REPO_MUST_BE_ENABLED,
620
627
            state)
621
628
 
 
629
 
622
630
class MultipleVersionsSupportTestCase(unittest.TestCase):
623
631
 
624
632
    def _make_version(self, not_automatic):
625
 
        from softwarecenter.db.pkginfo import _Version
626
633
        ver = Mock(_Version)
627
634
        ver.description ="not_automatic: %s" % not_automatic
628
635
        ver.summary ="summary not_automatic: %s" % not_automatic
640
647
        db = get_test_db()
641
648
        app = Application("", "software-center")
642
649
        details = app.get_details(db)
643
 
        versions = [ 
 
650
        versions = [
644
651
            self._make_version(not_automatic=True),
645
652
            self._make_version(not_automatic=False) ]
646
653
        details._pkg.versions = versions
647
654
        details._pkg.candidate = versions[1]
648
655
        self.assertEqual(
649
 
            details.get_not_automatic_archive_versions(), 
 
656
            details.get_not_automatic_archive_versions(),
650
657
            [  (versions[1].version, "precise"),
651
658
               (versions[0].version, "precise-backports") ])
652
659
 
691
698
        details.force_not_automatic_archive_suite("")
692
699
        self.assertEqual(app.archive_suite, "")
693
700
 
 
701
 
694
702
class TrackDBTestCase(unittest.TestCase):
695
 
    
 
703
 
696
704
    def test_track_db_open(self):
697
705
        tmpdir = tempfile.mkdtemp()
698
706
        tmpstamp = os.path.join(tmpdir, "update-stamp")
718
726
                break
719
727
        self.assertTrue(db._on_axi_stamp_changed.called)
720
728
 
 
729
 
721
730
if __name__ == "__main__":
722
 
    #import logging
723
 
    #logging.basicConfig(level=logging.DEBUG)
724
731
    unittest.main()