def setup(self):
self.serno = 31002
self.bus = MagicMock()
self.mod = Module(self.bus, self.serno)
self.protocols = {
'IMPBUS': 0,
'SDI12': 1}
self.event_modes = {
"NormalMeasure": 0x00,
"TRDScan": 0x01,
"AnalogOut": 0x02,
"ACIC_TC": 0x03,
"SelfTest": 0x04,
"MatTempSensor": 0x05}
self.measure_modes = {
"ModeA": 0x00,
"ModeB": 0x01,
"ModeC": 0x02}
self.average_modes = {
"CA": 0x00,
"CK": 0x01,
"CS": 0x02,
"CF": 0x03}
def setup(self):
self.serno = 31002
self.bus = MagicMock()
self.mod = Module(self.bus, self.serno)
self.protocols = {'IMPBUS': 0, 'SDI12': 1}
self.event_modes = {
"NormalMeasure": 0x00,
"TRDScan": 0x01,
"AnalogOut": 0x02,
"ACIC_TC": 0x03,
"SelfTest": 0x04,
"MatTempSensor": 0x05
}
self.measure_modes = {"ModeA": 0x00, "ModeB": 0x01, "ModeC": 0x02}
self.average_modes = {"CA": 0x00, "CK": 0x01, "CS": 0x02, "CF": 0x03}
class TestModule(object):
def setup(self):
self.serno = 31002
self.bus = MagicMock()
self.mod = Module(self.bus, self.serno)
self.protocols = {
'IMPBUS': 0,
'SDI12': 1}
self.event_modes = {
"NormalMeasure": 0x00,
"TRDScan": 0x01,
"AnalogOut": 0x02,
"ACIC_TC": 0x03,
"SelfTest": 0x04,
"MatTempSensor": 0x05}
self.measure_modes = {
"ModeA": 0x00,
"ModeB": 0x01,
"ModeC": 0x02}
self.average_modes = {
"CA": 0x00,
"CK": 0x01,
"CS": 0x02,
"CF": 0x03}
#
# __init__() tests
#
def test___init___protocols(self):
assert self.mod.protocols == self.protocols
def test___init___event_modes(self):
assert self.mod.event_modes == self.event_modes
def test___init___measure_modes(self):
assert self.mod.measure_modes == self.measure_modes
def test___init___average_modes(self):
assert self.mod.average_modes == self.average_modes
#
# unlock() tests
#
def test_unlock(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'SupportPW'
value = 66 + 0x8000
self.bus.set.return_value = True
assert self.mod.unlock()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# get_event_mode() tests
#
@pytest.mark.parametrize("mode", [
"NormalMeasure",
"TRDScan",
"AnalogOut",
"ACIC_TC",
"SelfTest",
"MatTempSensor"])
def test_get_event_mode(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
self.bus.get.return_value = (self.mod.event_modes[mode] + 0x80,)
assert self.mod.get_event_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_event_mode_UNKNOWN(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = 0x06
self.bus.get.return_value = (value,)
with pytest.raises(ModuleError) as e:
self.mod.get_event_mode()
assert e.value.message == "Unknown event mode: %s" % value
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# set_event_mode() tests
#
def test_set_event_mode_InvalidMode(self):
mode = 'UNKNOWN'
self.mod.unlock = MagicMock()
with pytest.raises(ModuleError) as e:
self.mod.set_event_mode(mode)
assert e.value.message == "%s: Invalid event mode!" % mode
self.mod.unlock.assert_not_called()
def test_set_event_mode_SetEventModeFailed(self):
mode = 'NormalMeasure'
self.mod.unlock = MagicMock()
self.bus.set.return_value = False
with pytest.raises(ModuleError) as e:
self.mod.set_event_mode(mode)
assert e.value.message == "Failed to set event mode!"
self.mod.unlock.assert_called_once_with()
@pytest.mark.parametrize("mode", [
"NormalMeasure",
"TRDScan",
"AnalogOut",
"ACIC_TC",
"SelfTest",
"MatTempSensor"])
def test_set_event_mode_Failed(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = self.event_modes[mode]
self.mod.unlock = MagicMock()
self.bus.get.return_value = [value]
expected = [call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param)]
with pytest.raises(ModuleError) as e:
self.mod.set_event_mode(mode)
assert e.value.message == "Failed to set event mode!"
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
assert self.bus.get.call_args_list == expected
@pytest.mark.parametrize("mode", [
"NormalMeasure",
"TRDScan",
"AnalogOut",
"ACIC_TC",
"SelfTest",
"MatTempSensor"])
def test_set_event_mode_FourAttempts(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = self.event_modes[mode]
self.mod.unlock = MagicMock()
self.bus.get.side_effect = [[value], [value], [value],
[value], [value + 0x80]]
expected = [call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param)]
assert self.mod.set_event_mode(mode)
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
assert self.bus.get.call_args_list == expected
@pytest.mark.parametrize("mode", [
"NormalMeasure",
"TRDScan",
"AnalogOut",
"ACIC_TC",
"SelfTest",
"MatTempSensor"])
def test_set_event_mode(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = self.event_modes[mode]
self.mod.unlock = MagicMock()
self.bus.get.return_value = [value + 0x80]
assert self.mod.set_event_mode(mode)
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# get_measure_mode() tests
#
@pytest.mark.parametrize("mode", [
"ModeA",
"ModeB",
"ModeC"])
def test_get_measure_mode(self, mode):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MeasMode'
self.bus.get.return_value = (self.mod.measure_modes[mode],)
assert self.mod.get_measure_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_measure_mode_UnknownMode(self):
value = 0x03
self.bus.get.return_value = (value,)
with pytest.raises(ModuleError) as e:
self.mod.get_measure_mode()
assert e.value.message == "Unknown measure mode: %s!" % value
#
# set_measure_mode() tests
#
def test_set_measure_mode_InvalidMeasureMode(self):
mode = "ModeD"
with pytest.raises(ModuleError) as e:
self.mod.set_measure_mode(mode)
assert e.value.message == "%s: Invalid measure mode!" % mode
def test_set_measure_mode_WrongEventModeMode(self):
mode = 'ModeA'
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError) as e:
self.mod.set_measure_mode(mode)
assert e.value.message == "Wrong event mode, need 'NormalMeasure'!"
self.mod.get_event_mode.assert_called_once_with()
def test_set_measure_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MeasMode'
mode = 'ModeA'
value = self.measure_modes[mode]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
assert self.mod.set_measure_mode(mode)
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# get_default_measure_mode() tests
#
@pytest.mark.parametrize("mode", [
"ModeA",
"ModeB",
"ModeC"])
def test_get_default_measure_mode(self, mode):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'DefaultMeasMode'
self.bus.get.return_value = (self.mod.measure_modes[mode],)
assert self.mod.get_default_measure_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_default_measure_mode_UnknownMode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'DefaultMeasMode'
value = 0x03
self.bus.get.return_value = (value,)
with pytest.raises(ModuleError) as e:
self.mod.get_default_measure_mode()
assert e.value.message == "Unknown default measure mode: %s!" % value
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# set_default_measure_mode() tests
#
def test_set_default_measure_mode_InvalidDefaultMeasureMode(self):
mode = "ModeD"
with pytest.raises(ModuleError) as e:
self.mod.set_default_measure_mode(mode)
assert e.value.message == "%s: Invalid default measure mode!" % mode
def test_set_default_measure_mode_WrongEventModeMode(self):
mode = 'ModeA'
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError) as e:
self.mod.set_default_measure_mode(mode)
assert e.value.message == "Wrong event mode, need 'NormalMeasure'!"
self.mod.get_event_mode.assert_called_once_with()
def test_set_default_measure_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'DefaultMeasMode'
mode = 'ModeA'
value = self.measure_modes[mode]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
assert self.mod.set_default_measure_mode(mode)
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# get_average_mode() tests
#
@pytest.mark.parametrize("mode", ["CA", "CK", "CS", "CF"])
def test_get_average_mode(self, mode):
table = 'APPLICATION_PARAMETER_TABLE'
param = 'AverageMode'
self.bus.get.return_value = (self.mod.average_modes[mode],)
assert self.mod.get_average_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_average_mode_UnknownMode(self):
table = 'APPLICATION_PARAMETER_TABLE'
param = 'AverageMode'
value = 0x04
self.bus.get.return_value = (value,)
with pytest.raises(ModuleError) as e:
self.mod.get_average_mode()
assert e.value.message == "Unknown average mode: %s!" % value
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# set_average_mode() tests
#
def test_set_average_mode_InvalidAverageMode(self):
mode = "CX"
with pytest.raises(ModuleError) as e:
self.mod.set_average_mode(mode)
assert e.value.message == "%s: Invalid average mode!" % mode
def test_set_average_mode(self):
table = 'APPLICATION_PARAMETER_TABLE'
param = 'AverageMode'
mode = 'CA'
value = self.average_modes[mode]
assert self.mod.set_average_mode(mode)
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# get_table() tests
#
def test_get_table(self):
with pytest.raises(NotImplementedError):
self.mod.get_table('TABLE')
#
# set_table() tests
#
def test_set_table(self):
with pytest.raises(NotImplementedError):
self.mod.set_table('TABLE', None)
#
# get_serno() tests
#
def test_get_serno(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'SerialNum'
self.bus.get.return_value = (self.serno,)
assert self.mod.get_serno() == self.serno
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# set_serno() tests
#
def test_set_serno(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'SerialNum'
value = self.serno + 1
self.bus.set.return_value = True
self.mod.unlock = MagicMock()
assert self.mod.set_serno(value)
assert self.mod._serno == value
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# read_eeprom() tests
#
def test_read_eeprom(self):
with pytest.raises(NotImplementedError):
self.mod.read_eeprom()
#
# write_eeprom() tests
#
def test_write_eeprom(self):
head = os.urandom(250)
midl = os.urandom(250)
tail = os.urandom(128)
gen = (x for x in [head, midl, tail])
eeprom = MagicMock()
eeprom.__iter__.return_value = gen
self.bus.set_eeprom_page.return_value = True
self.mod.unlock = MagicMock()
assert self.mod.write_eeprom(eeprom)
self.mod.unlock.assert_called_once_with()
expected = [call(self.serno, x, y) for x, y in
enumerate([head, midl, tail])]
assert self.bus.set_eeprom_page.call_args_list == expected
def test_write_eeprom_EEPROMWritingFailed(self):
head = os.urandom(250)
midl = os.urandom(250)
tail = os.urandom(128)
gen = (x for x in [head, midl, tail])
eeprom = MagicMock()
eeprom.__iter__.return_value = gen
self.bus.set_eeprom_page.side_effect = [False]
with pytest.raises(ModuleError) as e:
self.mod.write_eeprom(eeprom)
assert e.value.message == "Writing EEPROM failed!"
#
# get_hw_version() tests
#
def test_get_hw_version(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'HWVersion'
self.bus.get.return_value = (1.12176287368173,)
assert self.mod.get_hw_version() == '1.12'
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# get_fw_version() tests
#
def test_get_fw_version(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'FWVersion'
self.bus.get.return_value = (1.11176287368173,)
assert self.mod.get_fw_version() == '1.111763'
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# start_measure() tests
#
def test_start_measure_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError) as e:
self.mod.start_measure()
assert e.value.message == "Wrong event mode, need 'NormalMeasure'!"
self.mod.get_event_mode.assert_called_once_with()
def test_start_measure_WrongMeasureMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.mod.get_measure_mode = MagicMock()
self.mod.get_measure_mode.return_value = 'NotModeA'
with pytest.raises(ModuleError) as e:
self.mod.start_measure()
assert e.value.message == "Wrong measure mode, need 'ModeA'!"
self.mod.get_event_mode.assert_called_once_with()
self.mod.get_measure_mode.assert_called_once_with()
def test_start_measure_AlreadyRunning(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.mod.get_measure_mode = MagicMock()
self.mod.get_measure_mode.return_value = 'ModeA'
self.mod.measure_running = MagicMock()
self.mod.measure_running.return_value = True
with pytest.raises(ModuleError) as e:
self.mod.start_measure()
assert e.value.message == "Measurement cycle already in progress!"
self.mod.get_event_mode.assert_called_once_with()
self.mod.get_measure_mode.assert_called_once_with()
self.mod.measure_running.assert_called_once_with()
def test_start_measure(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'StartMeasure'
value = 1
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.mod.get_measure_mode = MagicMock()
self.mod.get_measure_mode.return_value = 'ModeA'
self.mod.measure_running = MagicMock()
self.mod.measure_running.return_value = False
self.bus.set.return_value = True
assert self.mod.start_measure()
self.mod.get_event_mode.assert_called_once_with()
self.mod.get_measure_mode.assert_called_once_with()
self.mod.measure_running.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# measure_running() tests
#
def test_measure_running_YES(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'StartMeasure'
self.bus.get.return_value = (1,)
assert self.mod.measure_running()
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_measure_running_Nop(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'StartMeasure'
self.bus.get.return_value = (0,)
assert not self.mod.measure_running()
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# get_measure() tests
#
def test_get_measurement(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'Moist'
moist = 17.77
self.bus.get.return_value = (moist,)
assert self.mod.get_measurement(quantity=param) == moist
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# get_moisture() tests
#
def test_get_moisture(self):
moist = 12.35
self.mod.start_measure = MagicMock()
self.mod.start_measure.return_value = True
self.mod.measure_running = MagicMock()
self.mod.measure_running.side_effect = (True, True, False)
self.mod.get_measurement = MagicMock()
self.mod.get_measurement.return_value = moist
expected = [call(), call(), call()]
assert self.mod.get_moisture() == moist
self.mod.start_measure.assert_called_once_with()
assert self.mod.measure_running.call_args_list == expected
self.mod.get_measurement.assert_called_once_with(quantity='Moist')
################################
# END of the Public API Testsv #
################################
#
# _get_analog_output_mode() tests
#
def test__get_analog_output_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'AnalogOutputMode'
mode = 0
self.bus.get.return_value = (mode,)
assert self.mod._get_analog_output_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _set_analog_output_mode() tests
#
def test__set_analog_output_mode_WrongMode(self):
with pytest.raises(ModuleError) as e:
self.mod._set_analog_output_mode(3)
assert e.value.message == "Wrong AnalogOutputMode!"
def test__set_analog_output_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'AnalogOutputMode'
value = 0
self.bus.set.return_value = True
assert self.mod._set_analog_output_mode(value)
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# _get_moist_max_value() tests
#
def test__get_moist_max_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MoistMaxValue'
self.bus.get.return_value = (50,)
assert self.mod._get_moist_max_value() == 50
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _get_moist_min_value() tests
#
def test__get_moist_min_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MoistMinValue'
self.bus.get.return_value = (0,)
assert self.mod._get_moist_min_value() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _get_temp_max_value() tests
#
def test__get_temp_max_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'TempMaxValue'
self.bus.get.return_value = (60,)
assert self.mod._get_temp_max_value() == 60
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _get_temp_min_value() tests
#
def test__get_temp_min_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'TempMinValue'
self.bus.get.return_value = (0,)
assert self.mod._get_temp_min_value() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _set_analog_moist() tests
#
def test__set_analog_moist_ValueToLow(self):
with pytest.raises(ModuleError) as e:
self.mod._set_analog_moist(-1)
assert e.value.message == "Value out of range!"
def test__set_analog_moist_ValueToHigh(self):
with pytest.raises(ModuleError) as e:
self.mod._set_analog_moist(1001)
assert e.value.message == "Value out of range!"
def test__set_analog_moist_WrongEventMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotAnalogOut"
with pytest.raises(ModuleError) as e:
self.mod._set_analog_moist(mvolt)
assert e.value.message == "Wrong event mode, need 'AnalogOut'!"
self.mod.get_event_mode.assert_called_once_with()
def test__set_analog_moist_WrongAnalogOutputMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = -1
with pytest.raises(ModuleError) as e:
self.mod._set_analog_moist(mvolt)
assert e.value.message == "Wrong AnalogOutputMode, need mode 0 here!"
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
def test__set_analog_moist(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'Moist'
mvolt = 500
min_value = 0
max_value = 10
value = (max_value - min_value) / 1000.0 * mvolt + min_value
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = 0
self.mod._get_moist_min_value = MagicMock()
self.mod._get_moist_min_value.return_value = 0
self.mod._get_moist_max_value = MagicMock()
self.mod._get_moist_max_value.return_value = 10
assert self.mod._set_analog_moist(mvolt)
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
self.mod._get_moist_min_value.assert_called_once_with()
self.mod._get_moist_max_value.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# _get_analog_moist() tests
#
def test__get_analog_moist(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'Moist'
self.bus.get.return_value = (0,)
assert self.mod._get_analog_moist() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _set_analog_temp() tests
#
def test__set_analog_temp_ValueToLow(self):
with pytest.raises(ModuleError) as e:
self.mod._set_analog_temp(-1)
assert e.value.message == "Value out of range!"
def test__set_analog_temp_ValueToHigh(self):
with pytest.raises(ModuleError) as e:
self.mod._set_analog_temp(1001)
assert e.value.message == "Value out of range!"
def test__set_analog_temp_WrongEventMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotAnalogOut"
with pytest.raises(ModuleError) as e:
self.mod._set_analog_temp(mvolt)
assert e.value.message == "Wrong event mode, need 'AnalogOut'!"
self.mod.get_event_mode.assert_called_once_with()
def test__set_analog_temp_WrongAnalogOutputMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = -1
with pytest.raises(ModuleError) as e:
self.mod._set_analog_temp(mvolt)
assert e.value.message == "Wrong AnalogOutputMode, need mode 0 here"
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
def test__set_analog_temp(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'CompTemp'
min_value = -20
max_value = 70
mvolt = 550
value = (max_value - min_value) / 1000.0 * mvolt + min_value
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = 0
self.mod._get_temp_min_value = MagicMock()
self.mod._get_temp_min_value.return_value = min_value
self.mod._get_temp_max_value = MagicMock()
self.mod._get_temp_max_value.return_value = max_value
assert self.mod._set_analog_temp(mvolt)
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
self.mod._get_temp_min_value.assert_called_once_with()
self.mod._get_temp_max_value.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# _get_analog_temp() tests
#
def test__get_analog_temp(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'CompTemp'
self.bus.get.return_value = (0,)
assert self.mod._get_analog_temp() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# _turn_asic_on() tests
#
def test__turn_asic_on_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotSelfTest"
with pytest.raises(ModuleError) as e:
self.mod._turn_asic_on()
assert e.value.message == "Wrong event mode, need 'SelfTest'!"
def test__turn_asic_on(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'SelfTest'
value = [1, 1, 63, 0]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "SelfTest"
assert self.mod._turn_asic_on()
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, value)
#
# _turn_asic_off() tests
#
def test__turn_asic_off_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotSelfTest"
with pytest.raises(ModuleError) as e:
self.mod._turn_asic_off()
assert e.value.message == "Wrong event mode, need 'SelfTest'!"
def test__turn_asic_off(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'SelfTest'
value = [1, 0, 255, 0]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "SelfTest"
assert self.mod._turn_asic_off()
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, value)
#
# _get_analog_moist() tests
#
def test__get_transit_time_tdr_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError) as e:
self.mod._get_transit_time_tdr()
assert e.value.message == "Wrong event mode, need 'NormalMeasure'!"
def test__get_transit_time_tdr(self):
transit_time = 123
tdr_value = 321
set_calls = [
call(self.serno,
'DEVICE_CONFIGURATION_PARAMETER_TABLE', 'MeasMode', [0]),
call(self.serno,
'ACTION_PARAMETER_TABLE', 'StartMeasure', [1]),
call(self.serno,
'DEVICE_CONFIGURATION_PARAMETER_TABLE', 'MeasMode', [2])
]
get_calls = [
call(self.serno, 'ACTION_PARAMETER_TABLE', 'StartMeasure'),
call(self.serno, 'ACTION_PARAMETER_TABLE', 'StartMeasure'),
call(self.serno, 'MEASURE_PARAMETER_TABLE', 'TransitTime'),
call(self.serno, 'MEASURE_PARAMETER_TABLE', 'TDRValue'),
]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.bus.set.return_value = True
self.bus.get.side_effect = [(1,), (0,), (transit_time,), (tdr_value,)]
assert self.mod._get_transit_time_tdr() == (transit_time, tdr_value)
self.mod.get_event_mode.assert_called_once_with()
assert self.bus.set.call_args_list == set_calls
assert self.bus.get.call_args_list == get_calls
#
# _set_sdi12_address() tests
#
def test__set_sdi12_address_WrongAddress(self):
with pytest.raises(ModuleError) as e:
self.mod._set_sdi12_address(2000)
assert e.value.message == 'SDI12 address out of range!'
def test__set_sdi12_address(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'ModuleInfo1'
value = 0
self.mod._set_sdi12_address(value)
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
#
# _set_protocol() tests
#
def test__set_protocol_WrongProtocol(self):
value = 'chocolate_jesus'
with pytest.raises(ModuleError) as e:
self.mod._set_protocol(value)
assert e.value.message == "Wrong protocol: %s" % value
def test__set_protocol(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'Protocol'
protocols = {'IMPBUS': 0, 'SDI12': 1}
assert protocols == self.mod.protocols
expected = []
for protocol in protocols:
value = protocols[protocol]
self.mod._set_protocol(protocol)
expected.append(call(self.serno, table, param, [value]))
assert self.bus.set.call_args_list == expected
class TestModule:
def setup(self):
self.serno = 31002
self.bus = MagicMock()
self.mod = Module(self.bus, self.serno)
self.protocols = {'IMPBUS': 0, 'SDI12': 1}
self.event_modes = {
"NormalMeasure": 0x00,
"TRDScan": 0x01,
"AnalogOut": 0x02,
"ACIC_TC": 0x03,
"SelfTest": 0x04,
"MatTempSensor": 0x05
}
self.measure_modes = {"ModeA": 0x00, "ModeB": 0x01, "ModeC": 0x02}
self.average_modes = {"CA": 0x00, "CK": 0x01, "CS": 0x02, "CF": 0x03}
def test___init___protocols(self):
assert self.mod.protocols == self.protocols
def test___init___event_modes(self):
assert self.mod.event_modes == self.event_modes
def test___init___measure_modes(self):
assert self.mod.measure_modes == self.measure_modes
def test___init___average_modes(self):
assert self.mod.average_modes == self.average_modes
def test_unlock(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'SupportPW'
value = 66 + 0x8000
self.bus.set.return_value = True
assert self.mod.unlock()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
@pytest.mark.parametrize("mode", [
"NormalMeasure", "TRDScan", "AnalogOut", "ACIC_TC", "SelfTest",
"MatTempSensor"
])
def test_get_event_mode(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
self.bus.get.return_value = (self.mod.event_modes[mode] + 0x80, )
assert self.mod.get_event_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_event_mode_UNKNOWN(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = 0x06
self.bus.get.return_value = (value, )
with pytest.raises(ModuleError,
message="Unknown event mode: {}".format(value)):
self.mod.get_event_mode()
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_set_event_mode_InvalidMode(self):
mode = 'UNKNOWN'
self.mod.unlock = MagicMock()
with pytest.raises(ModuleError,
message="{}: Invalid event mode!".format(mode)):
self.mod.set_event_mode(mode)
self.mod.unlock.assert_not_called()
def test_set_event_mode_SetEventModeFailed(self):
mode = 'NormalMeasure'
self.mod.unlock = MagicMock()
self.bus.set.return_value = False
with pytest.raises(ModuleError, message="Failed to set event mode!"):
self.mod.set_event_mode(mode)
self.mod.unlock.assert_called_once_with()
@pytest.mark.parametrize("mode", [
"NormalMeasure", "TRDScan", "AnalogOut", "ACIC_TC", "SelfTest",
"MatTempSensor"
])
def test_set_event_mode_Failed(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = self.event_modes[mode]
self.mod.unlock = MagicMock()
self.bus.get.return_value = [value]
expected = [
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param)
]
with pytest.raises(ModuleError, message="Failed to set event mode!"):
self.mod.set_event_mode(mode)
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
assert self.bus.get.call_args_list == expected
@pytest.mark.parametrize("mode", [
"NormalMeasure", "TRDScan", "AnalogOut", "ACIC_TC", "SelfTest",
"MatTempSensor"
])
def test_set_event_mode_FourAttempts(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = self.event_modes[mode]
self.mod.unlock = MagicMock()
self.bus.get.side_effect = [[value], [value], [value], [value],
[value + 0x80]]
expected = [
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param),
call(self.serno, table, param)
]
assert self.mod.set_event_mode(mode)
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
assert self.bus.get.call_args_list == expected
@pytest.mark.parametrize("mode", [
"NormalMeasure", "TRDScan", "AnalogOut", "ACIC_TC", "SelfTest",
"MatTempSensor"
])
def test_set_event_mode(self, mode):
table = 'ACTION_PARAMETER_TABLE'
param = 'Event'
value = self.event_modes[mode]
self.mod.unlock = MagicMock()
self.bus.get.return_value = [value + 0x80]
assert self.mod.set_event_mode(mode)
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
self.bus.get.assert_called_once_with(self.serno, table, param)
#
# get_measure_mode() tests
#
@pytest.mark.parametrize("mode", ["ModeA", "ModeB", "ModeC"])
def test_get_measure_mode(self, mode):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MeasMode'
self.bus.get.return_value = (self.mod.measure_modes[mode], )
assert self.mod.get_measure_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_measure_mode_UnknownMode(self):
value = 0x03
self.bus.get.return_value = (value, )
with pytest.raises(ModuleError,
message="Unknown measure mode: %s!".format(value)):
self.mod.get_measure_mode()
def test_set_measure_mode_InvalidMeasureMode(self):
mode = "ModeD"
with pytest.raises(ModuleError,
message="{}: Invalid measure mode!".format(mode)):
self.mod.set_measure_mode(mode)
def test_set_measure_mode_WrongEventModeMode(self):
mode = 'ModeA'
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'NormalMeasure'!"):
self.mod.set_measure_mode(mode)
self.mod.get_event_mode.assert_called_once_with()
def test_set_measure_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MeasMode'
mode = 'ModeA'
value = self.measure_modes[mode]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
assert self.mod.set_measure_mode(mode)
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
@pytest.mark.parametrize("mode", ["ModeA", "ModeB", "ModeC"])
def test_get_default_measure_mode(self, mode):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'DefaultMeasMode'
self.bus.get.return_value = (self.mod.measure_modes[mode], )
assert self.mod.get_default_measure_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_default_measure_mode_UnknownMode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'DefaultMeasMode'
value = 0x03
self.bus.get.return_value = (value, )
with pytest.raises(
ModuleError,
message="Unknown default measure mode: {}!".format(value)):
self.mod.get_default_measure_mode()
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_set_default_measure_mode_InvalidDefaultMeasureMode(self):
mode = "ModeD"
with pytest.raises(
ModuleError,
message="{}: Invalid default measure mode!".format(mode)):
self.mod.set_default_measure_mode(mode)
def test_set_default_measure_mode_WrongEventModeMode(self):
mode = 'ModeA'
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'NormalMeasure'!"):
self.mod.set_default_measure_mode(mode)
self.mod.get_event_mode.assert_called_once_with()
def test_set_default_measure_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'DefaultMeasMode'
mode = 'ModeA'
value = self.measure_modes[mode]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
assert self.mod.set_default_measure_mode(mode)
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
@pytest.mark.parametrize("mode", ["CA", "CK", "CS", "CF"])
def test_get_average_mode(self, mode):
table = 'APPLICATION_PARAMETER_TABLE'
param = 'AverageMode'
self.bus.get.return_value = (self.mod.average_modes[mode], )
assert self.mod.get_average_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_average_mode_UnknownMode(self):
table = 'APPLICATION_PARAMETER_TABLE'
param = 'AverageMode'
value = 0x04
self.bus.get.return_value = (value, )
with pytest.raises(ModuleError,
message="Unknown average mode: {}!".format(value)):
self.mod.get_average_mode()
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_set_average_mode_InvalidAverageMode(self):
mode = "CX"
with pytest.raises(ModuleError,
message="{}: Invalid average mode!".format(mode)):
self.mod.set_average_mode(mode)
def test_set_average_mode(self):
table = 'APPLICATION_PARAMETER_TABLE'
param = 'AverageMode'
mode = 'CA'
value = self.average_modes[mode]
assert self.mod.set_average_mode(mode)
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test_get_table(self):
with pytest.raises(NotImplementedError):
self.mod.get_table('TABLE')
def test_set_table(self):
with pytest.raises(NotImplementedError):
self.mod.set_table('TABLE', None)
def test_get_serno(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'SerialNum'
self.bus.get.return_value = (self.serno, )
assert self.mod.get_serno() == self.serno
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_set_serno(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'SerialNum'
value = self.serno + 1
self.bus.set.return_value = True
self.mod.unlock = MagicMock()
assert self.mod.set_serno(value)
assert self.mod._serno == value
self.mod.unlock.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test_read_eeprom(self):
with pytest.raises(NotImplementedError):
self.mod.read_eeprom()
def test_write_eeprom(self):
head = os.urandom(250)
midl = os.urandom(250)
tail = os.urandom(128)
gen = (x for x in [head, midl, tail])
eeprom = MagicMock()
eeprom.__iter__.return_value = gen
self.bus.set_eeprom_page.return_value = True
self.mod.unlock = MagicMock()
assert self.mod.write_eeprom(eeprom)
self.mod.unlock.assert_called_once_with()
expected = [
call(self.serno, x, y) for x, y in enumerate([head, midl, tail])
]
assert self.bus.set_eeprom_page.call_args_list == expected
def test_write_eeprom_EEPROMWritingFailed(self):
head = os.urandom(250)
midl = os.urandom(250)
tail = os.urandom(128)
gen = (x for x in [head, midl, tail])
eeprom = MagicMock()
eeprom.__iter__.return_value = gen
self.bus.set_eeprom_page.side_effect = [False]
with pytest.raises(ModuleError, message="Writing EEPROM failed!"):
self.mod.write_eeprom(eeprom)
def test_get_hw_version(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'HWVersion'
self.bus.get.return_value = (1.12176287368173, )
assert self.mod.get_hw_version() == '1.12'
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_fw_version(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'FWVersion'
self.bus.get.return_value = (1.11176287368173, )
assert self.mod.get_fw_version() == '1.111763'
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_start_measure_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'NormalMeasure'!"):
self.mod.start_measure()
self.mod.get_event_mode.assert_called_once_with()
def test_start_measure_WrongMeasureMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.mod.get_measure_mode = MagicMock()
self.mod.get_measure_mode.return_value = 'NotModeA'
with pytest.raises(ModuleError,
message="Wrong measure mode, need 'ModeA'!"):
self.mod.start_measure()
self.mod.get_event_mode.assert_called_once_with()
self.mod.get_measure_mode.assert_called_once_with()
def test_start_measure_AlreadyRunning(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.mod.get_measure_mode = MagicMock()
self.mod.get_measure_mode.return_value = 'ModeA'
self.mod.measure_running = MagicMock()
self.mod.measure_running.return_value = True
with pytest.raises(ModuleError,
message="Measurement cycle already in progress!"):
self.mod.start_measure()
self.mod.get_event_mode.assert_called_once_with()
self.mod.get_measure_mode.assert_called_once_with()
self.mod.measure_running.assert_called_once_with()
def test_start_measure(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'StartMeasure'
value = 1
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.mod.get_measure_mode = MagicMock()
self.mod.get_measure_mode.return_value = 'ModeA'
self.mod.measure_running = MagicMock()
self.mod.measure_running.return_value = False
self.bus.set.return_value = True
assert self.mod.start_measure()
self.mod.get_event_mode.assert_called_once_with()
self.mod.get_measure_mode.assert_called_once_with()
self.mod.measure_running.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test_measure_running_YES(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'StartMeasure'
self.bus.get.return_value = (1, )
assert self.mod.measure_running()
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_measure_running_Nop(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'StartMeasure'
self.bus.get.return_value = (0, )
assert not self.mod.measure_running()
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_measurement(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'Moist'
moist = 17.77
self.bus.get.return_value = (moist, )
assert self.mod.get_measurement(quantity=param) == moist
self.bus.get.assert_called_once_with(self.serno, table, param)
def test_get_moisture(self):
moist = 12.35
self.mod.start_measure = MagicMock()
self.mod.start_measure.return_value = True
self.mod.measure_running = MagicMock()
self.mod.measure_running.side_effect = (True, True, False)
self.mod.get_measurement = MagicMock()
self.mod.get_measurement.return_value = moist
expected = [call(), call(), call()]
assert self.mod.get_moisture() == moist
self.mod.start_measure.assert_called_once_with()
assert self.mod.measure_running.call_args_list == expected
self.mod.get_measurement.assert_called_once_with(quantity='Moist')
def test__get_analog_output_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'AnalogOutputMode'
mode = 0
self.bus.get.return_value = (mode, )
assert self.mod._get_analog_output_mode() == mode
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__set_analog_output_mode_WrongMode(self):
with pytest.raises(ModuleError, message="Wrong AnalogOutputMode!"):
self.mod._set_analog_output_mode(3)
def test__set_analog_output_mode(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'AnalogOutputMode'
value = 0
self.bus.set.return_value = True
assert self.mod._set_analog_output_mode(value)
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test__get_moist_max_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MoistMaxValue'
self.bus.get.return_value = (50, )
assert self.mod._get_moist_max_value() == 50
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__get_moist_min_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'MoistMinValue'
self.bus.get.return_value = (0, )
assert self.mod._get_moist_min_value() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__get_temp_max_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'TempMaxValue'
self.bus.get.return_value = (60, )
assert self.mod._get_temp_max_value() == 60
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__get_temp_min_value(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'TempMinValue'
self.bus.get.return_value = (0, )
assert self.mod._get_temp_min_value() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__set_analog_moist_ValueToLow(self):
with pytest.raises(ModuleError, message="Value out of range!"):
self.mod._set_analog_moist(-1)
def test__set_analog_moist_ValueToHigh(self):
with pytest.raises(ModuleError, message="Value out of range!"):
self.mod._set_analog_moist(1001)
def test__set_analog_moist_WrongEventMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotAnalogOut"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'AnalogOut'!"):
self.mod._set_analog_moist(mvolt)
self.mod.get_event_mode.assert_called_once_with()
def test__set_analog_moist_WrongAnalogOutputMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = -1
with pytest.raises(
ModuleError,
message="Wrong AnalogOutputMode, need mode 0 here!"):
self.mod._set_analog_moist(mvolt)
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
def test__set_analog_moist(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'Moist'
mvolt = 500
min_value = 0
max_value = 10
value = (max_value - min_value) / 1000.0 * mvolt + min_value
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = 0
self.mod._get_moist_min_value = MagicMock()
self.mod._get_moist_min_value.return_value = 0
self.mod._get_moist_max_value = MagicMock()
self.mod._get_moist_max_value.return_value = 10
assert self.mod._set_analog_moist(mvolt)
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
self.mod._get_moist_min_value.assert_called_once_with()
self.mod._get_moist_max_value.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test__get_analog_moist(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'Moist'
self.bus.get.return_value = (0, )
assert self.mod._get_analog_moist() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__set_analog_temp_ValueToLow(self):
with pytest.raises(ModuleError, message="Value out of range!"):
self.mod._set_analog_temp(-1)
def test__set_analog_temp_ValueToHigh(self):
with pytest.raises(ModuleError, message="Value out of range!"):
self.mod._set_analog_temp(1001)
def test__set_analog_temp_WrongEventMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotAnalogOut"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'AnalogOut'!"):
self.mod._set_analog_temp(mvolt)
self.mod.get_event_mode.assert_called_once_with()
def test__set_analog_temp_WrongAnalogOutputMode(self):
mvolt = 550
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = -1
with pytest.raises(ModuleError,
message="Wrong AnalogOutputMode, need mode 0 here"):
self.mod._set_analog_temp(mvolt)
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
def test__set_analog_temp(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'CompTemp'
min_value = -20
max_value = 70
mvolt = 550
value = (max_value - min_value) / 1000.0 * mvolt + min_value
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "AnalogOut"
self.mod._get_analog_output_mode = MagicMock()
self.mod._get_analog_output_mode.return_value = 0
self.mod._get_temp_min_value = MagicMock()
self.mod._get_temp_min_value.return_value = min_value
self.mod._get_temp_max_value = MagicMock()
self.mod._get_temp_max_value.return_value = max_value
assert self.mod._set_analog_temp(mvolt)
self.mod.get_event_mode.assert_called_once_with()
self.mod._get_analog_output_mode.assert_called_once_with()
self.mod._get_temp_min_value.assert_called_once_with()
self.mod._get_temp_max_value.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test__get_analog_temp(self):
table = 'MEASURE_PARAMETER_TABLE'
param = 'CompTemp'
self.bus.get.return_value = (0, )
assert self.mod._get_analog_temp() == 0
self.bus.get.assert_called_once_with(self.serno, table, param)
def test__turn_asic_on_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotSelfTest"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'SelfTest'!"):
self.mod._turn_asic_on()
def test__turn_asic_on(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'SelfTest'
value = [1, 1, 63, 0]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "SelfTest"
assert self.mod._turn_asic_on()
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, value)
def test__turn_asic_off_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotSelfTest"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'SelfTest'!"):
self.mod._turn_asic_off()
def test__turn_asic_off(self):
table = 'ACTION_PARAMETER_TABLE'
param = 'SelfTest'
value = [1, 0, 255, 0]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "SelfTest"
assert self.mod._turn_asic_off()
self.mod.get_event_mode.assert_called_once_with()
self.bus.set.assert_called_once_with(self.serno, table, param, value)
def test__get_transit_time_tdr_WrongEventMode(self):
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NotNormalMeasure"
with pytest.raises(ModuleError,
message="Wrong event mode, need 'NormalMeasure'!"):
self.mod._get_transit_time_tdr()
def test__get_transit_time_tdr(self):
transit_time = 123
tdr_value = 321
set_calls = [
call(self.serno, 'DEVICE_CONFIGURATION_PARAMETER_TABLE',
'MeasMode', [0]),
call(self.serno, 'ACTION_PARAMETER_TABLE', 'StartMeasure', [1]),
call(self.serno, 'DEVICE_CONFIGURATION_PARAMETER_TABLE',
'MeasMode', [2])
]
get_calls = [
call(self.serno, 'ACTION_PARAMETER_TABLE', 'StartMeasure'),
call(self.serno, 'ACTION_PARAMETER_TABLE', 'StartMeasure'),
call(self.serno, 'MEASURE_PARAMETER_TABLE', 'TransitTime'),
call(self.serno, 'MEASURE_PARAMETER_TABLE', 'TDRValue'),
]
self.mod.get_event_mode = MagicMock()
self.mod.get_event_mode.return_value = "NormalMeasure"
self.bus.set.return_value = True
self.bus.get.side_effect = [(1, ), (0, ), (transit_time, ),
(tdr_value, )]
assert self.mod._get_transit_time_tdr() == (transit_time, tdr_value)
self.mod.get_event_mode.assert_called_once_with()
assert self.bus.set.call_args_list == set_calls
assert self.bus.get.call_args_list == get_calls
def test__set_sdi12_address_WrongAddress(self):
with pytest.raises(ModuleError, message='SDI12 address out of range!'):
self.mod._set_sdi12_address(2000)
def test__set_sdi12_address(self):
table = 'SYSTEM_PARAMETER_TABLE'
param = 'ModuleInfo1'
value = 0
self.mod._set_sdi12_address(value)
self.bus.set.assert_called_once_with(self.serno, table, param, [value])
def test__set_protocol_WrongProtocol(self):
value = 'chocolate_jesus'
with pytest.raises(ModuleError,
message="Wrong protocol: {}".format(value)):
self.mod._set_protocol(value)
def test__set_protocol(self):
table = 'DEVICE_CONFIGURATION_PARAMETER_TABLE'
param = 'Protocol'
protocols = {'IMPBUS': 0, 'SDI12': 1}
assert protocols == self.mod.protocols
expected = []
for protocol in protocols:
value = protocols[protocol]
self.mod._set_protocol(protocol)
expected.append(call(self.serno, table, param, [value]))
assert self.bus.set.call_args_list == expected
