← Back to branch summary

~tomasgroth/openlp/portable-path

« back to all changes in this revision

Viewing changes to tests/functional/openlp_core/lib/test_pluginmanager.py

  • Committer: Tomas Groth
  • Date: 2019-04-30 19:02:42 UTC
  • mfrom: (2829.2.32 openlp)
  • Revision ID: tomasgroth@yahoo.dk-20190430190242-6zwjk8724tyux70m
trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/functional/openlp_core/lib/test_pluginmanager.py
4
4
###############################################################################
5
5
# OpenLP - Open Source Lyrics Projection                                      #
6
6
# --------------------------------------------------------------------------- #
7
 
# Copyright (c) 2008-2017 OpenLP Developers                                   #
 
7
# Copyright (c) 2008-2019 OpenLP Developers                                   #
8
8
# --------------------------------------------------------------------------- #
9
9
# This program is free software; you can redistribute it and/or modify it     #
10
10
# under the terms of the GNU General Public License as published by the Free  #
25
25
from unittest import TestCase
26
26
from unittest.mock import MagicMock, patch
27
27
 
 
28
from openlp.core.state import State
28
29
from openlp.core.common.registry import Registry
29
30
from openlp.core.common.settings import Settings
30
 
from openlp.core.lib import PluginStatus
 
31
from openlp.core.lib.plugin import PluginStatus
31
32
from openlp.core.lib.pluginmanager import PluginManager
32
33
 
33
34
 
46
47
        self.mocked_main_window.file_export_menu.return_value = None
47
48
        self.mocked_settings_form = MagicMock()
48
49
        Registry.create()
 
50
        State().load_settings()
49
51
        Registry().register('service_list', MagicMock())
50
52
        Registry().register('main_window', self.mocked_main_window)
51
53
        Registry().register('settings_form', self.mocked_settings_form)
57
59
        # GIVEN: A plugin manager with some mocked out methods
58
60
        manager = PluginManager()
59
61
 
60
 
        with patch.object(manager, 'find_plugins') as mocked_find_plugins, \
61
 
                patch.object(manager, 'hook_settings_tabs') as mocked_hook_settings_tabs, \
 
62
        with patch.object(manager, 'hook_settings_tabs') as mocked_hook_settings_tabs, \
62
63
                patch.object(manager, 'hook_media_manager') as mocked_hook_media_manager, \
63
64
                patch.object(manager, 'hook_import_menu') as mocked_hook_import_menu, \
64
65
                patch.object(manager, 'hook_export_menu') as mocked_hook_export_menu, \
66
67
                patch.object(manager, 'initialise_plugins') as mocked_initialise_plugins:
67
68
            # WHEN: bootstrap_initialise() is called
68
69
            manager.bootstrap_initialise()
 
70
            manager.bootstrap_post_set_up()
69
71
 
70
72
        # THEN: The hook methods should have been called
71
 
        mocked_find_plugins.assert_called_with()
72
73
        mocked_hook_settings_tabs.assert_called_with()
73
74
        mocked_hook_media_manager.assert_called_with()
74
75
        mocked_hook_import_menu.assert_called_with()
84
85
        mocked_plugin = MagicMock()
85
86
        mocked_plugin.status = PluginStatus.Disabled
86
87
        plugin_manager = PluginManager()
87
 
        plugin_manager.plugins = [mocked_plugin]
 
88
        Registry().register('mock_plugin', mocked_plugin)
 
89
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Disabled)
 
90
        State().flush_preconditions()
88
91
 
89
92
        # WHEN: We run hook_media_manager()
90
93
        plugin_manager.hook_media_manager()
101
104
        mocked_plugin = MagicMock()
102
105
        mocked_plugin.status = PluginStatus.Active
103
106
        plugin_manager = PluginManager()
104
 
        plugin_manager.plugins = [mocked_plugin]
 
107
        Registry().register('mock_plugin', mocked_plugin)
 
108
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
109
        State().flush_preconditions()
105
110
 
106
111
        # WHEN: We run hook_media_manager()
107
112
        plugin_manager.hook_media_manager()
117
122
        mocked_plugin = MagicMock()
118
123
        mocked_plugin.status = PluginStatus.Disabled
119
124
        plugin_manager = PluginManager()
120
 
        plugin_manager.plugins = [mocked_plugin]
 
125
        Registry().register('mock_plugin', mocked_plugin)
 
126
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
127
        State().flush_preconditions()
121
128
 
122
129
        # WHEN: We run hook_settings_tabs()
123
130
        plugin_manager.hook_settings_tabs()
134
141
        mocked_plugin = MagicMock()
135
142
        mocked_plugin.status = PluginStatus.Disabled
