OpenLP

Merge lp:~alisonken1/openlp/pjlink2-q into lp:openlp

  1. pjlink2-q
  2. Merge into trunk
Proposed by Ken Roberts
Status: Superseded
Proposed branch: lp:~alisonken1/openlp/pjlink2-q
Merge into: lp:openlp
Diff against target: 1438 lines (+415/-482)
8 files modified
openlp/core/projectors/constants.py (+53/-26)
openlp/core/projectors/editform.py (+21/-8)
openlp/core/projectors/manager.py (+3/-18)
openlp/core/projectors/pjlink.py (+157/-149)
tests/openlp_core/projectors/test_projector_db.py (+35/-2)
tests/openlp_core/projectors/test_projector_pjlink_cmd_routing.py (+21/-21)
tests/openlp_core/projectors/test_projector_pjlink_commands_02.py (+115/-4)
tests/openlp_core/projectors/test_projector_pjlink_udp.py (+10/-254)
To merge this branch: bzr merge lp:~alisonken1/openlp/pjlink2-q
Reviewer Review Type Date Requested Status
Tim Bentley Needs Fixing
Review via email: mp+341563@code.launchpad.net

This proposal has been superseded by a proposal from 2018-03-24.

Commit message

PJLink2 update Q

Description of the change

PJLink2 update Q

--------------------------------------------------------------------------------
lp:~alisonken1/openlp/pjlink2-q (revision 2814)
https://ci.openlp.io/job/Branch-01-Pull/2479/ [SUCCESS]
https://ci.openlp.io/job/Branch-02a-Linux-Tests/2380/ [SUCCESS]
https://ci.openlp.io/job/Branch-02b-macOS-Tests/167/ [FAILURE]
https://ci.openlp.io/job/Branch-03a-Build-Source/89/ [SUCCESS]
https://ci.openlp.io/job/Branch-03b-Build-macOS/82/ [SUCCESS]
https://ci.openlp.io/job/Branch-04a-Code-Analysis/1551/ [SUCCESS]
https://ci.openlp.io/job/Branch-04b-Test-Coverage/1364/ [SUCCESS]
https://ci.openlp.io/job/Branch-05-AppVeyor-Tests/296/ [FAILURE]

- Fix test_projector_db:TestProjectorDBUpdate segfault by
    creating self.main_window steps
- Pep8 on openlp/core/common/__init__.get_local_ip4()
- Collapse import from projector.constants from line-per-item to multi-items-per-line
- Change pjlink_functions to include class version for projector instance in command
- Set projector.editform to only allow editing IP address field for new entry only (used as db key entry)
- Collapse projector.manager imports from entry-per-line to compact import
- projector.pjlink:
    - Merge pjlink_functions_udp into pjlink_functions
    - Change pjlink_functions to add instance-specific version to commands
    - Fix command checks to changed pjlink_funcions
    - Update process_clss to update PJLink version in pjlink_functions
    - Update reset_information to update PJLink version in pjlink_functions
- renamed test_projectorsourceform.py to test_projector_sourceform.py
- renamed test_projectoreditform.py to test_projector_editform.py
- Fix projector tests

To post a comment you must log in.
lp:~alisonken1/openlp/pjlink2-q updated
2814. By Tim Bentley

Add some small items from wish lists
Various cleanups.

--------------------------------------------------------------------------------
lp:~trb143/openlp/cleanups02182 (revision 2835)
https://ci.openlp.io/job/Branch-01-Pull/2480/ [SUCCESS]
https://ci.openlp.io/job/Branch-02a-Linux-Tests/2381/ [SUCCESS]
https://ci.openlp.io/job/Branch-02b-macOS-Tests/168/ [FAILURE]
https://ci.openlp.io/job/Branch-03a-Build-Source/90/ ...

Revision history for this message
Tim Bentley (trb143) wrote :

Sorry will clash with one of my fixes which has been merged

See question

review: Needs Fixing
Revision history for this message
Ken Roberts (alisonken1) wrote :

> Sorry will clash with one of my fixes which has been merged
>
> See question

