← Back to branch summary

~free.ekanayaka/landscape-client/lucid-1.4.4-0ubuntu0.10.04

« back to all changes in this revision

Viewing changes to landscape/manager/tests/test_packagemanager.py

  • Committer: Bazaar Package Importer
  • Author(s): Free Ekanayaka
  • Date: 2009-12-16 10:50:05 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20091216105005-svplwdorkgz6vja7
Tags: 1.4.0-0ubuntu0.10.04.0
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 with several 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/manager/tests/test_packagemanager.py
2
2
 
3
3
from twisted.internet.defer import Deferred
4
4
 
5
 
from landscape.package.changer import find_changer_command
 
5
from landscape.package.changer import find_changer_command, PackageChanger
 
6
from landscape.package.releaseupgrader import (
 
7
    ReleaseUpgrader, find_release_upgrader_command)
6
8
from landscape.package.store import PackageStore
7
9
 
8
10
from landscape.manager.packagemanager import PackageManager
20
22
        """Initialize test helpers and create a sample thermal zone."""
21
23
        LandscapeIsolatedTest.setUp(self)
22
24
 
23
 
        self.manager = ManagerPluginRegistry(self.remote, self.broker_service.reactor,
 
25
        self.manager = ManagerPluginRegistry(self.remote,
 
26
                                             self.broker_service.reactor,
24
27
                                             self.broker_service.config)
25
28
 
26
 
        self.package_store_filename = self.makeFile()
27
 
        self.package_store = PackageStore(self.package_store_filename)
28
 
        self.package_manager = PackageManager(self.package_store_filename)
 
29
        self.package_store = PackageStore(os.path.join(self.data_path,
 
30
                                                       "package/database"))
 
31
        self.package_manager = PackageManager()
29
32
 
30
 
    def test_create_default_store_on_registration(self):
 
33
    def test_create_default_store_upon_message_handling(self):
 
34
        """
 
35
        If the package sqlite database file doesn't exist yet, it is created
 
36
        upon message handling.
 
37
        """
31
38
        filename = os.path.join(self.broker_service.config.data_path,
32
39
                                "package/database")
33
 
        package_manager = PackageManager()
34
40
        os.unlink(filename)
35
41
        self.assertFalse(os.path.isfile(filename))
36
 
        self.manager.add(package_manager)
 
42
 
 
43
        self.manager.add(self.package_manager)
 
44
        self.package_manager.spawn_handler = lambda x: None
 
45
        message = {"type": "release-upgrade"}
 
46
        self.package_manager.handle_release_upgrade(message)
37
47
        self.assertTrue(os.path.isfile(filename))
38
48
 
39
49
    def test_dont_spawn_changer_if_message_not_accepted(self):
40
 
        self.manager.add(self.package_manager)
41
 
 
42
 
        package_manager_mock = self.mocker.patch(self.package_manager)
43
 
        package_manager_mock.spawn_changer()
44
 
        self.mocker.count(0)
45
 
 
46
 
        self.mocker.replay()
47
 
 
48
 
        return self.package_manager.run()
49
 
 
50
 
    def test_spawn_changer_on_registration_when_already_accepted(self):
51
 
        package_manager_mock = self.mocker.patch(self.package_manager)
52
 
        package_manager_mock.spawn_changer()
 
50
        """
 
51
        The L{PackageManager} spawns a L{PackageChanger} run only if the
 
52
        appropriate message type is accepted.
 
53
        """
 
54
        self.manager.add(self.package_manager)
 
55
 
 
56
        package_manager_mock = self.mocker.patch(self.package_manager)
 
57
        package_manager_mock.spawn_handler(PackageChanger)
 
58
        self.mocker.count(0)
 
59
 
 
60
        self.mocker.replay()
 
61
 
 
62
        return self.package_manager.run()
 
63
 
 
64
    def test_dont_spawn_release_upgrader_if_message_not_accepted(self):
 
65
        """
 
66
        The L{PackageManager} spawns a L{ReleaseUpgrader} run only if the
 
67
        appropriate message type is accepted.
 
68
        """
 
69
        self.manager.add(self.package_manager)
 
70
 
 
71
        package_manager_mock = self.mocker.patch(self.package_manager)
 
72
        package_manager_mock.spawn_handler(ReleaseUpgrader)
 
73
        self.mocker.count(0)
 
74
 
 
75
        self.mocker.replay()
 
76
 
 
77
        return self.package_manager.run()
 
78
 
 
79
    def test_spawn_handler_on_registration_when_already_accepted(self):
 
80
        package_manager_mock = self.mocker.patch(self.package_manager)
 
81
        package_manager_mock.spawn_handler(PackageChanger)
53
82
 
54
83
        # Slightly tricky as we have to wait for the result of run(),
55
84
        # but we don't have its deferred yet.  To handle it, we create
56
85
        # our own deferred, and register a callback for when run()
57
86
        # returns, chaining both deferreds at that point.
58
87
        deferred = Deferred()
 
88
 
59
89
        def run_has_run(run_result_deferred):
60
90
            return run_result_deferred.chainDeferred(deferred)
61
91
 
71
101
        return deferred
72
102
 
73
103
    def test_spawn_changer_on_run_if_message_accepted(self):
 
104
        """
 
105
        The L{PackageManager} spawns a L{PackageChanger} run if messages
 
106
        of type C{"change-packages-result"} are accepted.
 
107
        """
74
108
        self.manager.add(self.package_manager)
75
109
 
76
110
        service = self.broker_service
77
111
        service.message_store.set_accepted_types(["change-packages-result"])
78
112
 
79
113
        package_manager_mock = self.mocker.patch(self.package_manager)
80
 
        package_manager_mock.spawn_changer()
 
114
        package_manager_mock.spawn_handler(PackageChanger)
 
115
        self.mocker.count(2) # Once for registration, then again explicitly.
 
116
 
 
117
        self.mocker.replay()
 
118
 
 
119
        return self.package_manager.run()
 
120
 
 
121
    def test_spawn_release_upgrader_on_run_if_message_accepted(self):
 
122
        """
 
123
        The L{PackageManager} spawns a L{ReleaseUpgrader} run if messages
 
124
        of type C{"operation-result"} are accepted.
 
125
        """
 
126
        self.manager.add(self.package_manager)
 
127
 
 
128
        service = self.broker_service
 
129
        service.message_store.set_accepted_types(["operation-result"])
 
130
 
 
131
        package_manager_mock = self.mocker.patch(self.package_manager)
 
132
        package_manager_mock.spawn_handler(ReleaseUpgrader)
81
133
        self.mocker.count(2) # Once for registration, then again explicitly.
82
134
 
83
135
        self.mocker.replay()
88
140
        self.manager.add(self.package_manager)
89
141
 
90
142
        package_manager_mock = self.mocker.patch(self.package_manager)
91
 
        package_manager_mock.spawn_changer()
 
143
        package_manager_mock.spawn_handler(PackageChanger)
92
144
        self.mocker.replay()
93
145
 
94
146
        message = {"type": "change-packages"}
98
150
        self.assertTrue(task)
99
151
        self.assertEquals(task.data, message)
100
152
 
 
153
    def test_release_upgrade_handling(self):
 
154
        """
 
155
        The L{PackageManager.handle_release_upgrade} method is registered has
 
156
        handler for messages of type C{"release-upgrade"}, and queues a task
 
157
        in the appropriate queue.
 
158
        """
 
159
        self.manager.add(self.package_manager)
 
160
 
 
161
        package_manager_mock = self.mocker.patch(self.package_manager)
 
162
        package_manager_mock.spawn_handler(ReleaseUpgrader)
 
163
        self.mocker.replay()
 
164
 
 
165
        message = {"type": "release-upgrade"}
 
166
        self.manager.dispatch_message(message)
 
167
        task = self.package_store.get_next_task("release-upgrader")
 
168
        self.assertTrue(task)
 
169
        self.assertEquals(task.data, message)
 
170
 
101
171
    def test_spawn_changer(self):
 
172
        """
 
173
        The L{PackageManager.spawn_handler} method executes the correct command
 
174
        when passed the L{PackageChanger} class as argument.
 
175
        """
102
176
        command = self.makeFile("#!/bin/sh\necho 'I am the changer!' >&2\n")
103
177
        os.chmod(command, 0755)
104
178
        find_command_mock = self.mocker.replace(find_changer_command)
108
182
 
109
183
        self.package_store.add_task("changer", "Do something!")
110
184
 
111
 
        package_manager = PackageManager(self.package_store_filename)
112
 
        self.manager.add(package_manager)
113
 
        result = package_manager.spawn_changer()
 
185
        self.manager.add(self.package_manager)
 
186
        result = self.package_manager.spawn_handler(PackageChanger)
114
187
 
115
188
        def got_result(result):
116
189
            log = self.logfile.getvalue()
119
192
 
120
193
        return result.addCallback(got_result)
121
194
 
122
 
    def test_spawn_changer_without_output(self):
 
195
    def test_spawn_release_upgrader(self):
 
196
        """
 
197
        The L{PackageManager.spawn_handler} method executes the correct command
 
198
        when passed the L{ReleaseUpgrader} class as argument.
 
199
        """
 
200
        command = self.makeFile("#!/bin/sh\necho 'I am the upgrader!' >&2\n")
 
201
        os.chmod(command, 0755)
 
202
        find_command_mock = self.mocker.replace(find_release_upgrader_command)
 
203
        find_command_mock()
 
204
        self.mocker.result(command)
 
205
        self.mocker.replay()
 
206
 
 
207
        self.package_store.add_task("release-upgrader", "Do something!")
 
208
 
 
209
        self.manager.add(self.package_manager)
 
210
        result = self.package_manager.spawn_handler(ReleaseUpgrader)
 
211
 
 
212
        def got_result(result):
 
213
            log = self.logfile.getvalue()
 
214
            self.assertIn("I am the upgrader!", log)
 
215
            self.assertNotIn(command, log)
 
216
 
 
217
        return result.addCallback(got_result)
 
218
 
 
219
    def test_spawn_handler_without_output(self):
123
220
        find_command_mock = self.mocker.replace(find_changer_command)
124
221
        find_command_mock()
125
222
        self.mocker.result("/bin/true")
127
224
 
128
225
        self.package_store.add_task("changer", "Do something!")
129
226
 
130
 
        package_manager = PackageManager(self.package_store_filename)
131
 
        self.manager.add(package_manager)
132
 
        result = package_manager.spawn_changer()
 
227
        self.manager.add(self.package_manager)
 
228
        result = self.package_manager.spawn_handler(PackageChanger)
133
229
 
134
230
        def got_result(result):
135
231
            log = self.logfile.getvalue()
137
233
 
138
234
        return result.addCallback(got_result)
139
235
 
140
 
    def test_spawn_changer_copies_environment(self):
 
236
    def test_spawn_handler_copies_environment(self):
141
237
        command = self.makeFile("#!/bin/sh\necho VAR: $VAR\n")
142
238
        os.chmod(command, 0755)
143
239
        find_command_mock = self.mocker.replace(find_changer_command)
145
241
        self.mocker.result(command)
146
242
        self.mocker.replay()
147
243
 
148
 
        package_manager = PackageManager(self.package_store_filename)
149
 
        self.manager.add(package_manager)
 
244
        self.manager.add(self.package_manager)
150
245
 
151
246
        self.package_store.add_task("changer", "Do something!")
152
247
 
153
248
        os.environ["VAR"] = "HI!"
154
249
 
155
 
        result = package_manager.spawn_changer()
 
250
        result = self.package_manager.spawn_handler(PackageChanger)
156
251
 
157
252
        def got_result(result):
158
253
            log = self.logfile.getvalue()
161
256
 
162
257
        return result.addCallback(got_result)
163
258
 
164
 
    def test_spawn_changer_passes_quiet_option(self):
 
259
    def test_spawn_handler_passes_quiet_option(self):
165
260
        command = self.makeFile("#!/bin/sh\necho OPTIONS: $@\n")
166
261
        os.chmod(command, 0755)
167
262
        find_command_mock = self.mocker.replace(find_changer_command)
169
264
        self.mocker.result(command)
170
265
        self.mocker.replay()
171
266
 
172
 
        package_manager = PackageManager(self.package_store_filename)
173
 
        self.manager.add(package_manager)
 
267
        self.manager.add(self.package_manager)
174
268
 
175
269
        self.package_store.add_task("changer", "Do something!")
176
270
 
177
 
        result = package_manager.spawn_changer()
 
271
        result = self.package_manager.spawn_handler(PackageChanger)
178
272
 
179
273
        def got_result(result):
180
274
            log = self.logfile.getvalue()
183
277
 
184
278
        return result.addCallback(got_result)
185
279
 
186
 
    def test_spawn_changer_wont_run_without_tasks(self):
 
280
    def test_spawn_handler_wont_run_without_tasks(self):
187
281
        command = self.makeFile("#!/bin/sh\necho RUN!\n")
188
282
        os.chmod(command, 0755)
189
 
        find_command_mock = self.mocker.replace(find_changer_command)
190
 
        find_command_mock()
191
 
        self.mocker.result(command)
192
 
        self.mocker.replay()
193
 
 
194
 
        package_manager = PackageManager(self.package_store_filename)
195
 
        self.manager.add(package_manager)
196
 
 
197
 
        result = package_manager.spawn_changer()
 
283
 
 
284
        self.manager.add(self.package_manager)
 
285
 
 
286
        result = self.package_manager.spawn_handler(PackageChanger)
198
287
 
199
288
        def got_result(result):
200
289
            log = self.logfile.getvalue()
202
291
 
203
292
        return result.addCallback(got_result)
204
293
 
205
 
    def test_spawn_changer_doesnt_chdir(self):
 
294
    def test_spawn_handler_doesnt_chdir(self):
206
295
        command = self.makeFile("#!/bin/sh\necho RUN\n")
207
296
        os.chmod(command, 0755)
208
 
        dir = self.make_dir()
 
297
        dir = self.makeDir()
209
298
        os.chdir(dir)
210
299
        os.chmod(dir, 0)
211
 
        
 
300
 
212
301
        find_command_mock = self.mocker.replace(find_changer_command)
213
302
        find_command_mock()
214
303
        self.mocker.result(command)
215
304
        self.mocker.replay()
216
305
 
217
 
        package_manager = PackageManager(self.package_store_filename)
218
 
        self.manager.add(package_manager)
 
306
        self.manager.add(self.package_manager)
219
307
 
220
308
        self.package_store.add_task("changer", "Do something!")
221
309
 
222
 
        result = package_manager.spawn_changer()
 
310
        result = self.package_manager.spawn_handler(PackageChanger)
223
311
 
224
312
        def got_result(result):
225
313
            log = self.logfile.getvalue()