← 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_reporter.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_reporter.py
2
2
import sys
3
3
import os
4
4
import logging
 
5
import unittest
5
6
 
6
7
from twisted.internet.defer import Deferred
7
8
from twisted.internet import reactor
8
9
 
9
10
from landscape.lib.fetch import fetch_async, FetchError
10
 
from landscape.lib.command import CommandError
11
 
 
12
11
from landscape.package.store import PackageStore, UnknownHashIDRequest
13
12
from landscape.package.reporter import (
14
 
    PackageReporter, HASH_ID_REQUEST_TIMEOUT, main, find_reporter_command)
 
13
    PackageReporter, HASH_ID_REQUEST_TIMEOUT, main, find_reporter_command,
 
14
    PackageReporterConfiguration)
15
15
from landscape.package import reporter
16
16
from landscape.package.facade import SmartFacade
17
 
 
18
 
from landscape.deployment import Configuration
19
17
from landscape.broker.remote import RemoteBroker
20
 
 
21
18
from landscape.package.tests.helpers import (
22
19
    SmartFacadeHelper, HASH1, HASH2, HASH3)
23
 
 
24
20
from landscape.tests.helpers import (
25
21
    LandscapeIsolatedTest, RemoteBrokerHelper)
26
22
from landscape.tests.mocker import ANY
27
23
 
 
24
SAMPLE_LSB_RELEASE = "DISTRIB_CODENAME=codename\n"
 
25
 
 
26
 
 
27
class PackageReporterConfigurationTest(unittest.TestCase):
 
28
 
 
29
    def test_force_smart_update_option(self):
 
30
        """
 
31
        The L{PackageReporterConfiguration} supports a '--force-smart-update'
 
32
        command line option.
 
33
        """
 
34
        config = PackageReporterConfiguration()
 
35
        self.assertFalse(config.force_smart_update)
 
36
        config.load(["--force-smart-update"])
 
37
        self.assertTrue(config.force_smart_update)
 
38
 
28
39
 
29
40
class PackageReporterTest(LandscapeIsolatedTest):
30
41
 
34
45
        super(PackageReporterTest, self).setUp()
35
46
 
36
47
        self.store = PackageStore(self.makeFile())
37
 
        self.config = Configuration()
38
 
        self.reporter = PackageReporter(self.store, self.facade, self.remote, self.config)
 
48
        self.config = PackageReporterConfiguration()
 
49
        self.reporter = PackageReporter(self.store, self.facade, self.remote,
 
50
                                        self.config)
39
51
 
40
52
    def set_pkg2_upgrades_pkg1(self):
41
53
        previous = self.Facade.channels_reloaded
 
54
 
42
55
        def callback(self):
43
56
            from smart.backends.deb.base import DebUpgrades
44
57
            previous(self)
49
62
 
50
63
    def set_pkg1_installed(self):
51
64
        previous = self.Facade.channels_reloaded
 
65
 
52
66
        def callback(self):
53
67
            previous(self)
54
68
            self.get_packages_by_name("name1")[0].installed = True
55
69
        self.Facade.channels_reloaded = callback
56
70
 
57
71
    def test_set_package_ids_with_all_known(self):
58
 
        request1 = self.store.add_hash_id_request(["hash1", "hash2"])
 
72
        self.store.add_hash_id_request(["hash1", "hash2"])
59
73
        request2 = self.store.add_hash_id_request(["hash3", "hash4"])
60
 
        request3 = self.store.add_hash_id_request(["hash5", "hash6"])
 
74
        self.store.add_hash_id_request(["hash5", "hash6"])
61
75
 
62
76
        self.store.add_task("reporter",
63
77
                            {"type": "package-ids", "ids": [123, 456],
164
178
                                "request-id": request2.id,
165
179
                  "type": "add-packages"}])
166
180
 
167
 
 
168
181
        class FakePackage(object):
169
182
            type = 65537
170
183
            name = u"name1"
