async def test_middleware_set_receive_activity_internal(self):
class PrintMiddleware(object):
def __init__(self):
super(PrintMiddleware, self).__init__()
async def on_process_request(self, context_or_string,
next_middleware):
print('PrintMiddleware says: %s.' % context_or_string)
return next_middleware
class ModifyInputMiddleware(Middleware):
def __init__(self):
super(ModifyInputMiddleware, self).__init__()
async def on_process_request(self, context_or_string,
next_middleware):
context_or_string = 'Hello'
print(context_or_string)
print('Here is the current context_or_string: %s' %
context_or_string)
return next_middleware
async def request_handler(context_or_string):
assert context_or_string == 'Hello'
middleware_set = MiddlewareSet().use(PrintMiddleware())
middleware_set.use(ModifyInputMiddleware())
await middleware_set.receive_activity_internal('Bye', request_handler)
async def test_mixed_middleware_anonymous_last(self):
called_regular_middleware = False
called_anonymous_middleware = False
middleware_set = MiddlewareSet()
class MyFirstMiddleware(Middleware):
async def on_process_request(self, context, logic):
nonlocal called_regular_middleware, called_anonymous_middleware
assert not called_anonymous_middleware
called_regular_middleware = True
return await logic()
async def anonymous_method(context, logic):
nonlocal called_regular_middleware, called_anonymous_middleware
assert called_regular_middleware
called_anonymous_middleware = True
return await logic()
middleware_set.use(MyFirstMiddleware())
middleware_set.use(AnonymousReceiveMiddleware(anonymous_method))
await middleware_set.receive_activity(None)
assert called_regular_middleware
assert called_anonymous_middleware
def test_invalid_middleware_should_not_be_added_to_middleware_set(self):
middleware_set = MiddlewareSet()
try:
middleware_set.use(2)
except TypeError:
pass
except Exception as e:
raise e
else:
raise AssertionError('MiddlewareSet.use(): should not have added an invalid middleware.')
async def test_anonymous_middleware(self):
did_run = False
middleware_set = MiddlewareSet()
async def processor(context, logic):
nonlocal did_run
did_run = True
return await logic()
middleware_set.use(AnonymousReceiveMiddleware(processor))
assert not did_run
await middleware_set.receive_activity(None)
assert did_run
async def test_middleware_set_receive_activity_internal(self):
class PrintMiddleware:
async def on_turn(self, context_or_string, next_middleware):
print("PrintMiddleware says: %s." % context_or_string)
return next_middleware
class ModifyInputMiddleware(Middleware):
async def on_turn(
self, context: TurnContext, logic: Callable[[TurnContext], Awaitable]
):
context = "Hello"
print(context)
print("Here is the current context_or_string: %s" % context)
return logic
async def request_handler(context_or_string):
assert context_or_string == "Hello"
middleware_set = MiddlewareSet().use(PrintMiddleware())
middleware_set.use(ModifyInputMiddleware())
await middleware_set.receive_activity_internal("Bye", request_handler)
async def test_anonymous_two_middleware_and_in_order(self):
called_first = False
called_second = False
middleware_set = MiddlewareSet()
async def processor_one(context, logic):
nonlocal called_first, called_second
called_first = True
assert not called_second
return await logic()
async def processor_two(context, logic):
nonlocal called_first, called_second
called_second = True
return await logic()
middleware_set.use(AnonymousReceiveMiddleware(processor_one))
middleware_set.use(AnonymousReceiveMiddleware(processor_two))
await middleware_set.receive_activity(None)
assert called_first
assert called_second