def makeConnection(self, identification=None):
self.client = yogi.TcpClient(self.scheduler, identification)
self.server = yogi.TcpServer(self.scheduler, self.ADDRESS, self.PORT,
identification)
def accept_handler(res, connection):
self.accept_handler_res = res
self.server_connection = connection
self.server.async_accept(5.0, accept_handler)
def connect_handler(res, connection):
self.connect_handler_res = res
self.client_connection = connection
self.client.async_connect(self.ADDRESS, self.PORT, 5.0,
connect_handler)
while self.accept_handler_res is None or self.connect_handler_res is None:
pass
self.assertEqual(yogi.Success(), self.accept_handler_res)
self.assertIsNotNone(self.server_connection)
self.assertEqual(yogi.Success(), self.connect_handler_res)
self.assertIsNotNone(self.client_connection)
def test_success():
"""Checks the Success class"""
assert yogi.Success(1)
assert yogi.Success(0)
assert str(yogi.Success(1)) == str(yogi.Result(1))
assert yogi.Success(1) == yogi.Result(1)
assert isinstance(yogi.Success(1), yogi.Result)
def fn(res, request):
self.assertEqual(yogi.Success(), res)
self.assertEqual("test", request.message.value)
response = tmA.make_response_message()
response.value = 123
request.respond(response)
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)
def fn(res, scattered_msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual("test", scattered_msg.message.value)
response = tmA.make_gather_message()
response.value = 123
scattered_msg.respond(response)
def handler_fn(res, ev, evres, info):
assert isinstance(res, yogi.Result)
assert res == yogi.Success()
assert isinstance(ev, yogi.BranchEvents)
assert ev == yogi.BranchEvents.BRANCH_DISCOVERED
assert isinstance(evres, yogi.Result)
assert evres.error_code == yogi.ErrorCode.BUSY
assert isinstance(info, yogi.BranchDiscoveredEventInfo)
nonlocal called
called = True
def test_success(self):
self.assertTrue(yogi.Success(1))
self.assertTrue(yogi.Success(0))
self.assertRaises(AssertionError, lambda: yogi.Success(-1))
self.assertEqual(str(yogi.Success(1)), str(yogi.Result(1)))
self.assertEqual(yogi.Success(1), yogi.Result(1))
self.assertIsInstance(yogi.Success(1), yogi.Result)
def test_cancel_await_death(self):
self.makeConnection()
def fn(res):
self.death_handler_res = res
self.server_connection.async_await_death(fn)
self.server_connection.cancel_await_death()
while self.death_handler_res is None:
pass
self.assertNotEqual(yogi.Success(), self.death_handler_res)
def test_start(self):
fn_res = None
fn_called = False
def fn(res):
nonlocal fn_res, fn_called
fn_res = res
fn_called = True
self.timer.start_async(yogi.Duration.from_milliseconds(1), fn)
while not fn_called:
self.context.run_one()
self.assertIsInstance(fn_res, yogi.Success)
self.assertEqual(fn_res, yogi.Success())
def test_await_death(self):
self.makeConnection()
self.server_connection.assign(self.endpointA, 0.05)
self.client_connection.assign(self.endpointB, 0.05)
def fn(res):
self.death_handler_res = res
self.server_connection.async_await_death(fn)
self.assertRaises(yogi.Failure,
lambda: self.server_connection.async_await_death(fn))
self.client_connection.destroy()
while self.death_handler_res is None:
pass
self.assertNotEqual(yogi.Success(), self.death_handler_res)
def test_await_signal(self):
fn_res = None
fn_signal = None
fn_sigarg = None
fn_called = False
def fn(res, signal, sigarg):
nonlocal fn_res, fn_signal, fn_sigarg, fn_called
fn_res = res
fn_signal = signal
fn_sigarg = sigarg
fn_called = True
sigset = yogi.SignalSet(self.context,
yogi.Signals.TERM | yogi.Signals.USR5)
sigset.await_signal_async(fn)
yogi.raise_signal(yogi.Signals.TERM, 123)
self.context.poll()
self.assertTrue(fn_called)
self.assertIsInstance(fn_res, yogi.Success)
self.assertEqual(fn_res, yogi.Success())
self.assertIsInstance(fn_signal, yogi.Signals)
self.assertEqual(fn_signal, yogi.Signals.TERM)
self.assertEqual(fn_sigarg, 123)
fn_called = False
sigset.await_signal_async(fn)
yogi.raise_signal(yogi.Signals.TERM)
self.context.poll()
self.assertTrue(fn_called)
self.assertEqual(fn_sigarg, None)
def fn2(res, signal):
nonlocal fn_called
fn_called = True
fn_called = False
sigset.await_signal_async(fn2)
yogi.raise_signal(yogi.Signals.TERM, 123)
self.context.poll()
self.assertTrue(fn_called)
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(123, msg.value)
self.assertFalse(cached)
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual('Hello', msg.value)
self.assertTrue(cached)
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(123, msg.value)
def fn(res, scattered_msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual("test", scattered_msg.message.value)
def fn(res, state):
self.assertEqual(yogi.Success(), res)
self.assertEqual(yogi.SubscriptionState.UNSUBSCRIBED, state)
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual('Mate', msg.value.first)
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)
def test_init(self):
self.assertRaises(Exception, lambda: yogi.Success(-1))
yogi.Success(1)
yogi.Success(0)
yogi.Success()
def test_comparison(self):
self.assertNotEqual(yogi.Success(), yogi.Result(123))
self.assertEqual(yogi.Success(123), yogi.Result(123))
self.assertEqual(yogi.Success(), yogi.Result(0))
def fn(res, request):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), request.message)
def fn2(res, gathered_msg):
self.assertEqual(yogi.Success(), res)
self.assertTrue(gathered_msg.flags
& yogi.GatherFlags.FINISHED)
self.assertEqual(123, gathered_msg.message.value)
return yogi.ControlFlow.STOP
def fn(res, msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
def fn(res, scattered_msg):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), scattered_msg.message)
def fn2(res, gathered_msg):
self.assertEqual(yogi.Success(), res)
self.assertTrue(gathered_msg.flags
& yogi.GatherFlags.IGNORED)
return yogi.ControlFlow.STOP
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertFalse(cached)
self.assertEqual(verbosity.value, msg.value)
def fn(res, msg, cached):
self.assertEqual(yogi.Success(), res)
self.assertEqual(bytes([1, 2, 3]), msg)
self.assertFalse(cached)
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)
def fn(res, request):
self.assertEqual(yogi.Success(), res)
self.assertEqual("test", request.message.value)
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)