136
143
        plugin_manager = PluginManager()
137
 
        plugin_manager.plugins = [mocked_plugin]
 
144
        Registry().register('mock_plugin', mocked_plugin)
138
145
        mocked_settings_form = MagicMock()
139
146
        # Replace the autoloaded plugin with the version for testing in real code this would error
140
147
        mocked_settings_form.plugin_manager = plugin_manager
 
148
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
149
        State().flush_preconditions()
141
150
 
142
151
        # WHEN: We run hook_settings_tabs()
143
152
        plugin_manager.hook_settings_tabs()
156
165
        mocked_plugin = MagicMock()
157
166
        mocked_plugin.status = PluginStatus.Active
158
167
        plugin_manager = PluginManager()
159
 
        plugin_manager.plugins = [mocked_plugin]
 
168
        Registry().register('mock_plugin', mocked_plugin)
160
169
        mocked_settings_form = MagicMock()
161
170
        # Replace the autoloaded plugin with the version for testing in real code this would error
162
171
        mocked_settings_form.plugin_manager = plugin_manager
 
172
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
173
        State().flush_preconditions()
163
174
 
164
175
        # WHEN: We run hook_settings_tabs()
165
176
        plugin_manager.hook_settings_tabs()
178
189
        mocked_plugin = MagicMock()
179
190
        mocked_plugin.status = PluginStatus.Active
180
191
        plugin_manager = PluginManager()
181
 
        plugin_manager.plugins = [mocked_plugin]
 
192
        Registry().register('mock_plugin', mocked_plugin)
 
193
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
194
        State().flush_preconditions()
182
195
 
183
196
        # WHEN: We run hook_settings_tabs()
184
197
        plugin_manager.hook_settings_tabs()
194
207
        mocked_plugin = MagicMock()
195
208
        mocked_plugin.status = PluginStatus.Disabled
196
209
        plugin_manager = PluginManager()
197
 
        plugin_manager.plugins = [mocked_plugin]
 
210
        Registry().register('mock_plugin', mocked_plugin)
 
211
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
212
        State().flush_preconditions()
198
213
 
199
214
        # WHEN: We run hook_import_menu()
200
215
        plugin_manager.hook_import_menu()
211
226
        mocked_plugin = MagicMock()
212
227
        mocked_plugin.status = PluginStatus.Active
213
228
        plugin_manager = PluginManager()
214
 
        plugin_manager.plugins = [mocked_plugin]
 
229
        Registry().register('mock_plugin', mocked_plugin)
 
230
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
231
        State().flush_preconditions()
215
232
 
216
233
        # WHEN: We run hook_import_menu()
217
234
        plugin_manager.hook_import_menu()
227
244
        mocked_plugin = MagicMock()
228
245
        mocked_plugin.status = PluginStatus.Disabled
229
246
        plugin_manager = PluginManager()
230
 
        plugin_manager.plugins = [mocked_plugin]
 
247
        Registry().register('mock_plugin', mocked_plugin)
 
248
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
249
        State().flush_preconditions()
231
250
 
232
251
        # WHEN: We run hook_export_menu()
233
252
        plugin_manager.hook_export_menu()
244
263
        mocked_plugin = MagicMock()
245
264
        mocked_plugin.status = PluginStatus.Active
246
265
        plugin_manager = PluginManager()
247
 
        plugin_manager.plugins = [mocked_plugin]
 
266
        Registry().register('mock_plugin', mocked_plugin)
 
267
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
268
        State().flush_preconditions()
248
269
 
249
270
        # WHEN: We run hook_export_menu()
250
271
        plugin_manager.hook_export_menu()
260
281
        mocked_plugin = MagicMock()
261
282
        mocked_plugin.status = PluginStatus.Disabled
262
283
        plugin_manager = PluginManager()
263
 
        plugin_manager.plugins = [mocked_plugin]
 
284
        Registry().register('mock_plugin', mocked_plugin)
 
285
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
286
        State().flush_preconditions()
264
287
        settings = Settings()
265
288
 
266
289
        # WHEN: We run hook_upgrade_plugin_settings()
278
301
        mocked_plugin = MagicMock()
279
302
        mocked_plugin.status = PluginStatus.Active
280
303
        plugin_manager = PluginManager()
281
 
        plugin_manager.plugins = [mocked_plugin]
 
304
        Registry().register('mock_plugin', mocked_plugin)
 
305
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
306
        State().flush_preconditions()
282
307
        settings = Settings()
283
308
 
284
309
        # WHEN: We run hook_upgrade_plugin_settings()
295
320
        mocked_plugin = MagicMock()
296
321
        mocked_plugin.status = PluginStatus.Disabled
297
322
        plugin_manager = PluginManager()
