def test_do_command_in_address_mode(self):
""" Test the behavior of do_command in address mode."""
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
sad = power_api.set_addressmode()
serial_mock = RS485(SerialMock(
[sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sout(''), # Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.NORMAL_MODE)),
sin(action.create_input(1, 3)),
sout(action.create_output(1, 3, 49.5))],
1
))
comm = self.__get_communicator(serial_mock)
comm.start()
comm.start_address_mode()
try:
comm.do_command(1, action)
self.assertFalse(True)
except InAddressModeException:
pass
comm.stop_address_mode()
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_address_mode_timeout(self):
""" Test address mode timeout. """
action = power_api.get_voltage(power_api.POWER_MODULE)
sad = power_api.set_addressmode(power_api.POWER_MODULE)
sad_p1c = power_api.set_addressmode(power_api.P1_CONCENTRATOR)
serial_mock = RS485(
SerialMock(
[
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 1,
power_api.ADDRESS_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 2,
power_api.ADDRESS_MODE)),
sout(''), # Timeout read after 1 second
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 3,
power_api.NORMAL_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 4,
power_api.NORMAL_MODE)),
sin(action.create_input(1, 5)),
sout(action.create_output(1, 5, 49.5))
],
1))
comm = PowerCommunicatorTest._get_communicator(serial_mock,
address_mode_timeout=1)
comm.start()
comm.start_address_mode()
time.sleep(1.1)
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_do_command_in_address_mode(self):
""" Test the behavior of do_command in address mode."""
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
sad = power_api.set_addressmode()
serial_mock = RS485(SerialMock(
[sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sout(''), ## Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.NORMAL_MODE)),
sin(action.create_input(1, 3)),
sout(action.create_output(1, 3, 49.5))
], 1))
comm = self.__get_communicator(serial_mock)
comm.start()
comm.start_address_mode()
try:
comm.do_command(1, action)
self.assertFalse(True)
except InAddressModeException:
pass
comm.stop_address_mode()
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_timekeeper(self):
""" Test the TimeKeeper. """
SetUpTestInjections(power_db=PowerCommunicatorTest.FILE)
power_controller = PowerController()
power_controller.register_power_module(1, power_api.POWER_MODULE)
time_action = power_api.set_day_night(power_api.POWER_MODULE)
times = [power_api.NIGHT for _ in range(8)]
action = power_api.get_voltage(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(time_action.create_input(1, 1, *times)),
sout(time_action.create_output(1, 1)),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 243))
], 1))
comm = PowerCommunicatorTest._get_communicator(
serial_mock, 1, power_controller=power_controller)
comm.start()
time.sleep(1.5)
self.assertEquals((243, ), comm.do_command(1, action))
def test_do_command_timeout_once(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action.create_input(1, 1)), sout(''),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
def test_do_command_timeout_once(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action.create_input(1, 1)), sout(''),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
def test_wrong_response(self):
""" Test PowerCommunicator.do_command when the power module returns a wrong response. """
action_1 = power_api.get_voltage(power_api.POWER_MODULE)
action_2 = power_api.get_frequency(power_api.POWER_MODULE)
self.power_data.extend([
sin(action_1.create_input(1, 1)),
sout(action_2.create_output(3, 2, 49.5))
])
self.serial.start()
self.communicator.start()
with self.assertRaises(Exception):
self.communicator.do_command(1, action_1)
def test_do_command_split_data(self):
""" Test PowerCommunicator.do_command when the data is split over multiple reads. """
action = power_api.get_voltage(power_api.POWER_MODULE)
out = action.create_output(1, 1, 49.5)
self.power_data.extend([
sin(action.create_input(1, 1)),
sout(out[:5]), sout(out[5:])
])
self.serial.start()
self.communicator.start()
output = self.communicator.do_command(1, action)
self.assertEqual((49.5, ), output)
def test_do_command_split_data(self):
""" Test PowerCommunicator.do_command when the data is split over multiple reads. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
out = action.create_output(1, 1, 49.5)
serial_mock = RS485(SerialMock(
[sin(action.create_input(1, 1)),
sout(out[:5]), sout(out[5:])]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
def test_do_command_split_data(self):
""" Test PowerCommunicator.do_command when the data is split over multiple reads. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
out = action.create_output(1, 1, 49.5)
serial_mock = RS485(SerialMock(
[sin(action.create_input(1, 1)),
sout(out[:5]), sout(out[5:])]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
def test_do_command_timeout_twice(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
self.power_data.extend([
sin(action.create_input(1, 1)),
sout(bytearray()),
sin(action.create_input(1, 2)),
sout(bytearray())
])
self.serial.start()
self.communicator.start()
with self.assertRaises(CommunicationTimedOutException):
self.communicator.do_command(1, action)
def test_do_command_timeout_once(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
self.power_data.extend([
sin(action.create_input(1, 1)),
sout(bytearray()),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 49.5))
])
self.serial.start()
self.communicator.start()
output = self.communicator.do_command(1, action)
self.assertEqual((49.5, ), output)
def test_do_command(self):
""" Test for standard behavior PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
self.power_data.extend([
sin(action.create_input(1, 1)), sout(action.create_output(1, 1, 49.5))
])
self.serial.start()
self.communicator.start()
output = self.communicator.do_command(1, action)
self.assertEqual((49.5, ), output)
self.assertEqual(14, self.communicator.get_communication_statistics()['bytes_written'])
self.assertEqual(18, self.communicator.get_communication_statistics()['bytes_read'])
def test_wrong_response(self):
""" Test PowerCommunicator.do_command when the power module returns a wrong response. """
action_1 = power_api.get_voltage(power_api.POWER_API_8_PORTS)
action_2 = power_api.get_frequency(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action_1.create_input(1, 1)),
sout(action_2.create_output(3, 2, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
try:
comm.do_command(1, action_1)
self.assertTrue(False)
except Exception:
pass
def test_do_command_timeout_twice(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action.create_input(1, 1)), sout(''),
sin(action.create_input(1, 2)),
sout('')]))
comm = self.__get_communicator(serial_mock)
comm.start()
try:
comm.do_command(1, action)
self.fail("Should receive timed out exception !")
except CommunicationTimedOutException:
pass # Ok !
def test_wrong_response(self):
""" Test PowerCommunicator.do_command when the power module returns a wrong response. """
action_1 = power_api.get_voltage(power_api.POWER_MODULE)
action_2 = power_api.get_frequency(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(action_1.create_input(1, 1)),
sout(action_2.create_output(3, 2, 49.5))
]))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
with self.assertRaises(Exception):
comm.do_command(1, action_1)
def test_do_command_timeout_twice(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action.create_input(1, 1)), sout(''),
sin(action.create_input(1, 2)),
sout('')]))
comm = self.__get_communicator(serial_mock)
comm.start()
try:
comm.do_command(1, action)
self.fail("Should receive timed out exception !")
except CommunicationTimedOutException:
pass # Ok !
def test_wrong_response(self):
""" Test PowerCommunicator.do_command when the power module returns a wrong response. """
action_1 = power_api.get_voltage(power_api.POWER_API_8_PORTS)
action_2 = power_api.get_frequency(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action_1.create_input(1, 1)),
sout(action_2.create_output(3, 2, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
try:
comm.do_command(1, action_1)
self.assertTrue(False)
except Exception:
pass
def test_do_command_timeout_twice(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(action.create_input(1, 1)),
sout(''),
sin(action.create_input(1, 2)),
sout('')
]))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
with self.assertRaises(CommunicationTimedOutException):
comm.do_command(1, action)
def test_do_command(self):
""" Test for standard behavior PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock(
[sin(action.create_input(1, 1)),
sout(action.create_output(1, 1, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
self.assertEquals(14, comm.get_bytes_written())
self.assertEquals(18, comm.get_bytes_read())
def test_do_command(self):
""" Test for standard behavior PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock(
[sin(action.create_input(1, 1)),
sout(action.create_output(1, 1, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
self.assertEquals(14, comm.get_bytes_written())
self.assertEquals(18, comm.get_bytes_read())
def test_timekeeper(self):
""" Test the TimeKeeper. """
self.store.register_power_module(1, power_api.POWER_MODULE)
time_action = power_api.set_day_night(power_api.POWER_MODULE)
times = [power_api.NIGHT for _ in range(8)]
action = power_api.get_voltage(power_api.POWER_MODULE)
self.power_data.extend([
sin(time_action.create_input(1, 1, *times)),
sout(time_action.create_output(1, 1)),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 243))
])
self.communicator = PowerCommunicator(time_keeper_period=1)
self.serial.start()
self.communicator.start()
time.sleep(1.5)
self.assertEqual((243, ), self.communicator.do_command(1, action))
def test_address_mode_timeout(self):
""" Test address mode timeout. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
sad = power_api.set_addressmode()
serial_mock = RS485(SerialMock(
[sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sout(''), ## Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.NORMAL_MODE)),
sin(action.create_input(1, 3)),
sout(action.create_output(1, 3, 49.5))
], 1))
comm = self.__get_communicator(serial_mock, address_mode_timeout=1)
comm.start()
comm.start_address_mode()
time.sleep(1.1)
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_do_command(self):
""" Test for standard behavior PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(action.create_input(1, 1)),
sout(action.create_output(1, 1, 49.5))
]))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
self.assertEquals(14,
comm.get_communication_statistics()['bytes_written'])
self.assertEquals(18,
comm.get_communication_statistics()['bytes_read'])
def test_timekeeper(self):
""" Test the TimeKeeper. """
power_controller = PowerController(PowerCommunicatorTest.FILE)
power_controller.register_power_module(1, power_api.POWER_API_8_PORTS)
time_action = power_api.set_day_night(power_api.POWER_API_8_PORTS)
times = [power_api.NIGHT for _ in range(8)]
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock(
[sin(time_action.create_input(1, 1, *times)),
sout(time_action.create_output(1, 1)),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 243))
], 1))
comm = self.__get_communicator(serial_mock, 1, power_controller=power_controller)
comm.start()
time.sleep(1.5)
self.assertEquals((243, ), comm.do_command(1, action))
def test_do_command_in_address_mode(self):
""" Test the behavior of do_command in address mode."""
action = power_api.get_voltage(power_api.POWER_MODULE)
sad = power_api.set_addressmode(power_api.POWER_MODULE)
sad_p1c = power_api.set_addressmode(power_api.P1_CONCENTRATOR)
serial_mock = RS485(
SerialMock(
[
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 1,
power_api.ADDRESS_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 2,
power_api.ADDRESS_MODE)),
sout(''), # Timeout read after 1 second
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 3,
power_api.NORMAL_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 4,
power_api.NORMAL_MODE)),
sin(action.create_input(1, 5)),
sout(action.create_output(1, 5, 49.5))
],
1))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
comm.start_address_mode()
with self.assertRaises(InAddressModeException):
comm.do_command(1, action)
comm.stop_address_mode()
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_address_mode_timeout(self):
""" Test address mode timeout. """
action = power_api.get_voltage(power_api.POWER_MODULE)
sad = power_api.set_addressmode(power_api.POWER_MODULE)
sad_p1c = power_api.set_addressmode(power_api.P1_CONCENTRATOR)
self.power_data.extend([
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sin(sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.ADDRESS_MODE)),
sout(bytearray()), # Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 3, power_api.NORMAL_MODE)),
sin(sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 4, power_api.NORMAL_MODE)),
sin(action.create_input(1, 5)),
sout(action.create_output(1, 5, 49.5))
])
self.communicator = PowerCommunicator(address_mode_timeout=1)
self.serial.start()
self.communicator.start()
self.communicator.start_address_mode()
time.sleep(1.1)
self.assertEqual((49.5, ), self.communicator.do_command(1, action))
def get_module_voltage(self, module):
# type: (Dict[str,Any]) -> List[Dict[str,Optional[float]]]
"""
Request phase voltages for all meters and parse repsonse.
"""
payloads = {}
for i in range(1, 4):
cmd = power_api.get_voltage(module['version'], phase=i)
payloads['phase{}'.format(
i)] = self._power_communicator.do_command(
module['address'], cmd)[0]
voltages = []
for port_id in range(NUM_PORTS[P1_CONCENTRATOR]):
phases = {} # type: Dict[str,Optional[float]]
for phase, payload in payloads.items():
try:
phases[phase] = float(payload[port_id * 7:(port_id + 1) *
7][:5])
except ValueError:
phases[phase] = None
voltages.append(phases)
return voltages
def test_do_command_in_address_mode(self):
""" Test the behavior of do_command in address mode."""
action = power_api.get_voltage(power_api.POWER_MODULE)
sad = power_api.set_addressmode(power_api.POWER_MODULE)
sad_p1c = power_api.set_addressmode(power_api.P1_CONCENTRATOR)
self.power_data.extend([
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sin(sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.ADDRESS_MODE)),
sout(bytearray()), # Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 3, power_api.NORMAL_MODE)),
sin(sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 4, power_api.NORMAL_MODE)),
sin(action.create_input(1, 5)),
sout(action.create_output(1, 5, 49.5))
])
self.serial.start()
self.communicator.start()
self.communicator.start_address_mode()
with self.assertRaises(InAddressModeException):
self.communicator.do_command(1, action)
self.communicator.stop_address_mode()
self.assertEqual((49.5, ), self.communicator.do_command(1, action))
def get_module_voltage(self, module, phase=None):
# type: (Dict[str,Any], Optional[int]) -> Tuple[Any, ...]
# TODO return type depends on module version/phase, translate here?
cmd = power_api.get_voltage(module['version'], phase=phase)
return self._power_communicator.do_command(module['address'], cmd)
def test_get_voltage(self):
action = power_api.get_voltage(power_api.POWER_MODULE)
assert decode(action.create_input(1,
1)) == 'STRE\x01\x01GVOL\x00\xb6\r\n'
assert decode(action.create_output(
1, 1, 49.5)) == 'RTRE\x01\x01GVOL\x04\x00\x00FB#\r\n'
