async def test_request_prediction(mock_endpoint):
sender_id = uuid.uuid4().hex
url = f"{mock_endpoint.url}/conversations/{sender_id}/predict"
with aioresponses() as mocked:
mocked.post(url, payload={})
await interactive.request_prediction(mock_endpoint, sender_id)
assert utilities.latest_request(mocked, "post", url) is not None
async def test_remote_action_runs(default_channel, default_nlg,
default_tracker, default_domain):
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
with aioresponses() as mocked:
mocked.post(
"https://example.com/webhooks/actions",
payload={
"events": [],
"responses": []
},
)
await remote_action.run(default_channel, default_nlg, default_tracker,
default_domain)
r = latest_request(mocked, "post",
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
"domain": default_domain.as_dict(),
"next_action": "my_action",
"sender_id": "my-sender",
"version": rasa.__version__,
"tracker": {
"latest_message": {
"entities": [],
"intent": {},
"text": None,
"message_id": None,
"metadata": {},
},
ACTIVE_LOOP: {},
"latest_action": {},
"latest_action_name": None,
"sender_id": "my-sender",
"paused": False,
"latest_event_time": None,
FOLLOWUP_ACTION: "action_listen",
"slots": {
"name": None,
REQUESTED_SLOT: None
},
"events": [],
"latest_input_channel": None,
},
}
async def test_slackbot_send_text_with_buttons_threaded():
from rasa.core.channels.slack import SlackBot
with aioresponses() as mocked:
mocked.post(
"https://www.slack.com/api/chat.postMessage",
payload={
"ok": True,
"purpose": "Testing bots"
},
)
bot = SlackBot("DummyToken", "General", thread_id="DummyThread")
buttons = [{"title": "title", "payload": "payload"}]
await bot.send_text_with_buttons("ID", "my message", buttons)
r = latest_request(mocked, "POST",
"https://www.slack.com/api/chat.postMessage")
assert r
request_params = json_of_latest_request(r)
text_block = {
"type": "section",
"text": {
"type": "plain_text",
"text": "my message"
},
}
button_block = {
"type":
"actions",
"elements": [{
"type": "button",
"text": {
"type": "plain_text",
"text": "title"
},
"value": "payload",
}],
}
assert request_params == {
"as_user": True,
"channel": "General",
"text": "my message",
"blocks": [text_block, button_block],
"thread_ts": "DummyThread",
}
async def test_endpoint_config():
with aioresponses() as mocked:
endpoint = EndpointConfig(
"https://example.com/",
params={"A": "B"},
headers={"X-Powered-By": "Rasa"},
basic_auth={
"username": "******",
"password": "******"
},
token="mytoken",
token_name="letoken",
type="redis",
port=6379,
db=0,
password="******",
timeout=30000,
)
mocked.post(
"https://example.com/test?A=B&P=1&letoken=mytoken",
payload={"ok": True},
repeat=True,
status=200,
)
await endpoint.request(
"post",
subpath="test",
content_type="application/text",
json={"c": "d"},
params={"P": "1"},
)
r = latest_request(mocked, "post",
"https://example.com/test?A=B&P=1&letoken=mytoken")
assert r
assert json_of_latest_request(r) == {"c": "d"}
assert r[-1].kwargs.get("params", {}).get("A") == "B"
assert r[-1].kwargs.get("params", {}).get("P") == "1"
assert r[-1].kwargs.get("params", {}).get("letoken") == "mytoken"
# unfortunately, the mock library won't report any headers stored on
# the session object, so we need to verify them separately
async with endpoint.session() as s:
assert s._default_headers.get("X-Powered-By") == "Rasa"
assert s._default_auth.login == "user"
assert s._default_auth.password == "pass"
async def test_http_interpreter():
with aioresponses() as mocked:
mocked.post("https://example.com/model/parse")
endpoint = EndpointConfig("https://example.com")
interpreter = RasaNLUHttpInterpreter(endpoint=endpoint)
await interpreter.parse(text="message_text")
r = latest_request(mocked, "POST", "https://example.com/model/parse")
query = json_of_latest_request(r)
response = {"text": "message_text", "token": None}
assert query == response
async def test_print_history(mock_endpoint):
tracker_dump = utils.read_file("data/test_trackers/tracker_moodbot.json")
sender_id = uuid.uuid4().hex
url = '{}/conversations/{}/tracker?include_events=AFTER_RESTART'.format(
mock_endpoint.url, sender_id)
with aioresponses() as mocked:
mocked.get(url,
body=tracker_dump,
headers={"Accept": "application/json"})
await interactive._print_history(sender_id, mock_endpoint)
assert latest_request(mocked, 'get', url) is not None
async def test_remote_action_runs(default_dispatcher_collecting,
default_domain):
tracker = DialogueStateTracker("default", default_domain.slots)
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
with aioresponses() as mocked:
mocked.post(
"https://example.com/webhooks/actions",
payload={
"events": [],
"responses": []
},
)
await remote_action.run(default_dispatcher_collecting, tracker,
default_domain)
r = latest_request(mocked, "post",
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
"domain": default_domain.as_dict(),
"next_action": "my_action",
"sender_id": "default",
"version": rasa.__version__,
"tracker": {
"latest_message": {
"entities": [],
"intent": {},
"text": None
},
"active_form": {},
"latest_action_name": None,
"sender_id": "default",
"paused": False,
"latest_event_time": None,
"followup_action": "action_listen",
"slots": {
"name": None
},
"events": [],
"latest_input_channel": None,
},
}
async def test_send_message(mock_endpoint: EndpointConfig):
sender_id = uuid.uuid4().hex
url = f"{mock_endpoint.url}/conversations/{sender_id}/messages"
with aioresponses() as mocked:
mocked.post(url, payload={})
await interactive.send_message(mock_endpoint, sender_id, "Hello")
r = utilities.latest_request(mocked, "post", url)
assert r
expected = {"sender": "user", "text": "Hello", "parse_data": None}
assert utilities.json_of_latest_request(r) == expected
async def test_segment_does_not_raise_exception_on_failure(
monkeypatch: MonkeyPatch):
monkeypatch.setenv("RASA_TELEMETRY_ENABLED", "true")
monkeypatch.setenv("RASA_TELEMETRY_WRITE_KEY", "foobar")
telemetry.initialize_telemetry()
with aioresponses() as mocked:
mocked.post("https://api.segment.io/v1/track", payload={}, status=505)
# this call should complete without throwing an exception
await telemetry.track("test event", {"foo": "bar"}, {"foobar": "baz"})
r = utilities.latest_request(mocked, "POST",
"https://api.segment.io/v1/track")
assert r
async def test_send_message(mock_endpoint):
sender_id = uuid.uuid4().hex
url = "{}/conversations/{}/messages".format(mock_endpoint.url, sender_id)
with aioresponses() as mocked:
mocked.post(url, payload={})
await interactive.send_message(mock_endpoint, sender_id, "Hello")
r = latest_request(mocked, "post", url)
assert r
expected = {"sender": "user", "text": "Hello", "parse_data": None}
assert json_of_latest_request(r) == expected
async def test_endpoint_config_with_cafile(tmp_path: Path):
cafile = "data/test_endpoints/cert.pem"
with aioresponses() as mocked:
endpoint = endpoint_utils.EndpointConfig("https://example.com/",
cafile=str(cafile))
mocked.post("https://example.com/", status=200)
await endpoint.request("post")
request = latest_request(mocked, "post", "https://example.com/")[-1]
ssl_context = request.kwargs["ssl"]
certs = ssl_context.get_ca_certs()
assert certs[0]["subject"][4][0] == ("organizationalUnitName", "rasa")
async def test_http_parsing():
message = UserMessage("lunch?")
endpoint = EndpointConfig("https://interpreter.com")
with aioresponses() as mocked:
mocked.post("https://interpreter.com/model/parse", repeat=True, status=200)
inter = RasaNLUHttpInterpreter(endpoint_config=endpoint)
try:
await MessageProcessor(inter, None, None, None, None).parse_message(message)
except KeyError:
pass # logger looks for intent and entities, so we except
r = latest_request(mocked, "POST", "https://interpreter.com/model/parse")
assert r
async def test_remote_action_runs(default_dispatcher_collecting,
default_domain):
tracker = DialogueStateTracker("default", default_domain.slots)
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
with aioresponses() as mocked:
mocked.post('https://example.com/webhooks/actions',
payload={
"events": [],
"responses": []
})
await remote_action.run(default_dispatcher_collecting, tracker,
default_domain)
r = latest_request(mocked, 'post',
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
'domain': default_domain.as_dict(),
'next_action': 'my_action',
'sender_id': 'default',
'version': rasa_core.__version__,
'tracker': {
'latest_message': {
'entities': [],
'intent': {},
'text': None
},
'active_form': {},
'latest_action_name': None,
'sender_id': 'default',
'paused': False,
'latest_event_time': None,
'followup_action': 'action_listen',
'slots': {
'name': None
},
'events': [],
'latest_input_channel': None
}
}
async def test_http_interpreter(endpoint_url, joined_url):
with aioresponses() as mocked:
mocked.post(joined_url)
endpoint = EndpointConfig(endpoint_url)
interpreter = RasaNLUHttpInterpreter(endpoint_config=endpoint)
await interpreter.parse(text="message_text", message_id="message_id")
r = latest_request(mocked, "POST", joined_url)
query = json_of_latest_request(r)
response = {
"text": "message_text",
"token": None,
"message_id": "message_id"
}
assert query == response
async def test_http_parsing():
message = UserMessage('lunch?')
endpoint = EndpointConfig('https://interpreter.com')
with aioresponses() as mocked:
mocked.post('https://interpreter.com/parse', repeat=True, status=200)
inter = RasaNLUHttpInterpreter(endpoint=endpoint)
try:
await MessageProcessor(inter, None, None, None,
None)._parse_message(message)
except KeyError:
pass # logger looks for intent and entities, so we except
r = latest_request(mocked, 'POST', "https://interpreter.com/parse")
assert r
assert json_of_latest_request(r)['message_id'] == message.message_id
async def test_http_interpreter():
with aioresponses() as mocked:
mocked.post("https://example.com/parse")
endpoint = EndpointConfig('https://example.com')
interpreter = RasaNLUHttpInterpreter(endpoint=endpoint)
await interpreter.parse(text='message_text', message_id='1134')
r = latest_request(mocked, "POST", "https://example.com/parse")
query = json_of_latest_request(r)
response = {
'project': 'default',
'q': 'message_text',
'message_id': '1134',
'model': None,
'token': None
}
assert query == response
async def test_slackbot_send_custom_json():
from rasa.core.channels.slack import SlackBot
with aioresponses() as mocked:
mocked.post(
"https://www.slack.com/api/chat.postMessage",
payload={"ok": True, "purpose": "Testing bots"},
)
bot = SlackBot("DummyToken", "General")
await bot.send_custom_json("ID", {"test_key": "test_value"})
r = latest_request(mocked, "POST", "https://www.slack.com/api/chat.postMessage")
assert r
request_params = json_of_latest_request(r)
assert request_params == {
"as_user": True,
"channel": "General",
"test_key": "test_value",
}
async def test_undo_latest_msg(mock_endpoint):
tracker_dump = rasa.shared.utils.io.read_file(
"data/test_trackers/tracker_moodbot.json")
sender_id = uuid.uuid4().hex
url = "{}/conversations/{}/tracker?include_events=ALL".format(
mock_endpoint.url, sender_id)
append_url = "{}/conversations/{}/tracker/events".format(
mock_endpoint.url, sender_id)
with aioresponses() as mocked:
mocked.get(url, body=tracker_dump)
mocked.post(append_url)
await interactive._undo_latest(sender_id, mock_endpoint)
r = utilities.latest_request(mocked, "post", append_url)
assert r
# this should be the events the interactive call send to the endpoint
# these events should have the last utterance omitted
corrected_event = utilities.json_of_latest_request(r)
assert corrected_event["event"] == "undo"
async def test_segment_gets_called(monkeypatch: MonkeyPatch):
monkeypatch.setenv("RASA_TELEMETRY_WRITE_KEY", "foobar")
monkeypatch.setenv("RASA_TELEMETRY_ENABLED", "true")
telemetry.initialize_telemetry()
with aioresponses() as mocked:
mocked.post(
"https://api.segment.io/v1/track",
payload={},
)
await telemetry.track("test event", {"foo": "bar"}, {"foobar": "baz"})
r = utilities.latest_request(mocked, "POST",
"https://api.segment.io/v1/track")
assert r
b = utilities.json_of_latest_request(r)
assert "userId" in b
assert b["event"] == "test event"
assert b["properties"].get("foo") == "bar"
assert b["context"].get("foobar") == "baz"
async def test_console_input():
from rasa.core.channels import console
# Overwrites the input() function and when someone else tries to read
# something from the command line this function gets called.
with utilities.mocked_cmd_input(console, text="Test Input"):
with aioresponses() as mocked:
mocked.post(
'https://example.com/webhooks/rest/webhook?stream=true',
repeat=True,
payload={})
await console.record_messages(server_url="https://example.com",
max_message_limit=3)
r = latest_request(
mocked, 'POST',
"https://example.com/webhooks/rest/webhook?stream=true")
assert r
b = json_of_latest_request(r)
assert b == {"message": "Test Input", "sender": "default"}
async def test_remote_action_logs_events(default_dispatcher_collecting,
default_domain):
tracker = DialogueStateTracker("default", default_domain.slots)
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
response = {
"events": [{
"event": "slot",
"value": "rasa",
"name": "name"
}],
"responses": [
{
"text": "test text",
"buttons": [{
"title": "cheap",
"payload": "cheap"
}]
},
{
"template": "utter_greet"
},
],
}
with aioresponses() as mocked:
mocked.post("https://example.com/webhooks/actions", payload=response)
events = await remote_action.run(default_dispatcher_collecting,
tracker, default_domain)
r = latest_request(mocked, "post",
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
"domain": default_domain.as_dict(),
"next_action": "my_action",
"sender_id": "default",
"version": rasa.__version__,
"tracker": {
"latest_message": {
"entities": [],
"intent": {},
"text": None
},
"active_form": {},
"latest_action_name": None,
"sender_id": "default",
"paused": False,
"followup_action": "action_listen",
"latest_event_time": None,
"slots": {
"name": None
},
"events": [],
"latest_input_channel": None,
},
}
assert events == [SlotSet("name", "rasa")]
channel = default_dispatcher_collecting.output_channel
assert channel.messages == [
{
"text": "test text",
"recipient_id": "my-sender",
"buttons": [{
"title": "cheap",
"payload": "cheap"
}],
},
{
"text": "hey there None!",
"recipient_id": "my-sender"
},
]
async def test_remote_action_logs_events(
default_channel: OutputChannel,
default_nlg: NaturalLanguageGenerator,
default_tracker: DialogueStateTracker,
domain: Domain,
):
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
response = {
"events": [{
"event": "slot",
"value": "rasa",
"name": "name"
}],
"responses": [
{
"text": "test text",
"response": None,
"buttons": [{
"title": "cheap",
"payload": "cheap"
}],
},
{
"response": "utter_greet"
},
],
}
with aioresponses() as mocked:
mocked.post("https://example.com/webhooks/actions", payload=response)
events = await remote_action.run(default_channel, default_nlg,
default_tracker, domain)
r = latest_request(mocked, "post",
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
"domain": domain.as_dict(),
"next_action": "my_action",
"sender_id": "my-sender",
"version": rasa.__version__,
"tracker": {
"latest_message": {
"entities": [],
"intent": {},
"text": None,
"message_id": None,
"metadata": {},
},
ACTIVE_LOOP: {},
"latest_action": {},
"latest_action_name": None,
"sender_id": "my-sender",
"paused": False,
FOLLOWUP_ACTION: ACTION_LISTEN_NAME,
"latest_event_time": None,
"slots": {
"name": None,
REQUESTED_SLOT: None,
SESSION_START_METADATA_SLOT: None,
},
"events": [],
"latest_input_channel": None,
},
}
assert len(events) == 3 # first two events are bot utterances
assert events[0] == BotUttered(
"test text", {"buttons": [{
"title": "cheap",
"payload": "cheap"
}]})
assert events[1] == BotUttered("hey there None!",
metadata={"utter_action": "utter_greet"})
assert events[2] == SlotSet("name", "rasa")
async def test_slackbot_send_attachment_with_text():
from rasa.core.channels.slack import SlackBot
with aioresponses() as mocked:
mocked.post(
"https://www.slack.com/api/chat.postMessage",
payload={
"ok": True,
"purpose": "Testing bots"
},
)
bot = SlackBot("DummyToken", "General")
attachment = {
"fallback":
"Financial Advisor Summary",
"color":
"#36a64f",
"author_name":
"ABE",
"title":
"Financial Advisor Summary",
"title_link":
"http://tenfactorialrocks.com",
"text":
"Here is the summary:",
"image_url":
"https://r.com/cancel/r12",
"thumb_url":
"https://r.com/cancel/r12",
"actions": [
{
"type": "button",
"text": "\ud83d\udcc8 Dashboard",
"url": "https://r.com/cancel/r12",
"style": "primary",
},
{
"type": "button",
"text": "\ud83d\udccb XL",
"url": "https://r.com/cancel/r12",
"style": "danger",
},
{
"type": "button",
"text": "\ud83d\udce7 E-Mail",
"url": "https://r.com/cancel/r123",
"style": "danger",
},
],
"footer":
"Powered by 1010rocks",
"ts":
1531889719,
}
await bot.send_attachment("ID", attachment)
r = latest_request(mocked, "POST",
"https://www.slack.com/api/chat.postMessage")
assert r
request_params = json_of_latest_request(r)
assert request_params == {
"channel": "General",
"as_user": True,
"attachments": [attachment],
}
async def test_remote_action_logs_events(default_channel, default_nlg,
default_tracker, default_domain):
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
response = {
"events": [{
"event": "slot",
"value": "rasa",
"name": "name"
}],
"responses": [
{
"text": "test text",
"template": None,
"buttons": [{
"title": "cheap",
"payload": "cheap"
}],
},
{
"template": "utter_greet"
},
],
}
with aioresponses() as mocked:
mocked.post("https://example.com/webhooks/actions", payload=response)
events = await remote_action.run(default_channel, default_nlg,
default_tracker, default_domain)
r = latest_request(mocked, "post",
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
"domain": default_domain.as_dict(),
"next_action": "my_action",
"sender_id": "my-sender",
"version": rasa.__version__,
"tracker": {
"latest_message": {
"entities": [],
"intent": {},
"text": None,
"message_id": None,
"metadata": {},
},
ACTIVE_LOOP: {},
"latest_action": {},
"latest_action_name": None,
"sender_id": "my-sender",
"paused": False,
"followup_action": "action_listen",
"latest_event_time": None,
"slots": {
"name": None
},
"events": [],
"latest_input_channel": None,
},
}
assert len(events) == 3 # first two events are bot utterances
assert events[0] == BotUttered(
"test text", {"buttons": [{
"title": "cheap",
"payload": "cheap"
}]})
assert events[1] == BotUttered("hey there None!",
metadata={"template_name": "utter_greet"})
assert events[2] == SlotSet("name", "rasa")
async def test_remote_action_logs_events(default_dispatcher_collecting,
default_domain):
tracker = DialogueStateTracker("default", default_domain.slots)
endpoint = EndpointConfig("https://example.com/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
response = {
"events": [{
"event": "slot",
"value": "rasa",
"name": "name"
}],
"responses": [{
"text": "test text",
"buttons": [{
"title": "cheap",
"payload": "cheap"
}]
}, {
"template": "utter_greet"
}]
}
with aioresponses() as mocked:
mocked.post('https://example.com/webhooks/actions', payload=response)
events = await remote_action.run(default_dispatcher_collecting,
tracker, default_domain)
r = latest_request(mocked, 'post',
"https://example.com/webhooks/actions")
assert r
assert json_of_latest_request(r) == {
'domain': default_domain.as_dict(),
'next_action': 'my_action',
'sender_id': 'default',
'version': rasa_core.__version__,
'tracker': {
'latest_message': {
'entities': [],
'intent': {},
'text': None
},
'active_form': {},
'latest_action_name': None,
'sender_id': 'default',
'paused': False,
'followup_action': 'action_listen',
'latest_event_time': None,
'slots': {
'name': None
},
'events': [],
'latest_input_channel': None
}
}
assert events == [SlotSet("name", "rasa")]
channel = default_dispatcher_collecting.output_channel
assert channel.messages == [{
"text":
"test text",
"recipient_id":
"my-sender",
"buttons": [{
"title": "cheap",
"payload": "cheap"
}]
}, {
"text": "hey there None!",
"recipient_id": "my-sender"
}]
