raoul
/
openlp
forked from openlp/openlp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

pjlink2 update v02

This commit is contained in:
Ken Roberts 2019-04-26 00:39:37 -07:00
parent 5f6887f837
commit ddd14a5fc2
1 changed files with 300 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

633
tests/openlp_core/projectors/test_projector_pjlink_base_01.py
View File

@ -22,10 +22,11 @@
""" """
Package to test the openlp.core.projectors.pjlink base package. Package to test the openlp.core.projectors.pjlink base package.
""" """
from unittest import TestCase, skip from unittest import TestCase
from unittest.mock import MagicMock, call, patch from unittest.mock import MagicMock, call, patch
import openlp.core.projectors.pjlink 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, \ 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 S_CONNECTED, S_CONNECTING, S_NOT_CONNECTED, S_OK, S_ON, STATUS_CODE, STATUS_MSG
from openlp.core.projectors.db import Projector from openlp.core.projectors.db import Projector
@ -37,47 +38,56 @@ class TestPJLinkBase(TestCase):
""" """
Tests for the PJLink module Tests for the PJLink module
""" """
@skip('Needs update to new setup') def setUp(self):
def test_status_change(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 Test process_command call with ERR2 (Parameter) status
""" """
# GIVEN: Test object # 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 # THEN: change_status should have called change_status with E_UNDEFINED
pjlink.process_command('POWR', 'ERR2') # 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 @patch.object(openlp.core.projectors.pjlink.PJLink, 'disconnect_from_host')
# as first parameter def test_socket_abort(self, mock_disconnect):
mock_changeStatus.called_with(E_PARAMETER,
'change_status should have been called with "{}"'.format(
STATUS_CODE[E_PARAMETER]))
@skip('Needs update to new setup')
def test_socket_abort(self):
""" """
Test PJLink.socket_abort calls disconnect_from_host Test PJLink.socket_abort calls disconnect_from_host
""" """
# GIVEN: Test object # GIVEN: Test object
with patch('openlp.core.projectors.pjlink.PJLink.disconnect_from_host') as mock_disconnect: pjlink = self.pjlink
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True)
# WHEN: Calling socket_abort # WHEN: Calling socket_abort
pjlink.socket_abort() pjlink.socket_abort()
# THEN: disconnect_from_host should be called # THEN: disconnect_from_host should be called
assert mock_disconnect.called is True, 'Should have called disconnect_from_host' assert mock_disconnect.called is True, 'Should have called disconnect_from_host'
@skip('Needs update to new setup')
def test_poll_loop_not_connected(self): def test_poll_loop_not_connected(self):
""" """
Test PJLink.poll_loop not connected return Test PJLink.poll_loop not connected return
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) pjlink = self.pjlink
pjlink.state = MagicMock() pjlink.state = MagicMock()
pjlink.timer = MagicMock() pjlink.timer = MagicMock()
pjlink.state.return_value = False pjlink.state.return_value = False
@ -89,412 +99,371 @@ class TestPJLinkBase(TestCase):
# THEN: poll_loop should exit without calling any other method # THEN: poll_loop should exit without calling any other method
assert pjlink.timer.called is False, 'Should have returned without calling any other method' assert pjlink.timer.called is False, 'Should have returned without calling any other method'
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_poll_loop_set_interval(self): def test_poll_loop_set_interval(self, mock_send_command):
""" """
Test PJLink.poll_loop makes correct calls Test PJLink.poll_loop makes correct calls
""" """
# GIVEN: Mocks and test data # GIVEN: Test object and data
with patch('openlp.core.projectors.pjlink.PJLink.send_command') as mock_send_command: 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.poll_time = 20
pjlink.state = MagicMock() pjlink.power = S_ON
pjlink.state.return_value = QSOCKET_STATE[S_CONNECTED] pjlink.source_available = None
pjlink.poll_timer = MagicMock() pjlink.other_info = None
pjlink.poll_timer.interval.return_value = 10 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 # WHEN: PJLink.poll_loop is called
pjlink.power = S_ON pjlink.poll_loop()
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 # THEN: proper calls were made to retrieve projector data
pjlink.poll_loop() # 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 @patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons')
# First, call to update the timer with the next interval @patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
assert pjlink.poll_timer.setInterval.called is True, 'Timer update interval should have been called' @patch.object(openlp.core.projectors.pjlink, 'log')
# Finally, should have called send_command with a list of projetctor status checks def test_projector_change_status_unknown_socket_error(self, mock_log, mock_changeStatus, mock_UpdateIcons):
mock_send_command.assert_has_calls(call_list, 'Should have queued projector queries')
@skip('Needs update to new setup')
def test_projector_change_status_unknown_socket_error(self):
""" """
Test change_status with connection error Test change_status with connection error
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus, \ pjlink.projector_status = 0
patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons') as mock_UpdateIcons: 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) # WHEN: change_status called with unknown socket error
pjlink.projector_status = 0 pjlink.change_status(status=E_UNKNOWN_SOCKET_ERROR)
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 # THEN: Proper settings should change and signals sent
pjlink.change_status(status=E_UNKNOWN_SOCKET_ERROR) 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 @patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons')
mock_log.debug.assert_has_calls(log_debug_calls) @patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
assert pjlink.projector_status == S_OK, 'Projector status should not have changed' @patch.object(openlp.core.projectors.pjlink, 'log')
assert pjlink.status_connect == E_NOT_CONNECTED, 'Status connect should be NOT CONNECTED' def test_projector_change_status_connection_status_connecting(self, mock_log, mock_changeStatus, mock_UpdateIcons):
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])
@skip('Needs update to new setup')
def test_projector_change_status_connection_status_connecting(self):
""" """
Test change_status with connecting status Test change_status with connecting status
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus, \ pjlink.projector_status = 0
patch.object(openlp.core.projectors.pjlink.PJLink, 'projectorUpdateIcons') as mock_UpdateIcons: pjlink.status_connect = 0
log_debug_calls = [
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
pjlink.projector_status = 0 status=STATUS_CODE[S_CONNECTING],
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],
msg=STATUS_MSG[S_CONNECTING])), msg=STATUS_MSG[S_CONNECTING])),
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name, call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
code=STATUS_CODE[S_OK], code=STATUS_CODE[S_CONNECTING],
msg=STATUS_MSG[S_OK])), msg=STATUS_MSG[S_CONNECTING])),
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name, call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
code=STATUS_CODE[S_OK], 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 # WHEN: change_status called with CONNECTING
pjlink.change_status(status=S_CONNECTING) pjlink.change_status(status=S_CONNECTING)
# THEN: Proper settings should change and signals sent # THEN: Proper settings should change and signals sent
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_CONNECTING, STATUS_MSG[S_CONNECTING]) 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.projector_status == S_OK, 'Projector status should not have changed'
assert pjlink.status_connect == S_CONNECTING, 'Status connect should be CONNECTING' assert pjlink.status_connect == S_CONNECTING, 'Status connect should be CONNECTING'
assert mock_UpdateIcons.emit.called is True, 'Should have called UpdateIcons' assert mock_UpdateIcons.emit.called is True, 'Should have called UpdateIcons'
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
def test_projector_change_status_connection_status_connected(self): @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 Test change_status with connected status
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus: pjlink.projector_status = 0
pjlink.status_connect = 0
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [
pjlink.projector_status = 0 call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
pjlink.status_connect = 0 status=STATUS_CODE[S_CONNECTED],
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],
msg=STATUS_MSG[S_CONNECTED])), msg=STATUS_MSG[S_CONNECTED])),
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name, call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
code=STATUS_CODE[S_OK], code=STATUS_CODE[S_CONNECTED],
msg=STATUS_MSG[S_OK])), msg=STATUS_MSG[S_CONNECTED])),
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name, call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
code=STATUS_CODE[S_OK], 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 # WHEN: change_status called with CONNECTED
pjlink.change_status(status=S_CONNECTED) pjlink.change_status(status=S_CONNECTED)
# THEN: Proper settings should change and signals sent # THEN: Proper settings should change and signals sent
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_CONNECTED, 'Connected') 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.projector_status == S_OK, 'Projector status should not have changed'
assert pjlink.status_connect == S_CONNECTED, 'Status connect should be CONNECTED' assert pjlink.status_connect == S_CONNECTED, 'Status connect should be CONNECTED'
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus')
def test_projector_change_status_connection_status_with_message(self): @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 Test change_status with connection status
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'changeStatus') as mock_changeStatus: pjlink.projector_status = 0
pjlink.status_connect = 0
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) test_message = 'Different Status Message than default'
pjlink.projector_status = 0 log_debug_calls = [
pjlink.status_connect = 0 call('({ip}) Changing status to {status} "{msg}"'.format(ip=pjlink.name,
test_message = 'Different Status Message than default' status=STATUS_CODE[S_ON],
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],
msg=test_message)), msg=test_message)),
call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name, call('({ip}) status_connect: {code}: "{msg}"'.format(ip=pjlink.name,
code=STATUS_CODE[S_ON], code=STATUS_CODE[S_OK],
msg=test_message)), msg=test_message)),
call('({ip}) error_status: {code}: "{msg}"'.format(ip=pjlink.name, call('({ip}) projector_status: {code}: "{msg}"'.format(ip=pjlink.name,
code=STATUS_CODE[S_OK], code=STATUS_CODE[S_ON],
msg=test_message))] 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 # WHEN: change_status called with projector ON status
pjlink.change_status(status=S_ON, msg=test_message) pjlink.change_status(status=S_ON, msg=test_message)
# THEN: Proper settings should change and signals sent # THEN: Proper settings should change and signals sent
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_changeStatus.emit.assert_called_once_with(pjlink.ip, S_ON, test_message) 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.projector_status == S_ON, 'Projector status should be ON'
assert pjlink.status_connect == S_OK, 'Status connect should not have changed' assert pjlink.status_connect == S_OK, 'Status connect should not have changed'
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_av_mute_status(self): @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 Test sending command to retrieve shutter/audio state
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'AVMT'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_av_mute_status is called # WHEN: get_av_mute_status is called
pjlink.get_av_mute_status() pjlink.get_av_mute_status()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data, priority=False) mock_send_command.assert_called_once_with(cmd=test_data, priority=False)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_available_inputs(self): @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 Test sending command to retrieve avaliable inputs
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'INST'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_available_inputs is called # WHEN: get_available_inputs is called
pjlink.get_available_inputs() pjlink.get_available_inputs()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_error_status(self): @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 Test sending command to retrieve projector error status
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'ERST'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_error_status is called # WHEN: get_error_status is called
pjlink.get_error_status() pjlink.get_error_status()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_input_source(self): @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 Test sending command to retrieve current input
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'INPT'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_input_source() pjlink.get_input_source()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_lamp_status(self): @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 Test sending command to retrieve lamp(s) status
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'LAMP'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_lamp_status() pjlink.get_lamp_status()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_manufacturer(self): @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 Test sending command to retrieve manufacturer name
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'INF1'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_manufacturer() pjlink.get_manufacturer()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_model(self): @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 Test sending command to get model information
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'INF2'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_model() pjlink.get_model()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_name(self): @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 Test sending command to get user-assigned name
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'NAME'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_name() pjlink.get_name()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_other_info(self): @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 Test sending command to retrieve other information
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'INFO'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_other_info() pjlink.get_other_info()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data) mock_send_command.assert_called_once_with(cmd=test_data)
@skip('Needs update to new setup') @patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command')
def test_projector_get_power_status(self): @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 Test sending command to retrieve current power state
""" """
# GIVEN: Test object and mocks # GIVEN: Test object
with patch.object(openlp.core.projectors.pjlink, 'log') as mock_log, \ pjlink = self.pjlink
patch.object(openlp.core.projectors.pjlink.PJLink, 'send_command') as mock_send_command: test_data = 'POWR'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) log_debug_calls = [call('({ip}) Sending {cmd} command'.format(ip=pjlink.name, cmd=test_data))]
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))]
# WHEN: get_input_source is called # WHEN: get_input_source is called
pjlink.get_power_status() pjlink.get_power_status()
# THEN: log data and send_command should have been called # THEN: log data and send_command should have been called
mock_log.debug.assert_has_calls(log_debug_calls) mock_log.debug.assert_has_calls(log_debug_calls)
mock_send_command.assert_called_once_with(cmd=test_data, priority=False) mock_send_command.assert_called_once_with(cmd=test_data, priority=False)
@skip('Needs update to new setup')
def test_projector_get_status_invalid(self): def test_projector_get_status_invalid(self):
""" """
Test to check returned information for error code Test to check returned information for error code
""" """
# GIVEN: Test object # GIVEN: Test object
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) pjlink = self.pjlink
test_string = 'NaN test' test_string = 'NaN test'
# WHEN: get_status called # WHEN: get_status called
@ -504,14 +473,13 @@ class TestPJLinkBase(TestCase):
assert code == -1, 'Should have returned -1 as a bad status check' assert code == -1, 'Should have returned -1 as a bad status check'
assert message is None, 'Invalid code type should have returned None for message' assert message is None, 'Invalid code type should have returned None for message'
@skip('Needs update to new setup')
def test_projector_get_status_valid(self): def test_projector_get_status_valid(self):
""" """
Test to check returned information for status codes Test to check returned information for status codes
""" """
# GIVEN: Test object # GIVEN: Test object
test_message = 'Not Connected' test_message = 'Not Connected'
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) pjlink = self.pjlink
# WHEN: get_status called # WHEN: get_status called
code, message = pjlink._get_status(status=S_NOT_CONNECTED) code, message = pjlink._get_status(status=S_NOT_CONNECTED)
@ -520,13 +488,12 @@ class TestPJLinkBase(TestCase):
assert code == 'S_NOT_CONNECTED', 'Code returned should have been the same code that was sent' assert code == 'S_NOT_CONNECTED', 'Code returned should have been the same code that was sent'
assert message == test_message, 'Description of code should have been returned' assert message == test_message, 'Description of code should have been returned'
@skip('Needs update to new setup')
def test_projector_get_status_unknown(self): def test_projector_get_status_unknown(self):
""" """
Test to check returned information for unknown code Test to check returned information for unknown code
""" """
# GIVEN: Test object # GIVEN: Test object
pjlink = PJLink(Projector(**TEST1_DATA), no_poll=True) pjlink = self.pjlink
# WHEN: get_status called # WHEN: get_status called
code, message = pjlink._get_status(status=9999) code, message = pjlink._get_status(status=9999)