def add_write_resp(aresponses: ResponsesMockServer, count, status=200):
async def handler(request):
return web.json_response(await request.json(), status=status)
aresponses.add(path_pattern='/history/datastore/set',
method_pattern='POST',
response=handler,
repeat=count)
async def test_ranges(app, client, aresponses: ResponsesMockServer):
vic = victoria.fget(app)
result = {
'metric': {
'__name__': 'sparkey/sensor'
},
'values': [
[1626367339.856, '1'],
[1626367349.856, '2'],
[1626367359.856, '3'],
],
}
aresponses.add(
path_pattern='/victoria/api/v1/query_range',
method_pattern='POST',
repeat=3,
response={
'status': 'success',
'data': {
'resultType': 'matrix',
'result': [result],
},
},
)
args = TimeSeriesRangesQuery(fields=['f1', 'f2', 'f3'])
retv = await vic.ranges(args)
assert retv == [TimeSeriesRange(**result)] * 3
async def test_fields(app, client, aresponses: ResponsesMockServer):
vic = victoria.fget(app)
aresponses.add(path_pattern='/victoria/api/v1/series',
method_pattern='POST',
response={
'status':
'success',
'data': [
{
'__name__':
'spock/setpoint-sensor-pair-2/setting[degC]'
},
{
'__name__': 'spock/actuator-1/value'
},
{
'__name__': 'sparkey/HERMS MT PID/integralReset'
},
{
'__name__':
'sparkey/HERMS HLT PID/inputValue[degC]'
},
]
})
args = TimeSeriesFieldsQuery(duration='1d')
assert await vic.fields(args) == [
'sparkey/HERMS HLT PID/inputValue[degC]',
'sparkey/HERMS MT PID/integralReset',
'spock/actuator-1/value',
'spock/setpoint-sensor-pair-2/setting[degC]',
]
def add_check_resp(aresponses: ResponsesMockServer, count, status=200):
async def handler(request):
return web.json_response({'ping': 'pong'}, status=status)
aresponses.add(path_pattern='/history/datastore/ping',
method_pattern='GET',
response=handler,
repeat=count)
def test_getmyip_json_service(aresponses: ResponsesMockServer,
event_loop: BaseEventLoop):
response = Response(body='{"ip": "1.2.3.5"}',
content_type='application/json')
aresponses.add('json.com', '/', 'GET', response)
assert get_ip([JSONService('http://json.com', 'ip')],
event_loop) == '1.2.3.5'
async def test_make_request(self, aresponses: ResponsesMockServer):
aresponses.add(
aresponses.ANY,
"/bot42:TEST/method",
"post",
aresponses.Response(
status=200,
text='{"ok": true, "result": 42}',
headers={"Content-Type": "application/json"},
),
)
session = AiohttpSession()
class TestMethod(TelegramMethod[int]):
__returning__ = int
def build_request(self) -> Request:
return Request(method="method", data={})
call = TestMethod()
with patch(
"aiogram.api.client.session.base.BaseSession.raise_for_status"
) as patched_raise_for_status:
result = await session.make_request("42:TEST", call)
assert isinstance(result, int)
assert result == 42
assert patched_raise_for_status.called_once()
async def test_resolve_rate(aresponses: ResponsesMockServer,
ok_response: Dict[str, Any]):
aresponses.add(TMDB_API_HOST, URL_PATH, "POST", response=ok_response)
result = await resolve_rate(movie_id=MOVIE_ID, rating=1.0)
assert result is True
aresponses.assert_plan_strictly_followed()
async def test_resolve_rate_tmdb_exception(aresponses: ResponsesMockServer):
aresponses.add(TMDB_API_HOST, URL_PATH, "POST",
aresponses.Response(status=500))
with pytest.raises(HTTPException):
await resolve_rate(movie_id=MOVIE_ID, rating=10.0)
aresponses.assert_plan_strictly_followed()
def test_getmyip_differing_ips(aresponses: ResponsesMockServer,
event_loop: BaseEventLoop):
aresponses.add('bad0.com', '/', 'GET', '1.2.3.6')
aresponses.add('bad1.com', '/', 'GET', '1.2.3.7')
with pytest.raises(InconsistentIPAddressesFound):
get_ip(
[TextService('http://bad0.com'),
TextService('http://bad1.com')], event_loop)
async def test_text_request(aresponses: ResponsesMockServer) -> None:
"""Test non XML response is handled correctly."""
aresponses.add(
MATCH_HOST,
"/response/text",
"GET",
aresponses.Response(status=200, text="OK"),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
response = await client._request("response/text")
assert response == "OK"
async def test_remote_search(aresponses: ResponsesMockServer) -> None:
"""Test remote search keypress is handled correctly."""
aresponses.add(
MATCH_HOST,
"/search/browse",
"POST",
aresponses.Response(status=200),
)
async with ClientSession() as session:
roku = Roku(HOST, session=session)
await roku.remote("search")
async def test_get_dns_state(
aresponses: ResponsesMockServer,
resolver: AsyncMock,
freezer,
) -> None:
"""Test get_dns_state is handled correctly."""
aresponses.add(
f"192.168.1.99:{PORT}",
"/support/hostname",
"GET",
aresponses.Response(status=200, text="OK"),
)
aresponses.add(
f"192.168.1.89:{PORT}",
"/support/hostname",
"GET",
aresponses.Response(status=200, text="OK"),
)
async with ClientSession() as session:
roku = Roku(HOST, session=session)
assert roku.get_dns_state() == {
"enabled": False,
"hostname": None,
"ip_address": None,
"resolved_at": None,
}
roku2 = Roku("roku.dev", session=session)
assert roku2.get_dns_state() == {
"enabled": True,
"hostname": "roku.dev",
"ip_address": None,
"resolved_at": None,
}
resolver.return_value = fake_addrinfo_results(["192.168.1.99"])
assert await roku2._request("support/hostname")
dns = roku2.get_dns_state()
assert dns["enabled"]
assert dns["hostname"] == "roku.dev"
assert dns["ip_address"] == "192.168.1.99"
assert dns["resolved_at"] == datetime(2022, 3, 27, 0, 0)
resolver.return_value = fake_addrinfo_results(["192.168.1.89"])
freezer.tick(delta=timedelta(hours=3))
assert await roku2._request("support/hostname")
dns = roku2.get_dns_state()
assert dns["enabled"]
assert dns["hostname"] == "roku.dev"
assert dns["ip_address"] == "192.168.1.89"
assert dns["resolved_at"] == datetime(2022, 3, 27, 3, 0)
async def test_http_error500(aresponses: ResponsesMockServer) -> None:
"""Test HTTP 500 response handling."""
aresponses.add(
MATCH_HOST,
"/http/500",
"GET",
aresponses.Response(text="Internal Server Error", status=500),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
with pytest.raises(RokuError):
assert await client._request("http/500")
async def test_ping(app, client, aresponses: ResponsesMockServer):
vic = victoria.fget(app)
aresponses.add(path_pattern='/victoria/health',
method_pattern='GET',
response='OK')
await vic.ping()
aresponses.add(path_pattern='/victoria/health',
method_pattern='GET',
response='NOK')
with pytest.raises(ConnectionError):
await vic.ping()
async def test_request_port(aresponses: ResponsesMockServer) -> None:
"""Test the handling of non-standard API port."""
aresponses.add(
f"{HOST}:{NON_STANDARD_PORT}",
"/support/port",
"GET",
aresponses.Response(status=200, text="OK"),
)
async with ClientSession() as session:
client = Roku(host=HOST, port=NON_STANDARD_PORT, session=session)
response = await client._request("support/port")
assert response == "OK"
async def test_post_request(aresponses: ResponsesMockServer) -> None:
"""Test POST requests are handled correctly."""
aresponses.add(
MATCH_HOST,
"/method/post",
"POST",
aresponses.Response(status=200, text="OK"),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
response = await client._request("method/post", method="POST")
assert response == "OK"
async def test_search(aresponses: ResponsesMockServer) -> None:
"""Test search is handled correctly."""
aresponses.add(
MATCH_HOST,
"/search/browse?keyword=test",
"POST",
aresponses.Response(status=200, text="OK"),
match_querystring=True,
)
async with ClientSession() as session:
roku = Roku(HOST, session=session)
await roku.search("test")
async def test_tune(aresponses: ResponsesMockServer) -> None:
"""Test tune is handled correctly."""
aresponses.add(
MATCH_HOST,
"/launch/tvinput.dtv?ch=13.4",
"POST",
aresponses.Response(status=200, text="OK"),
match_querystring=True,
)
async with ClientSession() as session:
roku = Roku(HOST, session=session)
await roku.tune("13.4")
async def test_http_error404(aresponses: ResponsesMockServer) -> None:
"""Test HTTP 404 response handling."""
aresponses.add(
MATCH_HOST,
"/http/404",
"GET",
aresponses.Response(text="Not Found!", status=404),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
with pytest.raises(RokuError):
assert await client._request("http/404")
async def test_batch_get_success(
aresponses: ResponsesMockServer,
context: Dict[str, Any],
query_paths: List[str],
json_companies: List[Dict[str, Any]],
company_keys: List[int],
):
for path, json_company in zip(query_paths, json_companies):
aresponses.add(TMDB_API_HOST, path, "GET", response=json_company)
company_loader = CompanyLoader.for_context(context)
companies = await company_loader.load_many(company_keys)
assert companies == [Company(**jc) for jc in json_companies]
aresponses.assert_plan_strictly_followed()
async def discovery_resp(app, aresponses: ResponsesMockServer, loop, mocker):
config = app['config']
mdns_host = config['mdns_host']
mdns_port = config['mdns_port']
for i in range(100):
aresponses.add(
f'{mdns_host}:{mdns_port}', '/mdns/discover', 'POST',
web.json_response({'host': 'enterprise', 'port': 1234})
)
aresponses.add(
f'mdns_error_host:{mdns_port}', '/mdns/discover', 'POST',
web.json_response({}, status=500)
)
return aresponses
async def test_csv(app, client, aresponses: ResponsesMockServer):
vic = victoria.fget(app)
aresponses.add(
path_pattern='/victoria/api/v1/export',
method_pattern='POST',
response='\n'.join([
'{"metric":{"__name__":"sparkey/HERMS BK PWM/setting"},' +
'"values":[0,0,0,0,0,0,0],' +
'"timestamps":[1626368070381,1626368075435,1626368080487,1626368085534,'
+ '1626368090630,1626368095687,1626368100749]}',
'{"metric":{"__name__":"sparkey/HERMS BK PWM/setting"},' +
'"values":[0,0,0,0],' +
'"timestamps":[1626368105840,1626368110891,1626368115940,1626368121034]}',
'{"metric":{"__name__":"spock/actuator-1/value"},' +
'"values":[40,40,40,40,40,40,40,40,40,40,40],' +
'"timestamps":[1626368070380,1626368078080,1626368083130,1626368088178,'
+
'1626368093272,1626368098328,1626368103383,1626368108480,1626368113533,1626368118579,1626368123669]}',
'{"metric":{"__name__":"spock/pin-actuator-1/state"},' +
'"values":[0,0,0,0,0,0,0,0,0,0,0],' +
'"timestamps":[1626368070380,1626368078080,1626368083130,1626368088178,'
+
'1626368093272,1626368098328,1626368103383,1626368108480,1626368113533,1626368118579,1626368123669]}',
]))
args = TimeSeriesCsvQuery(
fields=[
'sparkey/HERMS BK PWM/setting', 'spock/pin-actuator-1/state',
'spock/actuator-1/value'
],
precision='ISO8601',
)
result = []
async for line in vic.csv(args):
result.append(line)
assert len(result) == 23 # headers, 11 from sparkey, 11 from spock
assert result[0] == ','.join(['time'] + args.fields)
# line 1: values from spock
line = result[1].split(',')
assert ciso8601.parse_datetime(line[0])
assert line[1:] == ['', '0', '40']
# line 2: values from sparkey
line = result[2].split(',')
assert ciso8601.parse_datetime(line[0])
assert line[1:] == ['0', '', '']
async def test_get_active_app(aresponses: ResponsesMockServer) -> None:
"""Test _get_active_app method is handled correctly."""
aresponses.add(
MATCH_HOST,
"/query/active-app",
"GET",
aresponses.Response(
status=200,
headers={"Content-Type": "application/xml"},
text=load_fixture("active-app-amazon.xml"),
),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
assert await client._get_active_app()
def add_read_resp(aresponses: ResponsesMockServer, count, status=200):
async def handler(request):
return web.json_response(
{
'values': [{
'id': const.GLOBAL_UNITS_ID,
'namespace': const.GLOBAL_NAMESPACE,
'temperature': 'degF',
}]
},
status=status)
aresponses.add(path_pattern='/history/datastore/mget',
method_pattern='POST',
response=handler,
repeat=count)
async def test_get_media_state_play(aresponses: ResponsesMockServer) -> None:
"""Test _get_media_state method is handled correctly with playing media."""
aresponses.add(
MATCH_HOST,
"/query/media-player",
"GET",
aresponses.Response(
status=200,
headers={"Content-Type": "application/xml"},
text=load_fixture("media-player-pluto-play.xml"),
),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
assert await client._get_media_state()
async def test_play_on_roku(aresponses: ResponsesMockServer) -> None:
"""Test play_on_roku is handled correctly."""
video_url = "http://example.com/video file÷awe.mp4?v=2"
encoded = "http%3A%2F%2Fexample.com%2Fvideo+file%C3%B7awe.mp4%3Fv%3D2"
aresponses.add(
MATCH_HOST,
f"/input/15985?t=v&u={encoded}",
"POST",
aresponses.Response(status=200),
match_querystring=True,
)
async with ClientSession() as session:
roku = Roku(HOST, session=session)
await roku.play_on_roku(video_url)
async def test_get_tv_channels(aresponses: ResponsesMockServer) -> None:
"""Test _get_tv_channels method is handled correctly."""
aresponses.add(
MATCH_HOST,
"/query/tv-channels",
"GET",
aresponses.Response(
status=200,
headers={"Content-Type": "application/xml"},
text="<other>value</other>",
),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
with pytest.raises(RokuError):
assert await client._get_tv_channels()
async def test_get_apps_single_app(aresponses: ResponsesMockServer) -> None:
"""Test _get_apps method is handled correctly with single app."""
aresponses.add(
MATCH_HOST,
"/query/apps",
"GET",
aresponses.Response(
status=200,
headers={"Content-Type": "application/xml"},
text=load_fixture("apps-single.xml"),
),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
res = await client._get_apps()
assert isinstance(res, list)
assert len(res) == 1
async def test_internal_session(aresponses: ResponsesMockServer) -> None:
"""Test JSON response is handled correctly with internal session."""
aresponses.add(
MATCH_HOST,
"/response/xml",
"GET",
aresponses.Response(
status=200,
headers={"Content-Type": "application/xml"},
text="<status>OK</status>",
),
)
async with Roku(HOST) as client:
response = await client._request("response/xml")
assert isinstance(response, dict)
assert response["status"] == "OK"
async def test_xml_request_parse_error(
aresponses: ResponsesMockServer) -> None:
"""Test invalid XML response is handled correctly."""
aresponses.add(
MATCH_HOST,
"/response/xml-parse-error",
"GET",
aresponses.Response(
status=200,
headers={"Content-Type": "application/xml"},
text="<!status>>",
),
)
async with ClientSession() as session:
client = Roku(HOST, session=session)
with pytest.raises(RokuError):
assert await client._request("response/xml-parse-error")