← Back to branch summary

~tomasgroth/openlp/portable-path

« back to all changes in this revision

Viewing changes to tests/openlp_core/projectors/test_projector_pjlink_udp.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/openlp_core/projectors/test_projector_pjlink_udp.py
5
5
###############################################################################
6
6
# OpenLP - Open Source Lyrics Projection                                      #
7
7
# --------------------------------------------------------------------------- #
8
 
# Copyright (c) 2008-2018 OpenLP Developers                                   #
 
8
# Copyright (c) 2008-2019 OpenLP Developers                                   #
9
9
# --------------------------------------------------------------------------- #
10
10
# This program is free software; you can redistribute it and/or modify it     #
11
11
# under the terms of the GNU General Public License as published by the Free  #
28
28
from unittest.mock import call, patch
29
29
 
30
30
import openlp.core.projectors.pjlink
 
31
from openlp.core.common.registry import Registry
31
32
from openlp.core.projectors.constants import PJLINK_PORT
32
 
 
33
33
from openlp.core.projectors.pjlink import PJLinkUDP
 
34
from openlp.core.projectors.tab import ProjectorTab
 
35
 
 
36
from tests.helpers.testmixin import TestMixin
34
37
from tests.resources.projector.data import TEST1_DATA
35
38
 
36
39
 
37
 
class TestPJLinkBase(TestCase):
 
40
class TestPJLinkBase(TestCase, TestMixin):
38
41
    """
39
42
    Tests for the PJLinkUDP class
40
43
    """
 
44
    def setUp(self):
 
45
        """
 
46
        Create the UI and setup necessary options
 
47
        """
 
48
        self.setup_application()
 
49
        self.build_settings()
 
50
        Registry.create()
 
51
        """
 
52
        with patch('openlp.core.projectors.db.init_url') as mocked_init_url:
 
53
            if os.path.exists(TEST_DB):
 
54
                os.unlink(TEST_DB)
 
55
            mocked_init_url.return_value = 'sqlite:///%s' % TEST_DB
 
56
            self.projectordb = ProjectorDB()
 
57
            if not hasattr(self, 'projector_manager'):
 
58
                self.projector_manager = ProjectorManager(projectordb=self.projectordb)
 
59
        """
 
60
 
 
61
    def tearDown(self):
 
62
        """
 
63
        Remove test database.
 
64
        Delete all the C++ objects at the end so that we don't have a segfault.
 
65
        """
 
66
        # self.projectordb.session.close()
 
67
        self.destroy_settings()
 
68
        # del self.projector_manager
 
69
 
41
70
    @patch.object(openlp.core.projectors.pjlink, 'log')
42
71
    def test_get_datagram_data_negative_zero_length(self, mock_log):
43
72
        """
45
74
        """
46
75
        # GIVEN: Test setup
47
76
        pjlink_udp = PJLinkUDP()
48
 
        log_warning_calls = [call('(UDP) No data (-1)')]
49
 
        log_debug_calls = [call('(UDP) PJLinkUDP() Initialized for port 4352'),
50
 
                           call('(UDP) get_datagram() - Receiving data')]
 
77
        log_warning_calls = [call('(UDP:4352) No data (-1)')]
 
78
        log_debug_calls = [call('(UDP:4352) PJLinkUDP() Initialized'),
 
79
                           call('(UDP:4352) get_datagram() - Receiving data')]
51
80
        with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
52
81
                patch.object(pjlink_udp, 'readDatagram') as mock_read:
53
82
            mock_datagram.return_value = -1
67
96
        """
68
97
        # GIVEN: Test setup
69
98
        pjlink_udp = PJLinkUDP()
70
 
        log_warning_calls = [call('(UDP) get_datagram() called when pending data size is 0')]
71
 
        log_debug_calls = [call('(UDP) PJLinkUDP() Initialized for port 4352'),
72
 
                           call('(UDP) get_datagram() - Receiving data')]
 
99
        log_warning_calls = [call('(UDP:4352) get_datagram() called when pending data size is 0')]
 
100
        log_debug_calls = [call('(UDP:4352) PJLinkUDP() Initialized'),
 
101
                           call('(UDP:4352) get_datagram() - Receiving data')]
73
102
        with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
74
103
                patch.object(pjlink_udp, 'readDatagram') as mock_read:
75
104
            mock_datagram.return_value = 0
89
118
        """
90
119
        # GIVEN: Test setup
91
120
        pjlink_udp = PJLinkUDP()
92
 
        log_warning_calls = [call('(UDP) get_datagram() called when pending data size is 0')]
