← Back to branch summary

~landscape/landscape-client/trunk

« back to all changes in this revision

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

Merge mocker-manager-test-packagemanager [f=1592875] [r=adam-collard,landscape-builder,tribaal] [a=Bogdana Vereha]
Update manager.test_packagemanager to use mock instead of mocker

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/manager/tests/test_packagemanager.py
 
1
import mock
1
2
import os
2
3
 
3
4
from twisted.internet.defer import Deferred
4
5
 
5
 
from landscape.package.changer import find_changer_command, PackageChanger
6
 
from landscape.package.releaseupgrader import (
7
 
    ReleaseUpgrader, find_release_upgrader_command)
 
6
from landscape.package.changer import PackageChanger
 
7
from landscape.package.releaseupgrader import ReleaseUpgrader
8
8
from landscape.package.store import PackageStore
9
9
 
10
10
from landscape.manager.packagemanager import PackageManager
35
35
        self.assertFalse(os.path.isfile(filename))
36
36
 
37
37
        self.manager.add(self.package_manager)
38
 
        self.package_manager.spawn_handler = lambda x: None
39
 
        message = {"type": "release-upgrade"}
40
 
        self.package_manager.handle_release_upgrade(message)
41
 
        self.assertTrue(os.path.isfile(filename))
 
38
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
39
            message = {"type": "release-upgrade"}
 
40
            self.package_manager.handle_release_upgrade(message)
 
41
            self.assertTrue(os.path.isfile(filename))
42
42
 
43
43
    def test_dont_spawn_changer_if_message_not_accepted(self):
44
44
        """
46
46
        appropriate message type is accepted.
47
47
        """
48
48
        self.manager.add(self.package_manager)
49
 
 
50
 
        package_manager_mock = self.mocker.patch(self.package_manager)
51
 
        package_manager_mock.spawn_handler(PackageChanger)
52
 
        self.mocker.count(0)
53
 
 
54
 
        self.mocker.replay()
55
 
 
56
 
        return self.package_manager.run()
 
49
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
50
            self.package_manager.run()
 
51
            self.assertNotIn(PackageChanger,
 
52
                             self.package_manager.spawn_handler.call_args_list)
 
53
            self.assertEqual(0, self.package_manager.spawn_handler.call_count)
57
54
 
58
55
    def test_dont_spawn_release_upgrader_if_message_not_accepted(self):
59
56
        """
61
58
        appropriate message type is accepted.
62
59
        """
63
60
        self.manager.add(self.package_manager)
64
 
 
65
 
        package_manager_mock = self.mocker.patch(self.package_manager)
66
 
        package_manager_mock.spawn_handler(ReleaseUpgrader)
67
 
        self.mocker.count(0)
68
 
 
69
 
        self.mocker.replay()
70
 
 
71
 
        return self.package_manager.run()
 
61
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
62
            self.package_manager.run()
 
63
            self.assertNotIn(ReleaseUpgrader,
 
64
                             self.package_manager.spawn_handler.call_args_list)
 
65
            self.assertEqual(0, self.package_manager.spawn_handler.call_count)
72
66
 
73
67
    def test_spawn_handler_on_registration_when_already_accepted(self):
74
 
        package_manager_mock = self.mocker.patch(self.package_manager)
75
 
        package_manager_mock.spawn_handler(PackageChanger)
 
68
        real_run = self.package_manager.run
76
69
 
77
70
        # Slightly tricky as we have to wait for the result of run(),
78
71
        # but we don't have its deferred yet.  To handle it, we create
80
73
        # returns, chaining both deferreds at that point.
81
74
        deferred = Deferred()
82
75
 
83
 
        def run_has_run(run_result_deferred):
 
76
        def run_has_run():
 
77
            run_result_deferred = real_run()
84
78
            return run_result_deferred.chainDeferred(deferred)
85
79
 
86
 
        package_manager_mock.run()
87
 
        self.mocker.passthrough(run_has_run)
88
 
 
89
 
        self.mocker.replay()
90
 
 
91
 
        service = self.broker_service
92
 
        service.message_store.set_accepted_types(["change-packages-result"])
93
 
        self.manager.add(self.package_manager)
94
 
 
95
 
        return deferred
 
80
        with mock.patch.object(self.package_manager, "spawn_handler"), \
 
81
             mock.patch.object(self.package_manager, "run",
 
82
                               side_effect=run_has_run):
 
83
            service = self.broker_service
 
84
            service.message_store.set_accepted_types(
 
85
                ["change-packages-result"])
 
86
            self.manager.add(self.package_manager)
 
87
            self.successResultOf(deferred)
 
