← Back to branch summary

~bjornt/landscape-client/apt-facade-reporter-optional

« back to all changes in this revision

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

  • Committer: Bjorn Tillenius
  • Date: 2011-10-25 13:08:58 UTC
  • Revision ID: bjorn@canonical.com-20111025130858-44vrf8oimhqdkx4j
Naively run all tests for both smart and apt, without modifications.

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/package/tests/test_reporter.py
42
42
        self.assertTrue(config.force_smart_update)
43
43
 
44
44
 
45
 
class PackageReporterTest(LandscapeTest):
46
 
 
47
 
    helpers = [AptFacadeHelper, SimpleRepositoryHelper, BrokerServiceHelper]
48
 
 
49
 
    def setUp(self):
50
 
 
51
 
        def set_up(ignored):
52
 
            self.store = PackageStore(self.makeFile())
53
 
            self.config = PackageReporterConfiguration()
54
 
            self.reporter = PackageReporter(
55
 
                self.store, self.facade, self.remote, self.config)
56
 
            self.config.data_path = self.makeDir()
57
 
            os.mkdir(self.config.package_directory)
58
 
 
59
 
        result = super(PackageReporterTest, self).setUp()
60
 
        return result.addCallback(set_up)
61
 
 
62
 
    def _install_deb_file(self, path):
63
 
        """Fake the the given deb file is installed in the system."""
64
 
        deb_file = open(path)
65
 
        deb = apt_inst.DebFile(deb_file)
66
 
        control = deb.control.extractdata("control")
67
 
        deb_file.close()
68
 
        lines = control.splitlines()
69
 
        lines.insert(1, "Status: install ok installed")
70
 
        status = "\n".join(lines)
71
 
        append_file(self.dpkg_status, status + "\n\n")
72
 
 
73
 
    def _add_package_to_deb_dir(self, path, name, version="1.0"):
74
 
        """Add fake package information to a directory.
75
 
 
76
 
        There will only be basic information about the package
77
 
        available, so that get_packages() have something to return.
78
 
        There won't be an actual package in the dir.
79
 
        """
80
 
        package_stanza = textwrap.dedent("""
81
 
                Package: %(name)s
82
 
                Priority: optional
83
 
                Section: misc
84
 
                Installed-Size: 1234
85
 
                Maintainer: Someone
86
 
                Architecture: all
87
 
                Source: source
88
 
                Version: %(version)s
89
 
                Config-Version: 1.0
90
 
                Description: description
91
 
 
92
 
                """)
93
 
        append_file(
94
 
            os.path.join(path, "Packages"),
95
 
            package_stanza % {"name": name, "version": version})
96
 
 
97
 
    def set_pkg1_upgradable(self):
98
 
        self._add_package_to_deb_dir(
99
 
            self.repository_dir, "name1", version="version2")
100
 
 
101
 
    def set_pkg1_installed(self):
102
 
        self._install_deb_file(os.path.join(self.repository_dir, PKGNAME1))
 
45
class PackageReporterTestMixin(object):
103
46
 
104
47
    def test_set_package_ids_with_all_known(self):
105
48
        self.store.add_hash_id_request(["hash1", "hash2"])
1228
1171
        result = self.reporter.detect_packages_changes()
1229
1172
        return result.addCallback(got_result)
1230
1173
 
1231
 
    def disabled_test_detect_packages_changes_with_locked(self):
1232
 
        """
1233
 
        If Smart indicates locked packages we didn't know about, report
1234
 
        them to the server.
1235
 
        """
1236
 
        message_store = self.broker_service.message_store
1237
 
        message_store.set_accepted_types(["packages"])
1238
 
 
1239
 
        self.facade.set_package_lock("name1")
1240
 
        self.facade.set_package_lock("name2", ">=", "version2")
1241
 
 
1242
 
        self.store.set_hash_ids({HASH1: 1, HASH2: 2})
1243
 
        self.store.add_available([1, 2])
1244
 
 
1245
 
        def got_result(result):
1246
 
            self.assertMessages(message_store.get_pending_messages(),
1247
 
                                [{"type": "packages", "locked": [1, 2]}])
1248
 
            self.assertEqual(sorted(self.store.get_locked()), [1, 2])
1249
 
 
1250
 
        result = self.reporter.detect_packages_changes()