187
200
        message_store = self.broker_service.message_store
188
201
        message_store.set_accepted_types(["add-packages"])
189
202
 
190
 
        class Boom(Exception): pass
 
203
        class Boom(Exception):
 
204
            pass
 
205
 
191
206
        deferred = Deferred()
192
207
        deferred.errback(Boom())
193
208
 
236
251
        # Fake uuid, codename and arch
237
252
        message_store = self.broker_service.message_store
238
253
        message_store.set_server_uuid("uuid")
239
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
240
 
        command_mock("lsb_release -cs")
241
 
        self.mocker.result("codename")
 
254
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
242
255
        self.facade.set_arch("arch")
243
256
 
244
257
        # Let's say fetch_async is successful
282
295
        # Fake uuid, codename and arch
283
296
        message_store = self.broker_service.message_store
284
297
        message_store.set_server_uuid("uuid")
285
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
286
 
        command_mock("lsb_release -cs")
287
 
        self.mocker.result("codename")
 
298
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
288
299
        self.facade.set_arch("arch")
289
300
 
290
301
        # Intercept any call to fetch_async
331
342
        message_store.set_server_uuid("uuid")
332
343
 
333
344
        # Undetermined codename
334
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
335
 
        command_mock("lsb_release -cs")
336
 
        command_error = CommandError("lsb_release -cs", 1, "error")
337
 
        self.mocker.throw(command_error)
 
345
        self.reporter.lsb_release_filename = self.makeFile("Foo=bar")
338
346
 
339
347
        # The failure should be properly logged
340
348
        logging_mock = self.mocker.replace("logging.warning")
341
 
        logging_mock("Couldn't determine which hash=>id database to use: %s" %
342
 
                     str(command_error))
 
349
        logging_mock("Couldn't determine which hash=>id database to use: "
 
350
                     "missing code-name key in %s" %
 
351
                     self.reporter.lsb_release_filename)
343
352
        self.mocker.result(None)
344
353
 
345
354
        # Go!
353
362
        # Fake uuid and codename
354
363
        message_store = self.broker_service.message_store
355
364
        message_store.set_server_uuid("uuid")
356
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
357
 
        command_mock("lsb_release -cs")
358
 
        self.mocker.result("codename")
 
365
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
359
366
 
360
367
        # Undetermined arch
361
368
        self.facade.set_arch(None)
385
392
        # Fake uuid, codename and arch
386
393
        message_store = self.broker_service.message_store
387
394
        message_store.set_server_uuid("uuid")
388
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
389
 
        command_mock("lsb_release -cs")
390
 
        self.mocker.result("codename")
 
395
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
391
396
        self.facade.set_arch("arch")
392
397
 
393
398
        # Check fetch_async is called with the default url
419
424
        # Fake uuid, codename and arch
420
425
        message_store = self.broker_service.message_store
421
426
        message_store.set_server_uuid("uuid")
422
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
423
 
        command_mock("lsb_release -cs")
424
 
        self.mocker.result("codename")
 
427
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
425
428
        self.facade.set_arch("arch")
426
429
 
427
430
        # Let's say fetch_async fails
459
462
        # Fake uuid, codename and arch
460
463
        message_store = self.broker_service.message_store
461
464
        message_store.set_server_uuid("uuid")
462
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
463
 
        command_mock("lsb_release -cs")
464
 
        self.mocker.result("codename")
 
465
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
465
466
        self.facade.set_arch("arch")
466
467
 
467
468
        # The failure should be properly logged
495
496
        # Fake uuid, codename and arch
496
497
        message_store = self.broker_service.message_store
497
498
        message_store.set_server_uuid("uuid")
498
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
499
 
        command_mock("lsb_release -cs")
500
 
        self.mocker.result("codename")
 
499
        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
501
500
        self.facade.set_arch("arch")
502
501
 
503
502
        # Check fetch_async is called with the default url
531
530
        deferred = Deferred()
