def test_ProducerConsumerTerminals(self): tmA = self.terminalsB['pcConsumer'] tmB = self.terminalsA['pcProducer'] msg = bytes([1, 2, 3]) # publish without the terminal being bound self.assertRaises(yogi.Failure, lambda: tmB.publish(msg)) self.assertEqual(False, tmB.try_publish(msg)) # cancel receive message with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(msg) tmA.async_receive_message(wrap(fn)) tmA.cancel_receive_message() # successfully receive message self.connect(tmA) with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) tmA.async_receive_message(wrap(fn)) tmB.publish(msg) self.assertTrue(tmB.try_publish(msg))
def test_async_await_known_terminals_change(self): tm = None with AsyncCall() as wrap: def fn(res, info, change): self.assertEqual(yogi.Success(), res) self.assertIs(yogi.ProducerTerminal, info.type) self.assertEqual(0x0000d007, info.signature.raw) self.assertEqual('One', info.name) self.assertEqual(yogi.ChangeType.ADDED, change) self.node.async_await_known_terminals_change(wrap(fn)) tm = yogi.ProducerTerminal('One', yogi_0000d007_pb2, leaf=self.leaf) with AsyncCall() as wrap: def fn(res, info, change): self.assertEqual(yogi.Success(), res) self.assertIs(yogi.ProducerTerminal, info.type) self.assertEqual(0x0000d007, info.signature.raw) self.assertEqual('One', info.name) self.assertEqual(yogi.ChangeType.REMOVED, change) self.node.async_await_known_terminals_change(wrap(fn)) tm.destroy()
def test_RawCachedPublishSubscribeTerminal(self): tmA = self.terminalsA['cps'] tmB = self.terminalsB['cps'] bd = self.bindings['cps'] msg = bytes([1, 2, 3]) # publish without the terminal being bound self.assertRaises(yogi.Failure, lambda: tmB.publish(msg)) self.assertEqual(False, tmB.try_publish(msg)) # cancel receive message with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(msg) tmA.async_receive_message(wrap(fn)) tmA.cancel_receive_message() # successfully receive cached message with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) self.assertTrue(cached) tmA.async_receive_message(wrap(fn)) self.connect(bd) # successfully receive non-cached message with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) self.assertFalse(cached) tmA.async_receive_message(wrap(fn)) tmB.publish(msg) self.assertTrue(tmB.try_publish(msg)) # get cached message msg = tmA.get_cached_message() self.assertEqual(bytes([1, 2, 3]), msg)
def test_cancel_await_binding_state_changed(self): with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Canceled(), res) self.bd.async_await_binding_state_change(wrap(fn)) self.bd.cancel_await_binding_state_change()
def test_async_get_binding_state(self): with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.BindingState.RELEASED, state) self.bd.async_get_binding_state(wrap(fn)) self.connect() with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.BindingState.ESTABLISHED, state) self.bd.async_get_binding_state(wrap(fn))
def test_async_await_binding_state_changed(self): with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.BindingState.ESTABLISHED, state) self.bd.async_await_binding_state_change(wrap(fn)) self.connect() with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.BindingState.RELEASED, state) self.bd.async_await_binding_state_change(wrap(fn)) self.connection.destroy() self.connection = None
def test_cancel_await_subscription_state_changed(self): with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Canceled(), res) self.tmB.async_await_subscription_state_change(wrap(fn)) self.tmB.cancel_await_subscription_state_change()
def test_async_get_subscription_state(self): with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.SubscriptionState.UNSUBSCRIBED, state) self.tmB.async_get_subscription_state(wrap(fn)) self.connect() with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.SubscriptionState.SUBSCRIBED, state) self.tmB.async_get_subscription_state(wrap(fn))
def test_async_await_subscription_state_changed(self): with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.SubscriptionState.SUBSCRIBED, state) self.tmB.async_await_subscription_state_change(wrap(fn)) self.connect() with AsyncCall() as wrap: def fn(res, state): self.assertEqual(yogi.Success(), res) self.assertEqual(yogi.SubscriptionState.UNSUBSCRIBED, state) self.tmB.async_await_subscription_state_change(wrap(fn)) self.connection.destroy() self.connection = None
def check(errors, fn): with AsyncCall() as wrap: def handler_fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual([err.message for err in errors], msg.value) self.warnings_terminal.async_receive_message(wrap(handler_fn)) fn()
def check(state, fn): with AsyncCall() as wrap: def handler_fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(state, msg.value) self.operational_terminal.async_receive_message( wrap(handler_fn)) fn()
def test_cancel_await_known_terminals_change(self): with AsyncCall() as wrap: def fn(res, info, change): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(info) self.assertIsNone(change) self.node.async_await_known_terminals_change(wrap(fn)) self.node.cancel_await_known_terminals_change()
def change_verbosity(self, verbosity_terminal, verbosity): with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertFalse(cached) self.assertEqual(verbosity.value, msg.value) verbosity_terminal.async_receive_message(wrap(fn)) verbosity_terminal.publish( verbosity_terminal.make_message(value=verbosity.value))
def test_ProcessInterface(self): yogi.Logger.colourised_stdout = False argv = [ '-j', ''' { "logging": { "stdout": { "colourised": true, "max-verbosity": "DEBUG", "component-verbosity": { "App" : "ERROR", "Yogi" : "FATAL", "test" : "TRACE" } }, "yogi": { "max-verbosity": "INFO", "component-verbosity": { "App" : "DEBUG", "Yogi" : "INFO", "test" : "WARNING" } } } }''' ] scheduler = yogi.Scheduler() leaf = yogi.Leaf(scheduler) pi = yogi.ProcessInterface(argv) # check initial configuration self.assertTrue(yogi.Logger.colourised_stdout) self.assertIs(yogi.Verbosity.DEBUG, yogi.Logger.max_stdout_verbosity) self.assertIs(yogi.Verbosity.ERROR, yogi.Logger().stdout_verbosity) self.assertIs(yogi.Verbosity.ERROR, yogi.Logger('App').stdout_verbosity) self.assertIs(yogi.Verbosity.FATAL, yogi.Logger('Yogi').stdout_verbosity) self.assertIs(yogi.Verbosity.TRACE, yogi.Logger('test').stdout_verbosity) self.assertIs(yogi.Verbosity.INFO, yogi.Logger.max_yogi_verbosity) self.assertIs(yogi.Verbosity.DEBUG, yogi.Logger().yogi_verbosity) self.assertIs(yogi.Verbosity.DEBUG, yogi.Logger('App').yogi_verbosity) self.assertIs(yogi.Verbosity.INFO, yogi.Logger('Yogi').yogi_verbosity) self.assertIs(yogi.Verbosity.WARNING, yogi.Logger('test').yogi_verbosity) # check logging over YOGI log_terminal = yogi.ConsumerTerminal('/Process/Log', yogi_000009cd_pb2, leaf=leaf) connection = yogi.LocalConnection(leaf, pi.leaf) while log_terminal.get_binding_state() is yogi.BindingState.RELEASED: pass with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual('Hello', msg.value.first) info = json.loads(msg.value.second) self.assertEqual('App', info['component']) self.assertEqual('FATAL', info['severity']) self.assertGreater(info['thread'], 0) log_terminal.async_receive_message(wrap(fn)) yogi.log_fatal('Hello') # check changing verbosity levels at runtime logger = yogi.Logger('My Component') max_verbosity_terminal = yogi.CachedSlaveTerminal( '/Process/YOGI Log Verbosity/Max Verbosity', yogi_00004004_pb2, leaf=leaf) while max_verbosity_terminal.get_binding_state( ) is yogi.BindingState.RELEASED: pass while max_verbosity_terminal.get_subscription_state( ) is yogi.SubscriptionState.UNSUBSCRIBED: pass self.change_verbosity(max_verbosity_terminal, yogi.Verbosity.INFO) verbosity_terminal = yogi.CachedSlaveTerminal( '/Process/YOGI Log Verbosity/Components/My Component', yogi_00004004_pb2, leaf=leaf) while verbosity_terminal.get_binding_state( ) is yogi.BindingState.RELEASED: pass while verbosity_terminal.get_subscription_state( ) is yogi.SubscriptionState.UNSUBSCRIBED: pass self.change_verbosity(verbosity_terminal, yogi.Verbosity.DEBUG) # check that new verbosity levels are being applied with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual('Go', msg.value.first) log_terminal.async_receive_message(wrap(fn)) logger.log_info('Go') self.change_verbosity(verbosity_terminal, yogi.Verbosity.WARNING) with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual('Vegan', msg.value.first) log_terminal.async_receive_message(wrap(fn)) logger.log_info('Welcome') logger.log_warning('Vegan') self.change_verbosity(max_verbosity_terminal, yogi.Verbosity.ERROR) with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual('Mate', msg.value.first) log_terminal.async_receive_message(wrap(fn)) logger.log_warning('Dude') logger.log_error('Mate') # clean up connection.destroy() verbosity_terminal.destroy() max_verbosity_terminal.destroy() log_terminal.destroy() leaf.destroy() scheduler.destroy() pi.destroy()
def test_ServiceClientTerminals(self): tmA = self.terminalsA['scService'] tmB = self.terminalsB['scClient'] # cancel receive message with AsyncCall() as wrap: def fn(res, request): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(request) tmA.async_receive_request(wrap(fn)) tmA.cancel_receive_request() # ignore message self.connect(tmA, tmB) msg = bytes([1, 2, 3]) with AsyncCall() as wrap: def fn(res, request): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), request.message) request.ignore() tmA.async_receive_request(wrap(fn)) with AsyncCall() as wrap2: def fn2(res, gathered_msg): self.assertEqual(yogi.Success(), res) self.assertTrue(gathered_msg.flags & yogi.GatherFlags.IGNORED) return yogi.ControlFlow.STOP tmB.async_request(msg, wrap2(fn2)) # respond to message with AsyncCall() as wrap: def fn(res, request): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), request.message) response = bytes([4, 5, 6]) request.respond(response) tmA.async_receive_request(wrap(fn)) with AsyncCall() as wrap2: def fn2(res, gathered_msg): self.assertEqual(yogi.Success(), res) self.assertTrue(gathered_msg.flags & yogi.GatherFlags.FINISHED) self.assertEqual(bytes([4, 5, 6]), gathered_msg.message) return yogi.ControlFlow.STOP tmB.async_request(msg, wrap2(fn2)) # cancel operation with AsyncCall() as wrap: def fn(res, request): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), request.message) # do not respond tmA.async_receive_request(wrap(fn)) with AsyncCall() as wrap2: def fn2(res, gathered_msg): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(gathered_msg) operation = tmB.async_request(msg, wrap2(fn2)) operation.cancel()
def test_CachedMasterSlaveTerminals(self): tmA = self.terminalsA['cmsMaster'] tmB = self.terminalsB['cmsSlave'] msg = bytes([1, 2, 3]) # publish without the terminals being bound self.assertRaises(yogi.Failure, lambda: tmA.publish(msg)) self.assertEqual(False, tmA.try_publish(msg)) self.assertRaises(yogi.Failure, lambda: tmB.publish(msg)) self.assertEqual(False, tmB.try_publish(msg)) # cancel receive message with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(msg) tmA.async_receive_message(wrap(fn)) tmA.cancel_receive_message() with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(msg) tmB.async_receive_message(wrap(fn)) tmB.cancel_receive_message() # successfully receive cached message with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) self.assertTrue(cached) tmB.async_receive_message(wrap(fn)) with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) self.assertTrue(cached) tmA.async_receive_message(wrap(fn)) self.connect(tmB, tmA) while tmA.get_binding_state() == yogi.BindingState.RELEASED: pass while tmB.get_subscription_state( ) == yogi.SubscriptionState.UNSUBSCRIBED: pass # successfully receive non-cached message time.sleep( 0.01 ) # takes care of tmB receiving the bounced-back cached message it sent to tmA on connection with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) self.assertFalse(cached) tmB.async_receive_message(wrap(fn)) tmA.publish(msg) self.assertTrue(tmA.try_publish(msg)) with AsyncCall() as wrap: def fn(res, msg, cached): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) self.assertFalse(cached) tmA.async_receive_message(wrap(fn)) tmB.publish(msg) self.assertTrue(tmB.try_publish(msg)) # get cached message msg = tmA.get_cached_message() self.assertEqual(bytes([1, 2, 3]), msg) msg = tmB.get_cached_message() self.assertEqual(bytes([1, 2, 3]), msg)
def test_MasterSlaveTerminals(self): tmA = self.terminalsB['msMaster'] tmB = self.terminalsA['msSlave'] msg = bytes([1, 2, 3]) # publish without the terminals being bound self.assertRaises(yogi.Failure, lambda: tmA.publish(msg)) self.assertEqual(False, tmA.try_publish(msg)) self.assertRaises(yogi.Failure, lambda: tmB.publish(msg)) self.assertEqual(False, tmB.try_publish(msg)) # cancel receive message with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(msg) tmA.async_receive_message(wrap(fn)) tmA.cancel_receive_message() with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(msg) tmB.async_receive_message(wrap(fn)) tmB.cancel_receive_message() # establish connection self.connect(tmB, tmA) while tmA.get_binding_state() == yogi.BindingState.RELEASED: pass while tmB.get_subscription_state( ) == yogi.SubscriptionState.UNSUBSCRIBED: pass # successfully receive message with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) tmB.async_receive_message(wrap(fn)) tmA.publish(msg) self.assertTrue(tmA.try_publish(msg)) with AsyncCall() as wrap: def fn(res, msg): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), msg) tmA.async_receive_message(wrap(fn)) tmB.publish(msg) self.assertTrue(tmB.try_publish(msg))
def test_RawScatterGatherTerminal(self): tmA = self.terminalsA['sg'] tmB = self.terminalsB['sg'] bd = self.bindings['sg'] # cancel receive message with AsyncCall() as wrap: def fn(res, scattered_msg): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(scattered_msg) tmA.async_receive_scattered_message(wrap(fn)) tmA.cancel_receive_scattered_message() # ignore message self.connect(bd, tmB) msg = bytes([1, 2, 3]) with AsyncCall() as wrap: def fn(res, scattered_msg): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), scattered_msg.message) scattered_msg.ignore() tmA.async_receive_scattered_message(wrap(fn)) with AsyncCall() as wrap2: def fn2(res, gathered_msg): self.assertEqual(yogi.Success(), res) self.assertTrue(gathered_msg.flags & yogi.GatherFlags.IGNORED) return yogi.ControlFlow.STOP tmB.async_scatter_gather(msg, wrap2(fn2)) # respond to message with AsyncCall() as wrap: def fn(res, scattered_msg): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), scattered_msg.message) response = bytes([4, 5, 6]) scattered_msg.respond(response) tmA.async_receive_scattered_message(wrap(fn)) with AsyncCall() as wrap2: def fn2(res, gathered_msg): self.assertEqual(yogi.Success(), res) self.assertTrue(gathered_msg.flags & yogi.GatherFlags.FINISHED) self.assertEqual(bytes([4, 5, 6]), gathered_msg.message) return yogi.ControlFlow.STOP tmB.async_scatter_gather(msg, wrap2(fn2)) # cancel operation with AsyncCall() as wrap: def fn(res, scattered_msg): self.assertEqual(yogi.Success(), res) self.assertEqual(bytes([1, 2, 3]), scattered_msg.message) # do not respond tmA.async_receive_scattered_message(wrap(fn)) with AsyncCall() as wrap2: def fn2(res, gathered_msg): self.assertEqual(yogi.Canceled(), res) self.assertIsNone(gathered_msg) operation = tmB.async_scatter_gather(msg, wrap2(fn2)) operation.cancel()