async def test_begin_dialog_options_validation(self):
dialog_options = SkillDialogOptions()
sut = SkillDialog(dialog_options, dialog_id="dialog_id")
# empty options should raise
client = DialogTestClient("test", sut)
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
# non DialogArgs should raise
client = DialogTestClient("test", sut, {})
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
# Activity in DialogArgs should be set
client = DialogTestClient("test", sut, BeginSkillDialogOptions(None))
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
# Only Message and Event activities are supported
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(
Activity(type=ActivityTypes.conversation_update)),
)
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
async def begin_dialog_calls_skill(self, deliver_mode: str):
activity_sent = None
from_bot_id_sent = None
to_bot_id_sent = None
to_url_sent = None
async def capture(
from_bot_id: str,
to_bot_id: str,
to_url: str,
service_url: str, # pylint: disable=unused-argument
conversation_id: str, # pylint: disable=unused-argument
activity: Activity,
):
nonlocal from_bot_id_sent, to_bot_id_sent, to_url_sent, activity_sent
from_bot_id_sent = from_bot_id
to_bot_id_sent = to_bot_id
to_url_sent = to_url
activity_sent = activity
mock_skill_client = self._create_mock_skill_client(capture)
conversation_state = ConversationState(MemoryStorage())
dialog_options = SkillDialogTests.create_skill_dialog_options(
conversation_state, mock_skill_client)
sut = SkillDialog(dialog_options, "dialog_id")
activity_to_send = MessageFactory.text(str(uuid.uuid4()))
activity_to_send.delivery_mode = deliver_mode
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(activity=activity_to_send),
conversation_state=conversation_state,
)
# Send something to the dialog to start it
await client.send_activity(MessageFactory.text("irrelevant"))
# Assert results and data sent to the SkillClient for fist turn
assert dialog_options.bot_id == from_bot_id_sent
assert dialog_options.skill.app_id == to_bot_id_sent
assert dialog_options.skill.skill_endpoint == to_url_sent
assert activity_to_send.text == activity_sent.text
assert DialogTurnStatus.Waiting == client.dialog_turn_result.status
# Send a second message to continue the dialog
await client.send_activity(MessageFactory.text("Second message"))
# Assert results for second turn
assert activity_sent.text == "Second message"
assert DialogTurnStatus.Waiting == client.dialog_turn_result.status
# Send EndOfConversation to the dialog
await client.send_activity(
Activity(type=ActivityTypes.end_of_conversation))
# Assert we are done.
assert DialogTurnStatus.Complete == client.dialog_turn_result.status
async def test_begin_dialog_calls_skill(self):
activity_sent = None
from_bot_id_sent = None
to_bot_id_sent = None
to_url_sent = None
async def capture(
from_bot_id: str,
to_bot_id: str,
to_url: str,
service_url: str, # pylint: disable=unused-argument
conversation_id: str, # pylint: disable=unused-argument
activity: Activity,
):
nonlocal from_bot_id_sent, to_bot_id_sent, to_url_sent, activity_sent
from_bot_id_sent = from_bot_id
to_bot_id_sent = to_bot_id
to_url_sent = to_url
activity_sent = activity
mock_skill_client = self._create_mock_skill_client(capture)
conversation_state = ConversationState(MemoryStorage())
dialog_options = self._create_skill_dialog_options(
conversation_state, mock_skill_client)
sut = SkillDialog(dialog_options, "dialog_id")
activity_to_send = MessageFactory.text(str(uuid.uuid4()))
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(activity=activity_to_send),
conversation_state=conversation_state,
)
await client.send_activity(MessageFactory.text("irrelevant"))
assert dialog_options.bot_id == from_bot_id_sent
assert dialog_options.skill.app_id == to_bot_id_sent
assert dialog_options.skill.skill_endpoint == to_url_sent
assert activity_to_send.text == activity_sent.text
assert DialogTurnStatus.Waiting == client.dialog_turn_result.status
await client.send_activity(MessageFactory.text("Second message"))
assert activity_sent.text == "Second message"
assert DialogTurnStatus.Waiting == client.dialog_turn_result.status
await client.send_activity(
Activity(type=ActivityTypes.end_of_conversation))
assert DialogTurnStatus.Complete == client.dialog_turn_result.status
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_begin_dialog_options_validation(self):
dialog_options = SkillDialogOptions()
sut = SkillDialog(dialog_options, dialog_id="dialog_id")
# empty options should raise
client = DialogTestClient("test", sut)
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
# non DialogArgs should raise
client = DialogTestClient("test", sut, {})
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
# Activity in DialogArgs should be set
client = DialogTestClient("test", sut, BeginSkillDialogOptions(None))
with self.assertRaises(TypeError):
await client.send_activity("irrelevant")
async def test_should_not_intercept_oauth_cards_for_empty_connection_name(
self):
connection_name = "connectionName"
first_response = ExpectedReplies(activities=[
SkillDialogTests.create_oauth_card_attachment_activity(
"https://test")
])
sequence = 0
async def post_return():
nonlocal sequence
if sequence == 0:
result = InvokeResponse(body=first_response,
status=HTTPStatus.OK)
else:
result = InvokeResponse(status=HTTPStatus.OK)
sequence += 1
return result
mock_skill_client = self._create_mock_skill_client(None, post_return)
conversation_state = ConversationState(MemoryStorage())
dialog_options = SkillDialogTests.create_skill_dialog_options(
conversation_state, mock_skill_client)
sut = SkillDialog(dialog_options, dialog_id="dialog")
activity_to_send = SkillDialogTests.create_send_activity()
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(activity=activity_to_send, ),
conversation_state=conversation_state,
)
client.test_adapter.add_exchangeable_token(connection_name, "test",
"User1", "https://test",
"https://test1")
final_activity = await client.send_activity(
MessageFactory.text("irrelevant"))
self.assertIsNotNone(final_activity)
self.assertEqual(len(final_activity.attachments), 1)
async def test_should_throw_on_post_failure(self):
# This mock client will fail
mock_skill_client = self._create_mock_skill_client(None, 500)
conversation_state = ConversationState(MemoryStorage())
dialog_options = self._create_skill_dialog_options(
conversation_state, mock_skill_client)
sut = SkillDialog(dialog_options, "dialog_id")
activity_to_send = MessageFactory.text(str(uuid.uuid4()))
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(activity=activity_to_send),
conversation_state=conversation_state,
)
# A send should raise an exception
with self.assertRaises(Exception):
await client.send_activity("irrelevant")
async def handle_action_step(self, step_context: WaterfallStepContext):
action = str(step_context.result.value).lower()
if action == "login":
return await step_context.begin_dialog(SsoSignInDialog.__name__)
if action == "logout":
await step_context.context.adapter.sign_out_user(
step_context.context, self._connection_name)
await step_context.context.send_activity(
"You have been signed out.")
return await step_context.next(step_context.result)
if action == "show token":
token = await step_context.context.adapter.get_user_token(
step_context.context, self._connection_name)
if token is None:
await step_context.context.send_activity(
"User has no cached token.")
else:
await step_context.context.send_activity(
f"Here is your current SSO token: { token.token }")
return await step_context.next(step_context.result)
if action in ["call skill (with sso)", "call skill (without sso)"]:
begin_skill_activity = Activity(type=ActivityTypes.event,
name="Sso")
return await step_context.begin_dialog(
self.skill_dialog_id,
BeginSkillDialogOptions(activity=begin_skill_activity),
)
if action == "back":
return DialogTurnResult(DialogTurnStatus.Complete)
# This should never be hit since the previous prompt validates the choice
raise Exception(f"Unrecognized action: {action}")
async def test_cancel_dialog_sends_eoc(self):
activity_sent = None
async def capture(
from_bot_id: str, # pylint: disable=unused-argument
to_bot_id: str, # pylint: disable=unused-argument
to_url: str, # pylint: disable=unused-argument
service_url: str, # pylint: disable=unused-argument
conversation_id: str, # pylint: disable=unused-argument
activity: Activity,
):
nonlocal activity_sent
activity_sent = activity
mock_skill_client = self._create_mock_skill_client(capture)
conversation_state = ConversationState(MemoryStorage())
dialog_options = SkillDialogTests.create_skill_dialog_options(
conversation_state, mock_skill_client
)
sut = SkillDialog(dialog_options, "dialog_id")
activity_to_send = MessageFactory.text(str(uuid.uuid4()))
client = DialogTestClient(
"test",
sut,
BeginSkillDialogOptions(activity=activity_to_send),
conversation_state=conversation_state,
)
# Send something to the dialog to start it
await client.send_activity(MessageFactory.text("irrelevant"))
# Cancel the dialog so it sends an EoC to the skill
await client.dialog_context.cancel_all_dialogs()
assert activity_sent
assert activity_sent.type == ActivityTypes.end_of_conversation