93
 
        log_debug_calls = [call('(UDP) PJLinkUDP() Initialized for port 4352'),
94
 
                           call('(UDP) get_datagram() - Receiving data')]
 
121
        log_warning_calls = [call('(UDP:4352) get_datagram() called when pending data size is 0')]
 
122
        log_debug_calls = [call('(UDP:4352) PJLinkUDP() Initialized'),
 
123
                           call('(UDP:4352) get_datagram() - Receiving data')]
95
124
        with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram:
96
125
            mock_datagram.return_value = 0
97
126
 
101
130
            # THEN: Log entries should be made and method returns
102
131
            mock_log.warning.assert_has_calls(log_warning_calls)
103
132
            mock_log.debug.assert_has_calls(log_debug_calls)
 
133
 
 
134
    @patch.object(openlp.core.projectors.tab, 'log')
 
135
    def test_pjlinksettings_add_udp_listener(self, mock_log):
 
136
        """
 
137
        Test adding UDP listners to PJLink Settings tab
 
138
        """
 
139
        # GIVEN: Initial setup
 
140
        log_debug_calls = [call('PJLink settings tab initialized'),
 
141
                           call('PJLinkSettings: new callback list: dict_keys([4352])')]
 
142
        log_warning_calls = []
 
143
 
 
144
        pjlink_udp = PJLinkUDP()
 
145
        settings_tab = ProjectorTab(parent=None)
 
146
 
 
147
        # WHEN: add_udp_listener is called with single port
 
148
        settings_tab.add_udp_listener(port=pjlink_udp.port, callback=pjlink_udp.check_settings)
 
149
 
 
150
        # THEN: settings tab should have one entry
 
151
        assert len(settings_tab.udp_listeners) == 1
 
152
        assert pjlink_udp.port in settings_tab.udp_listeners
 
153
        mock_log.debug.assert_has_calls(log_debug_calls)
 
154
        mock_log.warning.assert_has_calls(log_warning_calls)
 
155
 
 
156
    @patch.object(openlp.core.projectors.tab, 'log')
 
157
    def test_pjlinksettings_add_udp_listener_multiple_same(self, mock_log):
 
158
        """
 
159
        Test adding second UDP listner with same port to PJLink Settings tab
 
160
        """
 
161
        # GIVEN: Initial setup
 
162
        log_debug_calls = [call('PJLink settings tab initialized'),
 
163
                           call('PJLinkSettings: new callback list: dict_keys([4352])')]
 
164
        log_warning_calls = [call('Port 4352 already in list - not adding')]
 
165
        pjlink_udp = PJLinkUDP()
 
166
        settings_tab = ProjectorTab(parent=None)
 
167
        settings_tab.add_udp_listener(port=pjlink_udp.port, callback=pjlink_udp.check_settings)
 
168
 
 
169
        # WHEN: add_udp_listener is called with second instance same port
 
170
        settings_tab.add_udp_listener(port=pjlink_udp.port, callback=pjlink_udp.check_settings)
 
171
 
 
172
        # THEN: settings tab should have one entry
 
173
        assert len(settings_tab.udp_listeners) == 1
 
174
        assert pjlink_udp.port in settings_tab.udp_listeners
 
175
        mock_log.debug.assert_has_calls(log_debug_calls)
 
176
        mock_log.warning.assert_has_calls(log_warning_calls)
 
177
 
 
178
    @patch.object(openlp.core.projectors.tab, 'log')
 
179
    def test_pjlinksettings_add_udp_listener_multiple_different(self, mock_log):
 
180
        """
 
181
        Test adding second UDP listner with different port to PJLink Settings tab
 
182
        """
 
183
        # GIVEN: Initial setup
 
184
        log_debug_calls = [call('PJLink settings tab initialized'),
 
185
                           call('PJLinkSettings: new callback list: dict_keys([4352])')]
 
186
        log_warning_calls = []
 
187
 
 
188
        settings_tab = ProjectorTab(parent=None)
 
189
        pjlink_udp1 = PJLinkUDP(port=4352)
 
190
        settings_tab.add_udp_listener(port=pjlink_udp1.port, callback=pjlink_udp1.check_settings)
 
191
 
 
192
        # WHEN: add_udp_listener is called with second instance different port
 
193
        pjlink_udp2 = PJLinkUDP(port=4353)
 
194
        settings_tab.add_udp_listener(port=pjlink_udp2.port, callback=pjlink_udp2.check_settings)
 
195
 
 
196
        # THEN: settings tab should have two entry
 
197
        assert len(settings_tab.udp_listeners) == 2
 
198
        assert pjlink_udp1.port in settings_tab.udp_listeners
 
199
        assert pjlink_udp2.port in settings_tab.udp_listeners
 
