start BotContext tests, refactor BotFrameworkAdapter and BotContext

Author: stevengum

libraries/botbuilder-core/botbuilder/core/bot_context.py

@@ -8,23 +8,39 @@
 from typing import List, Callable, Iterable, Tuple
 from botbuilder.schema import Activity, ActivityTypes, ConversationReference, ResourceResponse
 
-# from .bot_adapter import BotAdapter
-
 
 class BotContext(object):
  def __init__(self, adapter, request: Activity):
  self.adapter = adapter
- self.request: Activity = request
+ self.activity = request
  self.responses: List[Activity] = []
  self._services: dict = {}
- self._responded: bool = False
- self._on_send_activity: Callable[[]] = []
+ self._on_send_activities: Callable[[]] = []
  self._on_update_activity: Callable[[]] = []
  self._on_delete_activity: Callable[[]] = []
+ self.__responded: bool = False
 
- if not self.request:
+ if self.adapter is None:
+ raise TypeError('BotContext must be instantiated with an adapter.')
+ if self.activity is None:
  raise TypeError('BotContext must be instantiated with a request parameter of type Activity.')
 
+ def copy_to(self, context: 'BotContext') -> None:
+ for attribute in ['adapter', 'activity', 'responded', '_services',
+ '_on_send_activities', '_on_update_activity', '_on_delete_activity']:
+ setattr(context, attribute, getattr(self, attribute))
+
+ @property
+ def responded(self):
+ return self.__responded
+
+ @responded.setter
+ def responded(self, value):
+ if type(value) != bool or value is False:
+ raise ValueError('BotContext.responded(): cannot set BotContext.responded to False.')
+ else:
+ self.__responded = value
+
  def get(self, key: str) -> object:
  if not key or not isinstance(key, str):
  raise TypeError('"key" must be a valid string.')
@@ -56,7 +72,7 @@ def set(self, key: str, value: object) -> None:
  self._services[key] = value
 
  async def send_activity(self, *activity_or_text: Tuple[Activity, str]):
- reference = BotContext.get_conversation_reference(self.request)
+ reference = BotContext.get_conversation_reference(self.activity)
  output = [BotContext.apply_conversation_reference(
  Activity(text=a, type='message') if isinstance(a, str) else a, reference)
  for a in activity_or_text]
@@ -68,7 +84,7 @@ async def callback(context: 'BotContext', output):
  context._responded = True
  return responses
 
- await self._emit(self._on_send_activity, output, callback(self, output))
+ await self._emit(self._on_send_activities, output, callback(self, output))
 
  async def update_activity(self, activity: Activity):
  return await self._emit(self._on_update_activity, activity, self.adapter.update_activity(self, activity))

libraries/botbuilder-core/botbuilder/core/bot_framework_adapter.py

@@ -3,7 +3,10 @@
 
 import asyncio
 from typing import List, Callable
-from botbuilder.schema import Activity, ChannelAccount, ConversationReference, ConversationsResult
+from botbuilder.schema import (Activity, ChannelAccount,
+ ConversationAccount,
+ ConversationParameters, ConversationReference,
+ ConversationsResult, ConversationResourceResponse)
 from botframework.connector import ConnectorClient
 from botframework.connector.auth import (MicrosoftAppCredentials,
  JwtTokenValidation, SimpleCredentialProvider)
@@ -29,12 +32,56 @@ def __init__(self, settings: BotFrameworkAdapterSettings):
  self._credentials = MicrosoftAppCredentials(self.settings.app_id, self.settings.app_password)
  self._credential_provider = SimpleCredentialProvider(self.settings.app_id, self.settings.app_password)
 