532
531
 
533
532
        def do_test():
 
533
 
534
534
            def raiseme(x):
535
535
                raise Exception
 
536
 
536
537
            logging.warning = raiseme
537
538
            result = self.reporter.run_smart_update()
 
539
 
538
540
            def callback((out, err, code)):
539
541
                interval = self.reporter.smart_update_interval
540
542
                self.assertEquals(out, "--after %d" % interval)
546
548
        reactor.callWhenRunning(do_test)
547
549
        return deferred
548
550
 
 
551
    def test_run_smart_update_with_force_smart_update(self):
 
552
        """
 
553
        L{PackageReporter.run_smart_update} forces a smart-update run if
 
554
        the '--force-smart-update' command line option was passed.
 
555
 
 
556
        """
 
557
        self.config.load(["--force-smart-update"])
 
558
        self.reporter.smart_update_filename = self.makeFile(
 
559
            "#!/bin/sh\necho -n $@")
 
560
        os.chmod(self.reporter.smart_update_filename, 0755)
 
561
 
 
562
        deferred = Deferred()
 
563
 
 
564
        def do_test():
 
565
            result = self.reporter.run_smart_update()
 
566
 
 
567
            def callback((out, err, code)):
 
568
                self.assertEquals(out, "")
 
569
            result.addCallback(callback)
 
570
            result.chainDeferred(deferred)
 
571
 
 
572
        reactor.callWhenRunning(do_test)
 
573
        return deferred
 
574
 
549
575
    def test_run_smart_update_warns_about_failures(self):
550
576
        """
551
577
        The L{PackageReporter.run_smart_update} method should log a warning
562
588
 
563
589
        def do_test():
564
590
            result = self.reporter.run_smart_update()
 
591
 
565
592
            def callback((out, err, code)):
566
 
                interval = self.reporter.smart_update_interval
567
593
                self.assertEquals(out, "output")
568
594
                self.assertEquals(err, "error")
569
595
                self.assertEquals(code, 2)
586
612
                     " (error  )" % self.reporter.smart_update_filename)
587
613
        self.mocker.replay()
588
614
        deferred = Deferred()
 
615
 
589
616
        def do_test():
590
617
            result = self.reporter.run_smart_update()
 
618
 
591
619
            def callback((out, err, code)):
592
 
                interval = self.reporter.smart_update_interval
593
620
                self.assertEquals(out, "")
594
621
                self.assertEquals(err, "error  ")
595
622
                self.assertEquals(code, 1)
609
636
            "#!/bin/sh\necho\nexit 1")
610
637
        os.chmod(self.reporter.smart_update_filename, 0755)
611
638
        deferred = Deferred()
 
639
 
612
640
        def do_test():
 
641
 
613
642
            def raiseme(x):
614
643
                raise Exception
615
644
            logging.warning = raiseme
616
645
            result = self.reporter.run_smart_update()
 
646
 
617
647
            def callback((out, err, code)):
618
 
                interval = self.reporter.smart_update_interval
619
648
                self.assertEquals(out, "\n")
620
649
                self.assertEquals(err, "")
621
650
                self.assertEquals(code, 1)
780
809
        message_store = self.broker_service.message_store
781
810
        message_store.set_accepted_types(["unknown-package-hashes"])
782
811
 
783
 
        class Boom(Exception): pass
 
812
        class Boom(Exception):
 
813
            pass
 
814
 
784
815
        deferred = Deferred()
785
816
        deferred.errback(Boom())
786
817
 
860
891
                                [{"type": "packages",
861
892
                                  "not-available": [(1, 3)]}])
862
893
 
863
 
            self.assertEquals(sorted(self.store.get_available()), [])
 
894
            self.assertEquals(self.store.get_available(), [])
864
895
 
865
896
        result = self.reporter.detect_changes()
866
897
        return result.addCallback(got_result)
878
909
            self.assertMessages(message_store.get_pending_messages(),
879
910
                                [{"type": "packages", "installed": [1]}])
880
911
 
881
 
            self.assertEquals(sorted(self.store.get_installed()), [1])
 
912
            self.assertEquals(self.store.get_installed(), [1])
882
913
 
883
914
        result = self.reporter.detect_changes()
884
915
        return result.addCallback(got_result)
911
942
            self.assertMessages(message_store.get_pending_messages(),
912
943
                                [{"type": "packages", "not-installed": [1]}])
913
944
 
914
 
            self.assertEquals(sorted(self.store.get_installed()), [])
 
945
            self.assertEquals(self.store.get_installed(), [])
915
946
 
916
947
        result = self.reporter.detect_changes()
917
948
        return result.addCallback(got_result)
947
978
                                [{"type": "packages",
948
979
                                  "available-upgrades": [2]}])
949
980
 
950
 
            self.assertEquals(sorted(self.store.get_available_upgrades()), [2])
 
981
            self.assertEquals(self.store.get_available_upgrades(), [2])
951
982
 
952
983
        result = self.reporter.detect_changes()
953
984
        return result.addCallback(got_result)
965
996
                                [{"type": "packages",
966
997
                                  "not-available-upgrades": [2]}])
967
998
 
968
 
            self.assertEquals(sorted(self.store.get_available_upgrades()), [])
969
 
 
970
 
        result = self.reporter.detect_changes()
 
999
            self.assertEquals(self.store.get_available_upgrades(), [])
 
1000
 
 
1001
        result = self.reporter.detect_changes()
 
1002
        return result.addCallback(got_result)
 
1003
 
 
1004
    def test_detect_changes_with_locked(self):
 
1005
        """
 
