3
4
from twisted.internet.defer import Deferred
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
10
10
from landscape.manager.packagemanager import PackageManager
35
35
self.assertFalse(os.path.isfile(filename))
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))
43
43
def test_dont_spawn_changer_if_message_not_accepted(self):
46
46
appropriate message type is accepted.
48
48
self.manager.add(self.package_manager)
50
package_manager_mock = self.mocker.patch(self.package_manager)
51
package_manager_mock.spawn_handler(PackageChanger)
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)
58
55
def test_dont_spawn_release_upgrader_if_message_not_accepted(self):
61
58
appropriate message type is accepted.
63
60
self.manager.add(self.package_manager)
65
package_manager_mock = self.mocker.patch(self.package_manager)
66
package_manager_mock.spawn_handler(ReleaseUpgrader)
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)
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
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()
83
def run_has_run(run_result_deferred):
77
run_result_deferred = real_run()
84
78
return run_result_deferred.chainDeferred(deferred)
86
package_manager_mock.run()
87
self.mocker.passthrough(run_has_run)
91
service = self.broker_service
92
service.message_store.set_accepted_types(["change-packages-result"])
93
self.manager.add(self.package_manager)
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(
90
self.package_manager.run.assert_called_once_with()
97
92
def test_spawn_changer_on_run_if_message_accepted(self):
102
97
service = self.broker_service
103
98
service.message_store.set_accepted_types(["change-packages-result"])
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.
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(
105
# Method is called once for registration, then again explicitly.
106
self.assertEquals(2, self.package_manager.spawn_handler.call_count)
113
108
def test_run_on_package_data_changed(self):
119
114
service = self.broker_service
120
115
service.message_store.set_accepted_types(["change-packages-result"])
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.
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(
122
# Method is called once for registration, then again explicitly.
123
self.assertEquals(2, self.package_manager.spawn_handler.call_count)
130
125
def test_spawn_release_upgrader_on_run_if_message_accepted(self):
135
130
service = self.broker_service
136
131
service.message_store.set_accepted_types(["operation-result"])
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.
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(
138
# Method is called once for registration, then again explicitly.
139
self.assertEquals(2, self.package_manager.spawn_handler.call_count)
146
141
def test_change_packages_handling(self):
147
142
self.manager.add(self.package_manager)
149
package_manager_mock = self.mocker.patch(self.package_manager)
150
package_manager_mock.spawn_handler(PackageChanger)
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(
159
153
def test_change_packages_handling_with_reboot(self):
160
154
self.manager.add(self.package_manager)
162
package_manager_mock = self.mocker.patch(self.package_manager)
163
package_manager_mock.spawn_handler(PackageChanger)
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(
172
165
def test_release_upgrade_handling(self):
178
171
self.manager.add(self.package_manager)
180
package_manager_mock = self.mocker.patch(self.package_manager)
181
package_manager_mock.spawn_handler(ReleaseUpgrader)
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)
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(
182
@mock.patch("landscape.package.changer.find_changer_command")
183
def test_spawn_changer(self, find_command_mock):
192
185
The L{PackageManager.spawn_handler} method executes the correct command
193
186
when passed the L{PackageChanger} class as argument.
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)
199
self.mocker.result(command)
190
find_command_mock.return_value = command
202
192
self.package_store.add_task("changer", "Do something!")
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()
207
198
def got_result(result):
208
199
log = self.logfile.getvalue()
212
203
return result.addCallback(got_result)
214
def test_spawn_release_upgrader(self):
206
"landscape.package.releaseupgrader.find_release_upgrader_command")
207
def test_spawn_release_upgrader(self, find_command_mock):
216
209
The L{PackageManager.spawn_handler} method executes the correct command
217
210
when passed the L{ReleaseUpgrader} class as argument.
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)
223
self.mocker.result(command)
214
find_command_mock.return_value = command
226
216
self.package_store.add_task("release-upgrader", "Do something!")
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()
231
221
def got_result(result):
232
222
log = self.logfile.getvalue()
236
226
return result.addCallback(got_result)
238
def test_spawn_handler_without_output(self):
239
find_command_mock = self.mocker.replace(find_changer_command)
241
self.mocker.result("/bin/true")
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"
244
232
self.package_store.add_task("changer", "Do something!")
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()
249
238
def got_result(result):
250
239
log = self.logfile.getvalue()
253
242
return result.addCallback(got_result)
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)
260
self.mocker.result(command)
248
find_command_mock.return_value = command
263
250
self.manager.add(self.package_manager)
265
251
self.package_store.add_task("changer", "Do something!")
267
253
os.environ["VAR"] = "HI!"
269
254
result = self.package_manager.spawn_handler(PackageChanger)
255
find_command_mock.assert_called_once_with()
271
257
def got_result(result):
272
258
log = self.logfile.getvalue()
276
262
return result.addCallback(got_result)
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)
283
self.mocker.result(command)
268
find_command_mock.return_value = command
286
270
self.manager.add(self.package_manager)
288
271
self.package_store.add_task("changer", "Do something!")
290
272
result = self.package_manager.spawn_handler(PackageChanger)
273
find_command_mock.assert_called_once_with()
292
275
def got_result(result):
293
276
log = self.logfile.getvalue()
322
find_command_mock = self.mocker.replace(find_changer_command)
324
self.mocker.result(command)
305
find_command_mock.return_value = command
327
307
self.manager.add(self.package_manager)
329
308
self.package_store.add_task("changer", "Do something!")
331
309
result = self.package_manager.spawn_handler(PackageChanger)
310
find_command_mock.assert_called_once_with()
333
312
def got_result(result):
334
313
log = self.logfile.getvalue()
347
326
self.manager.add(self.package_manager)
349
package_manager_mock = self.mocker.patch(self.package_manager)
350
package_manager_mock.spawn_handler(PackageChanger)
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(