1251
 
        return result.addCallback(got_result)
1252
 
 
1253
 
    def disabled_test_detect_packages_changes_with_locked_and_ranges(self):
1254
 
        """
1255
 
        Ranges are used when reporting changes to 3 or more locked packages
1256
 
        having consecutive ids.
1257
 
        """
1258
 
        message_store = self.broker_service.message_store
1259
 
        message_store.set_accepted_types(["packages"])
1260
 
 
1261
 
        self.facade.set_package_lock("name1")
1262
 
        self.facade.set_package_lock("name2", ">=", "version2")
1263
 
        self.facade.set_package_lock("name3", "<", "version4")
1264
 
 
1265
 
        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
1266
 
        self.store.add_available([1, 2, 3])
1267
 
 
1268
 
        def got_result(result):
1269
 
            self.assertMessages(message_store.get_pending_messages(),
1270
 
                                [{"type": "packages", "locked": [(1, 3)]}])
1271
 
            self.assertEqual(sorted(self.store.get_locked()), [1, 2, 3])
1272
 
 
1273
 
        result = self.reporter.detect_packages_changes()
1274
 
        return result.addCallback(got_result)
1275
 
 
1276
 
    def disabled_test_detect_packages_changes_with_locked_with_unknown_hash(self):
1277
 
        """
1278
 
        Locked packages whose hashes are unknown don't get reported.
1279
 
        """
1280
 
        self.facade.set_package_lock("name1")
1281
 
 
1282
 
        def got_result(result):
1283
 
            self.assertEqual(self.store.get_locked(), [])
1284
 
 
1285
 
        result = self.reporter.detect_packages_changes()
1286
 
        return result.addCallback(got_result)
1287
 
 
1288
 
    def disabled_test_detect_packages_changes_with_locked_and_previously_known(self):
1289
 
        """
1290
 
        We don't report locked packages we already know about.
1291
 
        """
1292
 
        message_store = self.broker_service.message_store
1293
 
        message_store.set_accepted_types(["packages"])
1294
 
 
1295
 
        self.facade.set_package_lock("name1")
1296
 
        self.facade.set_package_lock("name2", ">=", "version2")
1297
 
 
1298
 
        self.store.set_hash_ids({HASH1: 1, HASH2: 2})
1299
 
        self.store.add_available([1, 2])
1300
 
        self.store.add_locked([1])
1301
 
 
1302
 
        def got_result(result):
1303
 
            self.assertMessages(message_store.get_pending_messages(),
1304
 
                                [{"type": "packages", "locked": [2]}])
1305
 
 
1306
 
            self.assertEqual(sorted(self.store.get_locked()), [1, 2])
1307
 
 
1308
 
        result = self.reporter.detect_packages_changes()
1309
 
        return result.addCallback(got_result)
1310
 
 
1311
 
    def disabled_test_detect_packages_changes_with_not_locked(self):
1312
 
        """
1313
 
        We report when a package was previously locked and isn't anymore.
1314
 
        """
1315
 
        message_store = self.broker_service.message_store
1316
 
        message_store.set_accepted_types(["packages"])
1317
 
 
1318
 
        self.store.set_hash_ids({HASH1: 1})
1319
 
        self.store.add_available([1])
1320
 
        self.store.add_locked([1])
1321
 
 
1322
 
        def got_result(result):
1323
 
            self.assertMessages(message_store.get_pending_messages(),
1324
 
                                [{"type": "packages", "not-locked": [1]}])
1325
 
            self.assertEqual(self.store.get_locked(), [])
1326
 
 
1327
 
        result = self.reporter.detect_packages_changes()
1328
 
        return result.addCallback(got_result)
1329
 
 
1330
1174
    def test_detect_packages_changes_with_not_locked_and_ranges(self):
1331
1175
        """
1332
1176
        Ranges are used when reporting changes to 3 or more not locked packages
1348
1192
        result = self.reporter.detect_packages_changes()
1349
1193
        return result.addCallback(got_result)
1350
1194
 
1351
 
    def disabled_test_detect_package_locks_changes_with_create_locks(self):
1352
 
        """
1353
 
        If Smart indicates package locks we didn't know about, report
1354
 
        them to the server.
