forked from openlp/openlp
Merge HEAD
This commit is contained in:
Bastian Germann
commit
d74e5203c3
|
|
@ -595,7 +595,7 @@ class MediaManagerItem(QtWidgets.QWidget, RegistryProperties):
|
|||
:param remote: Triggered from remote
|
||||
:param position: Position to place item
|
||||
"""
|
||||
service_item = self.build_service_item(item, True, remote=remote, context=ServiceItemContext.Service)
|
||||
service_item = self.build_service_item(item, remote=remote, context=ServiceItemContext.Service)
|
||||
if service_item:
|
||||
service_item.from_plugin = False
|
||||
self.service_manager.add_service_item(service_item, replace=replace, position=position)
|
||||
|
|
|
|||
|
|
@ -37,6 +37,8 @@ from openlp.core.ui.icons import UiIcons
|
|||
log = logging.getLogger(__name__)
|
||||
log.debug('editform loaded')
|
||||
|
||||
# TODO: Fix db entries for input source(s)
|
||||
|
||||
|
||||
class Ui_ProjectorEditForm(object):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -47,19 +47,19 @@ Website: http://pjlink.jbmia.or.jp/english/dl_class2.html
|
|||
where ``CCCC`` is the PJLink command being processed
|
||||
"""
|
||||
import logging
|
||||
import re
|
||||
from codecs import decode
|
||||
from copy import copy
|
||||
|
||||
from PyQt5 import QtCore, QtNetwork
|
||||
|
||||
from openlp.core.common import qmd5_hash
|
||||
from openlp.core.common.i18n import translate
|
||||
from openlp.core.common.settings import Settings
|
||||
from openlp.core.projectors.constants import CONNECTION_ERRORS, E_AUTHENTICATION, E_CONNECTION_REFUSED, E_GENERAL, \
|
||||
E_NETWORK, E_NOT_CONNECTED, E_SOCKET_TIMEOUT, PJLINK_CLASS, PJLINK_DEFAULT_CODES, PJLINK_ERRORS, PJLINK_ERST_DATA, \
|
||||
PJLINK_ERST_STATUS, PJLINK_MAX_PACKET, PJLINK_PORT, PJLINK_POWR_STATUS, PJLINK_PREFIX, PJLINK_SUFFIX, \
|
||||
from openlp.core.projectors.pjlinkcommands import process_command
|
||||
from openlp.core.projectors.constants import CONNECTION_ERRORS, E_CONNECTION_REFUSED, E_GENERAL, \
|
||||
E_NETWORK, E_NOT_CONNECTED, E_SOCKET_TIMEOUT, PJLINK_CLASS, \
|
||||
PJLINK_MAX_PACKET, PJLINK_PORT, PJLINK_PREFIX, PJLINK_SUFFIX, \
|
||||
PJLINK_VALID_CMD, PROJECTOR_STATE, QSOCKET_STATE, S_CONNECTED, S_CONNECTING, S_NOT_CONNECTED, S_OFF, S_OK, S_ON, \
|
||||
S_STANDBY, STATUS_CODE, STATUS_MSG
|
||||
STATUS_CODE, STATUS_MSG
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
|
@ -183,544 +183,7 @@ class PJLinkUDP(QtNetwork.QUdpSocket):
|
|||
self.udp_stop()
|
||||
|
||||
|
||||
class PJLinkCommands(object):
|
||||
"""
|
||||
Process replies from PJLink projector.
|
||||
"""
|
||||
# List of IP addresses and mac addresses found via UDP search command
|
||||
ackn_list = []
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
"""
|
||||
Setup for the process commands
|
||||
"""
|
||||
log.debug('PJlinkCommands(args={args} kwargs={kwargs})'.format(args=args, kwargs=kwargs))
|
||||
super().__init__()
|
||||
# Map PJLink command to method and include pjlink class version for this instance
|
||||
# Default initial pjlink class version is '1'
|
||||
self.pjlink_functions = {
|
||||
'ACKN': {"method": self.process_ackn, # Class 2 (command is SRCH)
|
||||
"version": "2"},
|
||||
'AVMT': {"method": self.process_avmt,
|
||||
"version": "1"},
|
||||
'CLSS': {"method": self.process_clss,
|
||||
"version": "1"},
|
||||
'ERST': {"method": self.process_erst,
|
||||
"version": "1"},
|
||||
'INFO': {"method": self.process_info,
|
||||
"version": "1"},
|
||||
'INF1': {"method": self.process_inf1,
|
||||
"version": "1"},
|
||||
'INF2': {"method": self.process_inf2,
|
||||
"version": "1"},
|
||||
'INPT': {"method": self.process_inpt,
|
||||
"version": "1"},
|
||||
'INST': {"method": self.process_inst,
|
||||
"version": "1"},
|
||||
'LAMP': {"method": self.process_lamp,
|
||||
"version": "1"},
|
||||
'LKUP': {"method": self.process_lkup, # Class 2 (reply only - no cmd)
|
||||
"version": "2"},
|
||||
'NAME': {"method": self.process_name,
|
||||
"version": "1"},
|
||||
'PJLINK': {"method": self.process_pjlink,
|
||||
"version": "1"},
|
||||
'POWR': {"method": self.process_powr,
|
||||
"version": "1"},
|
||||
'SNUM': {"method": self.process_snum,
|
||||
"version": "1"},
|
||||
'SRCH': {"method": self.process_srch, # Class 2 (reply is ACKN)
|
||||
"version": "2"},
|
||||
'SVER': {"method": self.process_sver,
|
||||
"version": "1"},
|
||||
'RFIL': {"method": self.process_rfil,
|
||||
"version": "1"},
|
||||
'RLMP': {"method": self.process_rlmp,
|
||||
"version": "1"}
|
||||
}
|
||||
|
||||
def reset_information(self):
|
||||
"""
|
||||
Initialize instance variables. Also used to reset projector-specific information to default.
|
||||
"""
|
||||
conn_state = STATUS_CODE[QSOCKET_STATE[self.state()]]
|
||||
log.debug('({ip}) reset_information() connect status is {state}'.format(ip=self.entry.name,
|
||||
state=conn_state))
|
||||
self.fan = None # ERST
|
||||
self.filter_time = None # FILT
|
||||
self.lamp = None # LAMP
|
||||
self.mac_adx_received = None # ACKN
|
||||
self.manufacturer = None # INF1
|
||||
self.model = None # INF2
|
||||
self.model_filter = None # RFIL
|
||||
self.model_lamp = None # RLMP
|
||||
self.mute = None # AVMT
|
||||
self.other_info = None # INFO
|
||||
self.pjlink_name = None # NAME
|
||||
self.power = S_OFF # POWR
|
||||
self.serial_no = None # SNUM
|
||||
self.serial_no_received = None
|
||||
self.sw_version = None # SVER
|
||||
self.sw_version_received = None
|
||||
self.shutter = None # AVMT
|
||||
self.source_available = None # INST
|
||||
self.source = None # INPT
|
||||
# These should be part of PJLink() class, but set here for convenience
|
||||
if hasattr(self, 'poll_timer'):
|
||||
log.debug('({ip}): Calling poll_timer.stop()'.format(ip=self.entry.name))
|
||||
self.poll_timer.stop()
|
||||
if hasattr(self, 'socket_timer'):
|
||||
log.debug('({ip}): Calling socket_timer.stop()'.format(ip=self.entry.name))
|
||||
self.socket_timer.stop()
|
||||
if hasattr(self, 'status_timer'):
|
||||
log.debug('({ip}): Calling status_timer.stop()'.format(ip=self.entry.name))
|
||||
self.status_timer.stop()
|
||||
self.status_timer_checks = {}
|
||||
self.send_busy = False
|
||||
self.send_queue = []
|
||||
self.priority_queue = []
|
||||
# Reset default version in command routing dict
|
||||
for cmd in self.pjlink_functions:
|
||||
self.pjlink_functions[cmd]["version"] = PJLINK_VALID_CMD[cmd]['default']
|
||||
|
||||
def process_command(self, cmd, data):
|
||||
"""
|
||||
Verifies any return error code. Calls the appropriate command handler.
|
||||
|
||||
:param cmd: Command to process
|
||||
:param data: Data being processed
|
||||
"""
|
||||
log.debug('({ip}) Processing command "{cmd}" with data "{data}"'.format(ip=self.entry.name,
|
||||
cmd=cmd,
|
||||
data=data))
|
||||
# cmd should already be in uppercase, but data may be in mixed-case.
|
||||
# Due to some replies should stay as mixed-case, validate using separate uppercase check
|
||||
_data = data.upper()
|
||||
# Check if we have a future command not available yet
|
||||
if cmd not in self.pjlink_functions:
|
||||
log.warning('({ip}) Unable to process command="{cmd}" (Future option?)'.format(ip=self.entry.name, cmd=cmd))
|
||||
return
|
||||
elif _data == 'OK':
|
||||
log.debug('({ip}) Command "{cmd}" returned OK'.format(ip=self.entry.name, cmd=cmd))
|
||||
# A command returned successfully, so do a query on command to verify status
|
||||
return self.send_command(cmd=cmd)
|
||||
elif _data in PJLINK_ERRORS:
|
||||
# Oops - projector error
|
||||
log.error('({ip}) {cmd}: {err}'.format(ip=self.entry.name,
|
||||
cmd=cmd,
|
||||
err=STATUS_MSG[PJLINK_ERRORS[_data]]))
|
||||
if PJLINK_ERRORS[_data] == E_AUTHENTICATION:
|
||||
self.disconnect_from_host()
|
||||
self.projectorAuthentication.emit(self.name)
|
||||
return self.change_status(status=E_AUTHENTICATION)
|
||||
# Command checks already passed
|
||||
log.debug('({ip}) Calling function for {cmd}'.format(ip=self.entry.name, cmd=cmd))
|
||||
self.pjlink_functions[cmd]["method"](data=data)
|
||||
|
||||
def process_ackn(self, data):
|
||||
"""
|
||||
Process the ACKN command.
|
||||
|
||||
:param data: Data in packet
|
||||
"""
|
||||
# TODO: Have to rethink this one
|
||||
pass
|
||||
|
||||
def process_avmt(self, data):
|
||||
"""
|
||||
Process shutter and speaker status. See PJLink specification for format.
|
||||
Update self.mute (audio) and self.shutter (video shutter).
|
||||
10 = Shutter open, audio unchanged
|
||||
11 = Shutter closed, audio unchanged
|
||||
20 = Shutter unchanged, Audio normal
|
||||
21 = Shutter unchanged, Audio muted
|
||||
30 = Shutter open, audio muted
|
||||
31 = Shutter closed, audio normal
|
||||
|
||||
:param data: Shutter and audio status
|
||||
"""
|
||||
settings = {'10': {'shutter': False, 'mute': self.mute},
|
||||
'11': {'shutter': True, 'mute': self.mute},
|
||||
'20': {'shutter': self.shutter, 'mute': False},
|
||||
'21': {'shutter': self.shutter, 'mute': True},
|
||||
'30': {'shutter': False, 'mute': False},
|
||||
'31': {'shutter': True, 'mute': True}
|
||||
}
|
||||
if data not in settings:
|
||||
log.warning('({ip}) Invalid shutter response: {data}'.format(ip=self.entry.name, data=data))
|
||||
return
|
||||
shutter = settings[data]['shutter']
|
||||
mute = settings[data]['mute']
|
||||
# Check if we need to update the icons
|
||||
update_icons = (shutter != self.shutter) or (mute != self.mute)
|
||||
self.shutter = shutter
|
||||
self.mute = mute
|
||||
if update_icons:
|
||||
if 'AVMT' in self.status_timer_checks:
|
||||
self.status_timer_delete('AVMT')
|
||||
self.projectorUpdateIcons.emit()
|
||||
return
|
||||
|
||||
def process_clss(self, data):
|
||||
"""
|
||||
PJLink class that this projector supports. See PJLink specification for format.
|
||||
Updates self.class.
|
||||
|
||||
:param data: Class that projector supports.
|
||||
"""
|
||||
# bug 1550891: Projector returns non-standard class response:
|
||||
# : Expected: '%1CLSS=1'
|
||||
# : Received: '%1CLSS=Class 1' (Optoma)
|
||||
# : Received: '%1CLSS=Version1' (BenQ)
|
||||
if len(data) > 1:
|
||||
log.warning('({ip}) Non-standard CLSS reply: "{data}"'.format(ip=self.entry.name, data=data))
|
||||
# Due to stupid projectors not following standards (Optoma, BenQ comes to mind),
|
||||
# AND the different responses that can be received, the semi-permanent way to
|
||||
# fix the class reply is to just remove all non-digit characters.
|
||||
chk = re.findall(r'\d', data)
|
||||
if len(chk) < 1:
|
||||
log.error('({ip}) No numbers found in class version reply "{data}" - '
|
||||
'defaulting to class "1"'.format(ip=self.entry.name, data=data))
|
||||
clss = '1'
|
||||
else:
|
||||
clss = chk[0] # Should only be the first match
|
||||
elif not data.isdigit():
|
||||
log.error('({ip}) NAN CLSS version reply "{data}" - '
|
||||
'defaulting to class "1"'.format(ip=self.entry.name, data=data))
|
||||
clss = '1'
|
||||
else:
|
||||
clss = data
|
||||
self.pjlink_class = clss
|
||||
log.debug('({ip}) Setting pjlink_class for this projector '
|
||||
'to "{data}"'.format(ip=self.entry.name,
|
||||
data=self.pjlink_class))
|
||||
# Update method class versions
|
||||
for cmd in self.pjlink_functions:
|
||||
if self.pjlink_class in PJLINK_VALID_CMD[cmd]['version']:
|
||||
self.pjlink_functions[cmd]['version'] = self.pjlink_class
|
||||
|
||||
# Since we call this one on first connect, setup polling from here
|
||||
if not self.no_poll:
|
||||
log.debug('({ip}) process_pjlink(): Starting timer'.format(ip=self.entry.name))
|
||||
self.poll_timer.setInterval(1000) # Set 1 second for initial information
|
||||
self.poll_timer.start()
|
||||
|
||||
return
|
||||
|
||||
def process_erst(self, data):
|
||||
"""
|
||||
Error status. See PJLink Specifications for format.
|
||||
Updates self.projector_errors
|
||||
|
||||
:param data: Error status
|
||||
"""
|
||||
if len(data) != PJLINK_ERST_DATA['DATA_LENGTH']:
|
||||
count = PJLINK_ERST_DATA['DATA_LENGTH']
|
||||
log.warning('({ip}) Invalid error status response "{data}": '
|
||||
'length != {count}'.format(ip=self.entry.name,
|
||||
data=data,
|
||||
count=count))
|
||||
return
|
||||
try:
|
||||
datacheck = int(data)
|
||||
except ValueError:
|
||||
# Bad data - ignore
|
||||
log.warning('({ip}) Invalid error status response "{data}"'.format(ip=self.entry.name, data=data))
|
||||
return
|
||||
if datacheck == 0:
|
||||
self.projector_errors = None
|
||||
# No errors
|
||||
return
|
||||
# We have some sort of status error, so check out what it/they are
|
||||
self.projector_errors = {}
|
||||
fan, lamp, temp, cover, filt, other = (data[PJLINK_ERST_DATA['FAN']],
|
||||
data[PJLINK_ERST_DATA['LAMP']],
|
||||
data[PJLINK_ERST_DATA['TEMP']],
|
||||
data[PJLINK_ERST_DATA['COVER']],
|
||||
data[PJLINK_ERST_DATA['FILTER']],
|
||||
data[PJLINK_ERST_DATA['OTHER']])
|
||||
if fan != PJLINK_ERST_STATUS[S_OK]:
|
||||
self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Fan')] = \
|
||||
PJLINK_ERST_STATUS[fan]
|
||||
if lamp != PJLINK_ERST_STATUS[S_OK]:
|
||||
self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Lamp')] = \
|
||||
PJLINK_ERST_STATUS[lamp]
|
||||
if temp != PJLINK_ERST_STATUS[S_OK]:
|
||||
self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Temperature')] = \
|
||||
PJLINK_ERST_STATUS[temp]
|
||||
if cover != PJLINK_ERST_STATUS[S_OK]:
|
||||
self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Cover')] = \
|
||||
PJLINK_ERST_STATUS[cover]
|
||||
if filt != PJLINK_ERST_STATUS[S_OK]:
|
||||
self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Filter')] = \
|
||||
PJLINK_ERST_STATUS[filt]
|
||||
if other != PJLINK_ERST_STATUS[S_OK]:
|
||||
self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Other')] = \
|
||||
PJLINK_ERST_STATUS[other]
|
||||
return
|
||||
|
||||
def process_inf1(self, data):
|
||||
"""
|
||||
Manufacturer name set in projector.
|
||||
Updates self.manufacturer
|
||||
|
||||
:param data: Projector manufacturer
|
||||
"""
|
||||
self.manufacturer = data
|
||||
log.debug('({ip}) Setting projector manufacturer data to "{data}"'.format(ip=self.entry.name,
|
||||
data=self.manufacturer))
|
||||
return
|
||||
|
||||
def process_inf2(self, data):
|
||||
"""
|
||||
Projector Model set in projector.
|
||||
Updates self.model.
|
||||
|
||||
:param data: Model name
|
||||
"""
|
||||
self.model = data
|
||||
log.debug('({ip}) Setting projector model to "{data}"'.format(ip=self.entry.name, data=self.model))
|
||||
return
|
||||
|
||||
def process_info(self, data):
|
||||
"""
|
||||
Any extra info set in projector.
|
||||
Updates self.other_info.
|
||||
|
||||
:param data: Projector other info
|
||||
"""
|
||||
self.other_info = data
|
||||
log.debug('({ip}) Setting projector other_info to "{data}"'.format(ip=self.entry.name, data=self.other_info))
|
||||
return
|
||||
|
||||
def process_inpt(self, data):
|
||||
"""
|
||||
Current source input selected. See PJLink specification for format.
|
||||
Update self.source
|
||||
|
||||
:param data: Currently selected source
|
||||
"""
|
||||
# First, see if we have a valid input based on what is installed (if available)
|
||||
if self.source_available is not None:
|
||||
# We have available inputs, so verify it's in the list
|
||||
if data not in self.source_available:
|
||||
log.warn('({ip}) Input source not listed in available sources - ignoring'.format(ip=self.entry.name))
|
||||
return
|
||||
elif data not in PJLINK_DEFAULT_CODES:
|
||||
# Hmm - no sources available yet, so check with PJLink defaults
|
||||
log.warn('({ip}) Input source not listed as a PJLink available source '
|
||||
'- ignoring'.format(ip=self.entry.name))
|
||||
return
|
||||
self.source = data
|
||||
log.debug('({ip}) Setting data source to "{data}"'.format(ip=self.entry.name, data=self.source))
|
||||
return
|
||||
|
||||
def process_inst(self, data):
|
||||
"""
|
||||
Available source inputs. See PJLink specification for format.
|
||||
Updates self.source_available
|
||||
|
||||
:param data: Sources list
|
||||
"""
|
||||
sources = []
|
||||
check = data.split()
|
||||
for source in check:
|
||||
sources.append(source)
|
||||
sources.sort()
|
||||
self.source_available = sources
|
||||
log.debug('({ip}) Setting projector source_available to "{data}"'.format(ip=self.entry.name,
|
||||
data=self.source_available))
|
||||
self.projectorUpdateIcons.emit()
|
||||
return
|
||||
|
||||
def process_lamp(self, data):
|
||||
"""
|
||||
Lamp(s) status. See PJLink Specifications for format.
|
||||
Data may have more than 1 lamp to process.
|
||||
Update self.lamp dictionary with lamp status.
|
||||
|
||||
:param data: Lamp(s) status.
|
||||
"""
|
||||
lamps = []
|
||||
lamp_list = data.split()
|
||||
if len(lamp_list) < 2:
|
||||
lamps.append({'Hours': int(lamp_list[0]), 'On': None})
|
||||
else:
|
||||
while lamp_list:
|
||||
try:
|
||||
fill = {'Hours': int(lamp_list[0]), 'On': False if lamp_list[1] == '0' else True}
|
||||
except ValueError:
|
||||
# In case of invalid entry
|
||||
log.warning('({ip}) process_lamp(): Invalid data "{data}"'.format(ip=self.entry.name, data=data))
|
||||
return
|
||||
lamps.append(fill)
|
||||
lamp_list.pop(0) # Remove lamp hours
|
||||
lamp_list.pop(0) # Remove lamp on/off
|
||||
self.lamp = lamps
|
||||
return
|
||||
|
||||
def process_lkup(self, data):
|
||||
"""
|
||||
Process reply indicating remote is available for connection
|
||||
|
||||
:param data: Data packet from remote
|
||||
"""
|
||||
log.debug('({ip}) Processing LKUP command'.format(ip=self.entry.name))
|
||||
if Settings().value('projector/connect when LKUP received'):
|
||||
self.connect_to_host()
|
||||
|
||||
def process_name(self, data):
|
||||
"""
|
||||
Projector name set in projector.
|
||||
Updates self.pjlink_name
|
||||
|
||||
:param data: Projector name
|
||||
"""
|
||||
self.pjlink_name = data
|
||||
log.debug('({ip}) Setting projector PJLink name to "{data}"'.format(ip=self.entry.name, data=self.pjlink_name))
|
||||
return
|
||||
|
||||
def process_pjlink(self, data):
|
||||
"""
|
||||
Process initial socket connection to terminal.
|
||||
|
||||
:param data: Initial packet with authentication scheme
|
||||
"""
|
||||
log.debug('({ip}) Processing PJLINK command'.format(ip=self.entry.name))
|
||||
chk = data.split(' ')
|
||||
if len(chk[0]) != 1:
|
||||
# Invalid - after splitting, first field should be 1 character, either '0' or '1' only
|
||||
log.error('({ip}) Invalid initial authentication scheme - aborting'.format(ip=self.entry.name))
|
||||
return self.disconnect_from_host()
|
||||
elif chk[0] == '0':
|
||||
# Normal connection no authentication
|
||||
if len(chk) > 1:
|
||||
# Invalid data - there should be nothing after a normal authentication scheme
|
||||
log.error('({ip}) Normal connection with extra information - aborting'.format(ip=self.entry.name))
|
||||
return self.disconnect_from_host()
|
||||
elif self.pin:
|
||||
log.error('({ip}) Normal connection but PIN set - aborting'.format(ip=self.entry.name))
|
||||
return self.disconnect_from_host()
|
||||
else:
|
||||
data_hash = None
|
||||
elif chk[0] == '1':
|
||||
if len(chk) < 2:
|
||||
# Not enough information for authenticated connection
|
||||
log.error('({ip}) Authenticated connection but not enough info - aborting'.format(ip=self.entry.name))
|
||||
return self.disconnect_from_host()
|
||||
elif not self.pin:
|
||||
log.error('({ip}) Authenticate connection but no PIN - aborting'.format(ip=self.entry.name))
|
||||
return self.disconnect_from_host()
|
||||
else:
|
||||
data_hash = str(qmd5_hash(salt=chk[1].encode('utf-8'), data=self.pin.encode('utf-8')),
|
||||
encoding='ascii')
|
||||
# Passed basic checks, so start connection
|
||||
self.readyRead.connect(self.get_socket)
|
||||
self.change_status(S_CONNECTED)
|
||||
log.debug('({ip}) process_pjlink(): Sending "CLSS" initial command'.format(ip=self.entry.name))
|
||||
# Since this is an initial connection, make it a priority just in case
|
||||
return self.send_command(cmd="CLSS", salt=data_hash, priority=True)
|
||||
|
||||
def process_powr(self, data):
|
||||
"""
|
||||
Power status. See PJLink specification for format.
|
||||
Update self.power with status. Update icons if change from previous setting.
|
||||
|
||||
:param data: Power status
|
||||
"""
|
||||
log.debug('({ip}: Processing POWR command'.format(ip=self.entry.name))
|
||||
if data in PJLINK_POWR_STATUS:
|
||||
power = PJLINK_POWR_STATUS[data]
|
||||
update_icons = self.power != power
|
||||
self.power = power
|
||||
self.change_status(PJLINK_POWR_STATUS[data])
|
||||
if update_icons:
|
||||
self.projectorUpdateIcons.emit()
|
||||
# Update the input sources available
|
||||
if power == S_ON:
|
||||
self.send_command('INST')
|
||||
else:
|
||||
# Log unknown status response
|
||||
log.warning('({ip}) Unknown power response: "{data}"'.format(ip=self.entry.name, data=data))
|
||||
if self.power in [S_ON, S_STANDBY, S_OFF] and 'POWR' in self.status_timer_checks:
|
||||
self.status_timer_delete(cmd='POWR')
|
||||
return
|
||||
|
||||
def process_rfil(self, data):
|
||||
"""
|
||||
Process replacement filter type
|
||||
"""
|
||||
if self.model_filter is None:
|
||||
self.model_filter = data
|
||||
else:
|
||||
log.warning('({ip}) Filter model already set'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) Saved model: "{old}"'.format(ip=self.entry.name, old=self.model_filter))
|
||||
log.warning('({ip}) New model: "{new}"'.format(ip=self.entry.name, new=data))
|
||||
|
||||
def process_rlmp(self, data):
|
||||
"""
|
||||
Process replacement lamp type
|
||||
"""
|
||||
if self.model_lamp is None:
|
||||
self.model_lamp = data
|
||||
else:
|
||||
log.warning('({ip}) Lamp model already set'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) Saved lamp: "{old}"'.format(ip=self.entry.name, old=self.model_lamp))
|
||||
log.warning('({ip}) New lamp: "{new}"'.format(ip=self.entry.name, new=data))
|
||||
|
||||
def process_snum(self, data):
|
||||
"""
|
||||
Serial number of projector.
|
||||
|
||||
:param data: Serial number from projector.
|
||||
"""
|
||||
if self.serial_no is None:
|
||||
log.debug('({ip}) Setting projector serial number to "{data}"'.format(ip=self.entry.name, data=data))
|
||||
self.serial_no = data
|
||||
self.db_update = False
|
||||
else:
|
||||
# Compare serial numbers and see if we got the same projector
|
||||
if self.serial_no != data:
|
||||
log.warning('({ip}) Projector serial number does not match saved serial '
|
||||
'number'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) Saved: "{old}"'.format(ip=self.entry.name, old=self.serial_no))
|
||||
log.warning('({ip}) Received: "{new}"'.format(ip=self.entry.name, new=data))
|
||||
log.warning('({ip}) NOT saving serial number'.format(ip=self.entry.name))
|
||||
self.serial_no_received = data
|
||||
|
||||
def process_srch(self, data):
|
||||
"""
|
||||
Process the SRCH command.
|
||||
|
||||
SRCH is processed by terminals so we ignore any packet.
|
||||
|
||||
:param data: Data in packet
|
||||
"""
|
||||
log.warning("({ip}) SRCH packet detected - ignoring".format(ip=self.entry.ip))
|
||||
return
|
||||
|
||||
def process_sver(self, data):
|
||||
"""
|
||||
Software version of projector
|
||||
"""
|
||||
if len(data) > 32:
|
||||
# Defined in specs max version is 32 characters
|
||||
log.warning('Invalid software version - too long')
|
||||
return
|
||||
elif self.sw_version is None:
|
||||
log.debug('({ip}) Setting projector software version to "{data}"'.format(ip=self.entry.name, data=data))
|
||||
else:
|
||||
if self.sw_version != data:
|
||||
log.warning('({ip}) Projector software version does not match saved '
|
||||
'software version'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) Saved: "{old}"'.format(ip=self.entry.name, old=self.sw_version))
|
||||
log.warning('({ip}) Received: "{new}"'.format(ip=self.entry.name, new=data))
|
||||
log.warning('({ip}) Updating software version'.format(ip=self.entry.name))
|
||||
self.sw_version = data
|
||||
self.db_update = True
|
||||
|
||||
|
||||
class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
||||
class PJLink(QtNetwork.QTcpSocket):
|
||||
"""
|
||||
Socket services for PJLink TCP packets.
|
||||
"""
|
||||
|
|
@ -797,6 +260,48 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
self.error.connect(self.get_error)
|
||||
self.projectorReceivedData.connect(self._send_command)
|
||||
|
||||
def reset_information(self):
|
||||
"""
|
||||
Initialize instance variables. Also used to reset projector-specific information to default.
|
||||
"""
|
||||
conn_state = STATUS_CODE[QSOCKET_STATE[self.state()]]
|
||||
log.debug('({ip}) reset_information() connect status is {state}'.format(ip=self.entry.name,
|
||||
state=conn_state))
|
||||
self.fan = None # ERST
|
||||
self.filter_time = None # FILT
|
||||
self.lamp = None # LAMP
|
||||
self.mac_adx_received = None # ACKN
|
||||
self.manufacturer = None # INF1
|
||||
self.model = None # INF2
|
||||
self.model_filter = None # RFIL
|
||||
self.model_lamp = None # RLMP
|
||||
self.mute = None # AVMT
|
||||
self.other_info = None # INFO
|
||||
self.pjlink_class = copy(PJLINK_CLASS)
|
||||
self.pjlink_name = None # NAME
|
||||
self.power = S_OFF # POWR
|
||||
self.serial_no = None # SNUM
|
||||
self.serial_no_received = None
|
||||
self.sw_version = None # SVER
|
||||
self.sw_version_received = None
|
||||
self.shutter = None # AVMT
|
||||
self.source_available = None # INST
|
||||
self.source = None # INPT
|
||||
# These should be part of PJLink() class, but set here for convenience
|
||||
if hasattr(self, 'poll_timer'):
|
||||
log.debug('({ip}): Calling poll_timer.stop()'.format(ip=self.entry.name))
|
||||
self.poll_timer.stop()
|
||||
if hasattr(self, 'socket_timer'):
|
||||
log.debug('({ip}): Calling socket_timer.stop()'.format(ip=self.entry.name))
|
||||
self.socket_timer.stop()
|
||||
if hasattr(self, 'status_timer'):
|
||||
log.debug('({ip}): Calling status_timer.stop()'.format(ip=self.entry.name))
|
||||
self.status_timer.stop()
|
||||
self.status_timer_checks = {}
|
||||
self.send_busy = False
|
||||
self.send_queue = []
|
||||
self.priority_queue = []
|
||||
|
||||
def socket_abort(self):
|
||||
"""
|
||||
Aborts connection and closes socket in case of brain-dead projectors.
|
||||
|
|
@ -1032,10 +537,7 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
log.debug('({ip}) get_data(buffer="{buff}"'.format(ip=self.entry.name, buff=buff))
|
||||
ignore_class = 'ignore_class' in kwargs
|
||||
# NOTE: Class2 has changed to some values being UTF-8
|
||||
if isinstance(buff, bytes):
|
||||
data_in = decode(buff, 'utf-8')
|
||||
else:
|
||||
data_in = buff
|
||||
data_in = decode(buff, 'utf-8') if isinstance(buff, bytes) else buff
|
||||
data = data_in.strip()
|
||||
# Initial packet checks
|
||||
if (len(data) < 7):
|
||||
|
|
@ -1088,7 +590,7 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
if not ignore_class:
|
||||
log.warning('({ip}) get_data(): Projector returned class reply higher '
|
||||
'than projector stated class'.format(ip=self.entry.name))
|
||||
self.process_command(cmd, data)
|
||||
process_command(self, cmd, data)
|
||||
return self.receive_data_signal()
|
||||
|
||||
@QtCore.pyqtSlot(QtNetwork.QAbstractSocket.SocketError)
|
||||
|
|
@ -1129,27 +631,32 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
:param salt: Optional salt for md5 hash initial authentication
|
||||
:param priority: Option to send packet now rather than queue it up
|
||||
"""
|
||||
if QSOCKET_STATE[self.state()] != S_CONNECTED:
|
||||
if QSOCKET_STATE[self.state()] != QSOCKET_STATE[S_CONNECTED]:
|
||||
log.warning('({ip}) send_command(): Not connected - returning'.format(ip=self.entry.name))
|
||||
return self.reset_information()
|
||||
if cmd not in PJLINK_VALID_CMD:
|
||||
log.error('({ip}) send_command(): Invalid command requested - ignoring.'.format(ip=self.entry.name))
|
||||
if self.priority_queue or self.send_queue:
|
||||
# Just in case there's already something to send
|
||||
return self._send_command()
|
||||
return
|
||||
log.debug('({ip}) send_command(): Building cmd="{command}" opts="{data}"{salt}'.format(ip=self.entry.name,
|
||||
command=cmd,
|
||||
data=opts,
|
||||
salt='' if salt is None
|
||||
else ' with hash'))
|
||||
header = PJLINK_HEADER.format(linkclass=self.pjlink_functions[cmd]["version"])
|
||||
# Until we absolutely have to start doing version checks, use the default
|
||||
# for PJLink class
|
||||
header = PJLINK_HEADER.format(linkclass=PJLINK_VALID_CMD[cmd]['default'])
|
||||
out = '{salt}{header}{command} {options}{suffix}'.format(salt="" if salt is None else salt,
|
||||
header=header,
|
||||
command=cmd,
|
||||
options=opts,
|
||||
suffix=PJLINK_SUFFIX)
|
||||
if out in self.priority_queue:
|
||||
log.debug('({ip}) send_command(): Already in priority queue - skipping'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) send_command(): Already in priority queue - skipping'.format(ip=self.entry.name))
|
||||
elif out in self.send_queue:
|
||||
log.debug('({ip}) send_command(): Already in normal queue - skipping'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) send_command(): Already in normal queue - skipping'.format(ip=self.entry.name))
|
||||
else:
|
||||
if priority:
|
||||
log.debug('({ip}) send_command(): Adding to priority queue'.format(ip=self.entry.name))
|
||||
|
|
@ -1170,7 +677,8 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
:param utf8: Send as UTF-8 string otherwise send as ASCII string
|
||||
"""
|
||||
if not data and not self.priority_queue and not self.send_queue:
|
||||
log.debug('({ip}) _send_command(): Nothing to send - returning'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) _send_command(): Nothing to send - returning'.format(ip=self.entry.name))
|
||||
self.send_busy = False
|
||||
return
|
||||
log.debug('({ip}) _send_command(data="{data}")'.format(ip=self.entry.name,
|
||||
data=data.strip() if data else data))
|
||||
|
|
@ -1182,7 +690,7 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
log.debug('({ip}) _send_command(): Connection status: {data}'.format(ip=self.entry.name,
|
||||
data=conn_state))
|
||||
if QSOCKET_STATE[self.state()] != S_CONNECTED:
|
||||
log.debug('({ip}) _send_command() Not connected - abort'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) _send_command() Not connected - abort'.format(ip=self.entry.name))
|
||||
self.send_busy = False
|
||||
return self.disconnect_from_host()
|
||||
if data and data not in self.priority_queue:
|
||||
|
|
@ -1205,7 +713,7 @@ class PJLink(QtNetwork.QTcpSocket, PJLinkCommands):
|
|||
log.debug('({ip}) _send_command(): Getting normal queued packet'.format(ip=self.entry.name))
|
||||
else:
|
||||
# No data to send
|
||||
log.debug('({ip}) _send_command(): No data to send'.format(ip=self.entry.name))
|
||||
log.warning('({ip}) _send_command(): No data to send'.format(ip=self.entry.name))
|
||||
self.send_busy = False
|
||||
return
|
||||
self.send_busy = True
|
||||
|
|
|
|||
|
|
@ -0,0 +1,550 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4
|
||||
|
||||
###############################################################################
|
||||
# OpenLP - Open Source Lyrics Projection #
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Copyright (c) 2008-2019 OpenLP Developers #
|
||||
# --------------------------------------------------------------------------- #
|
||||
# This program is free software; you can redistribute it and/or modify it #
|
||||
# under the terms of the GNU General Public License as published by the Free #
|
||||
# Software Foundation; version 2 of the License. #
|
||||
# #
|
||||
# This program is distributed in the hope that it will be useful, but WITHOUT #
|
||||
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or #
|
||||
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for #
|
||||
# more details. #
|
||||
# #
|
||||
# You should have received a copy of the GNU General Public License along #
|
||||
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
|
||||
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
|
||||
###############################################################################
|
||||
"""
|
||||
The :mod:`openlp.core.lib.projector.pjlinkcmmands` module provides the necessary functions for
|
||||
processing projector replies.
|
||||
|
||||
NOTE: PJLink Class (version) checks are handled in the respective PJLink/PJLinkUDP classes.
|
||||
process_clss is the only exception.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import re
|
||||
|
||||
from openlp.core.common import qmd5_hash
|
||||
|
||||
from openlp.core.common.i18n import translate
|
||||
from openlp.core.common.settings import Settings
|
||||
|
||||
from openlp.core.projectors.constants import E_AUTHENTICATION, PJLINK_DEFAULT_CODES, PJLINK_ERRORS, \
|
||||
PJLINK_ERST_DATA, PJLINK_ERST_STATUS, PJLINK_POWR_STATUS, S_CONNECTED, S_OFF, S_OK, S_ON, S_STANDBY, \
|
||||
STATUS_MSG
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
log.debug('Loading pjlinkcommands')
|
||||
|
||||
__all__ = ['process_command']
|
||||
|
||||
|
||||
# This should be the only function that's imported.
|
||||
def process_command(projector, cmd, data):
|
||||
"""
|
||||
Verifies any return error code. Calls the appropriate command handler.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param cmd: Command to process
|
||||
:param data: Data being processed
|
||||
"""
|
||||
log.debug('({ip}) Processing command "{cmd}" with data "{data}"'.format(ip=projector.entry.name,
|
||||
cmd=cmd,
|
||||
data=data))
|
||||
# cmd should already be in uppercase, but data may be in mixed-case.
|
||||
# Due to some replies should stay as mixed-case, validate using separate uppercase check
|
||||
_data = data.upper()
|
||||
# Check if we have a future command not available yet
|
||||
if cmd not in pjlink_functions:
|
||||
log.warning('({ip}) Unable to process command="{cmd}" (Future option?)'.format(ip=projector.entry.name,
|
||||
cmd=cmd))
|
||||
return
|
||||
elif _data == 'OK':
|
||||
log.debug('({ip}) Command "{cmd}" returned OK'.format(ip=projector.entry.name, cmd=cmd))
|
||||
# A command returned successfully, so do a query on command to verify status
|
||||
return projector.send_command(cmd=cmd, priority=True)
|
||||
elif _data in PJLINK_ERRORS:
|
||||
# Oops - projector error
|
||||
log.error('({ip}) {cmd}: {err}'.format(ip=projector.entry.name,
|
||||
cmd=cmd,
|
||||
err=STATUS_MSG[PJLINK_ERRORS[_data]]))
|
||||
if PJLINK_ERRORS[_data] == E_AUTHENTICATION:
|
||||
projector.disconnect_from_host()
|
||||
projector.projectorAuthentication.emit(projector.name)
|
||||
return projector.change_status(status=E_AUTHENTICATION)
|
||||
# Command checks already passed
|
||||
log.debug('({ip}) Calling function for {cmd}'.format(ip=projector.entry.name, cmd=cmd))
|
||||
pjlink_functions[cmd](projector=projector, data=data)
|
||||
|
||||
|
||||
def process_ackn(projector, data):
|
||||
"""
|
||||
Process the ACKN command.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Data in packet
|
||||
"""
|
||||
# TODO: Have to rethink this one
|
||||
pass
|
||||
|
||||
|
||||
def process_avmt(projector, data):
|
||||
"""
|
||||
Process shutter and speaker status. See PJLink specification for format.
|
||||
Update projector.mute (audio) and projector.shutter (video shutter).
|
||||
10 = Shutter open, audio unchanged
|
||||
11 = Shutter closed, audio unchanged
|
||||
20 = Shutter unchanged, Audio normal
|
||||
21 = Shutter unchanged, Audio muted
|
||||
30 = Shutter open, audio muted
|
||||
31 = Shutter closed, audio normal
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Shutter and audio status
|
||||
"""
|
||||
settings = {'10': {'shutter': False, 'mute': projector.mute},
|
||||
'11': {'shutter': True, 'mute': projector.mute},
|
||||
'20': {'shutter': projector.shutter, 'mute': False},
|
||||
'21': {'shutter': projector.shutter, 'mute': True},
|
||||
'30': {'shutter': False, 'mute': False},
|
||||
'31': {'shutter': True, 'mute': True}
|
||||
}
|
||||
if data not in settings:
|
||||
log.warning('({ip}) Invalid shutter response: {data}'.format(ip=projector.entry.name, data=data))
|
||||
return
|
||||
shutter = settings[data]['shutter']
|
||||
mute = settings[data]['mute']
|
||||
# Check if we need to update the icons
|
||||
update_icons = (shutter != projector.shutter) or (mute != projector.mute)
|
||||
projector.shutter = shutter
|
||||
projector.mute = mute
|
||||
if update_icons:
|
||||
if 'AVMT' in projector.status_timer_checks:
|
||||
projector.status_timer_delete('AVMT')
|
||||
projector.projectorUpdateIcons.emit()
|
||||
return
|
||||
|
||||
|
||||
def process_clss(projector, data):
|
||||
"""
|
||||
PJLink class that this projector supports. See PJLink specification for format.
|
||||
Updates projector.class.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Class that projector supports.
|
||||
"""
|
||||
# bug 1550891: Projector returns non-standard class response:
|
||||
# : Expected: '%1CLSS=1'
|
||||
# : Received: '%1CLSS=Class 1' (Optoma)
|
||||
# : Received: '%1CLSS=Version1' (BenQ)
|
||||
if len(data) > 1:
|
||||
log.warning('({ip}) Non-standard CLSS reply: "{data}"'.format(ip=projector.entry.name, data=data))
|
||||
# Due to stupid projectors not following standards (Optoma, BenQ comes to mind),
|
||||
# AND the different responses that can be received, the semi-permanent way to
|
||||
# fix the class reply is to just remove all non-digit characters.
|
||||
chk = re.findall(r'\d', data)
|
||||
if len(chk) < 1:
|
||||
log.error('({ip}) No numbers found in class version reply "{data}" - '
|
||||
'defaulting to class "1"'.format(ip=projector.entry.name, data=data))
|
||||
clss = '1'
|
||||
else:
|
||||
clss = chk[0] # Should only be the first match
|
||||
elif not data.isdigit():
|
||||
log.error('({ip}) NAN CLSS version reply "{data}" - '
|
||||
'defaulting to class "1"'.format(ip=projector.entry.name, data=data))
|
||||
clss = '1'
|
||||
else:
|
||||
clss = data
|
||||
projector.pjlink_class = clss
|
||||
log.debug('({ip}) Setting pjlink_class for this projector to "{data}"'.format(ip=projector.entry.name,
|
||||
data=projector.pjlink_class))
|
||||
if projector.no_poll:
|
||||
return
|
||||
|
||||
# Since we call this one on first connect, setup polling from here
|
||||
log.debug('({ip}) process_pjlink(): Starting timer'.format(ip=projector.entry.name))
|
||||
projector.poll_timer.setInterval(1000) # Set 1 second for initial information
|
||||
projector.poll_timer.start()
|
||||
return
|
||||
|
||||
|
||||
def process_erst(projector, data):
|
||||
"""
|
||||
Error status. See PJLink Specifications for format.
|
||||
Updates projector.projector_errors
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Error status
|
||||
"""
|
||||
if len(data) != PJLINK_ERST_DATA['DATA_LENGTH']:
|
||||
count = PJLINK_ERST_DATA['DATA_LENGTH']
|
||||
log.warning('({ip}) Invalid error status response "{data}": length != {count}'.format(ip=projector.entry.name,
|
||||
data=data,
|
||||
count=count))
|
||||
return
|
||||
if not data.isnumeric():
|
||||
# Bad data - ignore
|
||||
log.warning('({ip}) Invalid error status response "{data}"'.format(ip=projector.entry.name, data=data))
|
||||
return
|
||||
datacheck = int(data)
|
||||
if datacheck == 0:
|
||||
projector.projector_errors = None
|
||||
# No errors
|
||||
return
|
||||
# We have some sort of status error, so check out what it/they are
|
||||
projector.projector_errors = {}
|
||||
fan, lamp, temp, cover, filt, other = (data[PJLINK_ERST_DATA['FAN']],
|
||||
data[PJLINK_ERST_DATA['LAMP']],
|
||||
data[PJLINK_ERST_DATA['TEMP']],
|
||||
data[PJLINK_ERST_DATA['COVER']],
|
||||
data[PJLINK_ERST_DATA['FILTER']],
|
||||
data[PJLINK_ERST_DATA['OTHER']])
|
||||
if fan != PJLINK_ERST_STATUS[S_OK]:
|
||||
projector.projector_errors[translate('OpenLP.ProjectorPJLink', 'Fan')] = \
|
||||
PJLINK_ERST_STATUS[fan]
|
||||
if lamp != PJLINK_ERST_STATUS[S_OK]:
|
||||
projector.projector_errors[translate('OpenLP.ProjectorPJLink', 'Lamp')] = \
|
||||
PJLINK_ERST_STATUS[lamp]
|
||||
if temp != PJLINK_ERST_STATUS[S_OK]:
|
||||
projector.projector_errors[translate('OpenLP.ProjectorPJLink', 'Temperature')] = \
|
||||
PJLINK_ERST_STATUS[temp]
|
||||
if cover != PJLINK_ERST_STATUS[S_OK]:
|
||||
projector.projector_errors[translate('OpenLP.ProjectorPJLink', 'Cover')] = \
|
||||
PJLINK_ERST_STATUS[cover]
|
||||
if filt != PJLINK_ERST_STATUS[S_OK]:
|
||||
projector.projector_errors[translate('OpenLP.ProjectorPJLink', 'Filter')] = \
|
||||
PJLINK_ERST_STATUS[filt]
|
||||
if other != PJLINK_ERST_STATUS[S_OK]:
|
||||
projector.projector_errors[translate('OpenLP.ProjectorPJLink', 'Other')] = \
|
||||
PJLINK_ERST_STATUS[other]
|
||||
return
|
||||
|
||||
|
||||
def process_inf1(projector, data):
|
||||
"""
|
||||
Manufacturer name set in projector.
|
||||
Updates projector.manufacturer
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Projector manufacturer
|
||||
"""
|
||||
projector.manufacturer = data
|
||||
log.debug('({ip}) Setting projector manufacturer data to "{data}"'.format(ip=projector.entry.name,
|
||||
data=projector.manufacturer))
|
||||
return
|
||||
|
||||
|
||||
def process_inf2(projector, data):
|
||||
"""
|
||||
Projector Model set in projector.
|
||||
Updates projector.model.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Model name
|
||||
"""
|
||||
projector.model = data
|
||||
log.debug('({ip}) Setting projector model to "{data}"'.format(ip=projector.entry.name, data=projector.model))
|
||||
return
|
||||
|
||||
|
||||
def process_info(projector, data):
|
||||
"""
|
||||
Any extra info set in projector.
|
||||
Updates projector.other_info.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Projector other info
|
||||
"""
|
||||
projector.other_info = data
|
||||
log.debug('({ip}) Setting projector other_info to "{data}"'.format(ip=projector.entry.name,
|
||||
data=projector.other_info))
|
||||
return
|
||||
|
||||
|
||||
def process_inpt(projector, data):
|
||||
"""
|
||||
Current source input selected. See PJLink specification for format.
|
||||
Update projector.source
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Currently selected source
|
||||
"""
|
||||
# First, see if we have a valid input based on what is installed (if available)
|
||||
if projector.source_available is not None:
|
||||
# We have available inputs, so verify it's in the list
|
||||
if data not in projector.source_available:
|
||||
log.warn('({ip}) Input source not listed in available sources - ignoring'.format(ip=projector.entry.name))
|
||||
return
|
||||
elif data not in PJLINK_DEFAULT_CODES:
|
||||
# Hmm - no sources available yet, so check with PJLink defaults
|
||||
log.warn('({ip}) Input source not listed as a PJLink available source '
|
||||
'- ignoring'.format(ip=projector.entry.name))
|
||||
return
|
||||
projector.source = data
|
||||
log.debug('({ip}) Setting current source to "{data}"'.format(ip=projector.entry.name, data=projector.source))
|
||||
return
|
||||
|
||||
|
||||
def process_inst(projector, data):
|
||||
"""
|
||||
Available source inputs. See PJLink specification for format.
|
||||
Updates projector.source_available
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Sources list
|
||||
"""
|
||||
sources = []
|
||||
check = data.split()
|
||||
for source in check:
|
||||
sources.append(source)
|
||||
sources.sort()
|
||||
projector.source_available = sources
|
||||
log.debug('({ip}) Setting projector source_available to "{data}"'.format(ip=projector.entry.name,
|
||||
data=projector.source_available))
|
||||
projector.projectorUpdateIcons.emit()
|
||||
return
|
||||
|
||||
|
||||
def process_lamp(projector, data):
|
||||
"""
|
||||
Lamp(s) status. See PJLink Specifications for format.
|
||||
Data may have more than 1 lamp to process.
|
||||
Update projector.lamp dictionary with lamp status.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Lamp(s) status.
|
||||
"""
|
||||
lamps = []
|
||||
lamp_list = data.split()
|
||||
if len(lamp_list) < 2:
|
||||
lamps.append({'Hours': int(lamp_list[0]), 'On': None})
|
||||
else:
|
||||
while lamp_list:
|
||||
if not lamp_list[0].isnumeric() or not lamp_list[1].isnumeric():
|
||||
# Invalid data - we'll ignore the rest for now
|
||||
log.warning('({ip}) process_lamp(): Invalid data "{data}"'.format(ip=projector.entry.name, data=data))
|
||||
return
|
||||
fill = {'Hours': int(lamp_list[0]), 'On': False if lamp_list[1] == '0' else True}
|
||||
lamps.append(fill)
|
||||
lamp_list.pop(0) # Remove lamp hours
|
||||
lamp_list.pop(0) # Remove lamp on/off
|
||||
projector.lamp = lamps
|
||||
return
|
||||
|
||||
|
||||
def process_lkup(projector, data):
|
||||
"""
|
||||
Process reply indicating remote is available for connection
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Data packet from remote
|
||||
"""
|
||||
log.debug('({ip}) Processing LKUP command'.format(ip=projector.entry.name))
|
||||
if Settings().value('projector/connect when LKUP received'):
|
||||
projector.connect_to_host()
|
||||
|
||||
|
||||
def process_name(projector, data):
|
||||
"""
|
||||
Projector name set in projector.
|
||||
Updates projector.pjlink_name
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Projector name
|
||||
"""
|
||||
projector.pjlink_name = data
|
||||
log.debug('({ip}) Setting projector PJLink name to "{data}"'.format(ip=projector.entry.name,
|
||||
data=projector.pjlink_name))
|
||||
return
|
||||
|
||||
|
||||
def process_pjlink(projector, data):
|
||||
"""
|
||||
Process initial socket connection to terminal.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Initial packet with authentication scheme
|
||||
"""
|
||||
log.debug('({ip}) Processing PJLINK command'.format(ip=projector.entry.name))
|
||||
chk = data.split(' ')
|
||||
if len(chk[0]) != 1:
|
||||
# Invalid - after splitting, first field should be 1 character, either '0' or '1' only
|
||||
log.error('({ip}) Invalid initial authentication scheme - aborting'.format(ip=projector.entry.name))
|
||||
return projector.disconnect_from_host()
|
||||
elif chk[0] == '0':
|
||||
# Normal connection no authentication
|
||||
if len(chk) > 1:
|
||||
# Invalid data - there should be nothing after a normal authentication scheme
|
||||
log.error('({ip}) Normal connection with extra information - aborting'.format(ip=projector.entry.name))
|
||||
return projector.disconnect_from_host()
|
||||
elif projector.pin:
|
||||
log.error('({ip}) Normal connection but PIN set - aborting'.format(ip=projector.entry.name))
|
||||
return projector.disconnect_from_host()
|
||||
else:
|
||||
data_hash = None
|
||||
elif chk[0] == '1':
|
||||
if len(chk) < 2:
|
||||
# Not enough information for authenticated connection
|
||||
log.error('({ip}) Authenticated connection but not enough info - aborting'.format(ip=projector.entry.name))
|
||||
return projector.disconnect_from_host()
|
||||
elif not projector.pin:
|
||||
log.error('({ip}) Authenticate connection but no PIN - aborting'.format(ip=projector.entry.name))
|
||||
return projector.disconnect_from_host()
|
||||
else:
|
||||
data_hash = str(qmd5_hash(salt=chk[1].encode('utf-8'), data=projector.pin.encode('utf-8')),
|
||||
encoding='ascii')
|
||||
# Passed basic checks, so start connection
|
||||
projector.readyRead.connect(projector.get_socket)
|
||||
projector.change_status(S_CONNECTED)
|
||||
log.debug('({ip}) process_pjlink(): Sending "CLSS" initial command'.format(ip=projector.entry.name))
|
||||
# Since this is an initial connection, make it a priority just in case
|
||||
return projector.send_command(cmd="CLSS", salt=data_hash, priority=True)
|
||||
|
||||
|
||||
def process_powr(projector, data):
|
||||
"""
|
||||
Power status. See PJLink specification for format.
|
||||
Update projector.power with status. Update icons if change from previous setting.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Power status
|
||||
"""
|
||||
log.debug('({ip}: Processing POWR command'.format(ip=projector.entry.name))
|
||||
if data in PJLINK_POWR_STATUS:
|
||||
power = PJLINK_POWR_STATUS[data]
|
||||
update_icons = projector.power != power
|
||||
projector.power = power
|
||||
projector.change_status(PJLINK_POWR_STATUS[data])
|
||||
if update_icons:
|
||||
projector.projectorUpdateIcons.emit()
|
||||
# Update the input sources available
|
||||
if power == S_ON:
|
||||
projector.send_command('INST')
|
||||
else:
|
||||
# Log unknown status response
|
||||
log.warning('({ip}) Unknown power response: "{data}"'.format(ip=projector.entry.name, data=data))
|
||||
if projector.power in [S_ON, S_STANDBY, S_OFF] and 'POWR' in projector.status_timer_checks:
|
||||
projector.status_timer_delete(cmd='POWR')
|
||||
return
|
||||
|
||||
|
||||
def process_rfil(projector, data):
|
||||
"""
|
||||
Process replacement filter type
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Filter replacement model number
|
||||
"""
|
||||
if projector.model_filter is None:
|
||||
projector.model_filter = data
|
||||
else:
|
||||
log.warning('({ip}) Filter model already set'.format(ip=projector.entry.name))
|
||||
log.warning('({ip}) Saved model: "{old}"'.format(ip=projector.entry.name, old=projector.model_filter))
|
||||
log.warning('({ip}) New model: "{new}"'.format(ip=projector.entry.name, new=data))
|
||||
|
||||
|
||||
def process_rlmp(projector, data):
|
||||
"""
|
||||
Process replacement lamp type
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Lamp replacement model number
|
||||
"""
|
||||
if projector.model_lamp is None:
|
||||
projector.model_lamp = data
|
||||
else:
|
||||
log.warning('({ip}) Lamp model already set'.format(ip=projector.entry.name))
|
||||
log.warning('({ip}) Saved lamp: "{old}"'.format(ip=projector.entry.name, old=projector.model_lamp))
|
||||
log.warning('({ip}) New lamp: "{new}"'.format(ip=projector.entry.name, new=data))
|
||||
|
||||
|
||||
def process_snum(projector, data):
|
||||
"""
|
||||
Serial number of projector.
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Serial number from projector.
|
||||
"""
|
||||
if projector.serial_no is None:
|
||||
log.debug('({ip}) Setting projector serial number to "{data}"'.format(ip=projector.entry.name, data=data))
|
||||
projector.serial_no = data
|
||||
projector.db_update = False
|
||||
return
|
||||
|
||||
# Compare serial numbers and see if we got the same projector
|
||||
if projector.serial_no != data:
|
||||
log.warning('({ip}) Projector serial number does not match saved serial '
|
||||
'number'.format(ip=projector.entry.name))
|
||||
log.warning('({ip}) Saved: "{old}"'.format(ip=projector.entry.name, old=projector.serial_no))
|
||||
log.warning('({ip}) Received: "{new}"'.format(ip=projector.entry.name, new=data))
|
||||
log.warning('({ip}) NOT saving serial number'.format(ip=projector.entry.name))
|
||||
projector.serial_no_received = data
|
||||
|
||||
|
||||
def process_srch(projector=None, data=None):
|
||||
"""
|
||||
Process the SRCH command.
|
||||
|
||||
SRCH is processed by terminals so we ignore any packet.
|
||||
|
||||
:param projector: Projector instance (actually ignored for this command)
|
||||
:param data: Data in packet
|
||||
"""
|
||||
log.warning("({ip}) SRCH packet detected - ignoring".format(ip=projector.entry.ip))
|
||||
return
|
||||
|
||||
|
||||
def process_sver(projector, data):
|
||||
"""
|
||||
Software version of projector
|
||||
|
||||
:param projector: Projector instance
|
||||
:param data: Software version of projector
|
||||
"""
|
||||
if len(data) > 32:
|
||||
# Defined in specs max version is 32 characters
|
||||
log.warning('Invalid software version - too long')
|
||||
return
|
||||
if projector.sw_version is not None:
|
||||
if projector.sw_version == data:
|
||||
log.debug('({ip}) Software version same as saved version - returning'.format(ip=projector.entry.name))
|
||||
return
|
||||
log.warning('({ip}) Projector software version does not match saved '
|
||||
'software version'.format(ip=projector.entry.name))
|
||||
log.warning('({ip}) Saved: "{old}"'.format(ip=projector.entry.name, old=projector.sw_version))
|
||||
log.warning('({ip}) Received: "{new}"'.format(ip=projector.entry.name, new=data))
|
||||
log.warning('({ip}) Updating software version'.format(ip=projector.entry.name))
|
||||
|
||||
log.debug('({ip}) Setting projector software version to "{data}"'.format(ip=projector.entry.name, data=data))
|
||||
projector.sw_version = data
|
||||
projector.db_update = True
|
||||
|
||||
|
||||
# Map command to function.
|
||||
pjlink_functions = {
|
||||
'ACKN': process_ackn, # Class 2 (command is SRCH)
|
||||
'AVMT': process_avmt,
|
||||
'CLSS': process_clss,
|
||||
'ERST': process_erst,
|
||||
'INFO': process_info,
|
||||
'INF1': process_inf1,
|
||||
'INF2': process_inf2,
|
||||
'INPT': process_inpt,
|
||||
'INST': process_inst,
|
||||
'LAMP': process_lamp,
|
||||
'LKUP': process_lkup, # Class 2 (reply only - no cmd)
|
||||
'NAME': process_name,
|
||||
'PJLINK': process_pjlink,
|
||||
'POWR': process_powr,
|
||||
'SNUM': process_snum,
|
||||
'SRCH': process_srch, # Class 2 (reply is ACKN)
|
||||
'SVER': process_sver,
|
||||
'RFIL': process_rfil,
|
||||
'RLMP': process_rlmp
|
||||
}
|
||||
|
|
@ -239,7 +239,7 @@ class PrintServiceForm(QtWidgets.QDialog, Ui_PrintServiceDialog, RegistryPropert
|
|||
footer_html = footer_html.partition('<br>')[2]
|
||||
if footer_html:
|
||||
footer_html = html.escape(footer_html.replace('<br>', '\n'))
|
||||
self._add_element('div', footer_html.replace('\n', '<br>'), parent=div, classId='itemFooter')
|
||||
self._add_element('div', footer_html.replace('\n', '<br>'), parent=div, class_id='itemFooter')
|
||||
# Add service items' notes.
|
||||
if self.notes_check_box.isChecked():
|
||||
if item.notes:
|
||||
|
|
|
|||
|
|
@ -352,7 +352,7 @@ class PathEdit(QtWidgets.QWidget):
|
|||
:rtype: None
|
||||
"""
|
||||
if self._path != path:
|
||||
self.path = path
|
||||
self._path = path
|
||||
self.pathChanged.emit(path)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -187,7 +187,7 @@ class BibleManager(LogMixin, RegistryProperties):
|
|||
bible = self.db_cache[name]
|
||||
bible.session.close_all()
|
||||
bible.session = None
|
||||
return delete_file(bible.path, bible.file_path)
|
||||
return delete_file(bible.path / '{name}{suffix}'.format(name=name, suffix=self.suffix))
|
||||
|
||||
def get_bibles(self):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -67,4 +67,4 @@ class TestManager(TestCase):
|
|||
assert result is True
|
||||
mocked_close_all.assert_called_once_with()
|
||||
assert mocked_bible.session is None
|
||||
mocked_delete_file.assert_called_once_with(Path('bibles'), 'KJV.sqlite')
|
||||
mocked_delete_file.assert_called_once_with(Path('bibles') / 'KJV.sqlite')
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ class TestPJLinkBugs(TestCase):
|
|||
"""
|
||||
Tests for the PJLink module bugfixes
|
||||
"""
|
||||
def bug_1550891_process_clss_nonstandard_reply_1(self):
|
||||
def test_bug_1550891_process_clss_nonstandard_reply_1(self):
|
||||
"""
|
||||
Bugfix 1550891: CLSS request returns non-standard reply with Optoma/Viewsonic projector
|
||||
"""
|
||||
|
|
@ -42,7 +42,7 @@ class TestPJLinkBugs(TestCase):
|
|||
# Keeping here for bug reference
|
||||
pass
|
||||
|
||||
def bug_1550891_process_clss_nonstandard_reply_2(self):
|
||||
def test_bug_1550891_process_clss_nonstandard_reply_2(self):
|
||||
"""
|
||||
Bugfix 1550891: CLSS request returns non-standard reply with BenQ projector
|
||||
"""
|
||||
|
|
@ -50,7 +50,7 @@ class TestPJLinkBugs(TestCase):
|
|||
# Keeping here for bug reference
|
||||
pass
|
||||
|
||||
def bug_1593882_no_pin_authenticated_connection(self):
|
||||
def test_bug_1593882_no_pin_authenticated_connection(self):
|
||||
"""
|
||||
Test bug 1593882 no pin and authenticated request exception
|
||||
"""
|
||||
|
|
@ -58,7 +58,7 @@ class TestPJLinkBugs(TestCase):
|
|||
# Keeping here for bug reference
|
||||
pass
|
||||
|
||||
def bug_1593883_pjlink_authentication(self):
|
||||
def test_bug_1593883_pjlink_authentication(self):
|
||||
"""
|
||||
Test bugfix 1593883 pjlink authentication and ticket 92187
|
||||
"""
|
||||
|
|
@ -66,7 +66,7 @@ class TestPJLinkBugs(TestCase):
|
|||
# Keeping here for bug reference
|
||||
pass
|
||||
|
||||
def bug_1734275_process_lamp_nonstandard_reply(self):
|
||||
def test_bug_1734275_process_lamp_nonstandard_reply(self):
|
||||
"""
|
||||
Test bugfix 17342785 non-standard LAMP response with one lamp hours only
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ from unittest import TestCase
|
|||
from unittest.mock import MagicMock, call, patch
|
||||
|
||||
import openlp.core.projectors.pjlink
|
||||
from openlp.core.projectors.pjlinkcommands import process_command
|
||||
from openlp.core.projectors.constants import E_NOT_CONNECTED, E_PARAMETER, E_UNKNOWN_SOCKET_ERROR, QSOCKET_STATE, \
|
||||
S_CONNECTED, S_CONNECTING, S_NOT_CONNECTED, S_OK, S_ON, STATUS_CODE, STATUS_MSG
|
||||
from openlp.core.projectors.db import Projector
|
||||
|
|
@ -37,44 +38,56 @@ class TestPJLinkBase(TestCase):
|
|||
"""
|
||||
Tests for the PJLink module
|
||||
"""
|
||||
def test_status_change(self):
|
||||
def setUp(self):
|
||||
"""
|
||||
Initialize test state(s)
|
||||
"""
|
||||
# Default PJLink instance for tests
|
||||
self.pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
|
||||
def tearDown(self):
|
||||
"""
|
||||
Cleanup test state(s)
|
||||
"""
|
||||
del(self.pjlink)
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
|
||||
def test_status_change(self, mock_changeStatus):
|
||||
"""
|
||||
Test process_command call with ERR2 (Parameter) status
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
with patch('openlp.core.projectors.pjlink.PJLink.changeStatus') as mock_changeStatus:
|
||||
pjlink = self.pjlink
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
# WHEN: process_command is called with "ERR2" status from projector
|
||||
process_command(projector=pjlink, cmd='POWR', data='ERR2')
|
||||
|
||||
# WHEN: process_command is called with "ERR2" status from projector
|
||||
pjlink.process_command('POWR', 'ERR2')
|
||||
# THEN: change_status should have called change_status with E_UNDEFINED
|
||||
# as first parameter
|
||||
mock_changeStatus.called_with(E_PARAMETER,
|
||||
'change_status should have been called '
|
||||
'with "{}"'.format(STATUS_CODE[E_PARAMETER]))
|
||||
|
||||
# THEN: change_status should have called change_status with E_UNDEFINED
|
||||
# as first parameter
|
||||
mock_changeStatus.called_with(E_PARAMETER,
|
||||
'change_status should have been called with "{}"'.format(
|
||||
STATUS_CODE[E_PARAMETER]))
|
||||
|
||||
def test_socket_abort(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
|
||||
def test_socket_abort(self, mock_disconnect):
|
||||
"""
|
||||
Test PJLink.socket_abort calls disconnect_from_host
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
with patch('openlp.core.projectors.pjlink.PJLink.disconnect_from_host') as mock_disconnect:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink = self.pjlink
|
||||
|
||||
# WHEN: Calling socket_abort
|
||||
pjlink.socket_abort()
|
||||
# WHEN: Calling socket_abort
|
||||
pjlink.socket_abort()
|
||||
|
||||
# THEN: disconnect_from_host should be called
|
||||
assert mock_disconnect.called is True, 'Should have called disconnect_from_host'
|
||||
# THEN: disconnect_from_host should be called
|
||||
assert mock_disconnect.called is True, 'Should have called disconnect_from_host'
|
||||
|
||||
def test_poll_loop_not_connected(self):
|
||||
"""
|
||||
Test PJLink.poll_loop not connected return
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
pjlink.state = MagicMock()
|
||||
pjlink.timer = MagicMock()
|
||||
pjlink.state.return_value = False
|
||||
|
|
@ -86,396 +99,371 @@ class TestPJLinkBase(TestCase):
|
|||
# THEN: poll_loop should exit without calling any other method
|
||||
assert pjlink.timer.called is False, 'Should have returned without calling any other method'
|
||||
|
||||
def test_poll_loop_set_interval(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
def test_poll_loop_set_interval(self, mock_send_command):
|
||||
"""
|
||||
Test PJLink.poll_loop makes correct calls
|
||||
"""
|
||||
# GIVEN: Mocks and test data
|
||||
with patch('openlp.core.projectors.pjlink.PJLink.send_command') as mock_send_command:
|
||||
# GIVEN: Test object and data
|
||||
pjlink = self.pjlink
|
||||
pjlink.state = MagicMock()
|
||||
pjlink.state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
pjlink.poll_timer = MagicMock()
|
||||
pjlink.poll_timer.interval.return_value = 10
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.state = MagicMock()
|
||||
pjlink.state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
pjlink.poll_timer = MagicMock()
|
||||
pjlink.poll_timer.interval.return_value = 10
|
||||
pjlink.poll_time = 20
|
||||
pjlink.power = S_ON
|
||||
pjlink.source_available = None
|
||||
pjlink.other_info = None
|
||||
pjlink.manufacturer = None
|
||||
pjlink.model = None
|
||||
pjlink.pjlink_name = None
|
||||
call_list = [
|
||||
call('POWR'),
|
||||
call('ERST'),
|
||||
call('LAMP'),
|
||||
call('AVMT'),
|
||||
call('INPT'),
|
||||
call('INST'),
|
||||
call('INFO'),
|
||||
call('INF1'),
|
||||
call('INF2'),
|
||||
call('NAME'),
|
||||
]
|
||||
|
||||
pjlink.poll_time = 20
|
||||
pjlink.power = S_ON
|
||||
pjlink.source_available = None
|
||||
pjlink.other_info = None
|
||||
pjlink.manufacturer = None
|
||||
pjlink.model = None
|
||||
pjlink.pjlink_name = None
|
||||
call_list = [
|
||||
call('POWR'),
|
||||
call('ERST'),
|
||||
call('LAMP'),
|
||||
call('AVMT'),
|
||||
call('INPT'),
|
||||
call('INST'),
|
||||
call('INFO'),
|
||||
call('INF1'),
|
||||
call('INF2'),
|
||||
call('NAME'),
|
||||
]
|
||||
# WHEN: PJLink.poll_loop is called
|
||||
pjlink.poll_loop()
|
||||
|
||||
# WHEN: PJLink.poll_loop is called
|
||||
pjlink.poll_loop()
|
||||
# THEN: proper calls were made to retrieve projector data
|
||||
# First, call to update the timer with the next interval
|
||||
assert pjlink.poll_timer.setInterval.called is True, 'Timer update interval should have been called'
|
||||
# Finally, should have called send_command with a list of projetctor status checks
|
||||
mock_send_command.assert_has_calls(call_list, 'Should have queued projector queries')
|
||||
|
||||
# THEN: proper calls were made to retrieve projector data
|
||||
# First, call to update the timer with the next interval
|
||||
assert pjlink.poll_timer.setInterval.called is True, 'Timer update interval should have been called'
|
||||
# Finally, should have called send_command with a list of projetctor status checks
|
||||
mock_send_command.assert_has_calls(call_list, 'Should have queued projector queries')
|
||||
|
||||
def test_projector_change_status_unknown_socket_error(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_change_status_unknown_socket_error(self, mock_log, mock_changeStatus, mock_UpdateIcons):
|
||||
"""
|
||||
Test change_status with connection error
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons') as mock_UpdateIcons:
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[E_UNKNOWN_SOCKET_ERROR],
|
||||
msg=STATUS_MSG[E_UNKNOWN_SOCKET_ERROR])),
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[E_NOT_CONNECTED],
|
||||
msg=STATUS_MSG[E_NOT_CONNECTED])),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK])),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[E_UNKNOWN_SOCKET_ERROR],
|
||||
msg=STATUS_MSG[E_UNKNOWN_SOCKET_ERROR]))]
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[E_UNKNOWN_SOCKET_ERROR],
|
||||
msg=STATUS_MSG[E_UNKNOWN_SOCKET_ERROR])),
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[E_NOT_CONNECTED],
|
||||
msg=STATUS_MSG[E_NOT_CONNECTED])),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK])),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[E_UNKNOWN_SOCKET_ERROR],
|
||||
msg=STATUS_MSG[E_UNKNOWN_SOCKET_ERROR]))]
|
||||
# WHEN: change_status called with unknown socket error
|
||||
pjlink.change_status(status=E_UNKNOWN_SOCKET_ERROR)
|
||||
|
||||
# WHEN: change_status called with unknown socket error
|
||||
pjlink.change_status(status=E_UNKNOWN_SOCKET_ERROR)
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert pjlink.projector_status == S_OK, 'Projector status should not have changed'
|
||||
assert pjlink.status_connect == E_NOT_CONNECTED, 'Status connect should be NOT CONNECTED'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Should have called UpdateIcons'
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, E_UNKNOWN_SOCKET_ERROR,
|
||||
STATUS_MSG[E_UNKNOWN_SOCKET_ERROR])
|
||||
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert pjlink.projector_status == S_OK, 'Projector status should not have changed'
|
||||
assert pjlink.status_connect == E_NOT_CONNECTED, 'Status connect should be NOT CONNECTED'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Should have called UpdateIcons'
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, E_UNKNOWN_SOCKET_ERROR,
|
||||
STATUS_MSG[E_UNKNOWN_SOCKET_ERROR])
|
||||
|
||||
def test_projector_change_status_connection_status_connecting(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_change_status_connection_status_connecting(self, mock_log, mock_changeStatus, mock_UpdateIcons):
|
||||
"""
|
||||
Test change_status with connecting status
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons') as mock_UpdateIcons:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[S_CONNECTING],
|
||||
msg=STATUS_MSG[S_CONNECTING])),
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_CONNECTING],
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[S_CONNECTING],
|
||||
msg=STATUS_MSG[S_CONNECTING])),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK])),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_CONNECTING],
|
||||
msg=STATUS_MSG[S_CONNECTING])),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK]))]
|
||||
msg=STATUS_MSG[S_OK])),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK]))]
|
||||
|
||||
# WHEN: change_status called with CONNECTING
|
||||
pjlink.change_status(status=S_CONNECTING)
|
||||
# WHEN: change_status called with CONNECTING
|
||||
pjlink.change_status(status=S_CONNECTING)
|
||||
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_CONNECTING, STATUS_MSG[S_CONNECTING])
|
||||
assert pjlink.projector_status == S_OK, 'Projector status should not have changed'
|
||||
assert pjlink.status_connect == S_CONNECTING, 'Status connect should be CONNECTING'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Should have called UpdateIcons'
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_CONNECTING, STATUS_MSG[S_CONNECTING])
|
||||
assert pjlink.projector_status == S_OK, 'Projector status should not have changed'
|
||||
assert pjlink.status_connect == S_CONNECTING, 'Status connect should be CONNECTING'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Should have called UpdateIcons'
|
||||
|
||||
def test_projector_change_status_connection_status_connected(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_change_status_connection_status_connected(self, mock_log, mock_changeStatus):
|
||||
"""
|
||||
Test change_status with connected status
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[S_CONNECTED],
|
||||
msg=STATUS_MSG[S_CONNECTED])),
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_CONNECTED],
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[S_CONNECTED],
|
||||
msg=STATUS_MSG[S_CONNECTED])),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK])),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_CONNECTED],
|
||||
msg=STATUS_MSG[S_CONNECTED])),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK]))]
|
||||
msg=STATUS_MSG[S_OK])),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=STATUS_MSG[S_OK]))]
|
||||
|
||||
# WHEN: change_status called with CONNECTED
|
||||
pjlink.change_status(status=S_CONNECTED)
|
||||
# WHEN: change_status called with CONNECTED
|
||||
pjlink.change_status(status=S_CONNECTED)
|
||||
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_CONNECTED, 'Connected')
|
||||
assert pjlink.projector_status == S_OK, 'Projector status should not have changed'
|
||||
assert pjlink.status_connect == S_CONNECTED, 'Status connect should be CONNECTED'
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_CONNECTED, 'Connected')
|
||||
assert pjlink.projector_status == S_OK, 'Projector status should not have changed'
|
||||
assert pjlink.status_connect == S_CONNECTED, 'Status connect should be CONNECTED'
|
||||
|
||||
def test_projector_change_status_connection_status_with_message(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_change_status_connection_status_with_message(self, mock_log, mock_changeStatus):
|
||||
"""
|
||||
Test change_status with connection status
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
test_message = 'Different Status Message than default'
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[S_ON],
|
||||
msg=test_message)),
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
pjlink.projector_status = 0
|
||||
pjlink.status_connect = 0
|
||||
test_message = 'Different Status Message than default'
|
||||
log_debug_calls = [
|
||||
call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
|
||||
status=STATUS_CODE[S_ON],
|
||||
msg=test_message)),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_ON],
|
||||
msg=test_message)),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=test_message))]
|
||||
call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=test_message)),
|
||||
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_ON],
|
||||
msg=test_message)),
|
||||
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name,
|
||||
code=STATUS_CODE[S_OK],
|
||||
msg=test_message))]
|
||||
|
||||
# WHEN: change_status called with projector ON status
|
||||
pjlink.change_status(status=S_ON, msg=test_message)
|
||||
# WHEN: change_status called with projector ON status
|
||||
pjlink.change_status(status=S_ON, msg=test_message)
|
||||
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_ON, test_message)
|
||||
assert pjlink.projector_status == S_ON, 'Projector status should be ON'
|
||||
assert pjlink.status_connect == S_OK, 'Status connect should not have changed'
|
||||
# THEN: Proper settings should change and signals sent
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_ON, test_message)
|
||||
assert pjlink.projector_status == S_ON, 'Projector status should be ON'
|
||||
assert pjlink.status_connect == S_OK, 'Status connect should not have changed'
|
||||
|
||||
def test_projector_get_av_mute_status(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_av_mute_status(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve shutter/audio state
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'AVMT'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'AVMT'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_av_mute_status is called
|
||||
pjlink.get_av_mute_status()
|
||||
# WHEN: get_av_mute_status is called
|
||||
pjlink.get_av_mute_status()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data, priority=False)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data, priority=False)
|
||||
|
||||
def test_projector_get_available_inputs(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_available_inputs(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve avaliable inputs
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'INST'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'INST'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_available_inputs is called
|
||||
pjlink.get_available_inputs()
|
||||
# WHEN: get_available_inputs is called
|
||||
pjlink.get_available_inputs()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_error_status(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_error_status(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve projector error status
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'ERST'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'ERST'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_error_status is called
|
||||
pjlink.get_error_status()
|
||||
# WHEN: get_error_status is called
|
||||
pjlink.get_error_status()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_input_source(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_input_source(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve current input
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'INPT'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'INPT'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_input_source()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_input_source()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_lamp_status(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_lamp_status(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve lamp(s) status
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'LAMP'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'LAMP'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_lamp_status()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_lamp_status()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_manufacturer(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_manufacturer(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve manufacturer name
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'INF1'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'INF1'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_manufacturer()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_manufacturer()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_model(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_model(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to get model information
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'INF2'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'INF2'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_model()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_model()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_name(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_name(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to get user-assigned name
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'NAME'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'NAME'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_name()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_name()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_other_info(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_other_info(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve other information
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'INFO'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'INFO'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_other_info()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_other_info()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data)
|
||||
|
||||
def test_projector_get_power_status(self):
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_projector_get_power_status(self, mock_log, mock_send_command):
|
||||
"""
|
||||
Test sending command to retrieve current power state
|
||||
"""
|
||||
# GIVEN: Test object and mocks
|
||||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command:
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
test_data = 'POWR'
|
||||
log_debug_calls = [call('({ip}) reset_information() connect status is '
|
||||
'{state}'.format(ip=pjlink.name, state=STATUS_CODE[S_NOT_CONNECTED])),
|
||||
call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
# GIVEN: Test object
|
||||
pjlink = self.pjlink
|
||||
test_data = 'POWR'
|
||||
log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
|
||||
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_power_status()
|
||||
# WHEN: get_input_source is called
|
||||
pjlink.get_power_status()
|
||||
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data, priority=False)
|
||||
# THEN: log data and send_command should have been called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_send_command.assert_called_once_with(cmd=test_data, priority=False)
|
||||
|
||||
def test_projector_get_status_invalid(self):
|
||||
"""
|
||||
Test to check returned information for error code
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink = self.pjlink
|
||||
test_string = 'NaN test'
|
||||
|
||||
# WHEN: get_status called
|
||||
|
|
@ -491,7 +479,7 @@ class TestPJLinkBase(TestCase):
|
|||
"""
|
||||
# GIVEN: Test object
|
||||
test_message = 'Not Connected'
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink = self.pjlink
|
||||
|
||||
# WHEN: get_status called
|
||||
code, message = pjlink._get_status(status=S_NOT_CONNECTED)
|
||||
|
|
@ -505,7 +493,7 @@ class TestPJLinkBase(TestCase):
|
|||
Test to check returned information for unknown code
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink = self.pjlink
|
||||
|
||||
# WHEN: get_status called
|
||||
code, message = pjlink._get_status(status=9999)
|
||||
|
|
|
|||
|
|
@ -26,7 +26,8 @@ from unittest import TestCase
|
|||
from unittest.mock import call, patch
|
||||
|
||||
import openlp.core.projectors.pjlink
|
||||
from openlp.core.projectors.constants import S_NOT_CONNECTED
|
||||
from openlp.core.projectors.constants import E_NETWORK, PJLINK_PREFIX, PJLINK_SUFFIX, QSOCKET_STATE, \
|
||||
S_CONNECTED, S_NOT_CONNECTED
|
||||
from openlp.core.projectors.db import Projector
|
||||
from openlp.core.projectors.pjlink import PJLink
|
||||
from tests.resources.projector.data import TEST1_DATA
|
||||
|
|
@ -36,65 +37,658 @@ class TestPJLinkBase(TestCase):
|
|||
"""
|
||||
Tests for the PJLink module
|
||||
"""
|
||||
def setUp(self):
|
||||
"""
|
||||
Initialize test state(s)
|
||||
"""
|
||||
# Default PJLink instance for tests
|
||||
self.pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
|
||||
def tearDown(self):
|
||||
"""
|
||||
Cleanup test state(s)
|
||||
"""
|
||||
del(self.pjlink)
|
||||
|
||||
# ------------ Test PJLink._underscore_send_command ----------
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'change_status')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'write')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_network_error(self, mock_log, mock_reset, mock_state, mock_disconnect, mock_write,
|
||||
mock_change_status):
|
||||
"""
|
||||
Test _underscore_send_command when possible network error occured
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) _send_command(): -1 received - '
|
||||
'disconnecting from host'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = [call('({ip}) _send_command(data="None")'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): priority_queue: []'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): send_queue: ['{data}\\r']".format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): Connection status: S_CONNECTED'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Getting normal queued packet'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Sending "{data}"'.format(ip=self.pjlink.name,
|
||||
data=test_command.strip()))
|
||||
]
|
||||
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
mock_write.return_value = -1
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer, \
|
||||
patch.object(self.pjlink, 'waitForBytesWritten') as mock_waitBytes:
|
||||
mock_waitBytes.return_value = True
|
||||
self.pjlink._send_command()
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_change_status.called_with(E_NETWORK, 'Error while sending data to projector')
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert mock_timer.start.called, 'Timer should have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not should have been called'
|
||||
assert mock_disconnect.called, 'disconnect_from_host() should have been called'
|
||||
assert self.pjlink.send_busy, 'send_busy should be True'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_no_data(self, mock_log, mock_reset, mock_state):
|
||||
"""
|
||||
Test _underscore_send_command with no data to send
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) _send_command(): Nothing to send - returning'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = []
|
||||
mock_state.return_value = S_CONNECTED
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer:
|
||||
self.pjlink._send_command()
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_timer.called), 'Timer should not have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_no_data_queue_check(self, mock_log, mock_reset, mock_state):
|
||||
"""
|
||||
Test _underscore_send_command last queue length check
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) _send_command(): No data to send'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = []
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer, \
|
||||
patch.object(self.pjlink, 'send_queue') as mock_queue:
|
||||
# Unlikely case of send_queue not really empty, but len(send_queue) returns 0
|
||||
mock_queue.return_value = ['test']
|
||||
mock_queue.__len__.return_value = 0
|
||||
self.pjlink._send_command(data=None)
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_timer.called), 'Timer should not have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'write')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_normal_send(self, mock_log, mock_reset, mock_state, mock_disconnect, mock_write):
|
||||
"""
|
||||
Test _underscore_send_command using normal queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) _send_command(data="None")'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): priority_queue: []'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): send_queue: ['{data}\\r']".format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): Connection status: S_CONNECTED'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Getting normal queued packet'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Sending "{data}"'.format(ip=self.pjlink.name,
|
||||
data=test_command.strip()))
|
||||
]
|
||||
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
mock_write.return_value = len(test_command)
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer, \
|
||||
patch.object(self.pjlink, 'waitForBytesWritten') as mock_waitBytes:
|
||||
mock_waitBytes.return_value = True
|
||||
self.pjlink._send_command()
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert mock_timer.start.called, 'Timer should have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert (not mock_disconnect.called), 'disconnect_from_host() should not have been called'
|
||||
assert self.pjlink.send_busy, 'send_busy flag should be True'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_not_connected(self, mock_log, mock_reset, mock_state, mock_disconnect):
|
||||
"""
|
||||
Test _underscore_send_command when not connected
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) _send_command() Not connected - abort'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = [call('({ip}) _send_command(data="None")'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): priority_queue: []'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): send_queue: ['%1CLSS ?\\r']".format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Connection status: S_OK'.format(ip=self.pjlink.name))]
|
||||
mock_state.return_value = S_NOT_CONNECTED
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch here since pjlink does not have socket_timer until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer:
|
||||
self.pjlink._send_command()
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert (self.pjlink.send_queue == [test_command]), 'Send queue should have one entry'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_timer.called), 'Timer should not have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_disconnect.called, 'disconnect_from_host() should have been called'
|
||||
assert (not self.pjlink.send_busy), 'send_busy flag should be False'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'write')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_priority_send(self, mock_log, mock_reset, mock_state, mock_disconnect, mock_write):
|
||||
"""
|
||||
Test _underscore_send_command with priority queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) _send_command(data="{data}")'.format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): priority_queue: []'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): send_queue: []'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Connection status: S_CONNECTED'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Priority packet - '
|
||||
'adding to priority queue'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Getting priority queued packet'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Sending "{data}"'.format(ip=self.pjlink.name,
|
||||
data=test_command.strip()))
|
||||
]
|
||||
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
mock_write.return_value = len(test_command)
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer, \
|
||||
patch.object(self.pjlink, 'waitForBytesWritten') as mock_waitBytes:
|
||||
mock_waitBytes.return_value = True
|
||||
self.pjlink._send_command(data=test_command)
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert mock_timer.start.called, 'Timer should have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert (not mock_disconnect.called), 'disconnect_from_host() should not have been called'
|
||||
assert self.pjlink.send_busy, 'send_busy flag should be True'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'write')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_priority_send_with_normal_queue(self, mock_log, mock_reset, mock_state,
|
||||
mock_disconnect, mock_write):
|
||||
"""
|
||||
Test _underscore_send_command with priority queue when normal queue active
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) _send_command(data="{data}")'.format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): priority_queue: []'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): send_queue: ['{data}\\r']".format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): Connection status: S_CONNECTED'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Priority packet - '
|
||||
'adding to priority queue'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Getting priority queued packet'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Sending "{data}"'.format(ip=self.pjlink.name,
|
||||
data=test_command.strip()))
|
||||
]
|
||||
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
mock_write.return_value = len(test_command)
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer, \
|
||||
patch.object(self.pjlink, 'waitForBytesWritten') as mock_waitBytes:
|
||||
mock_waitBytes.return_value = True
|
||||
self.pjlink._send_command(data=test_command)
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert self.pjlink.send_queue, 'Send queue should have one entry'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert mock_timer.start.called, 'Timer should have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert (not mock_disconnect.called), 'disconnect_from_host() should not have been called'
|
||||
assert self.pjlink.send_busy, 'send_busy flag should be True'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_send_busy_normal_queue(self, mock_log, mock_reset, mock_state):
|
||||
"""
|
||||
Test _underscore_send_command send_busy flag with normal queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) _send_command(data="None")'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): priority_queue: []'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): send_queue: ['{data}\\r']".format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): Connection status: S_CONNECTED'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Still busy, returning'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Priority queue = []'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): Normal queue = "
|
||||
"['{data}\\r']".format(ip=self.pjlink.name, data=test_command.strip()))]
|
||||
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
self.pjlink.send_busy = True
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer:
|
||||
self.pjlink._send_command()
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert self.pjlink.send_queue, 'Send queue should have one entry'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_timer.start.called), 'Timer should not have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert self.pjlink.send_busy, 'send_busy flag should be True'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_send_busy_priority_queue(self, mock_log, mock_reset, mock_state):
|
||||
"""
|
||||
Test _underscore_send_command send_busy flag with priority queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) _send_command(data="None")'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): priority_queue: "
|
||||
"['{data}\\r']".format(ip=self.pjlink.name,
|
||||
data=test_command.strip())),
|
||||
call('({ip}) _send_command(): send_queue: []'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Connection status: S_CONNECTED'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Still busy, returning'.format(ip=self.pjlink.name)),
|
||||
call("({ip}) _send_command(): Priority queue = "
|
||||
"['{data}\\r']".format(ip=self.pjlink.name, data=test_command.strip())),
|
||||
call('({ip}) _send_command(): Normal queue = []'.format(ip=self.pjlink.name))
|
||||
]
|
||||
|
||||
mock_state.return_value = QSOCKET_STATE[S_CONNECTED]
|
||||
self.pjlink.send_busy = True
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = [test_command]
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch some attributes here since they are not available until after instantiation
|
||||
with patch.object(self.pjlink, 'socket_timer') as mock_timer:
|
||||
self.pjlink._send_command()
|
||||
|
||||
# THEN:
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert self.pjlink.priority_queue, 'Priority queue should have one entry'
|
||||
assert (not mock_timer.start.called), 'Timer should not have been called'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert self.pjlink.send_busy, 'send_busy flag should be True'
|
||||
|
||||
# ------------ Test PJLink.send_command ----------
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_no_data(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
def test_send_command_add_normal_command(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test _send_command with no data to send
|
||||
Test send_command adding normal queue item
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
log_warning_calls = [call('({ip}) send_command(): Not connected - returning'.format(ip=TEST1_DATA['name']))]
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) send_command(): Building cmd="CLSS" opts="?"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) send_command(): Adding to normal queue'.format(ip=self.pjlink.name))]
|
||||
mock_state.return_value = S_CONNECTED
|
||||
|
||||
log_debug_calls = [call('PJlink(projector="< Projector(id="None", ip="111.111.111.111", port="1111", '
|
||||
'mac_adx="11:11:11:11:11:11", pin="1111", name="___TEST_ONE___", '
|
||||
'location="location one", notes="notes one", pjlink_name="None", '
|
||||
'pjlink_class="None", manufacturer="None", model="None", '
|
||||
'serial_no="Serial Number 1", other="None", sources="None", source_list="[]", '
|
||||
'model_filter="Filter type 1", model_lamp="Lamp type 1", '
|
||||
'sw_version="Version 1") >", args="()" kwargs="{\'no_poll\': True}")'),
|
||||
call('PJlinkCommands(args=() kwargs={})')]
|
||||
mock_state.return_value = S_NOT_CONNECTED
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.send_queue = []
|
||||
pjlink.priority_queue = []
|
||||
# Patch here since pjlink does not have priority or send queue's until instantiated
|
||||
with patch.object(self.pjlink, 'send_queue') as mock_send, \
|
||||
patch.object(self.pjlink, 'priority_queue') as mock_priority:
|
||||
|
||||
# WHEN: _send_command called with no data and queue's empty
|
||||
pjlink.send_command(cmd='DONTCARE')
|
||||
# WHEN: send_command called with valid normal command
|
||||
self.pjlink.send_command(cmd='CLSS')
|
||||
|
||||
# THEN:
|
||||
mock_send.append.called_with(test_command)
|
||||
mock_priority.append.called is False
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_send_command.called, '_underscore_send_command() should have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_add_priority_command(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test _send_command adding priority queue item
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = []
|
||||
log_debug_calls = [call('({ip}) send_command(): Building cmd="CLSS" opts="?"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) send_command(): Adding to priority queue'.format(ip=self.pjlink.name))]
|
||||
mock_state.return_value = S_CONNECTED
|
||||
|
||||
# Patch here since pjlink does not have priority or send queue's until instantiated
|
||||
with patch.object(self.pjlink, 'send_queue') as mock_send, \
|
||||
patch.object(self.pjlink, 'priority_queue') as mock_priority:
|
||||
|
||||
# WHEN: send_command called with valid priority command
|
||||
self.pjlink.send_command(cmd='CLSS', priority=True)
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_priority.append.assert_called_with(test_command)
|
||||
assert (not mock_send.append.called), 'send_queue should not have changed'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_send_command.called, '_underscore_send_command() should have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_duplicate_normal_command(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test send_command with duplicate item for normal queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) send_command(): Already in normal queue - '
|
||||
'skipping'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = [call('({ip}) send_command(): Building cmd="CLSS" opts="?"'.format(ip=self.pjlink.name))]
|
||||
mock_state.return_value = S_CONNECTED
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: send_command called with same command in normal queue
|
||||
self.pjlink.send_command(cmd='CLSS')
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
assert mock_reset.called is True
|
||||
assert mock_reset.called is True
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert (self.pjlink.send_queue == [test_command]), 'Send queue should have one entry'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_send_command.called, '_underscore_send_command() should have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_local_send_command_no_data(self, mock_log):
|
||||
def test_send_command_duplicate_priority_command(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test _send_command with no data to send
|
||||
Test send_command with duplicate item for priority queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
log_debug_calls = [call('PJlink(projector="< Projector(id="None", ip="111.111.111.111", port="1111", '
|
||||
'mac_adx="11:11:11:11:11:11", pin="1111", name="___TEST_ONE___", '
|
||||
'location="location one", notes="notes one", pjlink_name="None", '
|
||||
'pjlink_class="None", manufacturer="None", model="None", '
|
||||
'serial_no="Serial Number 1", other="None", sources="None", source_list="[]", '
|
||||
'model_filter="Filter type 1", model_lamp="Lamp type 1", '
|
||||
'sw_version="Version 1") >", args="()" kwargs="{\'no_poll\': True}")'),
|
||||
call('PJlinkCommands(args=() kwargs={})'),
|
||||
call('(___TEST_ONE___) reset_information() connect status is S_NOT_CONNECTED'),
|
||||
call('(___TEST_ONE___) _send_command(): Nothing to send - returning')]
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) send_command(): Already in priority queue - '
|
||||
'skipping'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = [call('({ip}) send_command(): Building cmd="CLSS" opts="?"'.format(ip=self.pjlink.name))]
|
||||
mock_state.return_value = S_CONNECTED
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = [test_command]
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.send_queue = []
|
||||
pjlink.priority_queue = []
|
||||
# WHEN: send_command called with same command in priority queue
|
||||
self.pjlink.send_command(cmd='CLSS', priority=True)
|
||||
|
||||
# WHEN: _send_command called with no data and queue's emtpy
|
||||
# Patch here since pjlink does not have socket_timer until after instantiation
|
||||
with patch.object(pjlink, 'socket_timer') as mock_timer:
|
||||
pjlink._send_command(data=None, utf8=False)
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (self.pjlink.priority_queue == [test_command]), 'Priority queue should have one entry'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_send_command.called, '_underscore_send_command() should have been called'
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
assert mock_timer.called is False
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_invalid_command_empty_queues(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test send_command with invalid command
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
log_error_calls = [call('({ip}) send_command(): Invalid command requested - '
|
||||
'ignoring.'.format(ip=self.pjlink.name))]
|
||||
log_warning_calls = []
|
||||
log_debug_calls = []
|
||||
mock_state.return_value = S_CONNECTED
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: send_command with invalid command
|
||||
self.pjlink.send_command(cmd='DONTCARE')
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert (not mock_send_command.called), '_underscore_send_command() should not have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_invalid_command_normal_queue(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test _send_command with invalid command for normal queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = [call('({ip}) send_command(): Invalid command requested - '
|
||||
'ignoring.'.format(ip=self.pjlink.name))]
|
||||
log_warning_calls = []
|
||||
log_debug_calls = []
|
||||
mock_state.return_value = S_CONNECTED
|
||||
self.pjlink.send_queue = [test_command]
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: send_command with invalid command
|
||||
self.pjlink.send_command(cmd='DONTCARE')
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert self.pjlink.send_queue, 'Send queue should have one entry'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_send_command.called, '_underscore_send_command() should have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_invalid_command_priority_queue(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test _send_command with invalid command for priority queue
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
test_command = '{prefix}{clss}CLSS ?{suff}'.format(prefix=PJLINK_PREFIX,
|
||||
clss=self.pjlink.pjlink_class,
|
||||
suff=PJLINK_SUFFIX)
|
||||
log_error_calls = [call('({ip}) send_command(): Invalid command requested - '
|
||||
'ignoring.'.format(ip=self.pjlink.name))]
|
||||
log_warning_calls = []
|
||||
log_debug_calls = []
|
||||
mock_state.return_value = S_CONNECTED
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = [test_command]
|
||||
|
||||
# WHEN: send_command with invalid command
|
||||
self.pjlink.send_command(cmd='DONTCARE', priority=True)
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert self.pjlink.priority_queue, 'Priority queue should have one entry'
|
||||
assert (not mock_reset.called), 'reset_information() should not have been called'
|
||||
assert mock_send_command.called, '_underscore_send_command() should have been called'
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'state')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, 'reset_information')
|
||||
@patch.object(openlp.core.projectors.pjlink.PJLink, '_send_command')
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_send_command_not_connected(self, mock_log, mock_send_command, mock_reset, mock_state):
|
||||
"""
|
||||
Test send_command when not connected
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
log_error_calls = []
|
||||
log_warning_calls = [call('({ip}) send_command(): Not connected - returning'.format(ip=self.pjlink.name))]
|
||||
log_debug_calls = []
|
||||
mock_state.return_value = S_NOT_CONNECTED
|
||||
self.pjlink.send_queue = []
|
||||
self.pjlink.priority_queue = []
|
||||
|
||||
# WHEN: send_command called when not connected
|
||||
self.pjlink.send_command(cmd=None)
|
||||
|
||||
# THEN:
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warning_calls)
|
||||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
assert (not self.pjlink.send_queue), 'Send queue should be empty'
|
||||
assert (not self.pjlink.priority_queue), 'Priority queue should be empty'
|
||||
assert mock_reset.called, 'reset_information() should have been called'
|
||||
assert (not mock_send_command.called), '_underscore_send_command() should not have been called'
|
||||
|
|
|
|||
|
|
@ -23,10 +23,11 @@
|
|||
Package to test the openlp.core.projectors.pjlink command routing.
|
||||
"""
|
||||
|
||||
from unittest import TestCase
|
||||
from unittest import TestCase, skip
|
||||
from unittest.mock import MagicMock, call, patch
|
||||
|
||||
import openlp.core.projectors.pjlink
|
||||
from openlp.core.projectors.pjlinkcommands import process_command
|
||||
from openlp.core.projectors.constants import E_AUTHENTICATION, E_PARAMETER, E_PROJECTOR, E_UNAVAILABLE, E_UNDEFINED, \
|
||||
PJLINK_ERRORS, PJLINK_PREFIX, STATUS_MSG
|
||||
from openlp.core.projectors.db import Projector
|
||||
|
|
@ -38,43 +39,47 @@ class TestPJLinkRouting(TestCase):
|
|||
"""
|
||||
Tests for the PJLink module command routing
|
||||
"""
|
||||
def setUp(self):
|
||||
"""
|
||||
Setup test environment
|
||||
"""
|
||||
self.pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
|
||||
def tearDown(self):
|
||||
"""
|
||||
Reset test environment
|
||||
"""
|
||||
del(self.pjlink)
|
||||
|
||||
@patch.object(openlp.core.projectors.pjlink, 'log')
|
||||
def test_get_data_unknown_command(self, mock_log):
|
||||
"""
|
||||
Test not a valid command
|
||||
"""
|
||||
# GIVEN: Test object
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.pjlink_functions = MagicMock()
|
||||
self.pjlink.pjlink_functions = MagicMock()
|
||||
log_warning_text = [call('({ip}) get_data(): Invalid packet - '
|
||||
'unknown command "UNKN"'.format(ip=pjlink.name))]
|
||||
log_debug_text = [call('PJlink(projector="< Projector(id="None", ip="111.111.111.111", port="1111", '
|
||||
'mac_adx="11:11:11:11:11:11", pin="1111", name="___TEST_ONE___", '
|
||||
'location="location one", notes="notes one", pjlink_name="None", '
|
||||
'pjlink_class="None", manufacturer="None", model="None", serial_no="Serial Number 1", '
|
||||
'other="None", sources="None", source_list="[]", model_filter="Filter type 1", '
|
||||
'model_lamp="Lamp type 1", sw_version="Version 1") >", '
|
||||
'args="()" kwargs="{\'no_poll\': True}")'),
|
||||
call('PJlinkCommands(args=() kwargs={})'),
|
||||
call('(___TEST_ONE___) reset_information() connect status is S_NOT_CONNECTED'),
|
||||
call('(___TEST_ONE___) get_data(buffer="%1UNKN=Huh?"'),
|
||||
'unknown command "UNKN"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) _send_command(): Nothing to send - '
|
||||
'returning'.format(ip=self.pjlink.name))]
|
||||
log_debug_text = [call('(___TEST_ONE___) get_data(buffer="%1UNKN=Huh?"'),
|
||||
call('(___TEST_ONE___) get_data(): Checking new data "%1UNKN=Huh?"'),
|
||||
call('(___TEST_ONE___) get_data() header="%1UNKN" data="Huh?"'),
|
||||
call('(___TEST_ONE___) get_data() version="1" cmd="UNKN"'),
|
||||
call('(___TEST_ONE___) Cleaning buffer - msg = "get_data(): Invalid packet - '
|
||||
'unknown command "UNKN""'),
|
||||
call('(___TEST_ONE___) Finished cleaning buffer - 0 bytes dropped'),
|
||||
call('(___TEST_ONE___) _send_command(): Nothing to send - returning')]
|
||||
|
||||
call('(___TEST_ONE___) Cleaning buffer - msg = "get_data(): '
|
||||
'Invalid packet - unknown command "UNKN""'),
|
||||
call('(___TEST_ONE___) Finished cleaning buffer - 0 bytes dropped')]
|
||||
# WHEN: get_data called with an unknown command
|
||||
pjlink.get_data(buff='{prefix}1UNKN=Huh?'.format(prefix=PJLINK_PREFIX))
|
||||
self.pjlink.get_data(buff='{prefix}1UNKN=Huh?'.format(prefix=PJLINK_PREFIX))
|
||||
|
||||
# THEN: Appropriate log entries should have been made and methods called/not called
|
||||
mock_log.warning.assert_has_calls(log_warning_text)
|
||||
mock_log.debug.assert_has_calls(log_debug_text)
|
||||
assert pjlink.pjlink_functions.called is False, 'Should not have accessed pjlink_functions'
|
||||
assert self.pjlink.pjlink_functions.called is False, 'Should not have accessed pjlink_functions'
|
||||
|
||||
def test_process_command_call_clss(self):
|
||||
@skip('Needs update to new setup')
|
||||
@patch("openlp.core.projectors.pjlink.log")
|
||||
def test_process_command_call_clss(self, mock_log):
|
||||
"""
|
||||
Test process_command calls proper function
|
||||
"""
|
||||
|
|
@ -82,17 +87,17 @@ class TestPJLinkRouting(TestCase):
|
|||
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \
|
||||
patch.object(openlp.core.projectors.pjlink.PJLink, 'process_clss') as mock_process_clss:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_debug_calls = [call('({ip}) Processing command "CLSS" with data "1"'.format(ip=pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=pjlink.name))]
|
||||
log_debug_calls = [call('({ip}) Processing command "CLSS" with data "1"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command is called with valid function and data
|
||||
pjlink.process_command(cmd='CLSS', data='1')
|
||||
process_command(projector=self.pjlink, cmd='CLSS', data='1')
|
||||
|
||||
# THEN: Appropriate log entries should have been made and methods called
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_process_clss.assert_called_once_with(data='1')
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_erra(self):
|
||||
"""
|
||||
Test ERRA - Authentication Error
|
||||
|
|
@ -105,8 +110,9 @@ class TestPJLinkRouting(TestCase):
|
|||
patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorAuthentication') as mock_authentication:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_error_calls = [call('({ip}) PJLINK: {msg}'.format(ip=pjlink.name, msg=STATUS_MSG[E_AUTHENTICATION]))]
|
||||
log_debug_calls = [call('({ip}) Processing command "PJLINK" with data "ERRA"'.format(ip=pjlink.name))]
|
||||
log_error_calls = [call('({ip}) PJLINK: {msg}'.format(ip=self.pjlink.name,
|
||||
msg=STATUS_MSG[E_AUTHENTICATION]))]
|
||||
log_debug_calls = [call('({ip}) Processing command "PJLINK" with data "ERRA"'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command called with ERRA
|
||||
pjlink.process_command(cmd='PJLINK', data=PJLINK_ERRORS[E_AUTHENTICATION])
|
||||
|
|
@ -119,6 +125,7 @@ class TestPJLinkRouting(TestCase):
|
|||
mock_authentication.emit.assert_called_once_with(pjlink.name)
|
||||
mock_process_pjlink.assert_not_called()
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_err1(self):
|
||||
"""
|
||||
Test ERR1 - Undefined projector function
|
||||
|
|
@ -128,9 +135,9 @@ class TestPJLinkRouting(TestCase):
|
|||
patch.object(openlp.core.projectors.pjlink.PJLink, 'process_clss') as mock_process_clss:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=pjlink.name, msg=STATUS_MSG[E_UNDEFINED]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR1"'.format(ip=pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=pjlink.name))]
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=self.pjlink.name, msg=STATUS_MSG[E_UNDEFINED]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR1"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command called with ERR1
|
||||
pjlink.process_command(cmd='CLSS', data=PJLINK_ERRORS[E_UNDEFINED])
|
||||
|
|
@ -140,6 +147,7 @@ class TestPJLinkRouting(TestCase):
|
|||
mock_log.debug.assert_has_calls(log_debug_text)
|
||||
mock_process_clss.assert_called_once_with(data=PJLINK_ERRORS[E_UNDEFINED])
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_err2(self):
|
||||
"""
|
||||
Test ERR2 - Parameter Error
|
||||
|
|
@ -149,9 +157,9 @@ class TestPJLinkRouting(TestCase):
|
|||
patch.object(openlp.core.projectors.pjlink.PJLink, 'process_clss') as mock_process_clss:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=pjlink.name, msg=STATUS_MSG[E_PARAMETER]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR2"'.format(ip=pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=pjlink.name))]
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=self.pjlink.name, msg=STATUS_MSG[E_PARAMETER]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR2"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command called with ERR2
|
||||
pjlink.process_command(cmd='CLSS', data=PJLINK_ERRORS[E_PARAMETER])
|
||||
|
|
@ -161,6 +169,7 @@ class TestPJLinkRouting(TestCase):
|
|||
mock_log.debug.assert_has_calls(log_debug_text)
|
||||
mock_process_clss.assert_called_once_with(data=PJLINK_ERRORS[E_PARAMETER])
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_err3(self):
|
||||
"""
|
||||
Test ERR3 - Unavailable error
|
||||
|
|
@ -170,9 +179,9 @@ class TestPJLinkRouting(TestCase):
|
|||
patch.object(openlp.core.projectors.pjlink.PJLink, 'process_clss') as mock_process_clss:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=pjlink.name, msg=STATUS_MSG[E_UNAVAILABLE]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR3"'.format(ip=pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=pjlink.name))]
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=self.pjlink.name, msg=STATUS_MSG[E_UNAVAILABLE]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR3"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command called with ERR3
|
||||
pjlink.process_command(cmd='CLSS', data=PJLINK_ERRORS[E_UNAVAILABLE])
|
||||
|
|
@ -182,6 +191,7 @@ class TestPJLinkRouting(TestCase):
|
|||
mock_log.debug.assert_has_calls(log_debug_text)
|
||||
mock_process_clss.assert_called_once_with(data=PJLINK_ERRORS[E_UNAVAILABLE])
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_err4(self):
|
||||
"""
|
||||
Test ERR3 - Unavailable error
|
||||
|
|
@ -191,9 +201,9 @@ class TestPJLinkRouting(TestCase):
|
|||
patch.object(openlp.core.projectors.pjlink.PJLink, 'process_clss') as mock_process_clss:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=pjlink.name, msg=STATUS_MSG[E_PROJECTOR]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR4"'.format(ip=pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=pjlink.name))]
|
||||
log_error_text = [call('({ip}) CLSS: {msg}'.format(ip=self.pjlink.name, msg=STATUS_MSG[E_PROJECTOR]))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "ERR4"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) Calling function for CLSS'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command called with ERR4
|
||||
pjlink.process_command(cmd='CLSS', data=PJLINK_ERRORS[E_PROJECTOR])
|
||||
|
|
@ -203,6 +213,7 @@ class TestPJLinkRouting(TestCase):
|
|||
mock_log.debug.assert_has_calls(log_debug_text)
|
||||
mock_process_clss.assert_called_once_with(data=PJLINK_ERRORS[E_PROJECTOR])
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_future(self):
|
||||
"""
|
||||
Test command valid but no method to process yet
|
||||
|
|
@ -213,8 +224,10 @@ class TestPJLinkRouting(TestCase):
|
|||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
pjlink.pjlink_functions = MagicMock()
|
||||
log_warning_text = [call('({ip}) Unable to process command="CLSS" (Future option?)'.format(ip=pjlink.name))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" with data "Huh?"'.format(ip=pjlink.name))]
|
||||
log_warning_text = [call('({ip}) Unable to process command="CLSS" '
|
||||
'(Future option?)'.format(ip=self.pjlink.name))]
|
||||
log_debug_text = [call('({ip}) Processing command "CLSS" '
|
||||
'with data "Huh?"'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: Processing a possible future command
|
||||
pjlink.process_command(cmd='CLSS', data="Huh?")
|
||||
|
|
@ -225,6 +238,7 @@ class TestPJLinkRouting(TestCase):
|
|||
assert pjlink.pjlink_functions.called is False, 'Should not have accessed pjlink_functions'
|
||||
assert mock_process_clss.called is False, 'Should not have called process_clss'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_command_ok(self):
|
||||
"""
|
||||
Test command returned success
|
||||
|
|
@ -235,8 +249,8 @@ class TestPJLinkRouting(TestCase):
|
|||
patch.object(openlp.core.projectors.pjlink.PJLink, 'process_clss') as mock_process_clss:
|
||||
|
||||
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
|
||||
log_debug_calls = [call('({ip}) Processing command "CLSS" with data "OK"'.format(ip=pjlink.name)),
|
||||
call('({ip}) Command "CLSS" returned OK'.format(ip=pjlink.name))]
|
||||
log_debug_calls = [call('({ip}) Processing command "CLSS" with data "OK"'.format(ip=self.pjlink.name)),
|
||||
call('({ip}) Command "CLSS" returned OK'.format(ip=self.pjlink.name))]
|
||||
|
||||
# WHEN: process_command is called with valid function and data
|
||||
pjlink.process_command(cmd='CLSS', data='OK')
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
"""
|
||||
Package to test the openlp.core.projectors.pjlink commands package.
|
||||
"""
|
||||
from unittest import TestCase
|
||||
from unittest import TestCase, skip
|
||||
from unittest.mock import call, patch
|
||||
|
||||
import openlp.core.projectors.pjlink
|
||||
|
|
@ -37,6 +37,7 @@ class TestPJLinkCommands(TestCase):
|
|||
"""
|
||||
Tests for the PJLinkCommands class part 1
|
||||
"""
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_inf1(self):
|
||||
"""
|
||||
Test saving INF1 data (manufacturer)
|
||||
|
|
@ -53,6 +54,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Data should be saved
|
||||
assert pjlink.manufacturer == test_data, 'Test data should have been saved'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_inf2(self):
|
||||
"""
|
||||
Test saving INF2 data (model)
|
||||
|
|
@ -69,6 +71,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Data should be saved
|
||||
assert pjlink.model == test_data, 'Test data should have been saved'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_info(self):
|
||||
"""
|
||||
Test saving INFO data (other information)
|
||||
|
|
@ -85,6 +88,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Data should be saved
|
||||
assert pjlink.other_info == test_data, 'Test data should have been saved'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_avmt_bad_data(self):
|
||||
"""
|
||||
Test avmt bad data fail
|
||||
|
|
@ -103,6 +107,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.mute is True, 'Audio should not have changed'
|
||||
assert mock_UpdateIcons.emit.called is False, 'Update icons should NOT have been called'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_avmt_closed_muted(self):
|
||||
"""
|
||||
Test avmt status shutter closed and mute off
|
||||
|
|
@ -121,6 +126,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.mute is True, 'Audio should be muted'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Update icons should have been called'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_avmt_shutter_closed(self):
|
||||
"""
|
||||
Test avmt status shutter closed and audio unchanged
|
||||
|
|
@ -139,6 +145,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.mute is True, 'Audio should not have changed'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Update icons should have been called'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_avmt_audio_muted(self):
|
||||
"""
|
||||
Test avmt status shutter unchanged and mute on
|
||||
|
|
@ -157,6 +164,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.mute is True, 'Audio should be off'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Update icons should have been called'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_avmt_open_unmuted(self):
|
||||
"""
|
||||
Test avmt status shutter open and mute off
|
||||
|
|
@ -175,6 +183,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.mute is False, 'Audio should be on'
|
||||
assert mock_UpdateIcons.emit.called is True, 'Update icons should have been called'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_clss_one(self):
|
||||
"""
|
||||
Test class 1 sent from projector
|
||||
|
|
@ -188,6 +197,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Projector class should be set to 1
|
||||
assert pjlink.pjlink_class == '1', 'Projector should have set class=1'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_clss_two(self):
|
||||
"""
|
||||
Test class 2 sent from projector
|
||||
|
|
@ -201,6 +211,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Projector class should be set to 1
|
||||
assert pjlink.pjlink_class == '2', 'Projector should have set class=2'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_clss_invalid_nan(self):
|
||||
"""
|
||||
Test CLSS reply has no class number
|
||||
|
|
@ -222,6 +233,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_clss_invalid_no_version(self):
|
||||
"""
|
||||
Test CLSS reply has no class number
|
||||
|
|
@ -243,6 +255,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_log.error.assert_has_calls(log_error_calls)
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_clss_nonstandard_reply_1(self):
|
||||
"""
|
||||
Test CLSS request returns non-standard reply 1
|
||||
|
|
@ -256,6 +269,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Projector class should be set with proper value
|
||||
assert '1' == pjlink.pjlink_class, 'Non-standard class reply should have set class=1'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_clss_nonstandard_reply_2(self):
|
||||
"""
|
||||
Test CLSS request returns non-standard reply 2
|
||||
|
|
@ -269,6 +283,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Projector class should be set with proper value
|
||||
assert '2' == pjlink.pjlink_class, 'Non-standard class reply should have set class=2'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_erst_all_ok(self):
|
||||
"""
|
||||
Test to verify pjlink.projector_errors is set to None when no errors
|
||||
|
|
@ -284,6 +299,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: PJLink instance errors should be None
|
||||
assert pjlink.projector_errors is None, 'projector_errors should have been set to None'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_erst_data_invalid_length(self):
|
||||
"""
|
||||
Test test_projector_process_erst_data_invalid_length
|
||||
|
|
@ -306,6 +322,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_erst_data_invalid_nan(self):
|
||||
"""
|
||||
Test test_projector_process_erst_data_invalid_nan
|
||||
|
|
@ -327,6 +344,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_erst_all_warn(self):
|
||||
"""
|
||||
Test test_projector_process_erst_all_warn
|
||||
|
|
@ -354,6 +372,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: PJLink instance errors should match chk_value
|
||||
assert pjlink.projector_errors == chk_test, 'Projector errors should be all E_WARN'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_erst_all_error(self):
|
||||
"""
|
||||
Test test_projector_process_erst_all_error
|
||||
|
|
@ -381,6 +400,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: PJLink instance errors should match chk_value
|
||||
assert pjlink.projector_errors == chk_test, 'Projector errors should be all E_ERROR'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_erst_warn_cover_only(self):
|
||||
"""
|
||||
Test test_projector_process_erst_warn_cover_only
|
||||
|
|
@ -406,6 +426,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.projector_errors['Cover'] == E_WARN, '"Cover" should have E_WARN listed as error'
|
||||
assert chk_test == pjlink.projector_errors, 'projector_errors should match test errors'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_inpt_valid(self):
|
||||
"""
|
||||
Test input source status shows current input
|
||||
|
|
@ -426,6 +447,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.source == '21', 'Input source should be set to "21"'
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_input_not_in_list(self):
|
||||
"""
|
||||
Test setting input outside of available inputs
|
||||
|
|
@ -434,6 +456,7 @@ class TestPJLinkCommands(TestCase):
|
|||
"""
|
||||
pass
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_input_not_in_default(self):
|
||||
"""
|
||||
Test setting input with no sources available
|
||||
|
|
@ -441,6 +464,7 @@ class TestPJLinkCommands(TestCase):
|
|||
"""
|
||||
pass
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_input_invalid(self):
|
||||
"""
|
||||
Test setting input with an invalid value
|
||||
|
|
@ -448,6 +472,7 @@ class TestPJLinkCommands(TestCase):
|
|||
TODO: Future test
|
||||
"""
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_inst_class_1(self):
|
||||
"""
|
||||
Test saving video source available information
|
||||
|
|
@ -472,6 +497,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.source_available == chk_test, "Sources should have been sorted and saved"
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_lamp_invalid(self):
|
||||
"""
|
||||
Test status multiple lamp on/off and hours
|
||||
|
|
@ -494,6 +520,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert 11111 == pjlink.lamp[1]['Hours'], 'Lamp 2 hours should have been left at 11111'
|
||||
mock_log.warning.assert_has_calls(log_data)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_lamp_multiple(self):
|
||||
"""
|
||||
Test status multiple lamp on/off and hours
|
||||
|
|
@ -514,6 +541,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.lamp[2]['On'] is True, 'Lamp 3 power status should have been set to TRUE'
|
||||
assert 33333 == pjlink.lamp[2]['Hours'], 'Lamp 3 hours should have been set to 33333'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_lamp_single(self):
|
||||
"""
|
||||
Test status lamp on/off and hours
|
||||
|
|
@ -531,6 +559,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.lamp[0]['On'] is True, 'Lamp power status should have been set to TRUE'
|
||||
assert 22222 == pjlink.lamp[0]['Hours'], 'Lamp hours should have been set to 22222'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_lamp_single_hours_only(self):
|
||||
"""
|
||||
Test process lamp with 1 lamp reply hours only and no on/off status
|
||||
|
|
@ -547,6 +576,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert 45 == pjlink.lamp[0]['Hours'], 'Lamp hours should have equalled 45'
|
||||
assert pjlink.lamp[0]['On'] is None, 'Lamp power should be "None"'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_name(self):
|
||||
"""
|
||||
Test saving NAME data from projector
|
||||
|
|
@ -565,6 +595,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.pjlink_name == chk_data, 'Name test data should have been saved'
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_powr_on(self):
|
||||
"""
|
||||
Test status power to ON
|
||||
|
|
@ -586,6 +617,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_send_command.assert_called_once_with('INST')
|
||||
mock_change_status.assert_called_once_with(S_ON)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_powr_invalid(self):
|
||||
"""
|
||||
Test process_powr invalid call
|
||||
|
|
@ -610,6 +642,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_send_command.assert_not_called()
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_powr_off(self):
|
||||
"""
|
||||
Test status power to STANDBY
|
||||
|
|
@ -631,6 +664,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_change_status.assert_called_with(313)
|
||||
mock_send_command.assert_not_called()
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_rfil_save(self):
|
||||
"""
|
||||
Test saving filter type
|
||||
|
|
@ -647,6 +681,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Filter model number should be saved
|
||||
assert pjlink.model_filter == filter_model, 'Filter type should have been saved'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_rfil_nosave(self):
|
||||
"""
|
||||
Test saving filter type previously saved
|
||||
|
|
@ -668,6 +703,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.model_filter != filter_model, 'Filter type should NOT have been saved'
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_rlmp_save(self):
|
||||
"""
|
||||
Test saving lamp type
|
||||
|
|
@ -684,6 +720,7 @@ class TestPJLinkCommands(TestCase):
|
|||
# THEN: Filter model number should be saved
|
||||
assert pjlink.model_lamp == lamp_model, 'Lamp type should have been saved'
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_rlmp_nosave(self):
|
||||
"""
|
||||
Test saving lamp type previously saved
|
||||
|
|
@ -705,6 +742,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.model_lamp != lamp_model, 'Lamp type should NOT have been saved'
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_snum_set(self):
|
||||
"""
|
||||
Test saving serial number from projector
|
||||
|
|
@ -725,6 +763,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.serial_no == test_number, 'Projector serial number should have been set'
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_snum_different(self):
|
||||
"""
|
||||
Test projector serial number different than saved serial number
|
||||
|
|
@ -747,6 +786,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.serial_no != test_number, 'Projector serial number should NOT have been set'
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_sver(self):
|
||||
"""
|
||||
Test invalid software version information - too long
|
||||
|
|
@ -767,6 +807,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.sw_version == test_data, 'Software version should have been updated'
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_sver_changed(self):
|
||||
"""
|
||||
Test invalid software version information - Received different than saved
|
||||
|
|
@ -790,6 +831,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert pjlink.sw_version == test_data_new, 'Software version should have changed'
|
||||
mock_log.warning.assert_has_calls(log_warn_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_process_sver_invalid(self):
|
||||
"""
|
||||
Test invalid software version information - too long
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ class TestPJLinkCommands(TestCase):
|
|||
"""
|
||||
Tests for the PJLinkCommands class part 2
|
||||
"""
|
||||
@skip('Needs update to new setup')
|
||||
def test_projector_reset_information(self):
|
||||
"""
|
||||
Test reset_information() resets all information and stops timers
|
||||
|
|
@ -83,6 +84,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert mock_socket_timer.stop.called is True, 'Projector socket_timer.stop() should have been called'
|
||||
mock_log.debug.assert_has_calls(log_debug_calls)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_normal(self):
|
||||
"""
|
||||
Test initial connection prompt with no authentication
|
||||
|
|
@ -108,6 +110,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_change_status.assert_called_once_with(S_CONNECTED)
|
||||
mock_send_command.assert_called_with(cmd='CLSS', priority=True, salt=None)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_authenticate(self):
|
||||
"""
|
||||
Test initial connection prompt with authentication
|
||||
|
|
@ -133,6 +136,7 @@ class TestPJLinkCommands(TestCase):
|
|||
mock_change_status.assert_called_once_with(S_CONNECTED)
|
||||
mock_send_command.assert_called_with(cmd='CLSS', priority=True, salt=TEST_HASH)
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_normal_pin_set_error(self):
|
||||
"""
|
||||
Test process_pjlinnk called with no authentication but pin is set
|
||||
|
|
@ -154,6 +158,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert 1 == mock_disconnect_from_host.call_count, 'Should have only been called once'
|
||||
mock_send_command.assert_not_called()
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_normal_with_salt_error(self):
|
||||
"""
|
||||
Test process_pjlinnk called with no authentication but pin is set
|
||||
|
|
@ -175,6 +180,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert 1 == mock_disconnect_from_host.call_count, 'Should have only been called once'
|
||||
mock_send_command.assert_not_called()
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_invalid_authentication_scheme_length_error(self):
|
||||
"""
|
||||
Test initial connection prompt with authentication scheme longer than 1 character
|
||||
|
|
@ -195,6 +201,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert 1 == mock_disconnect_from_host.call_count, 'Should have only been called once'
|
||||
mock_send_command.assert_not_called()
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_invalid_authentication_data_length_error(self):
|
||||
"""
|
||||
Test initial connection prompt with authentication no salt
|
||||
|
|
@ -215,6 +222,7 @@ class TestPJLinkCommands(TestCase):
|
|||
assert 1 == mock_disconnect_from_host.call_count, 'Should have only been called once'
|
||||
mock_send_command.assert_not_called()
|
||||
|
||||
@skip('Needs update to new setup')
|
||||
def test_process_pjlink_authenticate_pin_not_set_error(self):
|
||||
"""
|
||||
Test process_pjlink authentication but pin not set
|
||||
|
|
|
|||
Loading…
Reference in New Issue