- async def process_request(self, req, auth_header: str, logic: Callable):
- request = await self.parse_request(req)
+ async def continue_conversation(self, reference: ConversationReference, logic):
+ """
+ Continues a conversation with a user. This is often referred to as the bots "Proactive Messaging"
+ flow as its lets the bot proactively send messages to a conversation or user that its already
+ communicated with. Scenarios like sending notifications or coupons to a user are enabled by this
+ method.
+ :param reference:
+ :param logic:
+ :return:
+ """
+ request = BotContext.apply_conversation_reference(Activity(), reference, is_incoming=True)
+ context = self.create_context(request)
+ return await self.run_middleware(context, logic)
+
+ async def create_conversation(self, reference: ConversationReference, logic):
+ try:
+ if reference.service_url is None:
+ raise TypeError('BotFrameworkAdapter.create_conversation(): reference.service_url cannot be None.')
+
+ # Create conversation
+ parameters = ConversationParameters(bot=reference.bot)
+ client = self.create_connector_client(reference.service_url)
+
+ resource_response = await client.conversations.create_conversation_async(parameters)
+ request = BotContext.apply_conversation_reference(Activity(), reference, is_incoming=True)
+ request.conversation = ConversationAccount(id=resource_response.id)
+ if resource_response.service_url:
+ request.service_url = resource_response.service_url
+
+ context = self.create_context(request)
+ return await self.run_middleware(context, logic)
+
+ except Exception as e:
+ raise e
+
+ async def process_activity(self, req, auth_header: str, logic: Callable):
+ """
+ Processes an activity received by the bots web server. This includes any messages sent from a
+ user and is the method that drives what's often referred to as the bots "Reactive Messaging"
+ flow.
+ :param req:
+ :param auth_header:
+ :param logic:
+ :return:
+ """
+ activity = await self.parse_request(req)
  auth_header = auth_header or ''
 
- await self.authenticate_request(request, auth_header)
- context = self.create_context(request)
+ await self.authenticate_request(activity, auth_header)
+ context = self.create_context(activity)
 
  return await self.run_middleware(context, logic)
 
@@ -84,22 +131,34 @@ async def validate_activity(activity: Activity):
  return req
 
  async def update_activity(self, context: BotContext, activity: Activity):
+ """
+ Replaces an activity that was previously sent to a channel. It should be noted that not all
+ channels support this feature.
+ :param context:
+ :param activity:
+ :return:
+ """
  try:
- connector_client = ConnectorClient(self._credentials, activity.service_url)
- connector_client.config.add_user_agent(USER_AGENT)
- return await connector_client.conversations.update_activity_async(
+ client = self.create_connector_client(activity.service_url)
+ return await client.conversations.update_activity_async(
  activity.conversation.id,
  activity.conversation.activity_id,
  activity)
  except Exception as e:
  raise e
 
  async def delete_activity(self, context: BotContext, conversation_reference: ConversationReference):
+ """
+ Deletes an activity that was previously sent to a channel. It should be noted that not all
+ channels support this feature.
+ :param context:
+ :param conversation_reference:
+ :return:
+ """
  try:
- connector_client = ConnectorClient(self._credentials, conversation_reference.service_url)
- connector_client.config.add_user_agent(USER_AGENT)
- await connector_client.conversations.delete_activity_async(conversation_reference.conversation.id,
- conversation_reference.activity_id)
+ client = self.create_connector_client(conversation_reference.service_url)
+ await client.conversations.delete_activity_async(conversation_reference.conversation.id,
+ conversation_reference.activity_id)
  except Exception as e:
  raise e
 
@@ -116,9 +175,8 @@ async def send_activity(self, context: BotContext, activities: List[Activity]):
  else:
  await asyncio.sleep(delay_in_ms)
  else:
- connector_client = ConnectorClient(self._credentials, activity.service_url)
- connector_client.config.add_user_agent(USER_AGENT)
- await connector_client.conversations.send_to_conversation_async(activity.conversation.id, activity)
+ client = self.create_connector_client(activity.service_url)
+ await client.conversations.send_to_conversation_async(activity.conversation.id, activity)
  except Exception as e:
  raise e
 
@@ -137,8 +195,7 @@ async def delete_conversation_member(self, context: BotContext, member_id: str)
  'conversation.id')
  service_url = context.request.service_url
  conversation_id = context.request.conversation.id