>> 'ACKN': {'version': ['2', ],
>> + 'default': '2',

>Why do we have a missing slot?

2 new commands in PJLink are only valid for version 2 and have no version 1 equivalent.
Missing slot is to maintain compatibility with version checker.

>> - def process_clss(self, data):
>> + def process_clss(self, data, *args, **kwargs):

>why args
Some commands take host,port arguments but not all of them do.
Since there is a common entry point, need to keep availability of consuming extra args/kwargs without causing exception due to extra parameters.
(Yes, there should be no args passed only keyword args, but better safe than sorry)

Revision history for this message
Ken Roberts (alisonken1) wrote :

which fix is clashing? I tried a merge from trunk and it merged fine.

lp:~alisonken1/openlp/pjlink2-q updated
2815. By Tim Bentley

Fix issues with VLC

lp:~trb143/openlp/media2018a (revision 2838)
https://ci.openlp.io/job/Branch-01-Pull/2481/ [SUCCESS]
https://ci.openlp.io/job/Branch-02a-Linux-Tests/2382/ [SUCCESS]
https://ci.openlp.io/job/Branch-02b-macOS-Tests/169/ [FAILURE]
https://ci.openlp.io/job/Branch-03a-Build-Source/91/ [SUCCESS]
https://ci.openlp.io/job/Branch-03b-Build-macOS/84/ [SUCCESS]
https://ci.openlp.io/job/B...

2816. By Tim Bentley

Replace the Memory check with a local server which stops and starts correctly.
One the 2nd instance pass the service file if one is included
Stop the 2nd instance starting as it will fail due to port clashes and a monster thread issue(may be connected).
Removed redundant code
Add a number of new tests.

lp:~trb143/openlp/localserver (revision 2850)
https://ci.openlp.io/job/Branch-01-Pull/2501/ [SUCCESS]
https://ci.openlp.io/job/Branch-02a-Linux-Tests/2402/ ...

2817. By Simon Hanna

Fix the fix for 1727517

2818. By Ken Roberts

PJLink2 update Q

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'openlp/core/common/__init__.py'
2=== modified file 'openlp/core/projectors/constants.py'
3--- openlp/core/projectors/constants.py 2018-01-03 00:35:14 +0000
4+++ openlp/core/projectors/constants.py 2018-03-24 08:13:55 +0000
5@@ -154,110 +154,137 @@
6 S_INFO
7 ]
8
9-# NOTE: Changed format to account for some commands are both class 1 and 2
10+# NOTE: Changed format to account for some commands are both class 1 and 2.
11+# Make sure the sequence of 'version' is lowest-to-highest.
12 PJLINK_VALID_CMD = {
13- 'ACKN': {'version': ['2', ],
14+ 'ACKN': {'version': ['2'],
15+ 'default': '2',
16 'description': translate('OpenLP.PJLinkConstants',
17 'Acknowledge a PJLink SRCH command - returns MAC address.')
18 },
19- 'AVMT': {'version': ['1', ],
20+ 'AVMT': {'version': ['1'],
21+ 'default': '1',
22 'description': translate('OpenLP.PJLinkConstants',
23 'Blank/unblank video and/or mute audio.')
24 },
25- 'CLSS': {'version': ['1', ],
26+ 'CLSS': {'version': ['1'],
27+ 'default': '1',
28 'description': translate('OpenLP.PJLinkConstants',
29 'Query projector PJLink class support.')
30 },
31 'ERST': {'version': ['1', '2'],
32+ 'default': '1',
33 'description': translate('OpenLP.PJLinkConstants',
34 'Query error status from projector. '
35 'Returns fan/lamp/temp/cover/filter/other error status.')
36 },
37- 'FILT': {'version': ['2', ],
38+ 'FILT': {'version': ['2'],
39+ 'default': '1',
40 'description': translate('OpenLP.PJLinkConstants',
41 'Query number of hours on filter.')
42 },
43- 'FREZ': {'version': ['2', ],
44+ 'FREZ': {'version': ['2'],
45+ 'default': '1',
46 'description': translate('OpenLP.PJLinkConstants',
47 'Freeze or unfreeze current image being projected.')
48 },
49- 'INF1': {'version': ['1', ],
50+ 'INF1': {'version': ['1'],
51+ 'default': '1',
52 'description': translate('OpenLP.PJLinkConstants',
53 'Query projector manufacturer name.')
54 },
55- 'INF2': {'version': ['1', ],
56+ 'INF2': {'version': ['1'],
57+ 'default': '1',
58 'description': translate('OpenLP.PJLinkConstants',
59 'Query projector product name.')
60 },
61- 'INFO': {'version': ['1', ],
62+ 'INFO': {'version': ['1'],
63+ 'default': '1',
64 'description': translate('OpenLP.PJLinkConstants',
65 'Query projector for other information set by manufacturer.')
66 },
67- 'INNM': {'version': ['2', ],
68+ 'INNM': {'version': ['2'],
69+ 'default': '2',
70 'description': translate('OpenLP.PJLinkConstants',
71 'Query specified input source name')
72 },
73- 'INPT': {'version': ['1', ],
74+ 'INPT': {'version': ['1'],
75+ 'default': '1',
76 'description': translate('OpenLP.PJLinkConstants',
77 'Switch to specified video source.')
78 },
79- 'INST': {'version': ['1', ],
80+ 'INST': {'version': ['1'],
81+ 'default': '1',
82 'description': translate('OpenLP.PJLinkConstants',
83 'Query available input sources.')
84 },
85- 'IRES': {'version:': ['2', ],
86+ 'IRES': {'version': ['2'],
87+ 'default': '2',
88 'description': translate('OpenLP.PJLinkConstants',
89 'Query current input resolution.')
90 },
91- 'LAMP': {'version': ['1', ],
92+ 'LAMP': {'version': ['1'],
93+ 'default': '1',
94 'description': translate('OpenLP.PJLinkConstants',
95 'Query lamp time and on/off status. Multiple lamps supported.')
96 },
97- 'LKUP': {'version': ['2', ],
98+ 'LKUP': {'version': ['2'],
99+ 'default': '2',
100 'description': translate('OpenLP.PJLinkConstants',
101 'UDP Status - Projector is now available on network. Includes MAC address.')
102 },
103- 'MVOL': {'version': ['2', ],
104+ 'MVOL': {'version': ['2'],
105+ 'default': '1',
106 'description': translate('OpenLP.PJLinkConstants',
107 'Adjust microphone volume by 1 step.')
108 },
109- 'NAME': {'version': ['1', ],
110+ 'NAME': {'version': ['1'],
111+ 'default': '1',
112 'description': translate('OpenLP.PJLinkConstants',
113 'Query customer-set projector name.')
114 },
115- 'PJLINK': {'version': ['1', ],
116+ 'PJLINK': {'version': ['1'],
117+ 'default': '1',
118 'description': translate('OpenLP.PJLinkConstants',
119 'Initial connection with authentication/no authentication request.')
120 },
121- 'POWR': {'version': ['1', ],
122+ 'POWR': {'version': ['1'],
123+ 'default': '1',
124 'description': translate('OpenLP.PJLinkConstants',
125 'Turn lamp on or off/standby.')
126 },
127- 'RFIL': {'version': ['2', ],
128+ 'RFIL': {'version': ['2'],
129+ 'default': '2',
130 'description': translate('OpenLP.PJLinkConstants',
131 'Query replacement air filter model number.')
132 },
133- 'RLMP': {'version': ['2', ],
134+ 'RLMP': {'version': ['2'],
135+ 'default': '2',
136 'description': translate('OpenLP.PJLinkConstants',
137 'Query replacement lamp model number.')
138 },
139- 'RRES': {'version': ['2', ],
140+ 'RRES': {'version': ['2'],
141+ 'default': '2',
142 'description': translate('OpenLP.PJLinkConstants',
143 'Query recommended resolution.')
144 },
145- 'SNUM': {'version': ['2', ],
146+ 'SNUM': {'version': ['2'],
147+ 'default': '2',
148 'description': translate('OpenLP.PJLinkConstants',
149 'Query projector serial number.')
150 },
151- 'SRCH': {'version': ['2', ],
152+ 'SRCH': {'version': ['2'],
153+ 'default': '2',
154 'description': translate('OpenLP.PJLinkConstants',
155 'UDP broadcast search request for available projectors. Reply is ACKN.')
156 },
157- 'SVER': {'version': ['2', ],
158+ 'SVER': {'version': ['2'],
159+ 'default': '2',
160 'description': translate('OpenLP.PJLinkConstants',
161 'Query projector software version number.')
162 },
163- 'SVOL': {'version': ['2', ],
164+ 'SVOL': {'version': ['2'],
165+ 'default': '2',
166 'description': translate('OpenLP.PJLinkConstants',
167 'Adjust speaker volume by 1 step.')
168 }
169
170=== modified file 'openlp/core/projectors/editform.py'
171--- openlp/core/projectors/editform.py 2017-12-29 09:15:48 +0000
172+++ openlp/core/projectors/editform.py 2018-03-24 08:13:55 +0000
173@@ -58,10 +58,15 @@
174 # IP Address
175 self.ip_label = QtWidgets.QLabel(edit_projector_dialog)
176 self.ip_label.setObjectName('projector_edit_ip_label')
177- self.ip_text = QtWidgets.QLineEdit(edit_projector_dialog)
178- self.ip_text.setObjectName('projector_edit_ip_text')
179+ self.ip_text_edit = QtWidgets.QLineEdit(edit_projector_dialog)
180+ self.ip_text_edit.setObjectName('projector_edit_ip_text')
181+ self.ip_text_show = QtWidgets.QLabel(edit_projector_dialog)
182+ self.ip_text_show.setObjectName('projector_show_ip_text')
183 self.dialog_layout.addWidget(self.ip_label, 0, 0)
184- self.dialog_layout.addWidget(self.ip_text, 0, 1)
185+ # For new projector, use edit widget
186+ self.dialog_layout.addWidget(self.ip_text_edit, 0, 1)
187+ # For edit projector, use show widget
188+ self.dialog_layout.addWidget(self.ip_text_show, 0, 1)
189 # Port number
190 self.port_label = QtWidgets.QLabel(edit_projector_dialog)
191 self.port_label.setObjectName('projector_edit_ip_label')
192@@ -111,8 +116,8 @@
193 title = translate('OpenLP.ProjectorEditForm', 'Edit Projector')
194 edit_projector_dialog.setWindowTitle(title)
195 self.ip_label.setText(translate('OpenLP.ProjectorEditForm', 'IP Address'))
196- self.ip_text.setText(self.projector.ip)
197- self.ip_text.setFocus()
198+ self.ip_text_edit.setText(self.projector.ip)
199+ self.ip_text_show.setText(self.projector.ip)
200 self.port_label.setText(translate('OpenLP.ProjectorEditForm', 'Port Number'))
201 self.port_text.setText(str(self.projector.port))
202 self.pin_label.setText(translate('OpenLP.ProjectorEditForm', 'PIN'))
203@@ -131,7 +136,7 @@
204 Class to add or edit a projector entry in the database.
205
206 Fields that are editable:
207- ip = Column(String(100))
208+ ip = Column(String(100)) (Only edit for new projector)
209 port = Column(String(8))
210 pin = Column(String(20))
211 name = Column(String(20))
212@@ -154,9 +159,15 @@
213 if projector is None:
214 self.projector = Projector()
215 self.new_projector = True
216+ self.ip_text_edit.setVisible(True)
217+ self.ip_text_edit.setFocus()
218+ self.ip_text_show.setVisible(False)
219 else:
220 self.projector = projector
221 self.new_projector = False
222+ self.ip_text_edit.setVisible(False)
223+ self.ip_text_show.setVisible(True)
224+ self.ip_text_show.setFocus()
225 self.retranslateUi(self)
226 reply = QtWidgets.QDialog.exec(self)
227 return reply
228@@ -187,7 +198,8 @@
229 record=record.id)))
230 valid = False
231 return
232- adx = self.ip_text.text()
233+ if self.new_projector:
234+ adx = self.ip_text_edit.text()
235 valid = verify_ip_address(adx)
236 if valid:
237 ip = self.projectordb.get_projector_by_ip(adx)
238@@ -223,7 +235,8 @@
239 'Default PJLink port is {port}'.format(port=PJLINK_PORT)))
240 valid = False
241 if valid:
242- self.projector.ip = self.ip_text.text()
243+ if self.new_projector:
244+ self.projector.ip = self.ip_text_edit.text()
245 self.projector.pin = self.pin_text.text()
246 self.projector.port = int(self.port_text.text())
247 self.projector.name = self.name_text.text()
248
249=== modified file 'openlp/core/projectors/manager.py'
250--- openlp/core/projectors/manager.py 2018-02-11 11:42:13 +0000
251+++ openlp/core/projectors/manager.py 2018-03-24 08:13:55 +0000
252@@ -35,24 +35,9 @@
253 from openlp.core.common.settings import Settings
254 from openlp.core.lib.ui import create_widget_action
255 from openlp.core.projectors import DialogSourceStyle
256-from openlp.core.projectors.constants import \
257- E_AUTHENTICATION, \
258- E_ERROR, \
259- E_NETWORK, \
260- E_NOT_CONNECTED, \
261- E_UNKNOWN_SOCKET_ERROR, \
262- S_CONNECTED, \
263- S_CONNECTING, \
264- S_COOLDOWN, \
265- S_INITIALIZE, \
266- S_NOT_CONNECTED, \
267- S_OFF, \
268- S_ON, \
269- S_STANDBY, \
270- S_WARMUP, \
271- STATUS_CODE, \
272- STATUS_MSG, \
273- QSOCKET_STATE
274+from openlp.core.projectors.constants import E_AUTHENTICATION, E_ERROR, E_NETWORK, E_NOT_CONNECTED, \
275+ E_UNKNOWN_SOCKET_ERROR, S_CONNECTED, S_CONNECTING, S_COOLDOWN, S_INITIALIZE, S_NOT_CONNECTED, S_OFF, S_ON, \
276+ S_STANDBY, S_WARMUP, STATUS_CODE, STATUS_MSG, QSOCKET_STATE
277
278 from openlp.core.projectors.db import ProjectorDB
279 from openlp.core.projectors.editform import ProjectorEditForm
280
281=== modified file 'openlp/core/projectors/pjlink.py'
282--- openlp/core/projectors/pjlink.py 2018-02-11 11:42:13 +0000
283+++ openlp/core/projectors/pjlink.py 2018-03-24 08:13:55 +0000
284@@ -57,8 +57,7 @@
285 from openlp.core.projectors.constants import CONNECTION_ERRORS, PJLINK_CLASS, PJLINK_DEFAULT_CODES, PJLINK_ERRORS, \
286 PJLINK_ERST_DATA, PJLINK_ERST_STATUS, PJLINK_MAX_PACKET, PJLINK_PREFIX, PJLINK_PORT, PJLINK_POWR_STATUS, \
287 PJLINK_SUFFIX, PJLINK_VALID_CMD, PROJECTOR_STATE, STATUS_CODE, STATUS_MSG, QSOCKET_STATE, \
288- E_AUTHENTICATION, E_CONNECTION_REFUSED, E_GENERAL, E_INVALID_DATA, E_NETWORK, E_NOT_CONNECTED, \
289- E_SOCKET_TIMEOUT, \
290+ E_AUTHENTICATION, E_CONNECTION_REFUSED, E_GENERAL, E_NETWORK, E_NOT_CONNECTED, E_SOCKET_TIMEOUT, \
291 S_CONNECTED, S_CONNECTING, S_NOT_CONNECTED, S_OFF, S_OK, S_ON
292
293 log = logging.getLogger(__name__)
294@@ -93,22 +92,9 @@
295 self.projector_list = projector_list
296 self.port = port
297 # Local defines
298- self.ackn_list = {} # Replies from online projetors
299 self.search_active = False
300 self.search_time = 30000 # 30 seconds for allowed time
301 self.search_timer = QtCore.QTimer()
302- # New commands available in PJLink Class 2
303- # ACKN/SRCH is processed here since it's used to find available projectors
304- # Other commands are processed by the individual projector instances
305- self.pjlink_udp_functions = {
306- 'ACKN': self.process_ackn, # Class 2, command is 'SRCH'
307- 'ERST': None, # Class 1/2
308- 'INPT': None, # Class 1/2
309- 'LKUP': None, # Class 2 (reply only - no cmd)
310- 'POWR': None, # Class 1/2
311- 'SRCH': self.process_srch # Class 2 (reply is ACKN)
312- }
313-
314 self.readyRead.connect(self.get_datagram)
315 log.debug('(UDP) PJLinkUDP() Initialized')
316
317@@ -118,88 +104,26 @@
318 Retrieve packet and basic checks
319 """
320 log.debug('(UDP) get_datagram() - Receiving data')
321- read = self.pendingDatagramSize()
322- if read < 0:
323- log.warn('(UDP) No data (-1)')
324+ read_size = self.pendingDatagramSize()
325+ if read_size < 0:
326+ log.warning('(UDP) No data (-1)')
327 return
328- if read < 1:
329- log.warn('(UDP) get_datagram() called when pending data size is 0')
330+ if read_size < 1:
331+ log.warning('(UDP) get_datagram() called when pending data size is 0')
332 return
333 data, peer_address, peer_port = self.readDatagram(self.pendingDatagramSize())
334 log.debug('(UDP) {size} bytes received from {adx} on port {port}'.format(size=len(data),
335 adx=peer_address,
336 port=peer_port))
337 log.debug('(UDP) packet "{data}"'.format(data=data))
338- if len(data) < 0:
339- log.warn('(UDP) No data (-1)')
340- return
341- elif len(data) < 8:
342- # Minimum packet is '%2CCCC='
343- log.warn('(UDP) Invalid packet - not enough data')
344- return
345- elif data is None:
346- log.warn('(UDP) No data (None)')
347- return
348- elif len(data) > PJLINK_MAX_PACKET:
349- log.warn('(UDP) Invalid packet - length too long')
350- return
351- elif not data.startswith(PJLINK_PREFIX):
352- log.warn('(UDP) Invalid packet - does not start with PJLINK_PREFIX')
353- return
354- elif data[1] != '2':
355- log.warn('(UDP) Invalid packet - missing/invalid PJLink class version')
356- return
357- elif data[6] != '=':
358- log.warn('(UDP) Invalid packet - separator missing')
359- return
360- # First two characters are header information we don't need at this time
361- cmd, data = data[2:].split('=')
362- if cmd not in self.pjlink_udp_functions:
363- log.warn('(UDP) Invalid packet - not a valid PJLink UDP reply')
364- return
365- if self.pjlink_udp_functions[cmd] is not None:
366- log.debug('(UDP) Processing {cmd} with "{data}"'.format(cmd=cmd, data=data))
367- return self.pjlink_udp_functions[cmd](data=data, host=peer_address, port=peer_port)
368- else:
369- log.debug('(UDP) Checking projector list for ip {host} to process'.format(host=peer_address))
370- for projector in self.projector_list:
371- if peer_address == projector.ip:
372- if cmd not in projector.pjlink_functions:
373- log.error('(UDP) Could not find method to process '
374- '"{cmd}" in {host}'.format(cmd=cmd, host=projector.ip))
375- return
376- log.debug('(UDP) Calling "{cmd}" in {host}'.format(cmd=cmd, host=projector.ip))
377- return projector.pjlink_functions[cmd](data=data)
378- log.warn('(UDP) Could not find projector with ip {ip} to process packet'.format(ip=peer_address))
379- return
380-
381- def process_ackn(self, data, host, port):
382- """
383- Process the ACKN command.
384-
385- :param data: Data in packet
386- :param host: IP address of sending host
387- :param port: Port received on
388- """
389- log.debug('(UDP) Processing ACKN packet')
390- if host not in self.ackn_list:
391- log.debug('(UDP) Adding {host} to ACKN list'.format(host=host))
392- self.ackn_list[host] = {'data': data,
393- 'port': port}
394- else:
395- log.warn('(UDP) Host {host} already replied - ignoring'.format(host=host))
396-
397- def process_srch(self, data, host, port):
398- """
399- Process the SRCH command.
400-
401- SRCH is processed by terminals so we ignore any packet.
402-
403- :param data: Data in packet
404- :param host: IP address of sending host
405- :param port: Port received on
406- """
407- log.debug('(UDP) SRCH packet received - ignoring')
408+ # Send to appropriate instance to process packet
409+ log.debug('(UDP) Checking projector list for ip {host} to process'.format(host=peer_address))
410+ for projector in self.projector_list:
411+ if peer_address == projector.ip:
412+ # Dispatch packet to appropriate remote instance
413+ log.debug('(UDP) Dispatching packet to {host}'.format(host=projector.entry.name))
414+ return projector.get_data(buff=data, ip=peer_address, host=peer_address, port=peer_port)
415+ log.warning('(UDP) Could not find projector with ip {ip} to process packet'.format(ip=peer_address))
416 return
417
418 def search_start(self):
419@@ -224,6 +148,8 @@
420 """
421 Process replies from PJLink projector.
422 """
423+ # List of IP addresses and mac addresses found via UDP search command
424+ ackn_list = []
425
426 def __init__(self, *args, **kwargs):
427 """
428@@ -231,24 +157,47 @@
429 """
430 log.debug('PJlinkCommands(args={args} kwargs={kwargs})'.format(args=args, kwargs=kwargs))
431 super().__init__()
432- # Map PJLink command to method
433+ # Map PJLink command to method and include pjlink class version for this instance
434+ # Default initial pjlink class version is '1'
435 self.pjlink_functions = {
436- 'AVMT': self.process_avmt,
437- 'CLSS': self.process_clss,
438- 'ERST': self.process_erst,
439- 'INFO': self.process_info,
440- 'INF1': self.process_inf1,
441- 'INF2': self.process_inf2,
442- 'INPT': self.process_inpt,
443- 'INST': self.process_inst,
444- 'LAMP': self.process_lamp,
445- 'NAME': self.process_name,
446- 'PJLINK': self.process_pjlink,
447- 'POWR': self.process_powr,
448- 'SNUM': self.process_snum,
449- 'SVER': self.process_sver,
450- 'RFIL': self.process_rfil,
451- 'RLMP': self.process_rlmp
452+ 'ACKN': {"method": self.process_ackn, # Class 2 (command is SRCH)
453+ "version": "2"},
454+ 'AVMT': {"method": self.process_avmt,
455+ "version": "1"},
456+ 'CLSS': {"method": self.process_clss,
457+ "version": "1"},
458+ 'ERST': {"method": self.process_erst,
459+ "version": "1"},
460+ 'INFO': {"method": self.process_info,
461+ "version": "1"},
462+ 'INF1': {"method": self.process_inf1,
463+ "version": "1"},
464+ 'INF2': {"method": self.process_inf2,
465+ "version": "1"},
466+ 'INPT': {"method": self.process_inpt,
467+ "version": "1"},
468+ 'INST': {"method": self.process_inst,
469+ "version": "1"},
470+ 'LAMP': {"method": self.process_lamp,
471+ "version": "1"},
472+ 'LKUP': {"method": self.process_lkup, # Class 2 (reply only - no cmd)
473+ "version": "2"},
474+ 'NAME': {"method": self.process_name,
475+ "version": "1"},
476+ 'PJLINK': {"method": self.process_pjlink,
477+ "version": "1"},
478+ 'POWR': {"method": self.process_powr,
479+ "version": "1"},
480+ 'SNUM': {"method": self.process_snum,
481+ "version": "1"},
482+ 'SRCH': {"method": self.process_srch, # Class 2 (reply is ACKN)
483+ "version": "2"},
484+ 'SVER': {"method": self.process_sver,
485+ "version": "1"},
486+ 'RFIL': {"method": self.process_rfil,
487+ "version": "1"},
488+ 'RLMP': {"method": self.process_rlmp,
489+ "version": "1"}
490 }
491
492 def reset_information(self):
493@@ -287,8 +236,11 @@
494 self.send_busy = False
495 self.send_queue = []
496 self.priority_queue = []
497+ # Reset default version in command routing dict
498+ for cmd in self.pjlink_functions:
499+ self.pjlink_functions[cmd]["version"] = PJLINK_VALID_CMD[cmd]['default']
500
501- def process_command(self, cmd, data):
502+ def process_command(self, cmd, data, *args, **kwargs):
503 """
504 Verifies any return error code. Calls the appropriate command handler.
505
506@@ -320,9 +272,25 @@
507 return self.change_status(status=E_AUTHENTICATION)
508 # Command checks already passed
509 log.debug('({ip}) Calling function for {cmd}'.format(ip=self.entry.name, cmd=cmd))
510- self.pjlink_functions[cmd](data=data)
511-
512- def process_avmt(self, data):
513+ self.pjlink_functions[cmd]["method"](data=data, *args, **kwargs)
514+
515+ def process_ackn(self, data, host, port):
516+ """
517+ Process the ACKN command.
518+
519+ :param data: Data in packet
520+ :param host: IP address of sending host
521+ :param port: Port received on
522+ """
523+ log.debug('({ip}) Processing ACKN packet'.format(ip=self.entry.name))
524+ if host not in self.ackn_list:
525+ log.debug('({ip}) Adding {host} to ACKN list'.format(ip=self.entry.name, host=host))
526+ self.ackn_list[host] = {'data': data,
527+ 'port': port}
528+ else:
529+ log.warning('({ip}) Host {host} already replied - ignoring'.format(ip=self.entry.name, host=host))
530+
531+ def process_avmt(self, data, *args, **kwargs):
532 """
533 Process shutter and speaker status. See PJLink specification for format.
534 Update self.mute (audio) and self.shutter (video shutter).
535@@ -351,7 +319,7 @@
536 self.projectorUpdateIcons.emit()
537 return
538
539- def process_clss(self, data):
540+ def process_clss(self, data, *args, **kwargs):
541 """
542 PJLink class that this projector supports. See PJLink specification for format.
543 Updates self.class.
544@@ -367,12 +335,13 @@
545 # Due to stupid projectors not following standards (Optoma, BenQ comes to mind),
546 # AND the different responses that can be received, the semi-permanent way to
547 # fix the class reply is to just remove all non-digit characters.
548- try:
549- clss = re.findall('\d', data)[0] # Should only be the first match
550- except IndexError:
551+ chk = re.findall('\d', data)
552+ if len(chk) < 1:
553 log.error('({ip}) No numbers found in class version reply "{data}" - '
554 'defaulting to class "1"'.format(ip=self.entry.name, data=data))
555 clss = '1'
556+ else:
557+ clss = chk[0] # Should only be the first match
558 elif not data.isdigit():
559 log.error('({ip}) NAN CLSS version reply "{data}" - '
560 'defaulting to class "1"'.format(ip=self.entry.name, data=data))
561@@ -383,6 +352,11 @@
562 log.debug('({ip}) Setting pjlink_class for this projector '
563 'to "{data}"'.format(ip=self.entry.name,
564 data=self.pjlink_class))
565+ # Update method class versions
566+ for cmd in self.pjlink_functions:
567+ if self.pjlink_class in PJLINK_VALID_CMD[cmd]['version']:
568+ self.pjlink_functions[cmd]['version'] = self.pjlink_class
569+
570 # Since we call this one on first connect, setup polling from here
571 if not self.no_poll:
572 log.debug('({ip}) process_pjlink(): Starting timer'.format(ip=self.entry.name))
573@@ -391,7 +365,7 @@
574
575 return
576
577- def process_erst(self, data):
578+ def process_erst(self, data, *args, **kwargs):
579 """
580 Error status. See PJLink Specifications for format.
581 Updates self.projector_errors
582@@ -443,7 +417,7 @@
583 PJLINK_ERST_STATUS[other]
584 return
585
586- def process_inf1(self, data):
587+ def process_inf1(self, data, *args, **kwargs):
588 """
589 Manufacturer name set in projector.
590 Updates self.manufacturer
591@@ -455,7 +429,7 @@
592 data=self.manufacturer))
593 return
594
595- def process_inf2(self, data):
596+ def process_inf2(self, data, *args, **kwargs):
597 """
598 Projector Model set in projector.
599 Updates self.model.
600@@ -466,7 +440,7 @@
601 log.debug('({ip}) Setting projector model to "{data}"'.format(ip=self.entry.name, data=self.model))
602 return
603
604- def process_info(self, data):
605+ def process_info(self, data, *args, **kwargs):
606 """
607 Any extra info set in projector.
608 Updates self.other_info.
609@@ -477,7 +451,7 @@
610 log.debug('({ip}) Setting projector other_info to "{data}"'.format(ip=self.entry.name, data=self.other_info))
611 return
612
613- def process_inpt(self, data):
614+ def process_inpt(self, data, *args, **kwargs):
615 """
616 Current source input selected. See PJLink specification for format.
617 Update self.source
618@@ -499,7 +473,7 @@
619 log.debug('({ip}) Setting data source to "{data}"'.format(ip=self.entry.name, data=self.source))
620 return
621
622- def process_inst(self, data):
623+ def process_inst(self, data, *args, **kwargs):
624 """
625 Available source inputs. See PJLink specification for format.
626 Updates self.source_available
627@@ -516,7 +490,7 @@
628 data=self.source_available))
629 return
630
631- def process_lamp(self, data):
632+ def process_lamp(self, data, *args, **kwargs):
633 """
634 Lamp(s) status. See PJLink Specifications for format.
635 Data may have more than 1 lamp to process.
636@@ -542,7 +516,18 @@
637 self.lamp = lamps
638 return
639
640- def process_name(self, data):
641+ def process_lkup(self, data, host, port):
642+ """
643+ Process reply indicating remote is available for connection
644+
645+ :param data: Data packet from remote
646+ :param host: Remote IP address
647+ :param port: Local port packet received on
648+ """
649+ # TODO: Check if autoconnect is enabled and connect?
650+ pass
651+
652+ def process_name(self, data, *args, **kwargs):
653 """
654 Projector name set in projector.
655 Updates self.pjlink_name
656@@ -553,7 +538,7 @@
657 log.debug('({ip}) Setting projector PJLink name to "{data}"'.format(ip=self.entry.name, data=self.pjlink_name))
658 return
659
660- def process_pjlink(self, data):
661+ def process_pjlink(self, data, *args, **kwargs):
662 """
663 Process initial socket connection to terminal.
664
665@@ -594,7 +579,7 @@
666 # Since this is an initial connection, make it a priority just in case
667 return self.send_command(cmd="CLSS", salt=data_hash, priority=True)
668
669- def process_powr(self, data):
670+ def process_powr(self, data, *args, **kwargs):
671 """
672 Power status. See PJLink specification for format.
673 Update self.power with status. Update icons if change from previous setting.
674@@ -617,7 +602,7 @@
675 log.warning('({ip}) Unknown power response: "{data}"'.format(ip=self.entry.name, data=data))
676 return
677
678- def process_rfil(self, data):
679+ def process_rfil(self, data, *args, **kwargs):
680 """
681 Process replacement filter type
682 """
683@@ -628,7 +613,7 @@
684 log.warning('({ip}) Saved model: "{old}"'.format(ip=self.entry.name, old=self.model_filter))
685 log.warning('({ip}) New model: "{new}"'.format(ip=self.entry.name, new=data))
686
687- def process_rlmp(self, data):
688+ def process_rlmp(self, data, *args, **kwargs):
689 """
690 Process replacement lamp type
691 """
692@@ -639,7 +624,7 @@
693 log.warning('({ip}) Saved lamp: "{old}"'.format(ip=self.entry.name, old=self.model_lamp))
694 log.warning('({ip}) New lamp: "{new}"'.format(ip=self.entry.name, new=data))
695
696- def process_snum(self, data):
697+ def process_snum(self, data, *args, **kwargs):
698 """
699 Serial number of projector.
700
701@@ -659,7 +644,20 @@
702 log.warning('({ip}) NOT saving serial number'.format(ip=self.entry.name))
703 self.serial_no_received = data
704
705- def process_sver(self, data):
706+ def process_srch(self, data, host, port):
707+ """
708+ Process the SRCH command.
709+
710+ SRCH is processed by terminals so we ignore any packet.
711+
712+ :param data: Data in packet
713+ :param host: IP address of sending host
714+ :param port: Port received on
715+ """
716+ log.warning('(UDP) SRCH packet received from {host} - ignoring'.format(host=host))
717+ return
718+
719+ def process_sver(self, data, *args, **kwargs):
720 """
721 Software version of projector
722 """
723@@ -716,6 +714,7 @@
724 self.pin = self.entry.pin
725 self.port = self.entry.port
726 self.pjlink_class = PJLINK_CLASS if self.entry.pjlink_class is None else self.entry.pjlink_class
727+ self.ackn_list = {} # Replies from online projectors (Class 2 option)
728 self.db_update = False # Use to check if db needs to be updated prior to exiting
729 # Poll time 20 seconds unless called with something else
730 self.poll_time = 20000 if 'poll_time' not in kwargs else kwargs['poll_time'] * 1000
731@@ -916,7 +915,10 @@
732 """
733 Clean out extraneous stuff in the buffer.
734 """
735- log.warning('({ip}) {message}'.format(ip=self.entry.name, message='Invalid packet' if msg is None else msg))
736+ log.debug('({ip}) Cleaning buffer - msg = "{message}"'.format(ip=self.entry.name, message=msg))
737+ if msg is None:
738+ msg = 'Invalid packet'
739+ log.warning('({ip}) {message}'.format(ip=self.entry.name, message=msg))
740 self.send_busy = False
741 trash_count = 0
742 while self.bytesAvailable() > 0:
743@@ -960,7 +962,7 @@
744 self.socket_timer.stop()
745 return self.get_data(buff=read, ip=self.ip)
746
747- def get_data(self, buff, ip=None):
748+ def get_data(self, buff, ip=None, *args, **kwargs):
749 """
750 Process received data
751
752@@ -973,45 +975,60 @@
753 ip = self.ip
754 log.debug('({ip}) get_data(ip="{ip_in}" buffer="{buff}"'.format(ip=self.entry.name, ip_in=ip, buff=buff))
755 # NOTE: Class2 has changed to some values being UTF-8
756- data_in = decode(buff, 'utf-8')
757+ if type(buff) is bytes:
758+ data_in = decode(buff, 'utf-8')
759+ else:
760+ data_in = buff
761 data = data_in.strip()
762+ # log.debug('({ip}) get_data() data_in="{data}"'.format(ip=self.entry.name, data=data_in))
763 # Initial packet checks
764 if (len(data) < 7):
765 self._trash_buffer(msg='get_data(): Invalid packet - length')
766 return self.receive_data_signal()
767 elif len(data) > self.max_size:
768- self._trash_buffer(msg='get_data(): Invalid packet - too long')
769+ self._trash_buffer(msg='get_data(): Invalid packet - too long ({length} bytes)'.format(length=len(data)))
770 return self.receive_data_signal()
771 elif not data.startswith(PJLINK_PREFIX):
772 self._trash_buffer(msg='get_data(): Invalid packet - PJLink prefix missing')
773 return self.receive_data_signal()
774- elif '=' not in data:
775+ elif data[6] != '=':
776 self._trash_buffer(msg='get_data(): Invalid reply - Does not have "="')
777 return self.receive_data_signal()
778 log.debug('({ip}) get_data(): Checking new data "{data}"'.format(ip=self.entry.name, data=data))
779 header, data = data.split('=')
780+ log.debug('({ip}) get_data() header="{header}" data="{data}"'.format(ip=self.entry.name,
781+ header=header, data=data))
782 # At this point, the header should contain:
783 # "PVCCCC"
784 # Where:
785 # P = PJLINK_PREFIX
786 # V = PJLink class or version
787 # C = PJLink command
788+ version, cmd = header[1], header[2:].upper()
789+ log.debug('({ip}) get_data() version="{version}" cmd="{cmd}"'.format(ip=self.entry.name,
790+ version=version, cmd=cmd))
791+ '''
792 try:
793 version, cmd = header[1], header[2:].upper()
794+ log.debug('({ip}) get_data() version="{version}" cmd="{cmd}"'.format(ip=self.entry.name,
795+ version=version, cmd=cmd))
796 except ValueError as e:
797 self.change_status(E_INVALID_DATA)
798 log.warning('({ip}) get_data(): Received data: "{data}"'.format(ip=self.entry.name, data=data_in))
799 self._trash_buffer('get_data(): Expected header + command + data')
800 return self.receive_data_signal()
801+ '''
802 if cmd not in PJLINK_VALID_CMD:
803- log.warning('({ip}) get_data(): Invalid packet - unknown command "{data}"'.format(ip=self.entry.name,
804+ self._trash_buffer('get_data(): Invalid packet - unknown command "{data}"'.format(ip=self.entry.name,
805 data=cmd))
806- self._trash_buffer(msg='get_data(): Unknown command "{data}"'.format(data=cmd))
807- return self.receive_data_signal()
808- if int(self.pjlink_class) < int(version):
809+ return self.receive_data_signal()
810+ elif version not in PJLINK_VALID_CMD[cmd]['version']:
811+ self._trash_buffer(msg='get_data() Command reply version does not match a valid command version')
812+ return self.receive_data_signal()
813+ elif int(self.pjlink_class) < int(version):
814 log.warning('({ip}) get_data(): Projector returned class reply higher '
815 'than projector stated class'.format(ip=self.entry.name))
816- self.process_command(cmd, data)
817+ self.process_command(cmd, data, *args, **kwargs)
818 return self.receive_data_signal()
819
820 @QtCore.pyqtSlot(QtNetwork.QAbstractSocket.SocketError)
821@@ -1063,16 +1080,7 @@
822 data=opts,
823 salt='' if salt is None
824 else ' with hash'))
825- cmd_ver = PJLINK_VALID_CMD[cmd]['version']
826- if self.pjlink_class in PJLINK_VALID_CMD[cmd]['version']:
827- header = PJLINK_HEADER.format(linkclass=self.pjlink_class)
828- elif len(cmd_ver) == 1 and (int(cmd_ver[0]) < int(self.pjlink_class)):
829- # Typically a class 1 only command
830- header = PJLINK_HEADER.format(linkclass=cmd_ver[0])
831- else:
832- # NOTE: Once we get to version 3 then think about looping
833- log.error('({ip}): send_command(): PJLink class check issue? Aborting'.format(ip=self.entry.name))
834- return
835+ header = PJLINK_HEADER.format(linkclass=self.pjlink_functions[cmd]["version"])
836 out = '{salt}{header}{command} {options}{suffix}'.format(salt="" if salt is None else salt,
837 header=header,
838 command=cmd,
839
840=== modified file 'tests/openlp_core/projectors/test_projector_db.py'
841--- tests/openlp_core/projectors/test_projector_db.py 2018-01-13 05:41:42 +0000
842+++ tests/openlp_core/projectors/test_projector_db.py 2018-03-24 08:13:55 +0000
843@@ -29,12 +29,15 @@
844 import shutil
845 from tempfile import mkdtemp
846 from unittest import TestCase
847-from unittest.mock import patch
848+from unittest.mock import MagicMock, patch
849
850+from openlp.core.common.registry import Registry
851 from openlp.core.lib.db import upgrade_db
852 from openlp.core.projectors import upgrade
853 from openlp.core.projectors.constants import PJLINK_PORT
854 from openlp.core.projectors.db import Manufacturer, Model, Projector, ProjectorDB, ProjectorSource, Source
855+from openlp.core.ui.mainwindow import MainWindow
856+from tests.helpers.testmixin import TestMixin
857 from tests.resources.projector.data import TEST_DB_PJLINK1, TEST_DB, TEST1_DATA, TEST2_DATA, TEST3_DATA
858 from tests.utils.constants import TEST_RESOURCES_PATH
859
860@@ -122,7 +125,7 @@
861 assert updated_to_version == latest_version, 'The projector DB should have been upgrade to the latest version'
862
863
864-class TestProjectorDB(TestCase):
865+class TestProjectorDB(TestCase, TestMixin):
866 """
867 Test case for ProjectorDB
868 """
869@@ -131,6 +134,33 @@
870 """
871 Set up anything necessary for all tests
872 """
873+ # Create a test app to keep from segfaulting
874+ Registry.create()
875+ self.registry = Registry()
876+ self.setup_application()
877+ # Mock cursor busy/normal methods.
878+ self.app.set_busy_cursor = MagicMock()
879+ self.app.set_normal_cursor = MagicMock()
880+ self.app.args = []
881+ Registry().register('application', self.app)
882+ Registry().set_flag('no_web_server', True)
883+ # Mock classes and methods used by mainwindow.
884+ with patch('openlp.core.ui.mainwindow.SettingsForm'), \
885+ patch('openlp.core.ui.mainwindow.ImageManager'), \
886+ patch('openlp.core.ui.mainwindow.LiveController'), \
887+ patch('openlp.core.ui.mainwindow.PreviewController'), \
888+ patch('openlp.core.ui.mainwindow.OpenLPDockWidget'), \
889+ patch('openlp.core.ui.mainwindow.QtWidgets.QToolBox'), \
890+ patch('openlp.core.ui.mainwindow.QtWidgets.QMainWindow.addDockWidget'), \
891+ patch('openlp.core.ui.mainwindow.ServiceManager'), \
892+ patch('openlp.core.ui.mainwindow.ThemeManager'), \
893+ patch('openlp.core.ui.mainwindow.ProjectorManager'), \
894+ patch('openlp.core.ui.mainwindow.Renderer'), \
895+ patch('openlp.core.ui.mainwindow.websockets.WebSocketServer'), \
896+ patch('openlp.core.ui.mainwindow.server.HttpServer'):
897+ self.main_window = MainWindow()
898+
899+ # Create a temporary database directory and database
900 self.tmp_folder = mkdtemp(prefix='openlp_')
901 tmpdb_url = 'sqlite:///{db}'.format(db=os.path.join(self.tmp_folder, TEST_DB))
902 mocked_init_url.return_value = tmpdb_url
903@@ -139,9 +169,12 @@
904 def tearDown(self):
905 """
906 Clean up
907+
908+ Delete all the C++ objects at the end so that we don't have a segfault
909 """
910 self.projector.session.close()
911 self.projector = None
912+ del self.main_window
913 # Ignore errors since windows can have problems with locked files
914 shutil.rmtree(self.tmp_folder, ignore_errors=True)
915
916
917=== renamed file 'tests/openlp_core/projectors/test_projectoreditform.py' => 'tests/openlp_core/projectors/test_projector_editform.py'
918=== modified file 'tests/openlp_core/projectors/test_projector_pjlink_cmd_routing.py'
919--- tests/openlp_core/projectors/test_projector_pjlink_cmd_routing.py 2018-01-13 05:41:42 +0000
920+++ tests/openlp_core/projectors/test_projector_pjlink_cmd_routing.py 2018-03-24 08:13:55 +0000
921@@ -39,30 +39,31 @@
922 """
923 Tests for the PJLink module command routing
924 """
925- def test_get_data_unknown_command(self):
926+ @patch.object(openlp.core.projectors.pjlink, 'log')
927+ def test_get_data_unknown_command(self, mock_log):
928 """
929 Test not a valid command
930 """
931 # GIVEN: Test object
932- with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
933- patch.object(openlp.core.projectors.pjlink.PJLink, '_trash_buffer') as mock_buffer:
934-
935- pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
936- pjlink.pjlink_functions = MagicMock()
937- log_warning_text = [call('({ip}) get_data(): Invalid packet - '
938- 'unknown command "UNK"'.format(ip=pjlink.name))]
939- log_debug_text = [call('({ip}) get_data(ip="111.111.111.111" '
940- 'buffer="b\'%1UNK=Huh?\'"'.format(ip=pjlink.name)),
941- call('({ip}) get_data(): Checking new data "%1UNK=Huh?"'.format(ip=pjlink.name))]
942-
943- # WHEN: get_data called with an unknown command
944- pjlink.get_data(buff='{prefix}1UNK=Huh?'.format(prefix=PJLINK_PREFIX).encode('utf-8'))
945-
946- # THEN: Appropriate log entries should have been made and methods called/not called
947- mock_log.debug.assert_has_calls(log_debug_text)
948- mock_log.warning.assert_has_calls(log_warning_text)
949- assert pjlink.pjlink_functions.called is False, 'Should not have accessed pjlink_functions'
950- assert mock_buffer.called is True, 'Should have called _trash_buffer'
951+ pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
952+ pjlink.pjlink_functions = MagicMock()
953+ log_warning_text = [call('({ip}) get_data(): Invalid packet - '
954+ 'unknown command "UNKN"'.format(ip=pjlink.name))]
955+ log_debug_text = [call('(___TEST_ONE___) get_data(ip="111.111.111.111" buffer="%1UNKN=Huh?"'),
956+ call('(___TEST_ONE___) get_data(): Checking new data "%1UNKN=Huh?"'),
957+ call('(___TEST_ONE___) get_data() header="%1UNKN" data="Huh?"'),
958+ call('(___TEST_ONE___) get_data() version="1" cmd="UNKN"'),
959+ call('(___TEST_ONE___) Cleaning buffer - msg = "get_data(): '
960+ 'Invalid packet - unknown command "UNKN""'),
961+ call('(___TEST_ONE___) Finished cleaning buffer - 0 bytes dropped')]
962+
963+ # WHEN: get_data called with an unknown command
964+ pjlink.get_data(buff='{prefix}1UNKN=Huh?'.format(prefix=PJLINK_PREFIX))
965+
966+ # THEN: Appropriate log entries should have been made and methods called/not called
967+ mock_log.warning.assert_has_calls(log_warning_text)
968+ mock_log.debug.assert_has_calls(log_debug_text)
969+ assert pjlink.pjlink_functions.called is False, 'Should not have accessed pjlink_functions'
970
971 def test_process_command_call_clss(self):
972 """
973@@ -219,7 +220,6 @@
974 """
975 Test command returned success
976 """
977- # GIVEN: Initial mocks and data
978 # GIVEN: Test object and mocks
979 with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
980 patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command, \
981
982=== modified file 'tests/openlp_core/projectors/test_projector_pjlink_commands_02.py'
983--- tests/openlp_core/projectors/test_projector_pjlink_commands_02.py 2018-01-13 05:41:42 +0000
984+++ tests/openlp_core/projectors/test_projector_pjlink_commands_02.py 2018-03-24 08:13:55 +0000
985@@ -22,14 +22,14 @@
986 """
987 Package to test the openlp.core.projectors.pjlink commands package.
988 """
989-from unittest import TestCase
990+from unittest import TestCase, skip
991 from unittest.mock import patch, call
992
993 import openlp.core.projectors.pjlink
994-from openlp.core.projectors.constants import S_CONNECTED, S_OFF, S_ON
995+from openlp.core.projectors.constants import PJLINK_PORT, S_CONNECTED, S_OFF, S_ON
996 from openlp.core.projectors.db import Projector
997-from openlp.core.projectors.pjlink import PJLink
998-from tests.resources.projector.data import TEST_HASH, TEST_PIN, TEST_SALT, TEST1_DATA
999+from openlp.core.projectors.pjlink import PJLink, PJLinkUDP
1000+from tests.resources.projector.data import TEST_HASH, TEST_PIN, TEST_SALT, TEST1_DATA, TEST2_DATA
1001
1002
1003 class TestPJLinkCommands(TestCase):
1004@@ -235,3 +235,114 @@
1005 mock_log.error.assert_has_calls(log_check)
1006 assert 1 == mock_disconnect_from_host.call_count, 'Should have only been called once'
1007 mock_send_command.assert_not_called()
1008+
1009+ @skip('Change to pjlink_udp.get_datagram() call')
1010+ @patch.object(openlp.core.projectors.pjlink, 'log')
1011+ def test_process_ackn_duplicate(self, mock_log):
1012+ """
1013+ Test process_ackn method with multiple calls with same data
1014+ """
1015+ # TODO: Change this to call pjlink_udp.get_datagram() so ACKN can be processed properly
1016+
1017+ # GIVEN: Test setup
1018+ pjlink = PJLink(projector=self.test_list[0])
1019+ check_list = {TEST1_DATA['ip']: {'data': TEST1_DATA['mac_adx'], 'port': PJLINK_PORT}}
1020+ log_warn_calls = [call('(___TEST_ONE___) Host {host} already replied - '
1021+ 'ignoring'.format(host=TEST1_DATA['ip']))]
1022+ log_debug_calls = [call('PJlinkCommands(args=() kwargs={})'),
1023+ call('(___TEST_ONE___) reset_information() connect status is S_NOT_CONNECTED'),
1024+ call('(___TEST_ONE___) Processing ACKN packet'),
1025+ call('(___TEST_ONE___) Adding {host} to ACKN list'.format(host=TEST1_DATA['ip'])),
1026+ call('(___TEST_ONE___) Processing ACKN packet')]
1027+
1028+ # WHEN: process_ackn called twice with same data
1029+ pjlink.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1030+ pjlink.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1031+
1032+ # THEN: pjlink_udp.ack_list should equal test_list
1033+ # NOTE: This assert only returns AssertionError - does not list differences. Maybe add a compare function?
1034+ if pjlink.ackn_list != check_list:
1035+ # Check this way so we can print differences to stdout
1036+ print('\nackn_list: ', pjlink.ackn_list)
1037+ print('test_list: ', check_list, '\n')
1038+ assert pjlink.ackn_list == check_list
1039+ mock_log.debug.assert_has_calls(log_debug_calls)
1040+ mock_log.warning.assert_has_calls(log_warn_calls)
1041+
1042+ @skip('Change to pjlink_udp.get_datagram() call')
1043+ @patch.object(openlp.core.projectors.pjlink, 'log')
1044+ def test_process_ackn_multiple(self, mock_log):
1045+ """
1046+ Test process_ackn method with multiple calls
1047+ """
1048+ # TODO: Change this to call pjlink_udp.get_datagram() so ACKN can be processed properly
1049+
1050+ # GIVEN: Test setup
1051+ pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1052+ check_list = {TEST1_DATA['ip']: {'data': TEST1_DATA['mac_adx'], 'port': PJLINK_PORT},
1053+ TEST2_DATA['ip']: {'data': TEST2_DATA['mac_adx'], 'port': PJLINK_PORT}}
1054+ log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1055+ call('(UDP) Processing ACKN packet'),
1056+ call('(UDP) Adding {host} to ACKN list'.format(host=TEST1_DATA['ip'])),
1057+ call('(UDP) Processing ACKN packet'),
1058+ call('(UDP) Adding {host} to ACKN list'.format(host=TEST2_DATA['ip']))]
1059+
1060+ # WHEN: process_ackn called twice with different data
1061+ pjlink_udp.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1062+ pjlink_udp.process_ackn(data=TEST2_DATA['mac_adx'], host=TEST2_DATA['ip'], port=PJLINK_PORT)
1063+
1064+ # THEN: pjlink_udp.ack_list should equal test_list
1065+ # NOTE: This assert only returns AssertionError - does not list differences. Maybe add a compare function?
1066+ if pjlink_udp.ackn_list != check_list:
1067+ # Check this way so we can print differences to stdout
1068+ print('\nackn_list: ', pjlink_udp.ackn_list)
1069+ print('test_list: ', check_list)
1070+ assert pjlink_udp.ackn_list == check_list
1071+ mock_log.debug.assert_has_calls(log_debug_calls)
1072+
1073+ @skip('Change to pjlink_udp.get_datagram() call')
1074+ @patch.object(openlp.core.projectors.pjlink, 'log')
1075+ def test_process_ackn_single(self, mock_log):
1076+ """
1077+ Test process_ackn method with single call
1078+ """
1079+ # TODO: Change this to call pjlink_udp.get_datagram() so ACKN can be processed properly
1080+
1081+ # GIVEN: Test setup
1082+ pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1083+ check_list = {TEST1_DATA['ip']: {'data': TEST1_DATA['mac_adx'], 'port': PJLINK_PORT}}
1084+ log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1085+ call('(UDP) Processing ACKN packet'),
1086+ call('(UDP) Adding {host} to ACKN list'.format(host=TEST1_DATA['ip']))]
1087+
1088+ # WHEN: process_ackn called twice with different data
1089+ pjlink_udp.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1090+
1091+ # THEN: pjlink_udp.ack_list should equal test_list
1092+ # NOTE: This assert only returns AssertionError - does not list differences. Maybe add a compare function?
1093+ if pjlink_udp.ackn_list != check_list:
1094+ # Check this way so we can print differences to stdout
1095+ print('\nackn_list: ', pjlink_udp.ackn_list)
1096+ print('test_list: ', check_list)
1097+ assert pjlink_udp.ackn_list == check_list
1098+ mock_log.debug.assert_has_calls(log_debug_calls)
1099+
1100+ @skip('Change to pjlink_udp.get_datagram() call')
1101+ @patch.object(openlp.core.projectors.pjlink, 'log')
1102+ def test_process_srch(self, mock_log):
1103+ """
1104+ Test process_srch method
1105+ """
1106+ # TODO: Change this to call pjlink_udp.get_datagram() so ACKN can be processed properly
1107+
1108+ # GIVEN: Test setup
1109+ log_warn_calls = [call('(UDP) SRCH packet received from {ip} - ignoring'.format(ip=TEST1_DATA['ip'])), ]
1110+ log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'), ]
1111+ pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1112+
1113+ # WHEN: process_srch called
1114+ pjlink_udp.process_srch(data=None, host=TEST1_DATA['ip'], port=PJLINK_PORT)
1115+
1116+ # THEN: log entries should be entered
1117+ mock_log.warning.assert_has_calls(log_warn_calls)
1118+ mock_log.debug.assert_has_calls(log_debug_calls)
1119
1120=== modified file 'tests/openlp_core/projectors/test_projector_pjlink_udp.py'
1121--- tests/openlp_core/projectors/test_projector_pjlink_udp.py 2018-02-11 11:42:13 +0000
1122+++ tests/openlp_core/projectors/test_projector_pjlink_udp.py 2018-03-24 08:13:55 +0000
1123@@ -28,10 +28,10 @@
1124 from unittest.mock import call, patch
1125
1126 import openlp.core.projectors.pjlink
1127-from openlp.core.projectors.constants import PJLINK_MAX_PACKET, PJLINK_PORT, PJLINK_PREFIX
1128+from openlp.core.projectors.constants import PJLINK_PORT
1129
1130 from openlp.core.projectors.db import Projector
1131-from openlp.core.projectors.pjlink import PJLinkUDP
1132+from openlp.core.projectors.pjlink import PJLinkUDP, PJLink
1133 from tests.resources.projector.data import TEST1_DATA, TEST2_DATA
1134
1135
1136@@ -43,7 +43,8 @@
1137 """
1138 Setup generic test conditions
1139 """
1140- self.test_list = [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]
1141+ self.test_list = [PJLink(projector=Projector(**TEST1_DATA)),
1142+ PJLink(projector=Projector(**TEST2_DATA))]
1143
1144 def tearDown(self):
1145 """
1146@@ -52,132 +53,6 @@
1147 self.test_list = None
1148
1149 @patch.object(openlp.core.projectors.pjlink, 'log')
1150- def test_get_datagram_data_invalid_class(self, mock_log):
1151- """
1152- Test get_datagram with invalid class number
1153- """
1154- # GIVEN: Test setup
1155- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1156- log_warn_calls = [call('(UDP) Invalid packet - missing/invalid PJLink class version')]
1157- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1158- call('(UDP) get_datagram() - Receiving data'),
1159- call('(UDP) 24 bytes received from 111.111.111.111 on port 4352'),
1160- call('(UDP) packet "%1ACKN=11:11:11:11:11:11"')]
1161- with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1162- patch.object(pjlink_udp, 'readDatagram') as mock_read:
1163- mock_datagram.return_value = 24
1164- mock_read.return_value = ('{prefix}1ACKN={mac}'.format(prefix=PJLINK_PREFIX, mac=TEST1_DATA['mac_adx']),
1165- TEST1_DATA['ip'], PJLINK_PORT)
1166-
1167- # WHEN: get_datagram called with 0 bytes ready
1168- pjlink_udp.get_datagram()
1169-
1170- # THEN: Log entries should be made and method returns
1171- mock_log.debug.assert_has_calls(log_debug_calls)
1172- mock_log.warn.assert_has_calls(log_warn_calls)
1173-
1174- @patch.object(openlp.core.projectors.pjlink, 'log')
1175- def test_get_datagram_data_invalid_command(self, mock_log):
1176- """
1177- Test get_datagram with invalid PJLink UDP command
1178- """
1179- # GIVEN: Test setup
1180- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1181- log_warn_calls = [call('(UDP) Invalid packet - not a valid PJLink UDP reply')]
1182- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1183- call('(UDP) get_datagram() - Receiving data'),
1184- call('(UDP) 24 bytes received from 111.111.111.111 on port 4352'),
1185- call('(UDP) packet "%2DUMB=11:11:11:11:11:11"')]
1186- with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1187- patch.object(pjlink_udp, 'readDatagram') as mock_read:
1188- mock_datagram.return_value = 24
1189- mock_read.return_value = ('{prefix}2DUMB={mac}'.format(prefix=PJLINK_PREFIX, mac=TEST1_DATA['mac_adx']),
1190- TEST1_DATA['ip'], PJLINK_PORT)
1191-
1192- # WHEN: get_datagram called with 0 bytes ready
1193- pjlink_udp.get_datagram()
1194-
1195- # THEN: Log entries should be made and method returns
1196- mock_log.debug.assert_has_calls(log_debug_calls)
1197- mock_log.warn.assert_has_calls(log_warn_calls)
1198-
1199- @patch.object(openlp.core.projectors.pjlink, 'log')
1200- def test_get_datagram_data_invalid_prefix(self, mock_log):
1201- """
1202- Test get_datagram when prefix != PJLINK_PREFIX
1203- """
1204- # GIVEN: Test setup
1205- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1206- log_warn_calls = [call('(UDP) Invalid packet - does not start with PJLINK_PREFIX')]
1207- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1208- call('(UDP) get_datagram() - Receiving data'),
1209- call('(UDP) 24 bytes received from 111.111.111.111 on port 4352'),
1210- call('(UDP) packet "$2ACKN=11:11:11:11:11:11"')]
1211- with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1212- patch.object(pjlink_udp, 'readDatagram') as mock_read:
1213- mock_datagram.return_value = 24
1214- mock_read.return_value = ('{prefix}2ACKN={mac}'.format(prefix='$', mac=TEST1_DATA['mac_adx']),
1215- TEST1_DATA['ip'], PJLINK_PORT)
1216-
1217- # WHEN: get_datagram called with 0 bytes ready
1218- pjlink_udp.get_datagram()
1219-
1220- # THEN: Log entries should be made and method returns
1221- mock_log.debug.assert_has_calls(log_debug_calls)
1222- mock_log.warn.assert_has_calls(log_warn_calls)
1223-
1224- @patch.object(openlp.core.projectors.pjlink, 'log')
1225- def test_get_datagram_data_invalid_separator(self, mock_log):
1226- """
1227- Test get_datagram when separator not equal to =
1228- """
1229- # GIVEN: Test setup
1230- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1231- log_warn_calls = [call('(UDP) Invalid packet - separator missing')]
1232- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1233- call('(UDP) get_datagram() - Receiving data'),
1234- call('(UDP) 24 bytes received from 111.111.111.111 on port 4352'),
1235- call('(UDP) packet "%2ACKN 11:11:11:11:11:11"')]
1236- with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1237- patch.object(pjlink_udp, 'readDatagram') as mock_read:
1238- mock_datagram.return_value = 24
1239- mock_read.return_value = ('{prefix}2ACKN {mac}'.format(prefix=PJLINK_PREFIX, mac=TEST1_DATA['mac_adx']),
1240- TEST1_DATA['ip'], PJLINK_PORT)
1241-
1242- # WHEN: get_datagram called with 0 bytes ready
1243- pjlink_udp.get_datagram()
1244-
1245- # THEN: Log entries should be made and method returns
1246- mock_log.debug.assert_has_calls(log_debug_calls)
1247- mock_log.warn.assert_has_calls(log_warn_calls)
1248-
1249- @patch.object(openlp.core.projectors.pjlink, 'log')
1250- def test_get_datagram_data_long(self, mock_log):
1251- """
1252- Test get_datagram when datagram > PJLINK_MAX_PACKET
1253- """
1254- # GIVEN: Test setup
1255- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1256- log_warn_calls = [call('(UDP) Invalid packet - length too long')]
1257- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1258- call('(UDP) get_datagram() - Receiving data'),
1259- call('(UDP) 143 bytes received from 111.111.111.111 on port 4352'),
1260- call('(UDP) packet "%2ACKN={long}"'.format(long='X' * PJLINK_MAX_PACKET))]
1261- with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1262- patch.object(pjlink_udp, 'readDatagram') as mock_read:
1263- mock_datagram.return_value = PJLINK_MAX_PACKET + 7
1264- mock_read.return_value = ('{prefix}2ACKN={long}'.format(prefix=PJLINK_PREFIX,
1265- long='X' * PJLINK_MAX_PACKET),
1266- TEST1_DATA['ip'], PJLINK_PORT)
1267-
1268- # WHEN: get_datagram called with 0 bytes ready
1269- pjlink_udp.get_datagram()
1270-
1271- # THEN: Log entries should be made and method returns
1272- mock_log.debug.assert_has_calls(log_debug_calls)
1273- mock_log.warn.assert_has_calls(log_warn_calls)
1274-
1275- @patch.object(openlp.core.projectors.pjlink, 'log')
1276 def test_get_datagram_data_negative_zero_length(self, mock_log):
1277 """
1278 Test get_datagram when pendingDatagramSize = 0
1279@@ -196,7 +71,7 @@
1280 pjlink_udp.get_datagram()
1281
1282 # THEN: Log entries should be made and method returns
1283- mock_log.warn.assert_has_calls(log_warn_calls)
1284+ mock_log.warning.assert_has_calls(log_warn_calls)
1285 mock_log.debug.assert_has_calls(log_debug_calls)
1286
1287 @patch.object(openlp.core.projectors.pjlink, 'log')
1288@@ -206,41 +81,18 @@
1289 """
1290 # GIVEN: Test setup
1291 pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1292- log_warn_calls = [call('(UDP) Invalid packet - not enough data')]
1293- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1294- call('(UDP) get_datagram() - Receiving data')]
1295+ log_warn_calls = [call('(UDP) get_datagram() called when pending data size is 0')]
1296+ log_debug_calls = [call('(UDP) get_datagram() - Receiving data')]
1297 with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1298 patch.object(pjlink_udp, 'readDatagram') as mock_read:
1299- mock_datagram.return_value = 1
1300+ mock_datagram.return_value = 0
1301 mock_read.return_value = ('', TEST1_DATA['ip'], PJLINK_PORT)
1302
1303 # WHEN: get_datagram called with 0 bytes ready
1304 pjlink_udp.get_datagram()
1305
1306 # THEN: Log entries should be made and method returns
1307- mock_log.warn.assert_has_calls(log_warn_calls)
1308- mock_log.debug.assert_has_calls(log_debug_calls)
1309-
1310- @patch.object(openlp.core.projectors.pjlink, 'log')
1311- def test_get_datagram_data_short(self, mock_log):
1312- """
1313- Test get_datagram when data length < 8
1314- """
1315- # GIVEN: Test setup
1316- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1317- log_warn_calls = [call('(UDP) Invalid packet - not enough data')]
1318- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1319- call('(UDP) get_datagram() - Receiving data')]
1320- with patch.object(pjlink_udp, 'pendingDatagramSize') as mock_datagram, \
1321- patch.object(pjlink_udp, 'readDatagram') as mock_read:
1322- mock_datagram.return_value = 6
1323- mock_read.return_value = ('{prefix}2ACKN'.format(prefix=PJLINK_PREFIX), TEST1_DATA['ip'], PJLINK_PORT)
1324-
1325- # WHEN: get_datagram called with 0 bytes ready
1326- pjlink_udp.get_datagram()
1327-
1328- # THEN: Log entries should be made and method returns
1329- mock_log.warn.assert_has_calls(log_warn_calls)
1330+ mock_log.warning.assert_has_calls(log_warn_calls)
1331 mock_log.debug.assert_has_calls(log_debug_calls)
1332
1333 @patch.object(openlp.core.projectors.pjlink, 'log')
1334@@ -260,101 +112,5 @@
1335 pjlink_udp.get_datagram()
1336
1337 # THEN: Log entries should be made and method returns
1338- mock_log.warn.assert_has_calls(log_warn_calls)
1339+ mock_log.warning.assert_has_calls(log_warn_calls)
1340 mock_log.debug.assert_has_calls(log_debug_calls)
1341-
1342- @patch.object(openlp.core.projectors.pjlink, 'log')
1343- def test_process_ackn_duplicate(self, mock_log):
1344- """
1345- Test process_ackn method with multiple calls with same data
1346- """
1347- # GIVEN: Test setup
1348- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1349- check_list = {TEST1_DATA['ip']: {'data': TEST1_DATA['mac_adx'], 'port': PJLINK_PORT}}
1350- log_warn_calls = [call('(UDP) Host {host} already replied - ignoring'.format(host=TEST1_DATA['ip']))]
1351- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1352- call('(UDP) Processing ACKN packet'),
1353- call('(UDP) Adding {host} to ACKN list'.format(host=TEST1_DATA['ip'])),
1354- call('(UDP) Processing ACKN packet')]
1355-
1356- # WHEN: process_ackn called twice with same data
1357- pjlink_udp.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1358- pjlink_udp.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1359-
1360- # THEN: pjlink_udp.ack_list should equal test_list
1361- # NOTE: This assert only returns AssertionError - does not list differences. Maybe add a compare function?
1362- if pjlink_udp.ackn_list != check_list:
1363- # Check this way so we can print differences to stdout
1364- print('\nackn_list: ', pjlink_udp.ackn_list)
1365- print('test_list: ', check_list)
1366- assert pjlink_udp.ackn_list == check_list
1367- mock_log.debug.assert_has_calls(log_debug_calls)
1368- mock_log.warn.assert_has_calls(log_warn_calls)
1369-
1370- @patch.object(openlp.core.projectors.pjlink, 'log')
1371- def test_process_ackn_multiple(self, mock_log):
1372- """
1373- Test process_ackn method with multiple calls
1374- """
1375- # GIVEN: Test setup
1376- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1377- check_list = {TEST1_DATA['ip']: {'data': TEST1_DATA['mac_adx'], 'port': PJLINK_PORT},
1378- TEST2_DATA['ip']: {'data': TEST2_DATA['mac_adx'], 'port': PJLINK_PORT}}
1379- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1380- call('(UDP) Processing ACKN packet'),
1381- call('(UDP) Adding {host} to ACKN list'.format(host=TEST1_DATA['ip'])),
1382- call('(UDP) Processing ACKN packet'),
1383- call('(UDP) Adding {host} to ACKN list'.format(host=TEST2_DATA['ip']))]
1384-
1385- # WHEN: process_ackn called twice with different data
1386- pjlink_udp.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1387- pjlink_udp.process_ackn(data=TEST2_DATA['mac_adx'], host=TEST2_DATA['ip'], port=PJLINK_PORT)
1388-
1389- # THEN: pjlink_udp.ack_list should equal test_list
1390- # NOTE: This assert only returns AssertionError - does not list differences. Maybe add a compare function?
1391- if pjlink_udp.ackn_list != check_list:
1392- # Check this way so we can print differences to stdout
1393- print('\nackn_list: ', pjlink_udp.ackn_list)
1394- print('test_list: ', check_list)
1395- assert pjlink_udp.ackn_list == check_list
1396- mock_log.debug.assert_has_calls(log_debug_calls)
1397-
1398- @patch.object(openlp.core.projectors.pjlink, 'log')
1399- def test_process_ackn_single(self, mock_log):
1400- """
1401- Test process_ackn method with single call
1402- """
1403- # GIVEN: Test setup
1404- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1405- check_list = {TEST1_DATA['ip']: {'data': TEST1_DATA['mac_adx'], 'port': PJLINK_PORT}}
1406- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1407- call('(UDP) Processing ACKN packet'),
1408- call('(UDP) Adding {host} to ACKN list'.format(host=TEST1_DATA['ip']))]
1409-
1410- # WHEN: process_ackn called twice with different data
1411- pjlink_udp.process_ackn(data=TEST1_DATA['mac_adx'], host=TEST1_DATA['ip'], port=PJLINK_PORT)
1412-
1413- # THEN: pjlink_udp.ack_list should equal test_list
1414- # NOTE: This assert only returns AssertionError - does not list differences. Maybe add a compare function?
1415- if pjlink_udp.ackn_list != check_list:
1416- # Check this way so we can print differences to stdout
1417- print('\nackn_list: ', pjlink_udp.ackn_list)
1418- print('test_list: ', check_list)
1419- assert pjlink_udp.ackn_list == check_list
1420- mock_log.debug.assert_has_calls(log_debug_calls)
1421-
1422- @patch.object(openlp.core.projectors.pjlink, 'log')
1423- def test_process_srch(self, mock_log):
1424- """
1425- Test process_srch method
1426- """
1427- # GIVEN: Test setup
1428- pjlink_udp = PJLinkUDP(projector_list=self.test_list)
1429- log_debug_calls = [call('(UDP) PJLinkUDP() Initialized'),
1430- call('(UDP) SRCH packet received - ignoring')]
1431-
1432- # WHEN: process_srch called
1433- pjlink_udp.process_srch(data=None, host=None, port=None)
1434-
1435- # THEN: debug log entry should be entered
1436- mock_log.debug.assert_has_calls(log_debug_calls)
1437
1438=== renamed file 'tests/openlp_core/projectors/test_projectorsourceform.py' => 'tests/openlp_core/projectors/test_projector_sourceform.py'