def setUpClass(cls):
cls.bot_id = str(uuid4())
cls.skill_id = str(uuid4())
cls._test_id_factory = ConversationIdFactoryForTest()
cls._claims_identity = ClaimsIdentity({}, False)
cls._claims_identity.claims[AuthenticationConstants.AUDIENCE_CLAIM] = cls.bot_id
cls._claims_identity.claims[AuthenticationConstants.APP_ID_CLAIM] = cls.skill_id
cls._claims_identity.claims[
AuthenticationConstants.SERVICE_URL_CLAIM
] = "http://testbot.com/api/messages"
cls._conversation_reference = ConversationReference(
conversation=ConversationAccount(id=str(uuid4())),
service_url="http://testbot.com/api/messages",
)
activity = Activity.create_message_activity()
activity.apply_conversation_reference(cls._conversation_reference)
skill = BotFrameworkSkill(
app_id=cls.skill_id,
id="skill",
skill_endpoint="http://testbot.com/api/messages",
)
cls._options = SkillConversationIdFactoryOptions(
from_bot_oauth_scope=cls.bot_id,
from_bot_id=cls.bot_id,
activity=activity,
bot_framework_skill=skill,
)
def _build_message_activity(
self, conversation_reference: ConversationReference) -> Activity:
if not conversation_reference:
raise TypeError(str(conversation_reference))
activity = Activity.create_message_activity()
activity.apply_conversation_reference(conversation_reference)
return activity
def create_begin_activity(self, action_id: str):
if action_id not in self.SkillAction:
raise Exception(
f'Unable to create begin activity for "${action_id}".')
# We only support one activity for Echo so no further checks are needed
activity = Activity.create_message_activity()
activity.name = self.SkillAction.MESSAGE.value
activity.text = "Begin the Echo Skill"
return activity
async def test_end_of_conversation_from_expect_replies_calls_delete_conversation_reference(
self,
):
activity_sent: Activity = None
# Callback to capture the parameters sent to the skill
async def capture_action(
from_bot_id: str, # pylint: disable=unused-argument
to_bot_id: str, # pylint: disable=unused-argument
to_uri: str, # pylint: disable=unused-argument
service_url: str, # pylint: disable=unused-argument
conversation_id: str, # pylint: disable=unused-argument
activity: Activity,
):
# Capture values sent to the skill so we can assert the right parameters were used.
nonlocal activity_sent
activity_sent = activity
eoc = Activity.create_end_of_conversation_activity()
expected_replies = list([eoc])
# Create a mock skill client to intercept calls and capture what is sent.
mock_skill_client = self._create_mock_skill_client(
capture_action, expected_replies=expected_replies
)
# Use Memory for conversation state
conversation_state = ConversationState(MemoryStorage())
dialog_options = self.create_skill_dialog_options(
conversation_state, mock_skill_client
)
# Create the SkillDialogInstance and the activity to send.
sut = SkillDialog(dialog_options, dialog_id="dialog")
activity_to_send = Activity.create_message_activity()
activity_to_send.delivery_mode = DeliveryModes.expect_replies
activity_to_send.text = str(uuid.uuid4())
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(activity_to_send),
conversation_state=conversation_state,
)
# Send something to the dialog to start it
await client.send_activity("hello")
simple_id_factory: SimpleConversationIdFactory = dialog_options.conversation_id_factory
self.assertEqual(0, len(simple_id_factory.conversation_refs))
self.assertEqual(1, simple_id_factory.create_count)
async def test_legacy_conversation_id_factory(self):
mock_adapter = Mock()
legacy_factory = LegacyConversationIdFactoryForTest()
conversation_reference = ConversationReference(
conversation=ConversationAccount(id=str(uuid4())),
service_url="http://testbot.com/api/messages",
)
conversation_id = await legacy_factory.create_skill_conversation_id(
conversation_reference
)
async def continue_conversation(
reference: ConversationReference,
callback: Callable,
bot_id: str = None,
claims_identity: ClaimsIdentity = None,
audience: str = None,
): # pylint: disable=unused-argument
# Invoke the callback created by the handler so we can assert the rest of the execution.
turn_context = TurnContext(
mock_adapter,
conversation_reference_extension.get_continuation_activity(
conversation_reference
),
)
await callback(turn_context)
async def send_activities(
context: TurnContext, activities: List[Activity]
): # pylint: disable=unused-argument
return [ResourceResponse(id="resourceId")]
mock_adapter.continue_conversation = continue_conversation
mock_adapter.send_activities = send_activities
activity = Activity.create_message_activity()
activity.apply_conversation_reference(conversation_reference)
sut = self.create_skill_handler_for_testing(mock_adapter, legacy_factory)
await sut.test_on_send_to_conversation(
self._claims_identity, conversation_id, activity
)
def test_create_message_activity(self):
# Act
result = Activity.create_message_activity()
# Assert
self.assertEqual(result.type, ActivityTypes.message)
