467 lines
15 KiB
Python
467 lines
15 KiB
Python
"""The tests for the Alexa component."""
|
|
# pylint: disable=protected-access
|
|
import asyncio
|
|
import json
|
|
import datetime
|
|
|
|
import pytest
|
|
|
|
from homeassistant.core import callback
|
|
from homeassistant.setup import async_setup_component
|
|
from homeassistant.components import alexa
|
|
|
|
SESSION_ID = "amzn1.echo-api.session.0000000-0000-0000-0000-00000000000"
|
|
APPLICATION_ID = "amzn1.echo-sdk-ams.app.000000-d0ed-0000-ad00-000000d00ebe"
|
|
REQUEST_ID = "amzn1.echo-api.request.0000000-0000-0000-0000-00000000000"
|
|
|
|
# pylint: disable=invalid-name
|
|
calls = []
|
|
|
|
NPR_NEWS_MP3_URL = "https://pd.npr.org/anon.npr-mp3/npr/news/newscast.mp3"
|
|
|
|
# 2016-10-10T19:51:42+00:00
|
|
STATIC_TIME = datetime.datetime.utcfromtimestamp(1476129102)
|
|
|
|
|
|
@pytest.fixture
|
|
def alexa_client(loop, hass, test_client):
|
|
"""Initialize a Home Assistant server for testing this module."""
|
|
@callback
|
|
def mock_service(call):
|
|
calls.append(call)
|
|
|
|
hass.services.async_register("test", "alexa", mock_service)
|
|
|
|
assert loop.run_until_complete(async_setup_component(hass, alexa.DOMAIN, {
|
|
# Key is here to verify we allow other keys in config too
|
|
"homeassistant": {},
|
|
"alexa": {
|
|
"flash_briefings": {
|
|
"weather": [
|
|
{"title": "Weekly forecast",
|
|
"text": "This week it will be sunny.",
|
|
"date": "2016-10-09T19:51:42.0Z"},
|
|
{"title": "Current conditions",
|
|
"text": "Currently it is 80 degrees fahrenheit.",
|
|
"date": STATIC_TIME}
|
|
],
|
|
"news_audio": {
|
|
"title": "NPR",
|
|
"audio": NPR_NEWS_MP3_URL,
|
|
"display_url": "https://npr.org",
|
|
"date": STATIC_TIME,
|
|
"uid": "uuid"
|
|
}
|
|
},
|
|
"intents": {
|
|
"WhereAreWeIntent": {
|
|
"speech": {
|
|
"type": "plaintext",
|
|
"text":
|
|
"""
|
|
{%- if is_state("device_tracker.paulus", "home")
|
|
and is_state("device_tracker.anne_therese",
|
|
"home") -%}
|
|
You are both home, you silly
|
|
{%- else -%}
|
|
Anne Therese is at {{
|
|
states("device_tracker.anne_therese")
|
|
}} and Paulus is at {{
|
|
states("device_tracker.paulus")
|
|
}}
|
|
{% endif %}
|
|
""",
|
|
}
|
|
},
|
|
"GetZodiacHoroscopeIntent": {
|
|
"speech": {
|
|
"type": "plaintext",
|
|
"text": "You told us your sign is {{ ZodiacSign }}.",
|
|
}
|
|
},
|
|
"AMAZON.PlaybackAction<object@MusicCreativeWork>": {
|
|
"speech": {
|
|
"type": "plaintext",
|
|
"text": "Playing {{ object_byArtist_name }}.",
|
|
}
|
|
},
|
|
"CallServiceIntent": {
|
|
"speech": {
|
|
"type": "plaintext",
|
|
"text": "Service called",
|
|
},
|
|
"action": {
|
|
"service": "test.alexa",
|
|
"data_template": {
|
|
"hello": "{{ ZodiacSign }}"
|
|
},
|
|
"entity_id": "switch.test",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}))
|
|
return loop.run_until_complete(test_client(hass.http.app))
|
|
|
|
|
|
def _intent_req(client, data={}):
|
|
return client.post(alexa.INTENTS_API_ENDPOINT, data=json.dumps(data),
|
|
headers={'content-type': 'application/json'})
|
|
|
|
|
|
def _flash_briefing_req(client, briefing_id):
|
|
return client.get(
|
|
"/api/alexa/flash_briefings/{}".format(briefing_id))
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_launch_request(alexa_client):
|
|
"""Test the launch of a request."""
|
|
data = {
|
|
"version": "1.0",
|
|
"session": {
|
|
"new": True,
|
|
"sessionId": SESSION_ID,
|
|
"application": {
|
|
"applicationId": APPLICATION_ID
|
|
},
|
|
"attributes": {},
|
|
"user": {
|
|
"userId": "amzn1.account.AM3B00000000000000000000000"
|
|
}
|
|
},
|
|
"request": {
|
|
"type": "LaunchRequest",
|
|
"requestId": REQUEST_ID,
|
|
"timestamp": "2015-05-13T12:34:56Z"
|
|
}
|
|
}
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
resp = yield from req.json()
|
|
assert "outputSpeech" in resp["response"]
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_request_with_slots(alexa_client):
|
|
"""Test a request with slots."""
|
|
data = {
|
|
"version": "1.0",
|
|
"session": {
|
|
"new": False,
|
|
"sessionId": SESSION_ID,
|
|
"application": {
|
|
"applicationId": APPLICATION_ID
|
|
},
|
|
"attributes": {
|
|
"supportedHoroscopePeriods": {
|
|
"daily": True,
|
|
"weekly": False,
|
|
"monthly": False
|
|
}
|
|
},
|
|
"user": {
|
|
"userId": "amzn1.account.AM3B00000000000000000000000"
|
|
}
|
|
},
|
|
"request": {
|
|
"type": "IntentRequest",
|
|
"requestId": REQUEST_ID,
|
|
"timestamp": "2015-05-13T12:34:56Z",
|
|
"intent": {
|
|
"name": "GetZodiacHoroscopeIntent",
|
|
"slots": {
|
|
"ZodiacSign": {
|
|
"name": "ZodiacSign",
|
|
"value": "virgo"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
data = yield from req.json()
|
|
text = data.get("response", {}).get("outputSpeech",
|
|
{}).get("text")
|
|
assert text == "You told us your sign is virgo."
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_request_with_slots_but_no_value(alexa_client):
|
|
"""Test a request with slots but no value."""
|
|
data = {
|
|
"version": "1.0",
|
|
"session": {
|
|
"new": False,
|
|
"sessionId": SESSION_ID,
|
|
"application": {
|
|
"applicationId": APPLICATION_ID
|
|
},
|
|
"attributes": {
|
|
"supportedHoroscopePeriods": {
|
|
"daily": True,
|
|
"weekly": False,
|
|
"monthly": False
|
|
}
|
|
},
|
|
"user": {
|
|
"userId": "amzn1.account.AM3B00000000000000000000000"
|
|
}
|
|
},
|
|
"request": {
|
|
"type": "IntentRequest",
|
|
"requestId": REQUEST_ID,
|
|
"timestamp": "2015-05-13T12:34:56Z",
|
|
"intent": {
|
|
"name": "GetZodiacHoroscopeIntent",
|
|
"slots": {
|
|
"ZodiacSign": {
|
|
"name": "ZodiacSign",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
data = yield from req.json()
|
|
text = data.get("response", {}).get("outputSpeech",
|
|
{}).get("text")
|
|
assert text == "You told us your sign is ."
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_request_without_slots(hass, alexa_client):
|
|
"""Test a request without slots."""
|
|
data = {
|
|
"version": "1.0",
|
|
"session": {
|
|
"new": False,
|
|
"sessionId": SESSION_ID,
|
|
"application": {
|
|
"applicationId": APPLICATION_ID
|
|
},
|
|
"attributes": {
|
|
"supportedHoroscopePeriods": {
|
|
"daily": True,
|
|
"weekly": False,
|
|
"monthly": False
|
|
}
|
|
},
|
|
"user": {
|
|
"userId": "amzn1.account.AM3B00000000000000000000000"
|
|
}
|
|
},
|
|
"request": {
|
|
"type": "IntentRequest",
|
|
"requestId": REQUEST_ID,
|
|
"timestamp": "2015-05-13T12:34:56Z",
|
|
"intent": {
|
|
"name": "WhereAreWeIntent",
|
|
}
|
|
}
|
|
}
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
json = yield from req.json()
|
|
text = json.get("response", {}).get("outputSpeech",
|
|
{}).get("text")
|
|
|
|
assert text == "Anne Therese is at unknown and Paulus is at unknown"
|
|
|
|
hass.states.async_set("device_tracker.paulus", "home")
|
|
hass.states.async_set("device_tracker.anne_therese", "home")
|
|
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
json = yield from req.json()
|
|
text = json.get("response", {}).get("outputSpeech",
|
|
{}).get("text")
|
|
assert text == "You are both home, you silly"
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_request_calling_service(alexa_client):
|
|
"""Test a request for calling a service."""
|
|
data = {
|
|
"version": "1.0",
|
|
"session": {
|
|
"new": False,
|
|
"sessionId": SESSION_ID,
|
|
"application": {
|
|
"applicationId": APPLICATION_ID
|
|
},
|
|
"attributes": {},
|
|
"user": {
|
|
"userId": "amzn1.account.AM3B00000000000000000000000"
|
|
}
|
|
},
|
|
"request": {
|
|
"type": "IntentRequest",
|
|
"requestId": REQUEST_ID,
|
|
"timestamp": "2015-05-13T12:34:56Z",
|
|
"intent": {
|
|
"name": "CallServiceIntent",
|
|
"slots": {
|
|
"ZodiacSign": {
|
|
"name": "ZodiacSign",
|
|
"value": "virgo",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
call_count = len(calls)
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
assert call_count + 1 == len(calls)
|
|
call = calls[-1]
|
|
assert call.domain == "test"
|
|
assert call.service == "alexa"
|
|
assert call.data.get("entity_id") == ["switch.test"]
|
|
assert call.data.get("hello") == "virgo"
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_session_ended_request(alexa_client):
|
|
"""Test the request for ending the session."""
|
|
data = {
|
|
"version": "1.0",
|
|
"session": {
|
|
"new": False,
|
|
"sessionId": SESSION_ID,
|
|
"application": {
|
|
"applicationId": APPLICATION_ID
|
|
},
|
|
"attributes": {
|
|
"supportedHoroscopePeriods": {
|
|
"daily": True,
|
|
"weekly": False,
|
|
"monthly": False
|
|
}
|
|
},
|
|
"user": {
|
|
"userId": "amzn1.account.AM3B00000000000000000000000"
|
|
}
|
|
},
|
|
"request": {
|
|
"type": "SessionEndedRequest",
|
|
"requestId": REQUEST_ID,
|
|
"timestamp": "2015-05-13T12:34:56Z",
|
|
"reason": "USER_INITIATED"
|
|
}
|
|
}
|
|
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
text = yield from req.text()
|
|
assert text == ''
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_intent_from_built_in_intent_library(alexa_client):
|
|
"""Test intents from the Built-in Intent Library."""
|
|
data = {
|
|
'request': {
|
|
'intent': {
|
|
'name': 'AMAZON.PlaybackAction<object@MusicCreativeWork>',
|
|
'slots': {
|
|
'object.byArtist.name': {
|
|
'name': 'object.byArtist.name',
|
|
'value': 'the shins'
|
|
},
|
|
'object.composer.name': {
|
|
'name': 'object.composer.name'
|
|
},
|
|
'object.contentSource': {
|
|
'name': 'object.contentSource'
|
|
},
|
|
'object.era': {
|
|
'name': 'object.era'
|
|
},
|
|
'object.genre': {
|
|
'name': 'object.genre'
|
|
},
|
|
'object.name': {
|
|
'name': 'object.name'
|
|
},
|
|
'object.owner.name': {
|
|
'name': 'object.owner.name'
|
|
},
|
|
'object.select': {
|
|
'name': 'object.select'
|
|
},
|
|
'object.sort': {
|
|
'name': 'object.sort'
|
|
},
|
|
'object.type': {
|
|
'name': 'object.type',
|
|
'value': 'music'
|
|
}
|
|
}
|
|
},
|
|
'timestamp': '2016-12-14T23:23:37Z',
|
|
'type': 'IntentRequest',
|
|
'requestId': REQUEST_ID,
|
|
|
|
},
|
|
'session': {
|
|
'sessionId': SESSION_ID,
|
|
'application': {
|
|
'applicationId': APPLICATION_ID
|
|
}
|
|
}
|
|
}
|
|
req = yield from _intent_req(alexa_client, data)
|
|
assert req.status == 200
|
|
data = yield from req.json()
|
|
text = data.get("response", {}).get("outputSpeech",
|
|
{}).get("text")
|
|
assert text == "Playing the shins."
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_flash_briefing_invalid_id(alexa_client):
|
|
"""Test an invalid Flash Briefing ID."""
|
|
req = yield from _flash_briefing_req(alexa_client, 10000)
|
|
assert req.status == 404
|
|
text = yield from req.text()
|
|
assert text == ''
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_flash_briefing_date_from_str(alexa_client):
|
|
"""Test the response has a valid date parsed from string."""
|
|
req = yield from _flash_briefing_req(alexa_client, "weather")
|
|
assert req.status == 200
|
|
data = yield from req.json()
|
|
assert data[0].get(alexa.ATTR_UPDATE_DATE) == "2016-10-09T19:51:42.0Z"
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_flash_briefing_date_from_datetime(alexa_client):
|
|
"""Test the response has a valid date from a datetime object."""
|
|
req = yield from _flash_briefing_req(alexa_client, "weather")
|
|
assert req.status == 200
|
|
data = yield from req.json()
|
|
assert data[1].get(alexa.ATTR_UPDATE_DATE) == '2016-10-10T19:51:42.0Z'
|
|
|
|
|
|
@asyncio.coroutine
|
|
def test_flash_briefing_valid(alexa_client):
|
|
"""Test the response is valid."""
|
|
data = [{
|
|
"titleText": "NPR",
|
|
"redirectionURL": "https://npr.org",
|
|
"streamUrl": NPR_NEWS_MP3_URL,
|
|
"mainText": "",
|
|
"uid": "uuid",
|
|
"updateDate": '2016-10-10T19:51:42.0Z'
|
|
}]
|
|
|
|
req = yield from _flash_briefing_req(alexa_client, "news_audio")
|
|
assert req.status == 200
|
|
json = yield from req.json()
|
|
assert json == data
|