88
            self.package_manager.spawn_handler.assert_called_once_with(
 
89
                PackageChanger)
 
90
            self.package_manager.run.assert_called_once_with()
96
91
 
97
92
    def test_spawn_changer_on_run_if_message_accepted(self):
98
93
        """
102
97
        service = self.broker_service
103
98
        service.message_store.set_accepted_types(["change-packages-result"])
104
99
 
105
 
        package_manager_mock = self.mocker.patch(self.package_manager)
106
 
        package_manager_mock.spawn_handler(PackageChanger)
107
 
        self.mocker.count(2)  # Once for registration, then again explicitly.
108
 
        self.mocker.replay()
109
 
 
110
 
        self.manager.add(self.package_manager)
111
 
        return self.package_manager.run()
 
100
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
101
            self.manager.add(self.package_manager)
 
102
            self.package_manager.run()
 
103
            self.package_manager.spawn_handler.assert_called_with(
 
104
                PackageChanger)
 
105
            # Method is called once for registration, then again explicitly.
 
106
            self.assertEquals(2, self.package_manager.spawn_handler.call_count)
112
107
 
113
108
    def test_run_on_package_data_changed(self):
114
109
        """
119
114
        service = self.broker_service
120
115
        service.message_store.set_accepted_types(["change-packages-result"])
121
116
 
122
 
        package_manager_mock = self.mocker.patch(self.package_manager)
123
 
        package_manager_mock.spawn_handler(PackageChanger)
124
 
        self.mocker.count(2)  # Once for registration, then again explicitly.
125
 
        self.mocker.replay()
126
 
 
127
 
        self.manager.add(self.package_manager)
128
 
        return self.manager.reactor.fire("package-data-changed")[0]
 
117
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
118
            self.manager.add(self.package_manager)
 
119
            self.manager.reactor.fire("package-data-changed")[0]
 
120
            self.package_manager.spawn_handler.assert_called_with(
 
121
                PackageChanger)
 
122
            # Method is called once for registration, then again explicitly.
 
123
            self.assertEquals(2, self.package_manager.spawn_handler.call_count)
129
124
 
130
125
    def test_spawn_release_upgrader_on_run_if_message_accepted(self):
131
126
        """
135
130
        service = self.broker_service
136
131
        service.message_store.set_accepted_types(["operation-result"])
137
132
 
138
 
        package_manager_mock = self.mocker.patch(self.package_manager)
139
 
        package_manager_mock.spawn_handler(ReleaseUpgrader)
140
 
        self.mocker.count(2)  # Once for registration, then again explicitly.
141
 
        self.mocker.replay()
142
 
 
143
 
        self.manager.add(self.package_manager)
144
 
        return self.package_manager.run()
 
133
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
134
            self.manager.add(self.package_manager)
 
135
            self.package_manager.run()
 
136
            self.package_manager.spawn_handler.assert_called_with(
 
137
                ReleaseUpgrader)
 
138
            # Method is called once for registration, then again explicitly.
 
139
            self.assertEquals(2, self.package_manager.spawn_handler.call_count)
145
140
 
146
141
    def test_change_packages_handling(self):
147
142
        self.manager.add(self.package_manager)
148
143
 
149
 
        package_manager_mock = self.mocker.patch(self.package_manager)
150
 
        package_manager_mock.spawn_handler(PackageChanger)
151
 
        self.mocker.replay()
152
 
 
153
 
        message = {"type": "change-packages"}
154
 
        self.manager.dispatch_message(message)
155
 
        task = self.package_store.get_next_task("changer")
156
 
        self.assertTrue(task)
157
 
        self.assertEqual(task.data, message)
 
144
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
145
            message = {"type": "change-packages"}
 
146
            self.manager.dispatch_message(message)
 
147
            task = self.package_store.get_next_task("changer")
 
148
            self.assertTrue(task)
 
149
            self.assertEqual(task.data, message)
 
150
            self.package_manager.spawn_handler.assert_called_once_with(
 
151
                PackageChanger)
158
152
 
159
153
    def test_change_packages_handling_with_reboot(self):
160
154
        self.manager.add(self.package_manager)
161
155
 
162
 
        package_manager_mock = self.mocker.patch(self.package_manager)
163
 
        package_manager_mock.spawn_handler(PackageChanger)
164
 
        self.mocker.replay()
165
 
 
166
 
        message = {"type": "change-packages", "reboot-if-necessary": True}
167
 
        self.manager.dispatch_message(message)
168
 
        task = self.package_store.get_next_task("changer")
169
 
        self.assertTrue(task)
170
 
        self.assertEqual(task.data, message)
 
156
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
157
            message = {"type": "change-packages", "reboot-if-necessary": True}
 
158
            self.manager.dispatch_message(message)
 
159
            task = self.package_store.get_next_task("changer")
 
160
            self.assertTrue(task)
 
161
            self.assertEqual(task.data, message)
 
162
            self.package_manager.spawn_handler.assert_called_once_with(
 
163
                PackageChanger)
171
164
 
172
165
    def test_release_upgrade_handling(self):
173
166
        """