- client = ConnectorClient(self._credentials, service_url)
- client.config.add_user_agent(USER_AGENT)
+ client = self.create_connector_client(service_url)
  return await client.conversations.delete_conversation_member_async(conversation_id, member_id)
  except AttributeError as attr_e:
  raise attr_e
@@ -164,8 +221,7 @@ async def get_activity_members(self, context: BotContext, activity_id: str):
  'context.activity.id')
  service_url = context.request.service_url
  conversation_id = context.request.conversation.id
- client = ConnectorClient(self._credentials, service_url)
- client.config.add_user_agent(USER_AGENT)
+ client = self.create_connector_client(service_url)
  return await client.conversations.get_activity_members_async(conversation_id, activity_id)
  except Exception as e:
  raise e
@@ -184,8 +240,7 @@ async def get_conversation_members(self, context: BotContext):
  'conversation.id')
  service_url = context.request.service_url
  conversation_id = context.request.conversation.id
- client = ConnectorClient(self._credentials, service_url)
- client.config.add_user_agent(USER_AGENT)
+ client = self.create_connector_client(service_url)
  return await client.conversations.get_conversation_members_async(conversation_id)
  except Exception as e:
  raise e
@@ -199,6 +254,10 @@ async def get_conversations(self, service_url: str, continuation_token: str=None
  :param continuation_token:
  :return:
  """
- client = ConnectorClient(self._credentials, service_url)
- client.config.add_user_agent(USER_AGENT)
+ client = self.create_connector_client(service_url)
  return await client.conversations.get_conversations_async(continuation_token)
+
+ def create_connector_client(self, service_url: str) -> ConnectorClient:
+ client = ConnectorClient(self._credentials, base_url=service_url)
+ client.config.add_user_agent(USER_AGENT)
+ return client

libraries/botbuilder-core/tests/test_bot_context.py

@@ -0,0 +1,58 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import pytest
+
+from botbuilder.schema import Activity
+from botbuilder.core import BotContext, TestAdapter
+
+ACTIVITY = Activity(id='1', type='message', text='test')
+ADAPTER = TestAdapter(None)
+
+
+class TestBotContext:
+ def test_should_create_context_with_request_and_adapter(self):
+ context = BotContext(ADAPTER, ACTIVITY)
+
+ def test_should_not_create_context_without_request(self):
+ try:
+ context = BotContext(ADAPTER, None)
+ except TypeError:
+ pass
+ except Exception as e:
+ raise e
+
+ def test_should_not_create_context_without_adapter(self):
+ try:
+ context = BotContext(None, ACTIVITY)
+ except TypeError:
+ pass
+ except Exception as e:
+ raise e
+
+ def test_copy_to_should_copy_references(self):
+ old_adapter = TestAdapter(None)
+ old_activity = Activity(id='2', type='message', text='test copy')
+ old_context = BotContext(old_adapter, old_activity)
+ old_context.responded = True
+
+ adapter = TestAdapter(None)
+ new_context = BotContext(adapter, ACTIVITY)
+ old_context.copy_to(new_context)
+
+ assert new_context.adapter == old_adapter
+ assert new_context.activity == old_activity
+ assert new_context.responded is True
+
+ def test_should_not_be_able_to_set_responded_to_True(self):
+ context = BotContext(ADAPTER, ACTIVITY)
+ context.responded = True
+
+ def test_should_not_be_able_to_set_responded_to_False(self):
+ context = BotContext(ADAPTER, ACTIVITY)
+ try:
+ context.responded = False
+ except ValueError:
+ pass
+ except Exception as e:
+ raise e

libraries/botbuilder-core/tests/test_test_adapter.py

@@ -16,47 +16,47 @@ class TestTestAdapter:
  async def test_should_call_bog_logic_when_receive_activity_is_called(self):
  async def logic(context: BotContext):
  assert context
- assert context.request
- assert context.request.type == 'message'
- assert context.request.text == 'test'
- assert context.request.id
- assert context.request.from_property
- assert context.request.recipient
- assert context.request.conversation
- assert context.request.channel_id
- assert context.request.service_url
+ assert context.activity
+ assert context.activity.type == 'message'
+ assert context.activity.text == 'test'
+ assert context.activity.id
+ assert context.activity.from_property
+ assert context.activity.recipient
+ assert context.activity.conversation
+ assert context.activity.channel_id
+ assert context.activity.service_url
  adapter = TestAdapter(logic)
  await adapter.receive_activity('test')
 
  @pytest.mark.asyncio
  async def test_should_support_receive_activity_with_activity(self):
  async def logic(context: BotContext):
- assert context.request.type == 'message'
- assert context.request.text == 'test'
+ assert context.activity.type == 'message'
+ assert context.activity.text == 'test'
  adapter = TestAdapter(logic)
  await adapter.receive_activity(Activity(type='message', text='test'))
 
  @pytest.mark.asyncio
  async def test_should_set_activity_type_when_receive_activity_receives_activity_without_type(self):
  async def logic(context: BotContext):
- assert context.request.type == 'message'
- assert context.request.text == 'test'
+ assert context.activity.type == 'message'
+ assert context.activity.text == 'test'
  adapter = TestAdapter(logic)
  await adapter.receive_activity(Activity(text='test'))
 
  @pytest.mark.asyncio
  async def test_should_support_custom_activity_id_in_receive_activity(self):
  async def logic(context: BotContext):
- assert context.request.id == 'myId'
- assert context.request.type == 'message'
- assert context.request.text == 'test'
+ assert context.activity.id == 'myId'
+ assert context.activity.type == 'message'
+ assert context.activity.text == 'test'
  adapter = TestAdapter(logic)
  await adapter.receive_activity(Activity(type='message', text='test', id='myId'))
 
  @pytest.mark.asyncio
  async def test_should_call_bot_logic_when_send_is_called(self):
  async def logic(context: BotContext):
- assert context.request.text == 'test'
+ assert context.activity.text == 'test'
  adapter = TestAdapter(logic)
  await adapter.send('test')
 

samples/Echo.Connector.Bot.Adapter/main.py

@@ -24,14 +24,14 @@ async def create_reply_activity(request_activity, text) -> Activity:
 
 
 async def handle_message(context: BotContext) -> web.Response:
- response = await create_reply_activity(context.request, 'You said %s.' % context.request.text)
+ response = await create_reply_activity(context.activity, 'You said %s.' % context.activity.text)
  await context.send_activity(response)
  return web.Response(status=202)
 
 
 async def handle_conversation_update(context: BotContext) -> web.Response:
- if context.request.members_added[0].id != context.request.recipient.id:
- response = await create_reply_activity(context.request, 'Welcome to the Echo Adapter Bot!')
+ if context.activity.members_added[0].id != context.activity.recipient.id:
+ response = await create_reply_activity(context.activity, 'Welcome to the Echo Adapter Bot!')
  await context.send_activity(response)
  return web.Response(status=200)
 
@@ -41,9 +41,9 @@ async def unhandled_activity() -> web.Response:
 
 
 async def request_handler(context: BotContext) -> web.Response:
- if context.request.type == 'message':
+ if context.activity.type == 'message':
  return await handle_message(context)
- elif context.request.type == 'conversationUpdate':
+ elif context.activity.type == 'conversationUpdate':
  return await handle_conversation_update(context)
  else:
  return await unhandled_activity()
@@ -54,7 +54,7 @@ async def messages(req: web.web_request) -> web.Response:
  activity = Activity().deserialize(body)
  auth_header = req.headers['Authorization'] if 'Authorization' in req.headers else ''
  try:
- return await ADAPTER.process_request(activity, auth_header, request_handler)
+ return await ADAPTER.process_activity(activity, auth_header, request_handler)
  except Exception as e:
  raise e