Ken Roberts has proposed merging lp:~alisonken1/openlp/pjlink2-v02 into
lp:openlp with lp:~alisonken1/openlp/pjlink2-v1 as a prerequisite.
Commit message:
PJLink2 Update V02
Requested reviews:
OpenLP Core (openlp-core)
For more details, see:
https://code.launchpad.net/~alisonken1/openlp/pjlink2-v02/+merge/366554
NOTE: Part 2 of a multi-part merge.
v[2..n] merges are to fix tests
WARNING: Requires merge of lp:~alisonken1/openlp/pjlink2-v1
- Updated pjlink imports
- Added setUp() and tearDown() to pjlinkcommands.py::TestPJLinkBase to have a
common
pjlink() instance creation
- Fix tests in test_projector_pjlink_base_01.py
- Move patch.object context managers to decorators
--------------------------------------------------------------------------------
lp:~alisonken1/openlp/pjlink2-v02 (revision 2860)
https://ci.openlp.io/job/Branch-01-Pull/2720/ [SUCCESS]
https://ci.openlp.io/job/Branch-02a-Linux-Tests/2614/ [SUCCESS]
https://ci.openlp.io/job/Branch-02b-macOS-Tests/389/ [SUCCESS]
https://ci.openlp.io/job/Branch-03a-Build-Source/212/ [SUCCESS]
https://ci.openlp.io/job/Branch-03b-Build-macOS/191/ [SUCCESS]
https://ci.openlp.io/job/Branch-04a-Code-Lint/1674/ [SUCCESS]
https://ci.openlp.io/job/Branch-04b-Test-Coverage/1487/ [SUCCESS]
https://ci.openlp.io/job/Branch-05-AppVeyor-Tests/369/ [FAILURE]
Stopping after failure
--
Your team OpenLP Core is requested to review the proposed merge of
lp:~alisonken1/openlp/pjlink2-v02 into lp:openlp.
=== modified file 'tests/openlp_core/projectors/test_projector_pjlink_base_01.py'
--- tests/openlp_core/projectors/test_projector_pjlink_base_01.py 2019-04-26 07:51:13 +0000
+++ tests/openlp_core/projectors/test_projector_pjlink_base_01.py 2019-04-26 07:51:13 +0000
@@ -22,10 +22,11 @@
"""
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
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,47 +38,56 @@
"""
Tests for the PJLink module
"""
- @skip('Needs update to new setup')
- 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 = PJLink(Projector(**TEST1_DATA), no_poll=True)
-
- # 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]))
-
- @skip('Needs update to new setup')
- def test_socket_abort(self):
+ pjlink = self.pjlink
+
+ # WHEN: process_command is called with "ERR2" status from projector
+ process_command(projector=pjlink, cmd='POWR', data='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]))
+
+ @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)
-
- # 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'
-
- @skip('Needs update to new setup')
+ pjlink = self.pjlink
+
+ # 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'
+
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
@@ -89,412 +99,371 @@
# THEN: poll_loop should exit 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')
- 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:
-
- 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'),
- ]
-
- # 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')
-
- @skip('Needs update to new setup')
- def test_projector_change_status_unknown_socket_error(self):
+ # 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.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()
+
+ # 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')
+
+ @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:
-
- 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)
-
- # 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])
-
- @skip('Needs update to new setup')
- def test_projector_change_status_connection_status_connecting(self):
+ # 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]))]
+
+ # 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])
+
+ @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]))]
-
- # 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'
-
- @skip('Needs update to new setup')
- def test_projector_change_status_connection_status_connected(self):
+ 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)
+
+ # 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'
+
+ @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]))]
-
- # 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'
-
- @skip('Needs update to new setup')
- def test_projector_change_status_connection_status_with_message(self):
+ 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)
+
+ # 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'
+
+ @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))]
-
- # 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'
-
- @skip('Needs update to new setup')
- def test_projector_get_av_mute_status(self):
+ 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)
+
+ # 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'
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_available_inputs(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_error_status(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_input_source(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_lamp_status(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_manufacturer(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_model(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_name(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_other_info(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
- def test_projector_get_power_status(self):
+ # 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()
+
+ # 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)
+
+ @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))]
-
- # 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)
-
- @skip('Needs update to new setup')
+ # 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()
+
+ # 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
@@ -504,14 +473,13 @@
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'
- @skip('Needs update to new setup')
def test_projector_get_status_valid(self):
"""
Test to check returned information for status codes
"""
# 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)
@@ -520,13 +488,12 @@
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'
- @skip('Needs update to new setup')
def test_projector_get_status_unknown(self):
"""
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)
_______________________________________________
Mailing list: https://launchpad.net/~openlp-core
Post to : openlp-core@lists.launchpad.net
Unsubscribe : https://launchpad.net/~openlp-core
More help : https://help.launchpad.net/ListHelp