1006
        If Smart indicates locked packages we didn't know about, report
 
1007
        them to the server.
 
1008
        """
 
1009
        message_store = self.broker_service.message_store
 
1010
        message_store.set_accepted_types(["packages"])
 
1011
 
 
1012
        self.facade.set_package_lock("name1")
 
1013
        self.facade.set_package_lock("name2", ">=", "version2")
 
1014
 
 
1015
        self.store.set_hash_ids({HASH1: 1, HASH2: 2})
 
1016
        self.store.add_available([1, 2])
 
1017
 
 
1018
        def got_result(result):
 
1019
            self.assertMessages(message_store.get_pending_messages(),
 
1020
                                [{"type": "packages", "locked": [1, 2]}])
 
1021
            self.assertEquals(sorted(self.store.get_locked()), [1, 2])
 
1022
 
 
1023
        result = self.reporter.detect_changes()
 
1024
        return result.addCallback(got_result)
 
1025
 
 
1026
    def test_detect_changes_with_locked_and_ranges(self):
 
1027
        """
 
1028
        Ranges are used when reporting changes to 3 or more locked packages
 
1029
        having consecutive ids.
 
1030
        """
 
1031
        message_store = self.broker_service.message_store
 
1032
        message_store.set_accepted_types(["packages"])
 
1033
 
 
1034
        self.facade.set_package_lock("name1")
 
1035
        self.facade.set_package_lock("name2", ">=", "version2")
 
1036
        self.facade.set_package_lock("name3", "<", "version4")
 
1037
 
 
1038
        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
 
1039
        self.store.add_available([1, 2, 3])
 
1040
 
 
1041
        def got_result(result):
 
1042
            self.assertMessages(message_store.get_pending_messages(),
 
1043
                                [{"type": "packages", "locked": [(1, 3)]}])
 
1044
            self.assertEquals(sorted(self.store.get_locked()), [1, 2, 3])
 
1045
 
 
1046
        result = self.reporter.detect_changes()
 
1047
        return result.addCallback(got_result)
 
1048
 
 
1049
    def test_detect_changes_with_locked_with_unknown_hash(self):
 
1050
        """
 
1051
        Locked packages whose hashes are unknown don't get reported.
 