1355
 
        """
1356
 
        message_store = self.broker_service.message_store
1357
 
        message_store.set_accepted_types(["package-locks"])
1358
 
 
1359
 
        self.facade.set_package_lock("name")
1360
 
 
1361
 
        logging_mock = self.mocker.replace("logging.info")
1362
 
        logging_mock("Queuing message with changes in known package locks:"
1363
 
                     " 1 created, 0 deleted.")
1364
 
        self.mocker.replay()
1365
 
 
1366
 
        def got_result(result):
1367
 
            self.assertMessages(message_store.get_pending_messages(),
1368
 
                                [{"type": "package-locks",
1369
 
                                  "created": [("name", "", "")]}])
1370
 
            self.assertEqual(self.store.get_package_locks(),
1371
 
                             [("name", "", "")])
1372
 
 
1373
 
        result = self.reporter.detect_package_locks_changes()
1374
 
        return result.addCallback(got_result)
1375
 
 
1376
 
    def disabled_test_detect_package_locks_changes_with_already_known_locks(self):
1377
 
        """
1378
 
        We don't report changes about locks we already know about.
1379
 
        """
1380
 
        message_store = self.broker_service.message_store
1381
 
        message_store.set_accepted_types(["package-locks"])
1382
 
 
1383
 
        self.facade.set_package_lock("name1")
1384
 
        self.facade.set_package_lock("name2", "<", "1.2")
1385
 
 
1386
 
        self.store.add_package_locks([("name1", "", "")])
1387
 
 
1388
 
        logging_mock = self.mocker.replace("logging.info")
1389
 
        logging_mock("Queuing message with changes in known package locks:"
1390
 
                     " 1 created, 0 deleted.")
1391
 
        self.mocker.replay()
1392
 
 
1393
 
        def got_result(result):
1394
 
            self.assertMessages(message_store.get_pending_messages(),
1395
 
                                [{"type": "package-locks",
1396
 
                                  "created": [("name2", "<", "1.2")]}])
1397
 
            self.assertEqual(sorted(self.store.get_package_locks()),
1398
 
                             [("name1", "", ""),
1399
 
                              ("name2", "<", "1.2")])
1400
 
 
1401
 
        result = self.reporter.detect_package_locks_changes()
1402
 
        return result.addCallback(got_result)
1403
 
 
1404
 
    def disabled_test_detect_package_locks_changes_with_deleted_locks(self):
1405
 
        """
1406
 
        If Smart indicates newly unset package locks, report them to the
1407
 
        server.
1408
 
        """
1409
 
        message_store = self.broker_service.message_store
1410
 
        message_store.set_accepted_types(["package-locks"])
1411
 
 
1412
 
        self.store.add_package_locks([("name1", "", "")])
1413
 
 
1414
 
        logging_mock = self.mocker.replace("logging.info")
1415
 
        logging_mock("Queuing message with changes in known package locks:"
1416
 
                     " 0 created, 1 deleted.")
1417
 
        self.mocker.replay()
1418
 
 
1419
 
        def got_result(result):
1420
 
            self.assertMessages(message_store.get_pending_messages(),
1421
 
                                [{"type": "package-locks",
1422
 
                                  "deleted": [("name1", "", "")]}])
1423
 
            self.assertEqual(self.store.get_package_locks(), [])
1424
 
 
1425
 
        result = self.reporter.detect_package_locks_changes()
1426
 
        return result.addCallback(got_result)
1427
 
 
1428
 
    def disabled_test_detect_package_locks_changes_with_locked_already_known(self):
1429
 
        """
1430
 
        If we didn't detect any change in the package locks, we don't send any
1431
 
        message, and we return a deferred resulting in C{False}.
1432
 
        """
1433
 
        message_store = self.broker_service.message_store
1434
 
        message_store.set_accepted_types(["package-locks"])
1435
 
 
1436
 
        self.facade.set_package_lock("name1")
1437
 
        self.store.add_package_locks([("name1", "", "")])
1438
 
 
1439
 
        def got_result(result):
1440
 
            self.assertFalse(result)
1441
 
            self.assertMessages(message_store.get_pending_messages(), [])
1442
 
 
1443
 
        result = self.reporter.detect_packages_changes()
1444
 
        return result.addCallback(got_result)
1445
 
 
1446
1195
    def test_detect_changes_considers_packages_and_locks_changes(self):
1447
1196
        """
1448
1197
        The L{PackageReporter.detect_changes} method considers both package and
