def setUp(self):
EventsMixin.setUp(self)
self.icestorm_topic_name = 'FF00000100000023.private'
self.servant = Mimic(Spy, SmartObject.AnalogSink)
self.proxy = self._adapter_add(AnalogSinkI(self.servant))
self._subscribe(self.icestorm_topic_name, self.proxy)
def test_linked_processors(self):
P0 = self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx)
P1_servant = Mimic(Spy, Cannon.Processor)
P1 = self.broker.add_servant(P1_servant, Cannon.ProcessorPrx)
P2_servant = Mimic(Spy, Cannon.Processor)
P2 = self.broker.add_servant(P2_servant, Cannon.ProcessorPrx)
collector_servant = Mimic(Spy, Cannon.Collector)
collector = self.broker.add_servant(collector_servant, Cannon.CollectorPrx)
A00 = M1(1)
B00 = M1(5)
P0.init(1, 1, P2, P1, 2, collector)
P0.injectFirst(A00, 0)
P0.injectSecond(B00, 0)
assert_that(P1_servant.injectFirst, called().asyncio(1).with_args(A00, 1, anything()))
assert_that(P2_servant.injectSecond, called().asyncio(1).with_args(B00, 1, anything()))
def test_2x2_processors_2x2_operands(self):
'''
initial shift:
1 2 1 2 5 6 5 8
3 4 < 4 3 7 8 7 6
^
processors and collector are distributed objects
'''
P = [self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx) for i in range(4)]
collector_servant = Mimic(Spy, Cannon.Collector)
collector = self.broker.add_servant(collector_servant, Cannon.CollectorPrx)
# by-hand shifted submatrices
A00 = M1(1)
A01 = M1(2)
A10 = M1(4)
A11 = M1(3)
B00 = M1(5)
B01 = M1(8)
B10 = M1(7)
B11 = M1(6)
# by-hand processor initialization
P[0].init(0, 0, P[2], P[1], 2, collector)
P[1].init(0, 1, P[3], P[0], 2, collector)
P[2].init(1, 0, P[0], P[3], 2, collector)
P[3].init(1, 1, P[1], P[2], 2, collector)
# by-hand processor loading
P[0].injectFirst(A00, 0); P[0].injectSecond(B00, 0)
P[1].injectFirst(A01, 0); P[1].injectSecond(B01, 0)
P[2].injectFirst(A10, 0); P[2].injectSecond(B10, 0)
P[3].injectFirst(A11, 0); P[3].injectSecond(B11, 0)
wait_that(collector_servant.injectSubmatrix,
called().times(4))
# expected result blocks
C00 = M1(19)
C01 = M1(22)
C10 = M1(43)
C11 = M1(50)
assert_that(collector_servant.injectSubmatrix, called().with_args(C00, 0, 0, anything()))
assert_that(collector_servant.injectSubmatrix, called().with_args(C01, 0, 1, anything()))
assert_that(collector_servant.injectSubmatrix, called().with_args(C10, 1, 0, anything()))
assert_that(collector_servant.injectSubmatrix, called().with_args(C11, 1, 1, anything()))
def test_linked_processors(self):
P0 = self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx)
P1_servant = Mimic(Spy, Cannon.Processor)
P1 = self.broker.add_servant(P1_servant, Cannon.ProcessorPrx)
P2_servant = Mimic(Spy, Cannon.Processor)
P2 = self.broker.add_servant(P2_servant, Cannon.ProcessorPrx)
collector_servant = Mimic(Spy, Cannon.Collector)
collector = self.broker.add_servant(collector_servant,
Cannon.CollectorPrx)
A0 = M1(1)
B0 = M1(5)
P0.init(3, 2, P2, P1, collector)
P0.injectA(A0, 0)
P0.injectB(B0, 0)
assert_that(P1_servant.injectA,
called(). async (1).with_args(A0, 1, anything()))
assert_that(P2_servant.injectB,
called(). async (1).with_args(B0, 1, anything()))
def test_collector_called(self):
# given
processor = self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx)
collector_servant = Mimic(Spy, Cannon.Collector)
collector = self.broker.add_servant(collector_servant, Cannon.CollectorPrx)
A = M2(1, 2, 3, 4)
B = M2(5, 6, 7, 8)
# when
processor.init(1, 1, None, None, 1, collector)
processor.injectFirst(A, 0)
processor.injectSecond(B, 0)
# then
C = M2(19, 22, 43, 50)
assert_that(collector_servant.injectSubmatrix,
called().asyncio(1).with_args(C, 1, 1, anything()))
def test_event_from_unconfigured_sensor_magnitude(self):
self.icestorm_topic_name_unconfigured = "Unconfigured"
self.servant_unconfigured = Mimic(Spy, SmartObject.AnalogSink)
self.proxy_unconfigured = self._adapter_add(self.servant_unconfigured)
self._subscribe(self.icestorm_topic_name_unconfigured,
self.proxy_unconfigured)
self.mqtt_msg = mqtt.MQTTMessage(mid=0, topic=b'meshliumf958/SCP4/HUM')
self.mqtt_msg.payload = (
'{\r\n "id": "186897",\r\n "id_wasp": "SCP4", \r\n '
'"id_secret": "751C67057C105442",\r\n '
'"sensor": "HUM",\r\n "value": "25.6",\r\n '
'"timestamp": "2018-07-19T11:01:41+03:00"\r\n}').encode()
self.mqtt_msg.payload = self.mqtt_msg.payload
self.formatted_timestamp = '1531987301'
self.mqtt_adapter.on_message(client=self.mqtt_client,
userdata=None,
msg=self.mqtt_msg)
meta = {SmartObject.MetadataField.Timestamp: self.formatted_timestamp}
assert_that(self.servant_unconfigured.notify, is_not(called()))
def test_2x2_processors_2x2_operands(self):
'''
initial shift:
1 2 1 2 5 6 5 8
3 4 < 4 3 7 8 7 6
^
processors and collectors are distributed objects
'''
P = [
self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx)
for i in range(4)
]
collector_servant = Mimic(Spy, Cannon.Collector)
collector = self.broker.add_servant(collector_servant,
Cannon.CollectorPrx)
# by-hand shifted submatrices
A0 = M1(1)
A1 = M1(2)
A2 = M1(4)
A3 = M1(3)
B0 = M1(5)
B1 = M1(8)
B2 = M1(7)
B3 = M1(6)
# by-hand processor initialization
P[0].init(0, 2, P[2], P[1], collector)
P[1].init(1, 2, P[3], P[0], collector)
P[2].init(2, 2, P[0], P[3], collector)
P[3].init(3, 2, P[1], P[2], collector)
# by-hand processor loading
P[0].injectA(A0, 0)
P[0].injectB(B0, 0)
P[1].injectA(A1, 0)
P[1].injectB(B1, 0)
P[2].injectA(A2, 0)
P[2].injectB(B2, 0)
P[3].injectA(A3, 0)
P[3].injectB(B3, 0)
wait_that(collector_servant.inject, called().times(4))
# expected result blocks
C0 = M1(19)
C1 = M1(22)
C2 = M1(43)
C3 = M1(50)
assert_that(collector_servant.inject,
called().with_args(0, C0, anything()))
assert_that(collector_servant.inject,
called().with_args(1, C1, anything()))
assert_that(collector_servant.inject,
called().with_args(2, C2, anything()))
assert_that(collector_servant.inject,
called().with_args(3, C3, anything()))