← Back to branch summary

~ubuntu-branches/ubuntu/trusty/landscape-client/trusty-proposed

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Free Ekanayaka
  • Date: 2010-04-07 16:27:45 UTC
  • mfrom: (1.1.14 upstream) (24.1.1 karmic-proposed)
  • Revision ID: james.westby@ubuntu.com-20100407162745-oeyoppvl0qyvii55
Tags: 1.5.0-0ubuntu0.10.04.0
https://launchpad.net/bugs/557244
https://launchpad.net/bugs/542215
https://launchpad.net/bugs/554007
https://launchpad.net/bugs/546531
https://launchpad.net/bugs/351927
https://launchpad.net/bugs/503384
https://launchpad.net/bugs/522688
* New upstream version (LP: #557244)
  - Fix package-changer running before smart-update has completed (LP: #542215)
  - Report the version of Eucalyptus used to generate topology data (LP: #554007)
  - Enable the Eucalyptus plugin by default, if supported (LP: #546531)
  - Use a whitelist of allowed filesystem types to instead of a blacklist (LP: #351927)
  - Report the update-manager logs to the server (LP: #503384)
  - Turn off Curl's DNS caching for requests. (LP: #522688)

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/package/tests/test_reporter.py
5
5
import unittest
6
6
import time
7
7
 
8
 
from twisted.internet.defer import Deferred
 
8
from twisted.internet.defer import Deferred, succeed
9
9
from twisted.internet import reactor
10
10
 
11
11
from landscape.lib.fetch import fetch_async, FetchError
49
49
        self.config = PackageReporterConfiguration()
50
50
        self.reporter = PackageReporter(self.store, self.facade, self.remote,
51
51
                                        self.config)
 
52
        self.config.data_path = self.makeDir()
 
53
        os.mkdir(self.config.package_directory)
52
54
 
53
55
    def set_pkg2_upgrades_pkg1(self):
54
56
        previous = self.Facade.channels_reloaded
136
138
                                     (196610, u"name1 = version1-release1"),
137
139
                                     (262148,
138
140
                                      u"prerequirename1 = prerequireversion1"),
139
 
                                     (262148, u"requirename1 = requireversion1"),
 
141
                                     (262148,
 
142
                                      u"requirename1 = requireversion1"),
140
143
                                     (393224, u"name1 < version1-release1"),
141
144
                                     (458768,
142
145
                                      u"conflictsname1 = conflictsversion1")],
257
260
 
258
261
        # Let's say fetch_async is successful
259
262
        hash_id_db_url = self.config.package_hash_id_url + "uuid_codename_arch"
260
 
        fetch_async_mock = self.mocker.replace("landscape.lib.fetch.fetch_async")
 
263
        fetch_async_mock = self.mocker.replace("landscape.lib."
 
264
                                               "fetch.fetch_async")
261
265
        fetch_async_mock(hash_id_db_url, cainfo=None)
262
266
        fetch_async_result = Deferred()
263
267
        fetch_async_result.callback("hash-ids")
300
304
        self.facade.set_arch("arch")
301
305
 
302
306
        # Intercept any call to fetch_async
303
 
        fetch_async_mock = self.mocker.replace("landscape.lib.fetch.fetch_async")
 
307
        fetch_async_mock = self.mocker.replace("landscape.lib."
 
308
                                               "fetch.fetch_async")
304
309
        fetch_async_mock(ANY)
305
310
 
306
311
        # Go!
399
404
        # Check fetch_async is called with the default url
400
405
        hash_id_db_url = "http://fake.url/path/hash-id-databases/" \
401
406
                         "uuid_codename_arch"
402
 
        fetch_async_mock = self.mocker.replace("landscape.lib.fetch.fetch_async")
 
407
        fetch_async_mock = self.mocker.replace("landscape.lib."
 
408
                                               "fetch.fetch_async")
403
409
        fetch_async_mock(hash_id_db_url, cainfo=None)
404
410
        fetch_async_result = Deferred()
405
411
        fetch_async_result.callback("hash-ids")
430
436
 
431
437
        # Let's say fetch_async fails
432
438
        hash_id_db_url = self.config.package_hash_id_url + "uuid_codename_arch"
433
 
        fetch_async_mock = self.mocker.replace("landscape.lib.fetch.fetch_async")
 
439
        fetch_async_mock = self.mocker.replace("landscape.lib."
 
440
                                               "fetch.fetch_async")
434
441
        fetch_async_mock(hash_id_db_url, cainfo=None)
435
442
        fetch_async_result = Deferred()
436
443
        fetch_async_result.errback(FetchError("fetch error"))
447
454
 
448
455
        # We shouldn't have any hash=>id database
449
456
        def callback(ignored):
450
 
            hash_id_db_filename = os.path.join(self.config.data_path, "package",
451
 
                                               "hash-id", "uuid_codename_arch")
 
457
            hash_id_db_filename = os.path.join(
 
458
                self.config.data_path, "package", "hash-id",
 
459
                "uuid_codename_arch")
452
460
            self.assertEquals(os.path.exists(hash_id_db_filename), False)
453
461
        result.addCallback(callback)
454
462
 
478
486
 
479
487
        # We shouldn't have any hash=>id database
480
488
        def callback(ignored):
481
 
            hash_id_db_filename = os.path.join(self.config.data_path, "package",
482
 
                                               "hash-id", "uuid_codename_arch")
 
489
            hash_id_db_filename = os.path.join(
 
490
                self.config.data_path, "package", "hash-id",
 
491
                "uuid_codename_arch")
483
492
            self.assertEquals(os.path.exists(hash_id_db_filename), False)
484
493
        result.addCallback(callback)
485
494
 
503
512
        # Check fetch_async is called with the default url
504
513
        hash_id_db_url = "http://fake.url/path/hash-id-databases/" \
505
514
                         "uuid_codename_arch"
506
 
        fetch_async_mock = self.mocker.replace("landscape.lib.fetch.fetch_async")
 
515
        fetch_async_mock = self.mocker.replace("landscape.lib."
 
516
                                               "fetch.fetch_async")
507
517
        fetch_async_mock(hash_id_db_url, cainfo=self.config.ssl_public_key)
508
518
        fetch_async_result = Deferred()
509
519
        fetch_async_result.callback("hash-ids")
584
594
        self.assertFalse(self.reporter._apt_sources_have_changed())
585
595
        self.reporter.sources_list_filename = self.makeFile("foo")
586
596
        self.assertTrue(self.reporter._apt_sources_have_changed())
587
 
        os.utime(self.reporter.sources_list_filename, (-1, time.time() - 1799));
 
597
        os.utime(self.reporter.sources_list_filename, (-1, time.time() - 1799))
588
598
        self.assertTrue(self.reporter._apt_sources_have_changed())
589
 
        os.utime(self.reporter.sources_list_filename, (-1, time.time() - 1800));
 
599
        os.utime(self.reporter.sources_list_filename, (-1, time.time() - 1800))
590
600
        self.assertFalse(self.reporter._apt_sources_have_changed())
591
601
 
592
602
    def test_wb_apt_sources_have_changed_with_directory(self):
709
719
        reactor.callWhenRunning(do_test)
710
720
        return deferred
711
721
 
 
722
    def test_run_smart_update_touches_stamp_file(self):
 
723
        """
 
724
        The L{PackageReporter.run_smart_update} method touches a stamp file
 
725
        after running the smart-update wrapper.
 
726
        """
 
727
        self.reporter.sources_list_filename = "/I/Dont/Exist"
 
728
        self.reporter.smart_update_filename = "/bin/true"
 
729
        deferred = Deferred()
 
730
 
 
731
        def do_test():
 
732
 
 
733
            result = self.reporter.run_smart_update()
 
734
 
 
735
            def callback(ignored):
 
736
                self.assertTrue(
 
737
                    os.path.exists(self.config.smart_update_stamp_filename))
 
738
            result.addCallback(callback)
 
739
            result.chainDeferred(deferred)
 
740
 
 
741
        reactor.callWhenRunning(do_test)
 
742
        return deferred
 
743
 
712
744
    def test_remove_expired_hash_id_request(self):
713
745
        request = self.store.add_hash_id_request(["hash1"])
714
746
        request.message_id = 9999
885
917
 
886
918
        return result.addCallback(got_result)
887
919
 
888
 
    def test_detect_changes_with_available(self):
 
920
    def test_detect_packages_changes_with_available(self):
889
921
        message_store = self.broker_service.message_store
890
922
        message_store.set_accepted_types(["packages"])
891
923
 
897
929
 
898
930
            self.assertEquals(sorted(self.store.get_available()), [1, 2, 3])
899
931
 
900
 
        result = self.reporter.detect_changes()
 
932
        result = self.reporter.detect_packages_changes()
901
933
        return result.addCallback(got_result)
902
934
 
903
 
    def test_detect_changes_with_available_and_unknown_hash(self):
 
935
    def test_detect_packages_changes_with_available_and_unknown_hash(self):
904
936
        message_store = self.broker_service.message_store
905
937
        message_store.set_accepted_types(["packages"])
906
938
 
912
944
 
913
945
            self.assertEquals(sorted(self.store.get_available()), [1, 3])
914
946
 
915
 
        result = self.reporter.detect_changes()
 
947
        result = self.reporter.detect_packages_changes()
916
948
        return result.addCallback(got_result)
917
949
 
918
 
    def test_detect_changes_with_available_and_previously_known(self):
 
950
    def test_detect_packages_changes_with_available_and_previously_known(self):
919
951
        message_store = self.broker_service.message_store
920
952
        message_store.set_accepted_types(["packages"])
921
953
 
928
960
 
929
961
            self.assertEquals(sorted(self.store.get_available()), [1, 2, 3])
930
962
 
931
 
        result = self.reporter.detect_changes()
 
963
        result = self.reporter.detect_packages_changes()
932
964
        return result.addCallback(got_result)
933
965
 
934
 
    def test_detect_changes_with_not_available(self):
 
966
    def test_detect_packages_changes_with_not_available(self):
935
967
        message_store = self.broker_service.message_store
936
968
        message_store.set_accepted_types(["packages"])
937
969
 
948
980
 
949
981
            self.assertEquals(self.store.get_available(), [])
950
982
 
951
 
        result = self.reporter.detect_changes()
 
983
        result = self.reporter.detect_packages_changes()
952
984
        return result.addCallback(got_result)
953
985
 
954
 
    def test_detect_changes_with_installed(self):
 
986
    def test_detect_packages_changes_with_installed(self):
955
987
        message_store = self.broker_service.message_store
956
988
        message_store.set_accepted_types(["packages"])
957
989
 
966
998
 
967
999
            self.assertEquals(self.store.get_installed(), [1])
968
1000
 
969
 
        result = self.reporter.detect_changes()
 
1001
        result = self.reporter.detect_packages_changes()
970
1002
        return result.addCallback(got_result)
971
1003
 
972
 
    def test_detect_changes_with_installed_already_known(self):
 
1004
    def test_detect_packages_changes_with_installed_already_known(self):
973
1005
        message_store = self.broker_service.message_store
974
1006
        message_store.set_accepted_types(["packages"])
975
1007
 
980
1012
        self.set_pkg1_installed()
981
1013
 
982
1014
        def got_result(result):
 
1015
            self.assertFalse(result)
983
1016
            self.assertMessages(message_store.get_pending_messages(), [])
984
1017
 
985
 
        result = self.reporter.detect_changes()
 
1018
        result = self.reporter.detect_packages_changes()
986
1019
        return result.addCallback(got_result)
987
1020
 
988
 
    def test_detect_changes_with_not_installed(self):
 
1021
    def test_detect_packages_changes_with_not_installed(self):
989
1022
        message_store = self.broker_service.message_store
990
1023
        message_store.set_accepted_types(["packages"])
991
1024
 
994
1027
        self.store.add_installed([1])
995
1028
 
996
1029
        def got_result(result):
 
1030
            self.assertTrue(result)
997
1031
            self.assertMessages(message_store.get_pending_messages(),
998
1032
                                [{"type": "packages", "not-installed": [1]}])
999
1033
 
1000
1034
            self.assertEquals(self.store.get_installed(), [])
1001
1035
 
1002
 
        result = self.reporter.detect_changes()
 
1036
        result = self.reporter.detect_packages_changes()
1003
1037
        return result.addCallback(got_result)
1004
1038
 
1005
 
    def test_detect_changes_with_upgrade_but_not_installed(self):
 
1039
    def test_detect_packages_changes_with_upgrade_but_not_installed(self):
1006
1040
        message_store = self.broker_service.message_store
1007
1041
        message_store.set_accepted_types(["packages"])
1008
1042
 
1014
1048
        def got_result(result):
1015
1049
            self.assertMessages(message_store.get_pending_messages(), [])
1016
1050
 
1017
 
        result = self.reporter.detect_changes()
 
1051
        result = self.reporter.detect_packages_changes()
1018
1052
        return result.addCallback(got_result)
1019
1053
 
1020
 
    def test_detect_changes_with_upgrade(self):
 
1054
    def test_detect_packages_changes_with_upgrade(self):
1021
1055
        message_store = self.broker_service.message_store
1022
1056
        message_store.set_accepted_types(["packages"])
1023
1057
 
1035
1069
 
1036
1070
            self.assertEquals(self.store.get_available_upgrades(), [2])
1037
1071
 
1038
 
        result = self.reporter.detect_changes()
 
1072
        result = self.reporter.detect_packages_changes()
1039
1073
        return result.addCallback(got_result)
1040
1074
 
1041
 
    def test_detect_changes_with_not_upgrade(self):
 
1075
    def test_detect_packages_changes_with_not_upgrade(self):
1042
1076
        message_store = self.broker_service.message_store
1043
1077
        message_store.set_accepted_types(["packages"])
1044
1078
 
1053
1087
 
1054
1088
            self.assertEquals(self.store.get_available_upgrades(), [])
1055
1089
 
1056
 
        result = self.reporter.detect_changes()
 
1090
        result = self.reporter.detect_packages_changes()
1057
1091
        return result.addCallback(got_result)
1058
1092
 
1059
 
    def test_detect_changes_with_locked(self):
 
1093
    def test_detect_packages_changes_with_locked(self):
1060
1094
        """
1061
1095
        If Smart indicates locked packages we didn't know about, report
1062
1096
        them to the server.
1075
1109
                                [{"type": "packages", "locked": [1, 2]}])
1076
1110
            self.assertEquals(sorted(self.store.get_locked()), [1, 2])
1077
1111
 
1078
 
        result = self.reporter.detect_changes()
 
1112
        result = self.reporter.detect_packages_changes()
1079
1113
        return result.addCallback(got_result)
1080
1114
 
1081
 
    def test_detect_changes_with_locked_and_ranges(self):
 
1115
    def test_detect_packages_changes_with_locked_and_ranges(self):
1082
1116
        """
1083
1117
        Ranges are used when reporting changes to 3 or more locked packages
1084
1118
        having consecutive ids.
1098
1132
                                [{"type": "packages", "locked": [(1, 3)]}])
1099
1133
            self.assertEquals(sorted(self.store.get_locked()), [1, 2, 3])
1100
1134
 
1101
 
        result = self.reporter.detect_changes()
 
1135
        result = self.reporter.detect_packages_changes()
1102
1136
        return result.addCallback(got_result)
1103
1137
 
1104
 
    def test_detect_changes_with_locked_with_unknown_hash(self):
 
1138
    def test_detect_packages_changes_with_locked_with_unknown_hash(self):
1105
1139
        """
1106
1140
        Locked packages whose hashes are unknown don't get reported.
1107
1141
        """
1110
1144
        def got_result(result):
1111
1145
            self.assertEquals(self.store.get_locked(), [])
1112
1146
 
1113
 
        result = self.reporter.detect_changes()
 
1147
        result = self.reporter.detect_packages_changes()
1114
1148
        return result.addCallback(got_result)
1115
1149
 
1116
 
    def test_detect_changes_with_locked_and_previously_known(self):
 
1150
    def test_detect_packages_changes_with_locked_and_previously_known(self):
1117
1151
        """
1118
1152
        We don't report locked packages we already know about.
1119
1153
        """
1133
1167
 
1134
1168
            self.assertEquals(sorted(self.store.get_locked()), [1, 2])
1135
1169
 
1136
 
        result = self.reporter.detect_changes()
 
1170
        result = self.reporter.detect_packages_changes()
1137
1171
        return result.addCallback(got_result)
1138
1172
 
1139
 
    def test_detect_changes_with_not_locked(self):
 
1173
    def test_detect_packages_changes_with_not_locked(self):
1140
1174
        """
1141
1175
        We report when a package was previously locked and isn't anymore.
1142
1176
        """
1152
1186
                                [{"type": "packages", "not-locked": [1]}])
1153
1187
            self.assertEquals(self.store.get_locked(), [])
1154
1188
 
1155
 
        result = self.reporter.detect_changes()
 
1189
        result = self.reporter.detect_packages_changes()
1156
1190
        return result.addCallback(got_result)
1157
1191
 
1158
 
    def test_detect_changes_with_not_locked_and_ranges(self):
 
1192
    def test_detect_packages_changes_with_not_locked_and_ranges(self):
1159
1193
        """
1160
1194
        Ranges are used when reporting changes to 3 or more not locked packages
1161
1195
        having consecutive ids.
1173
1207
                                [{"type": "packages", "not-locked": [(1, 3)]}])
1174
1208
            self.assertEquals(sorted(self.store.get_locked()), [])
1175
1209
 
1176
 
        result = self.reporter.detect_changes()
 
1210
        result = self.reporter.detect_packages_changes()
1177
1211
        return result.addCallback(got_result)
1178
1212
 
1179
1213
    def test_detect_package_locks_changes_with_create_locks(self):
1253
1287
        result = self.reporter.detect_package_locks_changes()
1254
1288
        return result.addCallback(got_result)
1255
1289
 
 
1290
    def test_detect_package_locks_changes_with_locked_already_known(self):
 
1291
        """
 
1292
        If we didn't detect any change in the package locks, we don't send any
 
1293
        message, and we return a deferred resulting in C{False}.
 
1294
        """
 
1295
        message_store = self.broker_service.message_store
 
1296
        message_store.set_accepted_types(["package-locks"])
 
1297
 
 
1298
        self.facade.set_package_lock("name1")
 
1299
        self.store.add_package_locks([("name1", "", "")])
 
1300
 
 
1301
        def got_result(result):
 
1302
            self.assertFalse(result)
 
1303
            self.assertMessages(message_store.get_pending_messages(), [])
 
1304
 
 
1305
        result = self.reporter.detect_packages_changes()
 
1306
        return result.addCallback(got_result)
 
1307
 
 
1308
    def test_detect_changes_considers_packages_and_locks_changes(self):
 
1309
        """
 
1310
        The L{PackageReporter.detect_changes} method considers both package and
 
1311
        package locks changes. It also releases smart locks by calling the
 
1312
        L{SmartFacade.deinit} method.
 
1313
        """
 
1314
        reporter_mock = self.mocker.patch(self.reporter)
 
1315
        reporter_mock.detect_packages_changes()
 
1316
        self.mocker.result(succeed(True))
 
1317
        reporter_mock.detect_package_locks_changes()
 
1318
        self.mocker.result(succeed(True))
 
1319
 
 
1320
        facade_mock = self.mocker.patch(self.facade)
 
1321
        facade_mock.deinit()
 
1322
 
 
1323
        self.mocker.replay()
 
1324
        return self.reporter.detect_changes()
 
1325
 
 
1326
    def test_detect_changes_fires_package_data_changed(self):
 
1327
        """
 
1328
        The L{PackageReporter.detect_changes} method fires an event of
 
1329
        type 'package-data-changed' if we detected something has changed
 
1330
        with respect to our previous run.
 
1331
        """
 
1332
        reporter_mock = self.mocker.patch(self.reporter)
 
1333
        reporter_mock.detect_packages_changes()
 
1334
        self.mocker.result(succeed(False))
 
1335
        reporter_mock.detect_package_locks_changes()
 
1336
        self.mocker.result(succeed(True))
 
1337
        self.mocker.replay()
 
1338
 
 
1339
        deferred = Deferred()
 
1340
        callback = lambda: deferred.callback(None)
 
1341
        self.broker_service.reactor.call_on("package-data-changed", callback)
 
1342
        self.reporter.detect_changes()
 
1343
        return deferred
 
1344
 
1256
1345
    def test_run(self):
1257
1346
        reporter_mock = self.mocker.patch(self.reporter)
1258
1347
 
1259
1348
        self.mocker.order()
1260
1349
 
1261
 
        results = [Deferred() for i in range(8)]
 
1350
        results = [Deferred() for i in range(7)]
1262
1351
 
1263
1352
        reporter_mock.run_smart_update()
1264
1353
        self.mocker.result(results[0])
1281
1370
        reporter_mock.detect_changes()
1282
1371
        self.mocker.result(results[6])
1283
1372
 
1284
 
        reporter_mock.detect_package_locks_changes()
1285
 
        self.mocker.result(results[7])
1286
 
 
1287
1373
        self.mocker.replay()
1288
1374
 
1289
1375
        self.reporter.run()
1352
1438
        self.assertEquals(self.store.get_installed(), [2])
1353
1439
        self.assertEquals(self.store.get_locked(), [3])
1354
1440
        self.assertEquals(self.store.get_package_locks(), [("name1", "", "")])
1355
 
        self.assertEquals(self.store.get_hash_id_request(request1.id).id, request1.id)
 
1441
        self.assertEquals(self.store.get_hash_id_request(request1.id).id,
 
1442
                          request1.id)
1356
1443
 
1357
1444
        self.store.add_task("reporter", {"type": "resynchronize"})
1358
1445
 
1368
1455
            # But the other data should.
1369
1456
            self.assertEquals(self.store.get_available_upgrades(), [])
1370
1457
 
1371
 
            # After running the resychronize task, detect_changes is called,
1372
 
            # and the existing known hashes are made available.
 
1458
            # After running the resychronize task, detect_packages_changes is
 
1459
            # called, and the existing known hashes are made available.
1373
1460
            self.assertEquals(self.store.get_available(), [3, 4])
1374
1461
            self.assertEquals(self.store.get_installed(), [])
1375
1462
            self.assertEquals(self.store.get_locked(), [3])