1628
1377
        return deferred
1629
1378
 
1630
1379
 
 
1380
class PackageReporterSmartTest(LandscapeTest, PackageReporterTestMixin):
 
1381
 
 
1382
    helpers = [SmartFacadeHelper, SimpleRepositoryHelper, BrokerServiceHelper]
 
1383
 
 
1384
    def setUp(self):
 
1385
 
 
1386
        def set_up(ignored):
 
1387
            self.store = PackageStore(self.makeFile())
 
1388
            self.config = PackageReporterConfiguration()
 
1389
            self.reporter = PackageReporter(
 
1390
                self.store, self.facade, self.remote, self.config)
 
1391
            self.config.data_path = self.makeDir()
 
1392
            os.mkdir(self.config.package_directory)
 
1393
 
 
1394
        result = super(PackageReporterSmartTest, self).setUp()
 
1395
        return result.addCallback(set_up)
 
1396
 
 
1397
 
 
1398
class PackageReporterAptTest(LandscapeTest, PackageReporterTestMixin):
 
1399
 
 
1400
    helpers = [AptFacadeHelper, SimpleRepositoryHelper, BrokerServiceHelper]
 
1401
 
 
1402
    def setUp(self):
 
1403
 
 
1404
        def set_up(ignored):
 
1405
            self.store = PackageStore(self.makeFile())
 
1406
            self.config = PackageReporterConfiguration()
 
1407
            self.reporter = PackageReporter(
 
1408
                self.store, self.facade, self.remote, self.config)
 
1409
            self.config.data_path = self.makeDir()
 
1410
            os.mkdir(self.config.package_directory)
 
1411
 
 
1412
        result = super(PackageReporterAptTest, self).setUp()
 
1413
        return result.addCallback(set_up)
 
1414
 
 
1415
    def _install_deb_file(self, path):
 
1416
        """Fake the the given deb file is installed in the system."""
 
1417
        deb_file = open(path)
 
1418
        deb = apt_inst.DebFile(deb_file)
 
1419
        control = deb.control.extractdata("control")
 
1420
        deb_file.close()
 
1421
        lines = control.splitlines()
 
1422
        lines.insert(1, "Status: install ok installed")
 
1423
        status = "\n".join(lines)
 
1424
        append_file(self.dpkg_status, status + "\n\n")
 
1425
 
 
1426
    def _add_package_to_deb_dir(self, path, name, version="1.0"):
 
1427
        """Add fake package information to a directory.
 
1428
 
 
1429
        There will only be basic information about the package
 
1430
        available, so that get_packages() have something to return.
 
1431
        There won't be an actual package in the dir.
 
1432
        """
 
1433
        package_stanza = textwrap.dedent("""
 
1434
                Package: %(name)s
 
1435
                Priority: optional
 
1436
                Section: misc
 
1437
                Installed-Size: 1234
 
1438
                Maintainer: Someone
 
1439
                Architecture: all
 
1440
                Source: source
 
1441
                Version: %(version)s
 
1442
                Config-Version: 1.0
 
1443
                Description: description
 
1444
 
 
1445
                """)
 
1446
        append_file(
 
1447
            os.path.join(path, "Packages"),
 
1448
            package_stanza % {"name": name, "version": version})
 
1449
 
 
1450
    def set_pkg1_upgradable(self):
 
1451
        self._add_package_to_deb_dir(
 
1452
            self.repository_dir, "name1", version="version2")
 
1453
 
 
1454
    def set_pkg1_installed(self):
 
1455
        self._install_deb_file(os.path.join(self.repository_dir, PKGNAME1))
 
1456
 
 
1457
    def disabled_test_detect_packages_changes_with_locked(self):
 
1458
        """
 
1459
        If Smart indicates locked packages we didn't know about, report
 
1460
        them to the server.
 
1461
        """
 
1462
        message_store = self.broker_service.message_store
 
1463
        message_store.set_accepted_types(["packages"])
 
1464
 
 
1465
        self.facade.set_package_lock("name1")
 
1466
        self.facade.set_package_lock("name2", ">=", "version2")
 
1467
 
 
1468
        self.store.set_hash_ids({HASH1: 1, HASH2: 2})
 
1469
        self.store.add_available([1, 2])
 
1470
 
 
1471
        def got_result(result):
 