1052
        """
 
1053
        self.facade.set_package_lock("name1")
 
1054
 
 
1055
        def got_result(result):
 
1056
            self.assertEquals(self.store.get_locked(), [])
 
1057
 
 
1058
        result = self.reporter.detect_changes()
 
1059
        return result.addCallback(got_result)
 
1060
 
 
1061
    def test_detect_changes_with_locked_and_previously_known(self):
 
1062
        """
 
1063
        We don't report locked packages we already know about.
 
1064
        """
 
1065
        message_store = self.broker_service.message_store
 
1066
        message_store.set_accepted_types(["packages"])
 
1067
 
 
1068
        self.facade.set_package_lock("name1")
 
1069
        self.facade.set_package_lock("name2", ">=", "version2")
 
1070
 
 
1071
        self.store.set_hash_ids({HASH1: 1, HASH2: 2})
 
1072
        self.store.add_available([1, 2])
 
1073
        self.store.add_locked([1])
 
1074
 
 
1075
        def got_result(result):
 
1076
            self.assertMessages(message_store.get_pending_messages(),
 
1077
                                [{"type": "packages", "locked": [2]}])
 
1078
 
 
1079
            self.assertEquals(sorted(self.store.get_locked()), [1, 2])
 
1080
 
 
1081
        result = self.reporter.detect_changes()
 
1082
        return result.addCallback(got_result)
 
1083
 
 
1084
    def test_detect_changes_with_not_locked(self):
 
1085
        """
 
1086
        We report when a package was previously locked and isn't anymore.
 
1087
        """
 
1088
        message_store = self.broker_service.message_store
 
1089
        message_store.set_accepted_types(["packages"])
 
1090
 
 
1091
        self.store.set_hash_ids({HASH1: 1})
 
1092
        self.store.add_available([1])
 
1093
        self.store.add_locked([1])
 
1094
 
 
1095
        def got_result(result):
 
1096
            self.assertMessages(message_store.get_pending_messages(),
 
1097
                                [{"type": "packages", "not-locked": [1]}])
 
1098
            self.assertEquals(self.store.get_locked(), [])
 
1099
 
 
1100
        result = self.reporter.detect_changes()
 
1101
        return result.addCallback(got_result)
 
1102
 
 
1103
    def test_detect_changes_with_not_locked_and_ranges(self):
 
1104
        """
 
1105
        Ranges are used when reporting changes to 3 or more not locked packages
 
1106
        having consecutive ids.
 
1107
        """
 
1108
        message_store = self.broker_service.message_store
 
1109
        message_store.set_accepted_types(["packages"])
 
1110
 
 
1111
        self.store.add_locked([1, 2, 3])
 
1112
 
 
1113
        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
 
1114
        self.store.add_available([1, 2, 3])
 
1115
 
 
1116
        def got_result(result):
 
1117
            self.assertMessages(message_store.get_pending_messages(),
 
1118
                                [{"type": "packages", "not-locked": [(1, 3)]}])
 
1119
            self.assertEquals(sorted(self.store.get_locked()), [])
 
1120
 
 
1121
        result = self.reporter.detect_changes()
 
1122
        return result.addCallback(got_result)
 
1123
 
 
1124
    def test_detect_package_locks_changes_with_create_locks(self):
 
1125
        """
 
1126
        If Smart indicates package locks we didn't know about, report
 
1127
        them to the server.
 
1128
        """
 
1129
        message_store = self.broker_service.message_store
 
1130
        message_store.set_accepted_types(["package-locks"])
 
1131
 
 
1132
        self.facade.set_package_lock("name")
 
1133
 
 
1134
        logging_mock = self.mocker.replace("logging.info")
 
1135
        logging_mock("Queuing message with changes in known package locks:"
 
1136
                     " 1 created, 0 deleted.")
 
1137
        self.mocker.replay()
 
1138
 
 
1139
        def got_result(result):
 
1140
            self.assertMessages(message_store.get_pending_messages(),
 
1141
                                [{"type": "package-locks",
 
1142
                                  "created": [("name", "", "")]}])
 
1143
            self.assertEquals(self.store.get_package_locks(),
 
1144
                              [("name", "", "")])
 
1145
 
 
1146
        result = self.reporter.detect_package_locks_changes()
 
1147
        return result.addCallback(got_result)
 
1148
 
 
1149
    def test_detect_package_locks_changes_with_already_known_locks(self):
 
1150
        """
 
