def test_projector_avmt_status_timer_check_delete(self, mock_log, mock_UpdateIcons): """ Test avmt deletes callback in projector.status_timer_check """ # GIVEN: Test object log_warning_text = [] log_debug_text = [ call('({ip}) Processing command "AVMT" with data "11"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for AVMT'.format( ip=self.pjlink.name)), call( '({ip}) Setting shutter to closed'.format(ip=self.pjlink.name)) ] self.pjlink.shutter = False self.pjlink.mute = True self.pjlink.status_timer_checks = { 'AVMT': self.pjlink.get_av_mute_status } # WHEN: Called with setting shutter closed and mute off with patch.object(self.pjlink, 'status_timer') as mock_status_timer: process_command(projector=self.pjlink, cmd='AVMT', data='11') # THEN: Shutter should be True and mute should be False assert self.pjlink.shutter, 'Shutter should have been set to closed' assert self.pjlink.mute, 'Audio should not have changed' assert mock_UpdateIcons.emit.called, 'Update icons should have been called' assert 'AVMT' not in self.pjlink.status_timer_checks, 'Status timer list should not have AVMT callback' assert mock_status_timer.stop.called, 'Projector status_timer.stop() should have been called' mock_log.warning.assert_has_calls(log_warning_text) mock_log.debug.assert_has_calls(log_debug_text)
def test_routing_command_unknown(self, mock_log, mock_functions, mock_clss): """ Test process_command receiving command not in function map """ # GIVEN: Test setup 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 "?"'.format( ip=self.pjlink.name)) ] # Fake CLSS command is not in list mock_functions.__contains__.return_value = False # WHEN: called with unknown command process_command(projector=self.pjlink, cmd='CLSS', data='?') # 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 (mock_functions.__contains__.call_count == 1 ), 'pjlink_functions should have been accessed only once' assert (not mock_clss.called), 'Should not have called process_clss'
def test_projector_avmt_open_unmuted(self, mock_log, mock_UpdateIcons): """ Test avmt status shutter open and mute off """ # GIVEN: Test object log_warning_text = [] log_debug_text = [ call('({ip}) Processing command "AVMT" with data "30"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for AVMT'.format( ip=self.pjlink.name)), call('({ip}) Setting shutter to open'.format(ip=self.pjlink.name)), call( '({ip}) Setting speaker to normal'.format(ip=self.pjlink.name)) ] self.pjlink.shutter = True self.pjlink.mute = True # WHEN: Called with setting shutter to closed and mute on process_command(projector=self.pjlink, cmd='AVMT', data='30') # THEN: Shutter should be closed and mute should be True assert not self.pjlink.shutter, 'Shutter should have been set to off' assert not self.pjlink.mute, 'Audio should be on' assert mock_UpdateIcons.emit.called, 'Update icons should have been called' mock_log.warning.assert_has_calls(log_warning_text) mock_log.debug.assert_has_calls(log_debug_text)
def test_projector_clss_invalid_no_version(self, mock_log): """ Test CLSS reply has no class number """ # GIVEN: Test object log_warning_calls = [ call('({ip}) No numbers found in class version reply "Invalid" ' '- defaulting to class "1"'.format(ip=self.pjlink.name)) ] log_debug_calls = [ call('({ip}) Processing command "CLSS" with data "Invalid"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for CLSS'.format( ip=self.pjlink.name)), call( '({ip}) Setting pjlink_class for this projector to "1"'.format( ip=self.pjlink.name)) ] # WHEN: Process invalid reply process_command(projector=self.pjlink, cmd='CLSS', data='Invalid') # THEN: Projector class should be set with default value assert self.pjlink.pjlink_class == '1', 'Invalid class reply should have set class=1' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_sver_changed(self, mock_log): """ Test invalid software version information - Received different than saved """ # GIVEN: Test object old_data = 'Test 1 Subtest 1' new_data = 'Test 1 Subtest 2' log_warning_calls = [call('({ip}) Projector software version does not match ' 'saved software version'.format(ip=self.pjlink.name)), call('({ip}) Saved: "{data}"'.format(ip=self.pjlink.name, data=old_data)), call('({ip}) Received: "{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) Updating software version'.format(ip=self.pjlink.name))] log_debug_calls = [call('({ip}) Processing command "SVER" with data ' '"{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) Calling function for SVER'.format(ip=self.pjlink.name)), call('({ip}) Setting projector software version to ' '"{data}"'.format(ip=self.pjlink.name, data=new_data))] self.pjlink.sw_version = old_data # WHEN: process_sver called with invalid data process_command(self.pjlink, cmd='SVER', data=new_data) # THEN: Version information should change assert self.pjlink.sw_version == new_data, 'Software version should have changed' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_clss_nonstandard_reply_2(self, mock_log): """ Test CLSS request returns non-standard reply 1 """ # GIVEN: Test object log_warning_calls = [ call('({ip}) Non-standard CLSS reply: "Version2"'.format( ip=self.pjlink.name)) ] log_debug_calls = [ call( '({ip}) Processing command "CLSS" with data "Version2"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for CLSS'.format( ip=self.pjlink.name)), call( '({ip}) Setting pjlink_class for this projector to "2"'.format( ip=self.pjlink.name)) ] # WHEN: Process non-standard reply process_command(projector=self.pjlink, cmd='CLSS', data='Version2') # THEN: Projector class should be set with proper value assert '2' == self.pjlink.pjlink_class, 'Non-standard class reply should have set class=1' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_snum_different(self, mock_log): """ Test projector serial number different than saved serial number """ # GIVEN: Test object new_data = 'Test Serial Number' old_data = 'Previous serial number' log_warning_calls = [call('({ip}) Projector serial number does not match ' 'saved serial number'.format(ip=self.pjlink.name)), call('({ip}) Saved: "{data}"'.format(ip=self.pjlink.name, data=old_data)), call('({ip}) Received: "{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) NOT saving serial number'.format(ip=self.pjlink.name))] log_debug_calls = [call('({ip}) Processing command "SNUM" with data ' '"{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) Calling function for SNUM'.format(ip=self.pjlink.name))] self.pjlink.serial_no = old_data # WHEN: No serial number is set and we receive serial number command process_command(projector=self.pjlink, cmd='SNUM', data=new_data) # THEN: Serial number should be set assert self.pjlink.serial_no != new_data, 'Projector serial number should NOT have been set' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_avmt_audio_muted(self, mock_log, mock_UpdateIcons): """ Test avmt status shutter unchanged and mute on """ # GIVEN: Test setup log_warning_text = [] log_debug_text = [ call('({ip}) Processing command "AVMT" with data "21"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for AVMT'.format( ip=self.pjlink.name)), call('({ip}) Setting speaker to muted'.format(ip=self.pjlink.name)) ] self.pjlink.shutter = True self.pjlink.mute = False # WHEN: Called with setting shutter closed and mute on process_command(projector=self.pjlink, cmd='AVMT', data='21') # THEN: Shutter should be closed and mute should be True assert self.pjlink.shutter, 'Shutter should not have changed' assert self.pjlink.mute, 'Audio should be off' assert mock_UpdateIcons.emit.called, 'Update icons should have been called' mock_log.warning.assert_has_calls(log_warning_text) mock_log.debug.assert_has_calls(log_debug_text)
def test_projector_erst_data_invalid_nan(self, mock_log): """ Test ERST called with invalid data """ # GIVEN: Test object chk_data = 'Z' + ('0' * (PJLINK_ERST_DATA['DATA_LENGTH'] - 1)) log_warn_calls = [ call('({ip}) Invalid error status response "{data}"'.format( ip=self.pjlink.name, data=chk_data)) ] log_debug_calls = [ call('({ip}) Processing command "ERST" with data "{data}"'.format( ip=self.pjlink.name, data=chk_data)), call( '({ip}) Calling function for ERST'.format(ip=self.pjlink.name)) ] self.pjlink.projector_errors = None # WHEN: process_erst called with invalid data (too many values process_command(self.pjlink, cmd='ERST', data=chk_data) # THEN: pjlink.projector_errors should be empty and warning logged assert not self.pjlink.projector_errors, 'There should be no errors' mock_log.warning.assert_has_calls(log_warn_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_erst_warn_cover_only(self, mock_log): """ Test test_projector_process_erst_warn_cover_only """ # GIVEN: Test object chk_data = '{fan}{lamp}{temp}{cover}{filt}{other}'.format( fan=PJLINK_ERST_STATUS[S_OK], lamp=PJLINK_ERST_STATUS[S_OK], temp=PJLINK_ERST_STATUS[S_OK], cover=PJLINK_ERST_STATUS[E_WARN], filt=PJLINK_ERST_STATUS[S_OK], other=PJLINK_ERST_STATUS[S_OK]) chk_test = {'Cover': E_WARN} log_warn_calls = [] log_debug_calls = [ call('({ip}) Processing command "ERST" with data "{data}"'.format( ip=self.pjlink.name, data=chk_data)), call( '({ip}) Calling function for ERST'.format(ip=self.pjlink.name)) ] self.pjlink.projector_errors = None # WHEN: process_erst with status set to WARN process_command(projector=self.pjlink, cmd='ERST', data=chk_data) # THEN: PJLink instance errors should match only cover warning assert 1 == len( self.pjlink.projector_errors ), 'There should only be 1 error listed in projector_errors' assert 'Cover' in self.pjlink.projector_errors, '"Cover" should be the only error listed' assert self.pjlink.projector_errors[ 'Cover'] == E_WARN, '"Cover" should have E_WARN listed as error' assert chk_test == self.pjlink.projector_errors, 'projector_errors should match test errors' mock_log.warning.assert_has_calls(log_warn_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_avmt_bad_data(self, mock_log, mock_UpdateIcons): """ Test avmt bad data fail """ # GIVEN: Test object log_warning_text = [ call('({ip}) Invalid av mute response: 36'.format( ip=self.pjlink.name)) ] log_debug_text = [ call('({ip}) Processing command "AVMT" with data "36"'.format( ip=self.pjlink.name)), call( '({ip}) Calling function for AVMT'.format(ip=self.pjlink.name)) ] self.pjlink.shutter = True self.pjlink.mute = True # WHEN: Called with an invalid setting process_command(projector=self.pjlink, cmd='AVMT', data='36') # THEN: Shutter should be closed and mute should be True assert self.pjlink.shutter, 'Shutter should changed' assert self.pjlink.mute, 'Audio should not have changed' assert not mock_UpdateIcons.emit.called, 'Update icons should NOT have been called' mock_log.warning.assert_has_calls(log_warning_text) mock_log.debug.assert_has_calls(log_debug_text)
def test_status_change(self, mock_changeStatus): """ Test process_command call with ERR2 (Parameter) status """ # GIVEN: Test object 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]))
def test_routing_pjink_errA(self, mock_log): """ Test rouing when PJLink ERRA received """ # GIVEN: Test setup err_code = E_AUTHENTICATION err_msg = STATUS_MSG[err_code] err_str = PJLINK_ERRORS[err_code] log_error_text = [ call('({ip}) CLSS: {err}'.format(ip=self.pjlink.name, err=err_msg)) ] log_debug_text = [ call('({ip}) Processing command "CLSS" with data "{err}"'.format( ip=self.pjlink.name, err=err_str)) ] # WHEN: routing called chk = process_command(projector=self.pjlink, cmd='CLSS', data=err_str) # THEN: Appropriate log entries should have been made and methods called/not called mock_log.error.assert_has_calls(log_error_text) mock_log.debug.assert_has_calls(log_debug_text) assert (chk == err_code), 'Should have returned {err}'.format( err=PJLINK_ERRORS[err_code])
def test_process_pjlink_authenticate_token_length(self, mock_log): """ Test initial connection prompt with authentication and bad token """ # GIVEN: Initial mocks and data bad_token = '1234abcde' # Length should be 8, this is 9 log_error_calls = [ call('({ip}) Authentication token invalid (size) - ' 'aborting'.format(ip=self.pjlink.name)) ] log_warning_calls = [] log_debug_calls = [ call('({ip}) Processing command "PJLINK" with data ' '"1 {data}"'.format(ip=self.pjlink.name, data=bad_token)), call('({ip}) Calling function for PJLINK'.format( ip=self.pjlink.name)), call( '({ip}) Processing PJLINK command'.format(ip=self.pjlink.name)) ] self.pjlink.pin = TEST_SALT # WHEN: process_pjlink called with bad token chk = process_command(projector=self.pjlink, cmd='PJLINK', data='1 {data}'.format(data=bad_token)) # THEN: proper processing should have occured 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 chk == E_NO_AUTHENTICATION, \ 'Should have returned {data}'.format(data=STATUS_CODE[E_NO_AUTHENTICATION])
def test_process_pjlink_authenticate_pin_not_set_error(self, mock_log): """ Test initial connection prompt with authentication and no pin set """ # GIVEN: Initial mocks and data log_error_calls = [ call('({ip}) Authenticate connection but no PIN - aborting'.format( ip=self.pjlink.name)) ] log_warning_calls = [] log_debug_calls = [ call('({ip}) Processing command "PJLINK" with data "1 {data}"'. format(ip=self.pjlink.name, data=TEST_SALT)), call('({ip}) Calling function for PJLINK'.format( ip=self.pjlink.name)), call( '({ip}) Processing PJLINK command'.format(ip=self.pjlink.name)) ] self.pjlink.pin = None # WHEN: process_pjlink called with no authentication required chk = process_command(projector=self.pjlink, cmd='PJLINK', data='1 {salt}'.format(salt=TEST_SALT)) # THEN: proper processing should have occured 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 chk == E_NO_AUTHENTICATION, \ 'Should have returned {data}'.format(data=STATUS_CODE[E_NO_AUTHENTICATION])
def test_process_pjlink_normal_with_token(self, mock_log): """ Test process_pjlinnk called with no authentication but pin is set """ # GIVEN: Initial mocks and data log_error_calls = [ call('({ip}) Normal connection with extra information - ' 'aborting'.format(ip=self.pjlink.name)) ] log_warning_calls = [] log_debug_calls = [ call('({ip}) Processing command "PJLINK" with data ' '"0 {data}"'.format(ip=self.pjlink.name, data=TEST_SALT)), call('({ip}) Calling function for PJLINK'.format( ip=self.pjlink.name)), call( '({ip}) Processing PJLINK command'.format(ip=self.pjlink.name)) ] self.pjlink.pin = TEST_PIN # WHEN: process_pjlink called with invalid authentication scheme chk = process_command(projector=self.pjlink, cmd='PJLINK', data='0 {data}'.format(data=TEST_SALT)) # THEN: Proper calls should be made 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 chk == E_NO_AUTHENTICATION, \ 'Should have returned {data}'.format(data=STATUS_CODE[E_NO_AUTHENTICATION])
def test_process_pjlink_normal(self, mock_log): """ Test processing PJLINK initial prompt """ # GIVEN: Mocks and data log_error_calls = [] log_warning_calls = [] log_debug_calls = [ call('({ip}) Processing command "PJLINK" with data "0"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for PJLINK'.format( ip=self.pjlink.name)), call('({ip}) Processing PJLINK command'.format( ip=self.pjlink.name)), call('({ip}) PJLINK: Returning {data}'.format( ip=self.pjlink.name, data=STATUS_CODE[S_CONNECT])) ] self.pjlink.pin = None # WHEN: process_pjlink called with no authentication required chk = process_command(projector=self.pjlink, cmd='PJLINK', data="0") # THEN: proper processing should have occured 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 chk == S_CONNECT, 'Should have returned {data}'.format( data=STATUS_CODE[S_CONNECT])
def test_process_pjlink_authenticate_token_missing(self, mock_log): """ Test initial connection prompt with authentication and missing token """ # GIVEN: Initial mocks and data log_error_calls = [ call('({ip}) Authenticated connection but not enough info - ' 'aborting'.format(ip=self.pjlink.name)) ] log_warning_calls = [] log_debug_calls = [ call('({ip}) Processing command "PJLINK" with data "1"'.format( ip=self.pjlink.name)), call('({ip}) Calling function for PJLINK'.format( ip=self.pjlink.name)), call( '({ip}) Processing PJLINK command'.format(ip=self.pjlink.name)) ] self.pjlink.pin = TEST_SALT # WHEN: process_pjlink called with bad token chk = process_command(projector=self.pjlink, cmd='PJLINK', data='1') # THEN: proper processing should have occured 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 chk == E_NO_AUTHENTICATION, \ 'Should have returned {data}'.format(data=STATUS_CODE[E_NO_AUTHENTICATION])
def test_projector_lamp_invalid_missing_data(self, mock_log): """ Test process lamp with 1 lamp reply hours only and no on/off status """ # GIVEN: Test object log_warning_calls = [call('({ip}) process_lamp(): Invalid data "45" - ' 'Missing data'.format(ip=self.pjlink.name))] log_debug_calls = [call('({ip}) Processing command "LAMP" with data "45"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for LAMP'.format(ip=self.pjlink.name))] self.pjlink.lamp = None # WHEN: Call process_command with 3 lamps process_command(projector=self.pjlink, cmd='LAMP', data='45') # THEN: Lamp should have been set with proper lamp status mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls) assert not self.pjlink.lamp, 'Projector lamp info should not have changed'
def test_projector_rlmp_save(self, mock_log): """ Test saving lamp type """ # GIVEN: Test object new_data = 'Lamp Type Test' log_warning_calls = [] log_debug_calls = [call('({ip}) Processing command "RLMP" with data ' '"{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) Calling function for RLMP'.format(ip=self.pjlink.name))] self.pjlink.model_lamp = None # WHEN: Filter model is received process_command(projector=self.pjlink, cmd='RLMP', data=new_data) # THEN: Filter model number should be saved mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls) assert self.pjlink.model_lamp == new_data, 'Lamp model should have been saved'
def test_projector_inpt_invalid(self, mock_log): """ Test input source returned not valid according to standard """ # GIVEN: Test object log_warning_calls = [call('({ip}) Input source not listed as a PJLink valid source - ' 'ignoring'.format(ip=self.pjlink.name))] log_debug_calls = [call('({ip}) Processing command "INPT" with data "91"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for INPT'.format(ip=self.pjlink.name))] self.pjlink.source = None self.pjlink.source_available = None # WHEN: Called with input source process_command(projector=self.pjlink, cmd='INPT', data='91') # THEN: Input selected should reflect current input assert not self.pjlink.source, 'Input source should not have changed' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_lamp_single(self, mock_log): """ Test status lamp on/off and hours """ # GIVEN: Test object log_warning_calls = [] log_debug_calls = [call('({ip}) Processing command "LAMP" with data "11111 1"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for LAMP'.format(ip=self.pjlink.name))] self.pjlink.lamp = None # WHEN: Call process_command with 3 lamps process_command(projector=self.pjlink, cmd='LAMP', data='11111 1') # THEN: Lamp should have been set with proper lamp status mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls) assert 1 == len(self.pjlink.lamp), 'Projector should have 1 lamp specified' assert self.pjlink.lamp[0]['On'], 'Lamp 1 power status should have been set to TRUE' assert 11111 == self.pjlink.lamp[0]['Hours'], 'Lamp 1 hours should have been set to 11111'
def test_projector_name(self, mock_log): """ Test saving NAME data from projector """ # GIVEN: Test object chk_data = "Some Name the End-User Set IN Projector" log_warning_calls = [] log_debug_calls = [call('({ip}) Processing command "NAME" with data ' '"Some Name the End-User Set IN Projector"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for NAME'.format(ip=self.pjlink.name)), call('({ip}) Setting projector PJLink name to ' '"Some Name the End-User Set IN Projector"'.format(ip=self.pjlink.name))] # WHEN: process_name called with test data process_command(projector=self.pjlink, cmd='NAME', data=chk_data) # THEN: name should be set and logged mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls) assert self.pjlink.pjlink_name == chk_data, 'Name test data should have been saved'
def test_projector_inpt_good(self, mock_log): """ Test input source status shows current input """ # GIVEN: Test object self.pjlink.source = '11' log_warning_calls = [] log_debug_calls = [call('({ip}) Processing command "INPT" with data "21"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for INPT'.format(ip=self.pjlink.name)), call('({ip}) Setting current source to "21"'.format(ip=self.pjlink.name))] chk_source_available = ['11', '12', '21', '22', '31', '32'] self.pjlink.source_available = chk_source_available # WHEN: Called with input source process_command(projector=self.pjlink, cmd='INPT', data='21') # THEN: Input selected should reflect current input assert '21' == self.pjlink.source, 'Input source should be set to "21"' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_inpt_not_in_list(self, mock_log): """ Test input source not listed in available sources """ # GIVEN: Test object log_warning_calls = [call('({ip}) Input source not listed in available sources - ' 'ignoring'.format(ip=self.pjlink.name))] log_debug_calls = [call('({ip}) Processing command "INPT" with data "25"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for INPT'.format(ip=self.pjlink.name))] self.pjlink.source = '11' chk_source_available = ['11', '12', '21', '22', '31', '32'] self.pjlink.source_available = chk_source_available # WHEN: Called with input source process_command(projector=self.pjlink, cmd='INPT', data='25') # THEN: Input selected should reflect current input assert '11' == self.pjlink.source, 'Input source should not have changed' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_powr_invalid(self, mock_log, mock_UpdateIcons, mock_change_status, mock_send_command): """ Test process_powr invalid call """ # GIVEN: Test object self.pjlink.power = S_STANDBY log_warning_calls = [call('({ip}) Unknown power response: "99"'.format(ip=self.pjlink.name))] log_debug_calls = [call('({ip}) Processing command "POWR" with data "99"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for POWR'.format(ip=self.pjlink.name)), call('({ip}) Processing POWR command'.format(ip=self.pjlink.name))] # WHEN: process_command called with test data process_command(projector=self.pjlink, cmd='POWR', data='99') # THEN: Projector power should not have changed mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls) assert S_STANDBY == self.pjlink.power, 'Power should not have changed' mock_UpdateIcons.emit.assert_not_called() mock_change_status.assert_not_called() mock_send_command.assert_not_called()
def test_projector_powr_on(self, mock_log, mock_UpdateIcons, mock_change_status, mock_send_command): """ Test status power to ON """ # GIVEN: Test object log_warning_calls = [] log_debug_calls = [call('({ip}) Processing command "POWR" with data "1"'.format(ip=self.pjlink.name)), call('({ip}) Calling function for POWR'.format(ip=self.pjlink.name)), call('({ip}) Processing POWR command'.format(ip=self.pjlink.name))] self.pjlink.power = S_STANDBY # WHEN: process_name called with test data process_command(projector=self.pjlink, cmd='POWR', data=PJLINK_POWR_STATUS[S_ON]) # THEN: Power should be set to ON mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls) assert S_ON == self.pjlink.power, 'Power should have been set to ON' assert mock_UpdateIcons.emit.called, 'projectorUpdateIcons should have been called' mock_send_command.assert_called_once_with('INST') mock_change_status.assert_called_once_with(S_ON)
def test_projector_erst_all_ok(self, mock_log): """ Test to verify pjlink.projector_errors is set to None when no errors """ # GIVEN: Test object chk_data = '0' * PJLINK_ERST_DATA['DATA_LENGTH'] log_warning_calls = [] log_debug_calls = [ call('({ip}) Processing command "ERST" with data "{chk}"'.format( ip=self.pjlink.name, chk=chk_data)), call( '({ip}) Calling function for ERST'.format(ip=self.pjlink.name)) ] # WHEN: process_erst with no errors process_command(projector=self.pjlink, cmd='ERST', data=chk_data) # THEN: PJLink instance errors should be None assert self.pjlink.projector_errors is None, 'projector_errors should have been set to None' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_snum_set(self, mock_log): """ Test saving serial number from projector """ # GIVEN: Test object new_data = 'Test Serial Number' self.pjlink.serial_no = None log_warning_calls = [] log_debug_calls = [call('({ip}) Processing command "SNUM" with data "{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) Calling function for SNUM'.format(ip=self.pjlink.name)), call('({ip}) Setting projector serial number to ' '"{data}"'.format(ip=self.pjlink.name, data=new_data))] # WHEN: No serial number is set and we receive serial number command process_command(projector=self.pjlink, cmd='SNUM', data=new_data) # THEN: Serial number should be set assert self.pjlink.serial_no == new_data, 'Projector serial number should have been set' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)
def test_projector_sver_invalid(self, mock_log): """ Test invalid software version information - too long """ # GIVEN: Test object new_data = 'This is a test software version line that is too long based on PJLink version 2 specs' log_warning_calls = [call('Invalid software version - too long')] log_debug_calls = [call('({ip}) Processing command "SVER" with data "{data}"'.format(ip=self.pjlink.name, data=new_data)), call('({ip}) Calling function for SVER'.format(ip=self.pjlink.name))] self.pjlink.sw_version = None self.pjlink.sw_version_received = None # WHEN: process_sver called with invalid data process_command(projector=self.pjlink, cmd='SVER', data=new_data) # THEN: Version information should not change assert not self.pjlink.sw_version, 'Software version should not have changed' assert not self.pjlink.sw_version_received, 'Received software version should not have changed' mock_log.warning.assert_has_calls(log_warning_calls) mock_log.debug.assert_has_calls(log_debug_calls)