177
170
        """
178
171
        self.manager.add(self.package_manager)
179
172
 
180
 
        package_manager_mock = self.mocker.patch(self.package_manager)
181
 
        package_manager_mock.spawn_handler(ReleaseUpgrader)
182
 
        self.mocker.replay()
183
 
 
184
 
        message = {"type": "release-upgrade"}
185
 
        self.manager.dispatch_message(message)
186
 
        task = self.package_store.get_next_task("release-upgrader")
187
 
        self.assertTrue(task)
188
 
        self.assertEqual(task.data, message)
189
 
 
190
 
    def test_spawn_changer(self):
 
173
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
174
            message = {"type": "release-upgrade"}
 
175
            self.manager.dispatch_message(message)
 
176
            task = self.package_store.get_next_task("release-upgrader")
 
177
            self.assertTrue(task)
 
178
            self.assertEqual(task.data, message)
 
179
            self.package_manager.spawn_handler.assert_called_once_with(
 
180
                ReleaseUpgrader)
 
181
 
 
182
    @mock.patch("landscape.package.changer.find_changer_command")
 
183
    def test_spawn_changer(self, find_command_mock):
191
184
        """
192
185
        The L{PackageManager.spawn_handler} method executes the correct command
193
186
        when passed the L{PackageChanger} class as argument.
194
187
        """
195
188
        command = self.makeFile("#!/bin/sh\necho 'I am the changer!' >&2\n")
196
189
        os.chmod(command, 0755)
197
 
        find_command_mock = self.mocker.replace(find_changer_command)
198
 
        find_command_mock()
199
 
        self.mocker.result(command)
200
 
        self.mocker.replay()
 
190
        find_command_mock.return_value = command
201
191
 
202
192
        self.package_store.add_task("changer", "Do something!")
203
193
 
204
194
        self.manager.add(self.package_manager)
205
195
        result = self.package_manager.spawn_handler(PackageChanger)
 
196
        find_command_mock.assert_called_once_with()
206
197
 
207
198
        def got_result(result):
208
199
            log = self.logfile.getvalue()
211
202
 
212
203
        return result.addCallback(got_result)
213
204
 
214
 
    def test_spawn_release_upgrader(self):
 
205
    @mock.patch(
 
206
        "landscape.package.releaseupgrader.find_release_upgrader_command")
 
207
    def test_spawn_release_upgrader(self, find_command_mock):
215
208
        """
216
209
        The L{PackageManager.spawn_handler} method executes the correct command
217
210
        when passed the L{ReleaseUpgrader} class as argument.