1151
        We don't report changes about locks we already know about.
 
1152
        """
 
1153
        message_store = self.broker_service.message_store
 
1154
        message_store.set_accepted_types(["package-locks"])
 
1155
 
 
1156
        self.facade.set_package_lock("name1")
 
1157
        self.facade.set_package_lock("name2", "<", "1.2")
 
1158
 
 
1159
        self.store.add_package_locks([("name1", "", "")])
 
1160
 
 
1161
        logging_mock = self.mocker.replace("logging.info")
 
1162
        logging_mock("Queuing message with changes in known package locks:"
 
1163
                     " 1 created, 0 deleted.")
 
1164
        self.mocker.replay()
 
1165
 
 
1166
        def got_result(result):
 
1167
            self.assertMessages(message_store.get_pending_messages(),
 
1168
                                [{"type": "package-locks",
 
1169
                                  "created": [("name2", "<", "1.2")]}])
 
1170
            self.assertEquals(sorted(self.store.get_package_locks()),
 
1171
                              [("name1", "", ""),
 
1172
                               ("name2", "<", "1.2")])
 
1173
 
 
1174
        result = self.reporter.detect_package_locks_changes()
 
1175
        return result.addCallback(got_result)
 
1176
 
 
1177
    def test_detect_package_locks_changes_with_deleted_locks(self):
 
1178
        """
 
1179
        If Smart indicates newly unset package locks, report them to the
 
1180
        server.
 
1181
        """
 
1182
        message_store = self.broker_service.message_store
 
1183
        message_store.set_accepted_types(["package-locks"])
 
1184
 
 
1185
        self.store.add_package_locks([("name1", "", "")])
 
1186
 
 
1187
        logging_mock = self.mocker.replace("logging.info")
 
1188
        logging_mock("Queuing message with changes in known package locks:"
 
1189
                     " 0 created, 1 deleted.")
 
1190
        self.mocker.replay()
 
1191
 
 
1192
        def got_result(result):
 
1193
            self.assertMessages(message_store.get_pending_messages(),
 
1194
                                [{"type": "package-locks",
 
1195
                                  "deleted": [("name1", "", "")]}])
 
1196
            self.assertEquals(self.store.get_package_locks(), [])
 
1197
 
 
1198
        result = self.reporter.detect_package_locks_changes()
971
1199
        return result.addCallback(got_result)
972
1200
 
973
1201
    def test_run(self):
975
1203
 
976
1204
        self.mocker.order()
977
1205
 
978
 
        results = [Deferred() for i in range(7)]
 
1206
        results = [Deferred() for i in range(8)]
979
1207
 
980
1208
        reporter_mock.run_smart_update()
981
1209
        self.mocker.result(results[0])
998
1226
        reporter_mock.detect_changes()
999
1227
        self.mocker.result(results[6])
1000
1228
 
 
1229
        reporter_mock.detect_package_locks_changes()
 
1230
        self.mocker.result(results[7])
 
1231
 
1001
1232
        self.mocker.replay()
1002
1233
 
1003
1234
        self.reporter.run()
1011
1242
            deferred.callback(None)
1012
1243
 
1013
1244
    def test_main(self):
1014
 
        data_path = self.makeDir()
1015
 
 
1016
1245
        run_task_handler = self.mocker.replace("landscape.package.taskhandler"
1017
1246
                                               ".run_task_handler",
1018
1247
                                               passthrough=False)