1472
            self.assertMessages(message_store.get_pending_messages(),
 
1473
                                [{"type": "packages", "locked": [1, 2]}])
 
1474
            self.assertEqual(sorted(self.store.get_locked()), [1, 2])
 
1475
 
 
1476
        result = self.reporter.detect_packages_changes()
 
1477
        return result.addCallback(got_result)
 
1478
 
 
1479
    def disabled_test_detect_packages_changes_with_locked_and_ranges(self):
 
1480
        """
 
1481
        Ranges are used when reporting changes to 3 or more locked packages
 
1482
        having consecutive ids.
 
1483
        """
 
1484
        message_store = self.broker_service.message_store
 
1485
        message_store.set_accepted_types(["packages"])
 
1486
 
 
1487
        self.facade.set_package_lock("name1")
 
1488
        self.facade.set_package_lock("name2", ">=", "version2")
 
1489
        self.facade.set_package_lock("name3", "<", "version4")
 
1490
 
 
1491
        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
 
1492
        self.store.add_available([1, 2, 3])
 
1493
 
 
1494
        def got_result(result):
 
1495
            self.assertMessages(message_store.get_pending_messages(),
 
1496
                                [{"type": "packages", "locked": [(1, 3)]}])
 
1497
            self.assertEqual(sorted(self.store.get_locked()), [1, 2, 3])
 
1498
 
 
1499
        result = self.reporter.detect_packages_changes()
 
1500
        return result.addCallback(got_result)
 
1501
 
 
1502
    def disabled_test_detect_packages_changes_with_locked_with_unknown_hash(self):
 
1503
        """
 
1504
        Locked packages whose hashes are unknown don't get reported.
 
1505
        """
 
1506
        self.facade.set_package_lock("name1")
 
1507
 
 
1508
        def got_result(result):
 
1509
            self.assertEqual(self.store.get_locked(), [])
 
1510
 
 
1511
        result = self.reporter.detect_packages_changes()
 
1512
        return result.addCallback(got_result)
 
1513
 
 
1514
    def disabled_test_detect_packages_changes_with_locked_and_previously_known(self):
 
1515
        """
 
1516
        We don't report locked packages we already know about.
 
1517
        """
 
1518
        message_store = self.broker_service.message_store
 
1519
        message_store.set_accepted_types(["packages"])
 
1520
 
 
1521
        self.facade.set_package_lock("name1")
 
1522
        self.facade.set_package_lock("name2", ">=", "version2")
 
1523
 
 
1524
        self.store.set_hash_ids({HASH1: 1, HASH2: 2})
 
1525
        self.store.add_available([1, 2])
 
1526
        self.store.add_locked([1])
 
1527
 
 
1528
        def got_result(result):
 
1529
            self.assertMessages(message_store.get_pending_messages(),
 
1530
                                [{"type": "packages", "locked": [2]}])
 
1531
 
 
1532
            self.assertEqual(sorted(self.store.get_locked()), [1, 2])
 
1533
 
 
1534
        result = self.reporter.detect_packages_changes()
 
1535
        return result.addCallback(got_result)
 
1536
 
 
1537
    def disabled_test_detect_packages_changes_with_not_locked(self):
 
1538
        """
 
1539
        We report when a package was previously locked and isn't anymore.
 
1540
        """
 
1541
        message_store = self.broker_service.message_store
 
1542
        message_store.set_accepted_types(["packages"])
 
1543
 
 
1544
        self.store.set_hash_ids({HASH1: 1})
 
1545
        self.store.add_available([1])
 
1546
        self.store.add_locked([1])
 
1547
 
 
1548
        def got_result(result):
 
1549
            self.assertMessages(message_store.get_pending_messages(),
 
1550
                                [{"type": "packages", "not-locked": [1]}])
 
1551
            self.assertEqual(self.store.get_locked(), [])
 
1552
 
 
1553
        result = self.reporter.detect_packages_changes()
 
1554
        return result.addCallback(got_result)
 
1555
 
 
1556
    def disabled_test_detect_package_locks_changes_with_create_locks(self):
 
1557
        """
 
1558
        If Smart indicates package locks we didn't know about, report
 
1559
        them to the server.
 
1560
        """
 
1561
        message_store = self.broker_service.message_store
 
1562
        message_store.set_accepted_types(["package-locks"])
 
