async def test_message_processor(default_processor):
out = CollectingOutputChannel()
await default_processor.handle_message(
UserMessage('/greet{"name":"Core"}', out))
assert {
'recipient_id': 'default',
'text': 'hey there Core!'
} == out.latest_output()
async def receive(request: Request) -> HTTPResponse:
sender_id = await self._extract_sender(request)
text = self._extract_message(request)
input_channel = self._extract_input_channel(request)
metadata = self.get_metadata(request)
collector = CollectingOutputChannel()
# noinspection PyBroadException
try:
message = UserMessage(
text,
collector,
sender_id,
input_channel=input_channel,
metadata=metadata,
)
await on_new_message(message)
except CancelledError:
logger.error("Message handling timed out for "
"user message '{}'.".format(text))
except Exception:
logger.exception("An exception occured while handling "
"user message '{}'.".format(text))
return response.json(
self.__filter_confidence_below_threshold(
request=request,
message=collector.messages,
sender_id=sender_id))
async def test_2nd_affirmation_failed(intent_which_lets_action_give_up: Text):
tracker = DialogueStateTracker.from_events(
"some-sender",
evts=[
# User sends message with low NLU confidence
*_message_requiring_fallback(),
ActiveLoop(ACTION_TWO_STAGE_FALLBACK_NAME),
# Action asks user to affirm
*_two_stage_clarification_request(),
ActionExecuted(ACTION_LISTEN_NAME),
# User denies suggested intents
UserUttered("hi", {"name": USER_INTENT_OUT_OF_SCOPE}),
# Action asks user to rephrase
*_two_stage_clarification_request(),
# User rephrased with low confidence
*_message_requiring_fallback(),
# Actions asks user to affirm for the last time
*_two_stage_clarification_request(),
ActionExecuted(ACTION_LISTEN_NAME),
# User denies suggested intents for the second time
UserUttered("hi", {"name": intent_which_lets_action_give_up}),
],
)
domain = Domain.empty()
action = TwoStageFallbackAction()
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.responses),
tracker,
domain,
)
assert events == [ActiveLoop(None), UserUtteranceReverted()]
async def execute_action(request: Request, conversation_id: Text):
request_params = request.json
action_to_execute = request_params.get("name", None)
if not action_to_execute:
raise ErrorResponse(
400,
"BadRequest",
"Name of the action not provided in request body.",
{"parameter": "name", "in": "body"},
)
policy = request_params.get("policy", None)
confidence = request_params.get("confidence", None)
verbosity = event_verbosity_parameter(request, EventVerbosity.AFTER_RESTART)
try:
out = CollectingOutputChannel()
await app.agent.execute_action(
conversation_id, action_to_execute, out, policy, confidence
)
except Exception as e:
logger.debug(traceback.format_exc())
raise ErrorResponse(
500,
"ConversationError",
"An unexpected error occurred. Error: {}".format(e),
)
tracker = obtain_tracker_store(app.agent, conversation_id)
state = tracker.current_state(verbosity)
return response.json({"tracker": state, "messages": out.messages})
async def test_action_rejection():
form_name = "my form"
slot_to_fill = "some slot"
tracker = DialogueStateTracker.from_events(
sender_id="bla",
evts=[
ActiveLoop(form_name),
SlotSet(REQUESTED_SLOT, slot_to_fill),
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("haha", {"name": "greet"}),
],
)
form_name = "my form"
action = FormAction(form_name, None)
domain = f"""
forms:
{form_name}:
{slot_to_fill}:
- type: from_entity
entity: some_entity
slots:
{slot_to_fill}:
type: unfeaturized
"""
domain = Domain.from_yaml(domain)
with pytest.raises(ActionExecutionRejection):
await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
async def test_run_end_to_end_utterance_action():
end_to_end_utterance = "Hi"
domain = Domain.from_yaml(
textwrap.dedent(f"""
actions:
- my_action
{KEY_E2E_ACTIONS}:
- {end_to_end_utterance}
- Bye Bye
"""))
e2e_action = action.action_for_name_or_text("Hi", domain, None)
events = await e2e_action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
DialogueStateTracker.from_events("sender", evts=[]),
domain,
)
assert events == [
BotUttered(
end_to_end_utterance,
{
"elements": None,
"quick_replies": None,
"buttons": None,
"attachment": None,
"image": None,
"custom": None,
},
{},
)
]
async def test_ask_affirm_after_rephrasing():
tracker = DialogueStateTracker.from_events(
"some-sender",
evts=[
# User sends message with low NLU confidence
*_message_requiring_fallback(),
ActiveLoop(ACTION_TWO_STAGE_FALLBACK_NAME),
# Action asks user to affirm
*_two_stage_clarification_request(),
ActionExecuted(ACTION_LISTEN_NAME),
# User denies suggested intents
UserUttered("hi", {"name": USER_INTENT_OUT_OF_SCOPE}),
# Action asks user to rephrase
ActionExecuted(ACTION_TWO_STAGE_FALLBACK_NAME),
BotUttered("please rephrase"),
# User rephrased with low confidence
*_message_requiring_fallback(),
],
)
domain = Domain.empty()
action = TwoStageFallbackAction()
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.responses),
tracker,
domain,
)
assert len(events) == 1
assert isinstance(events[0], BotUttered)
async def test_activate():
tracker = DialogueStateTracker.from_events(sender_id="bla", evts=[])
form_name = "my form"
action = FormAction(form_name, None)
slot_name = "num_people"
domain = f"""
forms:
{form_name}:
{slot_name}:
- type: from_entity
entity: number
responses:
utter_ask_num_people:
- text: "How many people?"
"""
domain = Domain.from_yaml(domain)
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
assert events[:-1] == [
ActiveLoop(form_name),
SlotSet(REQUESTED_SLOT, slot_name)
]
assert isinstance(events[-1], BotUttered)
async def test_loop_without_activate_and_without_deactivate():
expected_do_events = [ActionExecuted("do")]
form_name = "my form"
class MyLoop(LoopAction):
def name(self) -> Text:
return form_name
async def activate(self, *args: Any) -> List[Event]:
raise ValueError("this shouldn't be called")
async def do(self, *args: Any) -> List[Event]:
return expected_do_events
async def deactivate(self, *args) -> List[Event]:
return [SlotSet("deactivated")]
async def is_activated(self, *args: Any) -> bool:
return True
async def is_done(self, *args) -> bool:
return False
tracker = DialogueStateTracker.from_events("some sender", [])
domain = Domain.empty()
action = MyLoop()
actual = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.responses),
tracker,
domain,
)
assert actual == [*expected_do_events]
async def test_1st_affirmation_is_successful():
tracker = DialogueStateTracker.from_events(
"some-sender",
evts=[
# User sends message with low NLU confidence
*_message_requiring_fallback(),
ActiveLoop(ACTION_TWO_STAGE_FALLBACK_NAME),
# Action asks user to affirm
*_two_stage_clarification_request(),
ActionExecuted(ACTION_LISTEN_NAME),
# User affirms
UserUttered("hi", {"name": "greet", "confidence": 1.0}),
],
)
domain = Domain.empty()
action = TwoStageFallbackAction()
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
for events in events:
tracker.update(events, domain)
applied_events = tracker.applied_events()
assert applied_events == [
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("hi", {"name": "greet", "confidence": 1.0}),
]
async def test_set_slot_and_deactivate():
form_name = "my form"
slot_name = "num_people"
slot_value = "dasdasdfasdf"
events = [
Form(form_name),
SlotSet(REQUESTED_SLOT, slot_name),
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered(slot_value),
]
tracker = DialogueStateTracker.from_events(sender_id="bla", evts=events)
domain = f"""
forms:
- {form_name}:
{slot_name}:
- type: from_text
slots:
{slot_name}:
type: unfeaturized
"""
domain = Domain.from_yaml(domain)
action = FormAction(form_name, None)
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
assert events == [
SlotSet(slot_name, slot_value),
SlotSet(REQUESTED_SLOT, None),
Form(None),
]
async def test_activate_with_prefilled_slot():
slot_name = "num_people"
slot_value = 5
tracker = DialogueStateTracker.from_events(
sender_id="bla", evts=[SlotSet(slot_name, slot_value)])
form_name = "my form"
action = FormAction(form_name, None)
next_slot_to_request = "next slot to request"
domain = f"""
forms:
{form_name}:
{slot_name}:
- type: from_entity
entity: {slot_name}
{next_slot_to_request}:
- type: from_text
slots:
{slot_name}:
type: unfeaturized
"""
domain = Domain.from_yaml(domain)
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
assert events == [
ActiveLoop(form_name),
SlotSet(slot_name, slot_value),
SlotSet(REQUESTED_SLOT, next_slot_to_request),
]
async def test_reminder_scheduled(default_processor):
out = CollectingOutputChannel()
sender_id = uuid.uuid4().hex
d = Dispatcher(sender_id, out, default_processor.nlg)
r = ReminderScheduled("utter_greet", datetime.datetime.now())
t = default_processor.tracker_store.get_or_create_tracker(sender_id)
t.update(UserUttered("test"))
t.update(ActionExecuted("action_reminder_reminder"))
t.update(r)
default_processor.tracker_store.save(t)
await default_processor.handle_reminder(r, d)
# retrieve the updated tracker
t = default_processor.tracker_store.retrieve(sender_id)
assert t.events[-4] == UserUttered(None)
assert t.events[-3] == ActionExecuted("utter_greet")
assert t.events[-2] == BotUttered("hey there None!", {
'elements': None,
'buttons': None,
'attachment': None
})
assert t.events[-1] == ActionExecuted("action_listen")
async def test_ask_for_slot(
domain: Dict,
expected_action: Text,
monkeypatch: MonkeyPatch,
default_nlg: TemplatedNaturalLanguageGenerator,
):
slot_name = "sun"
action_from_name = Mock(return_value=action.ActionListen())
endpoint_config = Mock()
monkeypatch.setattr(action, action.action_for_name_or_text.__name__,
action_from_name)
form = FormAction("my_form", endpoint_config)
domain = Domain.from_dict(domain)
await form._ask_for_slot(
domain,
default_nlg,
CollectingOutputChannel(),
slot_name,
DialogueStateTracker.from_events("dasd", []),
)
action_from_name.assert_called_once_with(expected_action, domain,
endpoint_config)
async def respond(request: Request, sender_id: Text):
request_params = request_parameters(request)
if "query" in request_params:
message = request_params["query"]
elif "q" in request_params:
message = request_params["q"]
else:
raise ErrorResponse(
400,
"InvalidParameter",
"Missing the message parameter.",
{
"parameter": "query",
"in": "query"
},
)
try:
# Set the output channel
out = CollectingOutputChannel()
# Fetches the appropriate bot response in a json format
responses = await app.agent.handle_text(message,
output_channel=out,
sender_id=sender_id)
return response.json(responses)
except Exception as e:
logger.exception("Caught an exception during respond.")
raise ErrorResponse(500, "ActionException",
"Server failure. Error: {}".format(e))
async def execute_action(request: Request, sender_id: Text):
request_params = request.json
# we'll accept both parameters to specify the actions name
action_to_execute = request_params.get("name") or request_params.get(
"action")
policy = request_params.get("policy", None)
confidence = request_params.get("confidence", None)
verbosity = event_verbosity_parameter(request,
EventVerbosity.AFTER_RESTART)
try:
out = CollectingOutputChannel()
await app.agent.execute_action(sender_id, action_to_execute, out,
policy, confidence)
# retrieve tracker and set to requested state
tracker = app.agent.tracker_store.get_or_create_tracker(sender_id)
state = tracker.current_state(verbosity)
return response.json({"tracker": state, "messages": out.messages})
except ValueError as e:
raise ErrorResponse(400, "ValueError", e)
except Exception as e:
logger.error("Encountered an exception while running action '{}'. "
"Bot will continue, but the actions events are lost. "
"Make sure to fix the exception in your custom "
"code.".format(action_to_execute))
logger.debug(e, exc_info=True)
raise ErrorResponse(500, "ValueError",
"Server failure. Error: {}".format(e))
async def test_validate_slots_on_activation_with_other_action_after_user_utterance(
):
form_name = "my form"
slot_name = "num_people"
slot_value = "hi"
events = [
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered(slot_value,
entities=[{
"entity": "num_tables",
"value": 5
}]),
ActionExecuted("action_in_between"),
]
tracker = DialogueStateTracker.from_events(sender_id="bla", evts=events)
domain = f"""
slots:
{slot_name}:
type: unfeaturized
forms:
{form_name}:
{slot_name}:
- type: from_text
actions:
- validate_{form_name}
"""
domain = Domain.from_yaml(domain)
action_server_url = "http:/my-action-server:5055/webhook"
expected_slot_value = "✅"
with aioresponses() as mocked:
mocked.post(
action_server_url,
payload={
"events": [{
"event": "slot",
"name": slot_name,
"value": expected_slot_value
}]
},
)
action_server = EndpointConfig(action_server_url)
action = FormAction(form_name, action_server)
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
assert events == [
ActiveLoop(form_name),
SlotSet(slot_name, expected_slot_value),
SlotSet(REQUESTED_SLOT, None),
ActiveLoop(None),
]
async def test_message_processor(default_channel: CollectingOutputChannel,
default_processor: MessageProcessor):
await default_processor.handle_message(
UserMessage('/greet{"name":"Core"}', default_channel))
assert {
"recipient_id": "default",
"text": "hey there Core!",
} == default_channel.latest_output()
async def test_2nd_affirm_successful(default_processor: MessageProcessor):
tracker = DialogueStateTracker.from_events(
"some-sender",
evts=[
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("my name is John", {
"name": "say_name",
"confidence": 1.0
}),
SlotSet("some_slot", "example_value"),
# User sends message with low NLU confidence
*_message_requiring_fallback(),
ActiveLoop(ACTION_TWO_STAGE_FALLBACK_NAME),
# Action asks user to affirm
*_two_stage_clarification_request(),
ActionExecuted(ACTION_LISTEN_NAME),
# User denies suggested intents
UserUttered("hi", {"name": USER_INTENT_OUT_OF_SCOPE}),
# Action asks user to rephrase
*_two_stage_clarification_request(),
# User rephrased with low confidence
*_message_requiring_fallback(),
*_two_stage_clarification_request(),
# Actions asks user to affirm for the last time
ActionExecuted(ACTION_LISTEN_NAME),
# User affirms successfully
UserUttered("hi", {"name": "greet"}),
],
)
domain = Domain.empty()
action = TwoStageFallbackAction()
await default_processor._run_action(
action,
tracker,
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.responses),
PolicyPrediction([], "some policy"),
)
applied_events = tracker.applied_events()
assert applied_events == [
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("my name is John", {
"name": "say_name",
"confidence": 1.0
}),
SlotSet("some_slot", "example_value"),
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("hi", {"name": "greet"}),
]
async def test_dispatcher_template_invalid_vars():
templates = {
"my_made_up_template": [
{"text": "a template referencing an invalid {variable}."}
]
}
bot = CollectingOutputChannel()
nlg = TemplatedNaturalLanguageGenerator(templates)
dispatcher = Dispatcher("my-sender", bot, nlg)
tracker = DialogueStateTracker("my-sender", slots=[])
await dispatcher.utter_template("my_made_up_template", tracker)
collected = dispatcher.output_channel.latest_output()
assert collected["text"].startswith("a template referencing an invalid {variable}.")
async def test_dispatcher_utter_buttons_from_domain_templ(default_tracker):
domain_file = "examples/moodbot/domain.yml"
domain = Domain.load(domain_file)
bot = CollectingOutputChannel()
nlg = TemplatedNaturalLanguageGenerator(domain.templates)
dispatcher = Dispatcher("my-sender", bot, nlg)
await dispatcher.utter_template("utter_greet", default_tracker)
assert len(bot.messages) == 1
assert bot.messages[0]["text"] == "Hey! How are you?"
assert bot.messages[0]["buttons"] == [
{"payload": "great", "title": "great"},
{"payload": "super sad", "title": "super sad"},
]
async def test_validate_slots(validate_return_events: List[Dict],
expected_events: List[Event]):
form_name = "my form"
slot_name = "num_people"
slot_value = "hi"
events = [
ActiveLoop(form_name),
SlotSet(REQUESTED_SLOT, slot_name),
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered(slot_value,
entities=[{
"entity": "num_tables",
"value": 5
}]),
]
tracker = DialogueStateTracker.from_events(sender_id="bla", evts=events)
domain = f"""
slots:
{slot_name}:
type: any
num_tables:
type: any
forms:
{form_name}:
{slot_name}:
- type: from_text
num_tables:
- type: from_entity
entity: num_tables
actions:
- validate_{form_name}
"""
domain = Domain.from_yaml(domain)
action_server_url = "http:/my-action-server:5055/webhook"
with aioresponses() as mocked:
mocked.post(action_server_url,
payload={"events": validate_return_events})
action_server = EndpointConfig(action_server_url)
action = FormAction(form_name, action_server)
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
assert events == expected_events
async def test_ask_affirmation(events: List[Event]):
tracker = DialogueStateTracker.from_events("some-sender", evts=events)
domain = Domain.empty()
action = TwoStageFallbackAction()
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.responses),
tracker,
domain,
)
assert len(events) == 2
assert events[0] == ActiveLoop(ACTION_TWO_STAGE_FALLBACK_NAME)
assert isinstance(events[1], BotUttered)
async def replay_events(tracker: DialogueStateTracker, agent: "Agent") -> None:
"""Take a tracker and replay the logged user utterances against an agent.
During replaying of the user utterances, the executed actions and events
created by the agent are compared to the logged ones of the tracker that
is getting replayed. If they differ, a warning is logged.
At the end, the tracker stored in the agent's tracker store for the
same sender id will have quite the same state as the one
that got replayed."""
actions_between_utterances = []
last_prediction = [ACTION_LISTEN_NAME]
for i, event in enumerate(tracker.events_after_latest_restart()):
if isinstance(event, UserUttered):
_check_prediction_aligns_with_story(last_prediction,
actions_between_utterances)
actions_between_utterances = []
cliutils.print_success(event.text)
out = CollectingOutputChannel()
await agent.handle_text(event.text,
sender_id=tracker.sender_id,
output_channel=out)
for m in out.messages:
buttons = m.pop("buttons", None) # for non-terminal stdin
console.print_bot_output(m)
if buttons is not None:
color = rasa.cli.utils.bcolors.OKBLUE
rasa.cli.utils.print_color("Buttons:", color=color)
for idx, button in enumerate(buttons):
rasa.cli.utils.print_color(console.button_to_string(
button, idx),
color=color)
tracker = agent.tracker_store.retrieve(tracker.sender_id)
last_prediction = actions_since_last_utterance(tracker)
elif isinstance(event, ActionExecuted):
actions_between_utterances.append(event.action_name)
_check_prediction_aligns_with_story(last_prediction,
actions_between_utterances)
async def test_ask_for_slot_if_not_utter_ask(
monkeypatch: MonkeyPatch,
default_nlg: TemplatedNaturalLanguageGenerator):
action_from_name = Mock(return_value=action.ActionListen())
endpoint_config = Mock()
monkeypatch.setattr(action, action.action_for_name_or_text.__name__,
action_from_name)
form = FormAction("my_form", endpoint_config)
events = await form._ask_for_slot(
Domain.empty(),
default_nlg,
CollectingOutputChannel(),
"some slot",
DialogueStateTracker.from_events("dasd", []),
)
assert not events
action_from_name.assert_not_called()
async def test_reminder_aborted(default_processor):
out = CollectingOutputChannel()
sender_id = uuid.uuid4().hex
d = Dispatcher(sender_id, out, default_processor.nlg)
r = ReminderScheduled("utter_greet",
datetime.datetime.now(),
kill_on_user_message=True)
t = default_processor.tracker_store.get_or_create_tracker(sender_id)
t.update(r)
t.update(UserUttered("test")) # cancels the reminder
default_processor.tracker_store.save(t)
await default_processor.handle_reminder(r, d)
# retrieve the updated tracker
t = default_processor.tracker_store.retrieve(sender_id)
assert len(t.events) == 3 # nothing should have been executed
async def test_activate_and_immediate_deactivate():
slot_name = "num_people"
slot_value = 5
tracker = DialogueStateTracker.from_events(
sender_id="bla",
evts=[
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered(
"haha",
{"name": "greet"},
entities=[{
"entity": slot_name,
"value": slot_value
}],
),
],
)
form_name = "my form"
action = FormAction(form_name, None)
domain = f"""
forms:
{form_name}:
{slot_name}:
- type: from_entity
entity: {slot_name}
slots:
{slot_name}:
type: unfeaturized
"""
domain = Domain.from_yaml(domain)
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
assert events == [
ActiveLoop(form_name),
SlotSet(slot_name, slot_value),
SlotSet(REQUESTED_SLOT, None),
ActiveLoop(None),
]
async def test_2nd_affirm_successful():
tracker = DialogueStateTracker.from_events(
"some-sender",
evts=[
# User sends message with low NLU confidence
*_message_requiring_fallback(),
ActiveLoop(ACTION_TWO_STAGE_FALLBACK_NAME),
# Action asks user to affirm
*_two_stage_clarification_request(),
ActionExecuted(ACTION_LISTEN_NAME),
# User denies suggested intents
UserUttered("hi", {"name": USER_INTENT_OUT_OF_SCOPE}),
# Action asks user to rephrase
*_two_stage_clarification_request(),
# User rephrased with low confidence
*_message_requiring_fallback(),
*_two_stage_clarification_request(),
# Actions asks user to affirm for the last time
ActionExecuted(ACTION_LISTEN_NAME),
# User affirms successfully
UserUttered("hi", {"name": "greet"}),
],
)
domain = Domain.empty()
action = TwoStageFallbackAction()
events = await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
for event in events:
tracker.update(event)
applied_events = tracker.applied_events()
assert applied_events == [
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("hi", {"name": "greet"}),
]
async def test_reminder_cancelled(default_processor):
out = CollectingOutputChannel()
sender_ids = [uuid.uuid4().hex, uuid.uuid4().hex]
trackers = []
for sender_id in sender_ids:
t = default_processor.tracker_store.get_or_create_tracker(sender_id)
t.update(UserUttered("test"))
t.update(ActionExecuted("action_reminder_reminder"))
t.update(
ReminderScheduled(
"utter_greet", datetime.datetime.now(), kill_on_user_message=True
)
)
trackers.append(t)
# cancel reminder for the first user
trackers[0].update(ReminderCancelled("utter_greet"))
for i, t in enumerate(trackers):
default_processor.tracker_store.save(t)
d = Dispatcher(sender_id, out, default_processor.nlg)
await default_processor._schedule_reminders(t.events, t, d)
# check that the jobs were added
assert len((await jobs.scheduler()).get_jobs()) == 2
for t in trackers:
await default_processor._cancel_reminders(t.events, t)
# check that only one job was removed
assert len((await jobs.scheduler()).get_jobs()) == 1
# execute the jobs
await asyncio.sleep(3)
t = default_processor.tracker_store.retrieve(sender_ids[0])
# there should be no utter_greet action
assert ActionExecuted("utter_greet") not in t.events
t = default_processor.tracker_store.retrieve(sender_ids[1])
# there should be utter_greet action
assert ActionExecuted("utter_greet") in t.events
async def test_no_slots_extracted_with_custom_slot_mappings(
custom_events: List[Event]):
form_name = "my form"
events = [
ActiveLoop(form_name),
SlotSet(REQUESTED_SLOT, "num_tables"),
ActionExecuted(ACTION_LISTEN_NAME),
UserUttered("off topic"),
]
tracker = DialogueStateTracker.from_events(sender_id="bla", evts=events)
domain = f"""
slots:
num_tables:
type: any
forms:
{form_name}:
num_tables:
- type: from_entity
entity: num_tables
actions:
- validate_{form_name}
"""
domain = Domain.from_yaml(domain)
action_server_url = "http:/my-action-server:5055/webhook"
with aioresponses() as mocked:
mocked.post(action_server_url, payload={"events": custom_events})
action_server = EndpointConfig(action_server_url)
action = FormAction(form_name, action_server)
with pytest.raises(ActionExecutionRejection):
await action.run(
CollectingOutputChannel(),
TemplatedNaturalLanguageGenerator(domain.templates),
tracker,
domain,
)
