def __init__(
self,
configuration: dict,
dialog_id: str = None,
telemetry_client: BotTelemetryClient = NullTelemetryClient(),
):
super(MainDialog, self).__init__(dialog_id or MainDialog.__name__)
self._configuration = configuration
self.telemetry_client = telemetry_client
text_prompt = TextPrompt(TextPrompt.__name__)
text_prompt.telemetry_client = self.telemetry_client
booking_dialog = BookingDialog(telemetry_client=self._telemetry_client)
booking_dialog.telemetry_client = self.telemetry_client
wf_dialog = WaterfallDialog(
"WFDialog", [self.intro_step, self.act_step, self.final_step])
wf_dialog.telemetry_client = self.telemetry_client
self.add_dialog(text_prompt)
self.add_dialog(booking_dialog)
self.add_dialog(wf_dialog)
self.initial_dialog_id = "WFDialog"
def test_none_telemetry_client(self):
# arrange
dialog = WaterfallDialog("myId")
# act
dialog.telemetry_client = None
# assert
self.assertEqual(type(dialog.telemetry_client), NullTelemetryClient)
async def test_cancelling_waterfall_telemetry(self):
# Arrange
dialog_id = "waterfall"
index = 0
guid = "(guid)"
async def my_waterfall_step(step) -> DialogTurnResult:
await step.context.send_activity("step1 response")
return Dialog.end_of_turn
dialog = WaterfallDialog(dialog_id, [my_waterfall_step])
telemetry_client = create_autospec(NullTelemetryClient)
dialog.telemetry_client = telemetry_client
dialog_instance = DialogInstance()
dialog_instance.id = dialog_id
dialog_instance.state = {"instanceId": guid, "stepIndex": index}
# Act
await dialog.end_dialog(
TurnContext(TestAdapter(), Activity()),
dialog_instance,
DialogReason.CancelCalled,
)
# Assert
telemetry_props = telemetry_client.track_event.call_args_list[0][0][1]
self.assertEqual(3, len(telemetry_props))
self.assertEqual(dialog_id, telemetry_props["DialogId"])
self.assertEqual(my_waterfall_step.__qualname__,
telemetry_props["StepName"])
self.assertEqual(guid, telemetry_props["InstanceId"])
telemetry_client.track_event.assert_called_once()
def __init__(
self,
dialog_id: str = None,
telemetry_client: BotTelemetryClient = NullTelemetryClient(),
):
super(BookingDialog,
self).__init__(dialog_id or BookingDialog.__name__,
telemetry_client)
self.telemetry_client = telemetry_client
text_prompt = TextPrompt(TextPrompt.__name__)
text_prompt.telemetry_client = telemetry_client
waterfall_dialog = WaterfallDialog(
WaterfallDialog.__name__,
[
self.destination_step,
self.origin_step,
self.travel_date_step,
# self.confirm_step,
self.final_step,
],
)
waterfall_dialog.telemetry_client = telemetry_client
self.add_dialog(text_prompt)
# self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__))
self.add_dialog(
DateResolverDialog(DateResolverDialog.__name__,
self.telemetry_client))
self.add_dialog(waterfall_dialog)
self.initial_dialog_id = WaterfallDialog.__name__
def __init__(
self,
luis_recognizer: FlightBookingRecognizer,
booking_dialog: BookingDialog,
telemetry_client: BotTelemetryClient = None,
):
super(MainDialog, self).__init__(MainDialog.__name__)
self.telemetry_client = telemetry_client or NullTelemetryClient()
text_prompt = TextPrompt(TextPrompt.__name__)
text_prompt.telemetry_client = self.telemetry_client
booking_dialog.telemetry_client = self.telemetry_client
wf_dialog = WaterfallDialog(
"WFDialog", [self.intro_step, self.act_step, self.final_step])
wf_dialog.telemetry_client = self.telemetry_client
self._luis_recognizer = luis_recognizer
self._booking_dialog_id = booking_dialog.id
self.add_dialog(text_prompt)
self.add_dialog(booking_dialog)
self.add_dialog(wf_dialog)
self.initial_dialog_id = "WFDialog"
def __init__(self,
dialog_id: str = None,
telemetry_client: BotTelemetryClient = NullTelemetryClient()):
super(DateResolverDialog,
self).__init__(dialog_id or DateResolverDialog.__name__,
telemetry_client)
self.telemetry_client = telemetry_client
date_time_prompt = DateTimePrompt(
DateTimePrompt.__name__,
DateResolverDialog.datetime_prompt_validator)
date_time_prompt.telemetry_client = telemetry_client
waterfall_dialog = WaterfallDialog(
WaterfallDialog.__name__ + '2',
[self.initial_step, self.final_step])
waterfall_dialog.telemetry_client = telemetry_client
self.add_dialog(date_time_prompt)
self.add_dialog(waterfall_dialog)
self.initial_dialog_id = WaterfallDialog.__name__ + '2'
async def test_execute_sequence_waterfall_steps(self, MockTelemetry): # pylint: disable=invalid-name
# arrange
# Create new ConversationState with MemoryStorage and register the state as middleware.
convo_state = ConversationState(MemoryStorage())
telemetry = MockTelemetry()
# Create a DialogState property, DialogSet and register the WaterfallDialog.
dialog_state = convo_state.create_property("dialogState")
dialogs = DialogSet(dialog_state)
async def step1(step) -> DialogTurnResult:
await step.context.send_activity("bot responding.")
return Dialog.end_of_turn
async def step2(step) -> DialogTurnResult:
await step.context.send_activity("ending WaterfallDialog.")
return Dialog.end_of_turn
# act
my_dialog = WaterfallDialog("test", [step1, step2])
my_dialog.telemetry_client = telemetry
dialogs.add(my_dialog)
# Initialize TestAdapter
async def exec_test(turn_context: TurnContext) -> None:
dialog_context = await dialogs.create_context(turn_context)
results = await dialog_context.continue_dialog()
if results.status == DialogTurnStatus.Empty:
await dialog_context.begin_dialog("test")
else:
if results.status == DialogTurnStatus.Complete:
await turn_context.send_activity(results.result)
await convo_state.save_changes(turn_context)
adapt = TestAdapter(exec_test)
test_flow = TestFlow(None, adapt)
tf2 = await test_flow.send(BEGIN_MESSAGE)
tf3 = await tf2.assert_reply("bot responding.")
tf4 = await tf3.send("continue")
await tf4.assert_reply("ending WaterfallDialog.")
# assert
telemetry_calls = [
("WaterfallStart", {
"DialogId": "test"
}),
("WaterfallStep", {
"DialogId": "test",
"StepName": "Step1of2"
}),
("WaterfallStep", {
"DialogId": "test",
"StepName": "Step2of2"
}),
]
self.assert_telemetry_calls(telemetry, telemetry_calls)
async def test_ensure_end_dialog_called(self, MockTelemetry): # pylint: disable=invalid-name
# arrange
# Create new ConversationState with MemoryStorage and register the state as middleware.
convo_state = ConversationState(MemoryStorage())
telemetry = MockTelemetry()
# Create a DialogState property, DialogSet and register the WaterfallDialog.
dialog_state = convo_state.create_property("dialogState")
dialogs = DialogSet(dialog_state)
async def step1(step) -> DialogTurnResult:
await step.context.send_activity("step1 response")
return Dialog.end_of_turn
async def step2(step) -> DialogTurnResult:
await step.context.send_activity("step2 response")
return Dialog.end_of_turn
# act
my_dialog = WaterfallDialog("test", [step1, step2])
my_dialog.telemetry_client = telemetry
dialogs.add(my_dialog)
# Initialize TestAdapter
async def exec_test(turn_context: TurnContext) -> None:
dialog_context = await dialogs.create_context(turn_context)
await dialog_context.continue_dialog()
if not turn_context.responded:
await dialog_context.begin_dialog("test", None)
await convo_state.save_changes(turn_context)
adapt = TestAdapter(exec_test)
test_flow = TestFlow(None, adapt)
tf2 = await test_flow.send(BEGIN_MESSAGE)
tf3 = await tf2.assert_reply("step1 response")
tf4 = await tf3.send("continue")
tf5 = await tf4.assert_reply("step2 response")
await tf5.send(
"Should hit end of steps - this will restart the dialog and trigger COMPLETE event"
)
# assert
telemetry_calls = [
("WaterfallStart", {
"DialogId": "test"
}),
("WaterfallStep", {
"DialogId": "test",
"StepName": "Step1of2"
}),
("WaterfallStep", {
"DialogId": "test",
"StepName": "Step2of2"
}),
("WaterfallComplete", {
"DialogId": "test"
}),
("WaterfallStart", {
"DialogId": "test"
}),
("WaterfallStep", {
"DialogId": "test",
"StepName": "Step1of2"
}),
]
print(str(telemetry.track_event.call_args_list))
self.assert_telemetry_calls(telemetry, telemetry_calls)