298
 
        plugin_manager.plugins = [mocked_plugin]
 
323
        Registry().register('mock_plugin', mocked_plugin)
 
324
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
325
        State().flush_preconditions()
299
326
 
300
327
        # WHEN: We run hook_tools_menu()
301
328
        plugin_manager.hook_tools_menu()
312
339
        mocked_plugin = MagicMock()
313
340
        mocked_plugin.status = PluginStatus.Active
314
341
        plugin_manager = PluginManager()
315
 
        plugin_manager.plugins = [mocked_plugin]
 
342
        Registry().register('mock_plugin', mocked_plugin)
 
343
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
344
        State().flush_preconditions()
316
345
 
317
346
        # WHEN: We run hook_tools_menu()
318
347
        plugin_manager.hook_tools_menu()
329
358
        mocked_plugin.status = PluginStatus.Disabled
330
359
        mocked_plugin.is_active.return_value = False
331
360
        plugin_manager = PluginManager()
332
 
        plugin_manager.plugins = [mocked_plugin]
 
361
        Registry().register('mock_plugin', mocked_plugin)
 
362
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
363
        State().flush_preconditions()
333
364
 
334
365
        # WHEN: We run initialise_plugins()
335
366
        plugin_manager.initialise_plugins()
347
378
        mocked_plugin.status = PluginStatus.Active
348
379
        mocked_plugin.is_active.return_value = True
349
380
        plugin_manager = PluginManager()
350
 
        plugin_manager.plugins = [mocked_plugin]
 
381
        Registry().register('mock_plugin', mocked_plugin)
 
382
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
383
        State().flush_preconditions()
351
384
 
352
385
        # WHEN: We run initialise_plugins()
353
386
        plugin_manager.initialise_plugins()
365
398
        mocked_plugin.status = PluginStatus.Disabled
366
399
        mocked_plugin.is_active.return_value = False
367
400
        plugin_manager = PluginManager()
368
 
        plugin_manager.plugins = [mocked_plugin]
 
401
        Registry().register('mock_plugin', mocked_plugin)
 
402
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
403
        State().flush_preconditions()
369
404
 
370
405
        # WHEN: We run finalise_plugins()
371
406
        plugin_manager.finalise_plugins()
383
418
        mocked_plugin.status = PluginStatus.Active
384
419
        mocked_plugin.is_active.return_value = True
385
420
        plugin_manager = PluginManager()
386
 
        plugin_manager.plugins = [mocked_plugin]
 
421
        Registry().register('mock_plugin', mocked_plugin)
 
422
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
423
        State().flush_preconditions()
387
424
 
388
425
        # WHEN: We run finalise_plugins()
389
426
        plugin_manager.finalise_plugins()
400
437
        mocked_plugin = MagicMock()
401
438
        mocked_plugin.name = 'Mocked Plugin'
402
439
        plugin_manager = PluginManager()
403
 
        plugin_manager.plugins = [mocked_plugin]
 
440
        Registry().register('mock_plugin', mocked_plugin)
 
441
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
442
        State().flush_preconditions()
404
443
 
405
444
        # WHEN: We run finalise_plugins()
406
445
        result = plugin_manager.get_plugin_by_name('Missing Plugin')
416
455
        mocked_plugin = MagicMock()
417
456
        mocked_plugin.name = 'Mocked Plugin'
418
457
        plugin_manager = PluginManager()
419
 
        plugin_manager.plugins = [mocked_plugin]
 
458
        Registry().register('mock_plugin', mocked_plugin)
 
459
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
460
        State().flush_preconditions()
420
461
 
421
462
        # WHEN: We run finalise_plugins()
422
463
        result = plugin_manager.get_plugin_by_name('Mocked Plugin')
433
474
        mocked_plugin.status = PluginStatus.Disabled
434
475
        mocked_plugin.is_active.return_value = False
435
476
        plugin_manager = PluginManager()
436
 
        plugin_manager.plugins = [mocked_plugin]
 
477
        Registry().register('mock_plugin', mocked_plugin)
 
478
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
479
        State().flush_preconditions()
437
480
 
438
481
        # WHEN: We run finalise_plugins()
439
482
        plugin_manager.new_service_created()
452
495
        mocked_plugin.status = PluginStatus.Active
453
496
        mocked_plugin.is_active.return_value = True
454
497
        plugin_manager = PluginManager()
455
 
        plugin_manager.plugins = [mocked_plugin]
 
498
        Registry().register('mock_plugin', mocked_plugin)
 
499
        State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
 
500
        State().flush_preconditions()
456
501
 
457
502
        # WHEN: We run new_service_created()
458
503
        plugin_manager.new_service_created()