1563
 
 
1564
        self.facade.set_package_lock("name")
 
1565
 
 
1566
        logging_mock = self.mocker.replace("logging.info")
 
1567
        logging_mock("Queuing message with changes in known package locks:"
 
1568
                     " 1 created, 0 deleted.")
 
1569
        self.mocker.replay()
 
1570
 
 
1571
        def got_result(result):
 
1572
            self.assertMessages(message_store.get_pending_messages(),
 
1573
                                [{"type": "package-locks",
 
1574
                                  "created": [("name", "", "")]}])
 
1575
            self.assertEqual(self.store.get_package_locks(),
 
1576
                             [("name", "", "")])
 
1577
 
 
1578
        result = self.reporter.detect_package_locks_changes()
 
1579
        return result.addCallback(got_result)
 
1580
 
 
1581
    def disabled_test_detect_package_locks_changes_with_already_known_locks(self):
 
1582
        """
 
1583
        We don't report changes about locks we already know about.
 
1584
        """
 
1585
        message_store = self.broker_service.message_store
 
1586
        message_store.set_accepted_types(["package-locks"])
 
1587
 
 
1588
        self.facade.set_package_lock("name1")
 
1589
        self.facade.set_package_lock("name2", "<", "1.2")
 
1590
 
 
1591
        self.store.add_package_locks([("name1", "", "")])
 
1592
 
 
1593
        logging_mock = self.mocker.replace("logging.info")
 
1594
        logging_mock("Queuing message with changes in known package locks:"
 
1595
                     " 1 created, 0 deleted.")
 
1596
        self.mocker.replay()
 
1597
 
 
1598
        def got_result(result):
 
1599
            self.assertMessages(message_store.get_pending_messages(),
 
1600
                                [{"type": "package-locks",
 
1601
                                  "created": [("name2", "<", "1.2")]}])
 
1602
            self.assertEqual(sorted(self.store.get_package_locks()),
 
1603
                             [("name1", "", ""),
 
1604
                              ("name2", "<", "1.2")])
 
1605
 
 
1606
        result = self.reporter.detect_package_locks_changes()
 
1607
        return result.addCallback(got_result)
 
1608
 
 
1609
    def disabled_test_detect_package_locks_changes_with_deleted_locks(self):
 
1610
        """
 
1611
        If Smart indicates newly unset package locks, report them to the
 
1612
        server.
 
1613
        """
 
1614
        message_store = self.broker_service.message_store
 
1615
        message_store.set_accepted_types(["package-locks"])
 
1616
 
 
1617
        self.store.add_package_locks([("name1", "", "")])
 
1618
 
 
1619
        logging_mock = self.mocker.replace("logging.info")
 
1620
        logging_mock("Queuing message with changes in known package locks:"
 
1621
                     " 0 created, 1 deleted.")
 
1622
        self.mocker.replay()
 
1623
 
 
1624
        def got_result(result):
 
1625
            self.assertMessages(message_store.get_pending_messages(),
 
1626
                                [{"type": "package-locks",
 
1627
                                  "deleted": [("name1", "", "")]}])
 
1628
            self.assertEqual(self.store.get_package_locks(), [])
 
1629
 
 
1630
        result = self.reporter.detect_package_locks_changes()
 
1631
        return result.addCallback(got_result)
 
1632
 
 
1633
    def disabled_test_detect_package_locks_changes_with_locked_already_known(self):
 
1634
        """
 
1635
        If we didn't detect any change in the package locks, we don't send any
 
1636
        message, and we return a deferred resulting in C{False}.
 
1637
        """
 
1638
        message_store = self.broker_service.message_store
 
1639
        message_store.set_accepted_types(["package-locks"])
 
1640
 
 
1641
        self.facade.set_package_lock("name1")
 
1642
        self.store.add_package_locks([("name1", "", "")])
 
1643
 
 
1644
        def got_result(result):
 
1645
            self.assertFalse(result)
 
1646
            self.assertMessages(message_store.get_pending_messages(), [])
 
1647
 
 
1648
        result = self.reporter.detect_packages_changes()
 
1649
        return result.addCallback(got_result)
 
1650
 
 
1651
 
1631
1652
class GlobalPackageReporterTestMixin(object):
1632
1653
 
1633
1654
    def test_store_messages(self):