218
211
        """
219
212
        command = self.makeFile("#!/bin/sh\necho 'I am the upgrader!' >&2\n")
220
213
        os.chmod(command, 0755)
221
 
        find_command_mock = self.mocker.replace(find_release_upgrader_command)
222
 
        find_command_mock()
223
 
        self.mocker.result(command)
224
 
        self.mocker.replay()
 
214
        find_command_mock.return_value = command
225
215
 
226
216
        self.package_store.add_task("release-upgrader", "Do something!")
227
 
 
228
217
        self.manager.add(self.package_manager)
229
218
        result = self.package_manager.spawn_handler(ReleaseUpgrader)
 
219
        find_command_mock.assert_called_once_with()
230
220
 
231
221
        def got_result(result):
232
222
            log = self.logfile.getvalue()
235
225
 
236
226
        return result.addCallback(got_result)
237
227
 
238
 
    def test_spawn_handler_without_output(self):
239
 
        find_command_mock = self.mocker.replace(find_changer_command)
240
 
        find_command_mock()
241
 
        self.mocker.result("/bin/true")
242
 
        self.mocker.replay()
 
228
    @mock.patch("landscape.package.changer.find_changer_command")
 
229
    def test_spawn_handler_without_output(self, find_command_mock):
 
230
        find_command_mock.return_value = "/bin/true"
243
231
 
244
232
        self.package_store.add_task("changer", "Do something!")
245
233
 
246
234
        self.manager.add(self.package_manager)
247
235
        result = self.package_manager.spawn_handler(PackageChanger)
 
236
        find_command_mock.assert_called_once_with()
248
237
 
249
238
        def got_result(result):
250
239
            log = self.logfile.getvalue()
252
241
 
253
242
        return result.addCallback(got_result)
254
243
 
255
 
    def test_spawn_handler_copies_environment(self):
 
244
    @mock.patch("landscape.package.changer.find_changer_command")
 
245
    def test_spawn_handler_copies_environment(self, find_command_mock):
256
246
        command = self.makeFile("#!/bin/sh\necho VAR: $VAR\n")
257
247
        os.chmod(command, 0755)
258
 
        find_command_mock = self.mocker.replace(find_changer_command)
259
 
        find_command_mock()
260
 
        self.mocker.result(command)
261
 
        self.mocker.replay()
 
248
        find_command_mock.return_value = command
262
249
 
263
250
        self.manager.add(self.package_manager)
264
 
 
265
251
        self.package_store.add_task("changer", "Do something!")
266
252
 
267
253
        os.environ["VAR"] = "HI!"
268
 
 
269
254
        result = self.package_manager.spawn_handler(PackageChanger)
 
255
        find_command_mock.assert_called_once_with()
270
256
 
271
257
        def got_result(result):
272
258
            log = self.logfile.getvalue()
275
261
 
276
262
        return result.addCallback(got_result)
277
263
 
278
 
    def test_spawn_handler_passes_quiet_option(self):
 
264
    @mock.patch("landscape.package.changer.find_changer_command")
 
265
    def test_spawn_handler_passes_quiet_option(self, find_command_mock):
279
266
        command = self.makeFile("#!/bin/sh\necho OPTIONS: $@\n")
280
267
        os.chmod(command, 0755)
281
 
        find_command_mock = self.mocker.replace(find_changer_command)
282
 
        find_command_mock()
283
 
        self.mocker.result(command)
284
 
        self.mocker.replay()
 
268
        find_command_mock.return_value = command
285
269
 
286
270
        self.manager.add(self.package_manager)
287
 
 
288
271
        self.package_store.add_task("changer", "Do something!")
289
 
 
290
272
        result = self.package_manager.spawn_handler(PackageChanger)
 
273
        find_command_mock.assert_called_once_with()
291
274
 
292
275
        def got_result(result):
293
276
            log = self.logfile.getvalue()
301
284
        os.chmod(command, 0755)
302
285
 
303
286
        self.manager.add(self.package_manager)
304
 
 
305
287
        result = self.package_manager.spawn_handler(PackageChanger)
306
288
 
307
289
        def got_result(result):
310
292
 
311
293
        return result.addCallback(got_result)
312
294
 
313
 
    def test_spawn_handler_doesnt_chdir(self):
 
295
    @mock.patch("landscape.package.changer.find_changer_command")
 
296
    def test_spawn_handler_doesnt_chdir(self, find_command_mock):
314
297
        command = self.makeFile("#!/bin/sh\necho RUN\n")
315
298
        os.chmod(command, 0755)
316
299
        cwd = os.getcwd()
319
302
        os.chdir(dir)
320
303
        os.chmod(dir, 0)
321
304
 
322
 
        find_command_mock = self.mocker.replace(find_changer_command)
323
 
        find_command_mock()
324
 
        self.mocker.result(command)
325
 
        self.mocker.replay()
 
305
        find_command_mock.return_value = command
326
306
 
327
307
        self.manager.add(self.package_manager)
328
 
 
329
308
        self.package_store.add_task("changer", "Do something!")
330
 
 
331
309
        result = self.package_manager.spawn_handler(PackageChanger)
 
310
        find_command_mock.assert_called_once_with()
332
311
 
333
312
        def got_result(result):
334
313
            log = self.logfile.getvalue()
346
325
        """
347
326
        self.manager.add(self.package_manager)
348
327
 
349
 
        package_manager_mock = self.mocker.patch(self.package_manager)
350
 
        package_manager_mock.spawn_handler(PackageChanger)
351
 
        self.mocker.replay()
352
 
 
353
 
        message = {"type": "change-package-locks"}
354
 
        self.manager.dispatch_message(message)
355
 
        task = self.package_store.get_next_task("changer")
356
 
        self.assertTrue(task)
357
 
        self.assertEqual(task.data, message)
 
328
        with mock.patch.object(self.package_manager, "spawn_handler"):
 
329
            message = {"type": "change-package-locks"}
 
330
            self.manager.dispatch_message(message)
 
331
            task = self.package_store.get_next_task("changer")
 
332
            self.assertTrue(task)
 
333
            self.assertEqual(task.data, message)
 
334
            self.package_manager.spawn_handler.assert_called_once_with(
 
335
                PackageChanger)