200
        mock_log.debug.assert_has_calls(log_debug_calls)
 
201
        mock_log.warning.assert_has_calls(log_warning_calls)
 
202
 
 
203
    @patch.object(openlp.core.projectors.tab, 'log')
 
204
    def test_pjlinksettings_remove_udp_listener(self, mock_log):
 
205
        """
 
206
        Test removing UDP listners to PJLink Settings tab
 
207
        """
 
208
        # GIVEN: Initial setup
 
209
        log_debug_calls = [call('PJLink settings tab initialized'),
 
210
                           call('PJLinkSettings: new callback list: dict_keys([4352])'),
 
211
                           call('PJLinkSettings: new callback list: dict_keys([])')]
 
212
        log_warning_calls = []
 
213
 
 
214
        pjlink_udp = PJLinkUDP()
 
215
        settings_tab = ProjectorTab(parent=None)
 
216
        settings_tab.add_udp_listener(port=pjlink_udp.port, callback=pjlink_udp.check_settings)
 
217
 
 
218
        # WHEN: remove_udp_listener is called with single port
 
219
        settings_tab.remove_udp_listener(port=pjlink_udp.port)
 
220
 
 
221
        # THEN: settings tab should have one entry
 
222
        assert len(settings_tab.udp_listeners) == 0
 
223
        mock_log.debug.assert_has_calls(log_debug_calls)
 
224
        mock_log.warning.assert_has_calls(log_warning_calls)
 
225
 
 
226
    @patch.object(openlp.core.projectors.tab, 'log')
 
227
    def test_pjlinksettings_remove_udp_listener_multiple_different(self, mock_log):
 
228
        """
 
229
        Test adding second UDP listner with different port to PJLink Settings tab
 
230
        """
 
231
        # GIVEN: Initial setup
 
232
        log_debug_calls = [call('PJLink settings tab initialized'),
 
233
                           call('PJLinkSettings: new callback list: dict_keys([4352])')]
 
234
        log_warning_calls = []
 
235
 
 
236
        settings_tab = ProjectorTab(parent=None)
 
237
        pjlink_udp1 = PJLinkUDP(port=4352)
 
238
        settings_tab.add_udp_listener(port=pjlink_udp1.port, callback=pjlink_udp1.check_settings)
 
239
        pjlink_udp2 = PJLinkUDP(port=4353)
 
240
        settings_tab.add_udp_listener(port=pjlink_udp2.port, callback=pjlink_udp2.check_settings)
 
241
 
 
242
        # WHEN: remove_udp_listener called for one port
 
243
        settings_tab.remove_udp_listener(port=4353)
 
244
 
 
245
        # THEN: settings tab should have one entry
 
246
        assert len(settings_tab.udp_listeners) == 1
 
247
        assert pjlink_udp1.port in settings_tab.udp_listeners
 
248
        assert pjlink_udp2.port not in settings_tab.udp_listeners
 
249
        mock_log.debug.assert_has_calls(log_debug_calls)
 
250
        mock_log.warning.assert_has_calls(log_warning_calls)
 
251
 
 
252
    @patch.object(PJLinkUDP, 'check_settings')
 
253
    @patch.object(openlp.core.projectors.pjlink, 'log')
 
254
    @patch.object(openlp.core.projectors.tab, 'log')
 
255
    def test_pjlinksettings_call_udp_listener(self, mock_tab_log, mock_pjlink_log, mock_check_settings):
 
256
        """
 
257
        Test calling UDP listners in PJLink Settings tab
 
258
        """
 
259
        # GIVEN: Initial setup
 
260
        tab_debug_calls = [call('PJLink settings tab initialized'),
 
261
                           call('PJLinkSettings: new callback list: dict_keys([4352])'),
 
262
                           call('PJLinkSettings: Calling UDP listeners')]
 
263
        pjlink_debug_calls = [call.debug('(UDP:4352) PJLinkUDP() Initialized')]
 
264
 
 
265
        pjlink_udp = PJLinkUDP()
 
266
        settings_tab = ProjectorTab(parent=None)
 
267
        settings_tab.add_udp_listener(port=pjlink_udp.port, callback=pjlink_udp.check_settings)
 
268
 
 
269
        # WHEN: calling UDP listener via registry
 
270
        settings_tab.call_udp_listener()
 
271
 
 
272
        # THEN: settings tab should have one entry
 
273
        assert len(settings_tab.udp_listeners) == 1
 
274
        mock_check_settings.assert_called()
 
275
        mock_tab_log.debug.assert_has_calls(tab_debug_calls)
 
276
        mock_pjlink_log.assert_has_calls(pjlink_debug_calls)