def test_parse_strings(self):
in_data = tags.string_tag('stra', '') + \
tags.string_tag('strb', 'test string')
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(2, len(parsed))
self.assertEqual('', parser.first(parsed, 'stra'))
self.assertEqual('test string', parser.first(parsed, 'strb'))
def test_parse_bool(self):
in_data = tags.bool_tag('bola', True) + \
tags.bool_tag('bolb', False)
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(2, len(parsed))
self.assertTrue(parser.first(parsed, 'bola'))
self.assertFalse(parser.first(parsed, 'bolb'))
def test_parse_binary_plist():
data = {"key": "value"}
in_data = tags.raw_tag("plst", plistlib.dumps(data,
fmt=plistlib.FMT_BINARY))
parsed = parser.parse(in_data, lookup_tag)
assert 1 == len(parsed)
assert data, parser.first(parsed, "plst")
def test_parse_binary_plist(self):
data = {"key": "value"}
in_data = tags.raw_tag("plst",
plistlib.dumps(data, fmt=plistlib.FMT_BINARY))
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(1, len(parsed))
self.assertEqual(data, parser.first(parsed, "plst"))
def test_parse_strings():
in_data = tags.string_tag("stra", "") + tags.string_tag(
"strb", "test string")
parsed = parser.parse(in_data, lookup_tag)
assert 2 == len(parsed)
assert "" == parser.first(parsed, "stra")
assert "test string" == parser.first(parsed, "strb")
def test_parse_strings(self):
in_data = tags.string_tag("stra", "") + tags.string_tag(
"strb", "test string")
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(2, len(parsed))
self.assertEqual("", parser.first(parsed, "stra"))
self.assertEqual("test string", parser.first(parsed, "strb"))
async def _do(self, action, retry=True, is_login=False, is_daap=True):
resp, status = await action()
if is_daap:
resp = parser.parse(resp, lookup_tag)
self._log_response(action.log_text, resp, is_daap)
if 200 <= status < 300:
return resp
# Seems to be the case?
if status == 500:
raise exceptions.NotSupportedError(
"command not supported at this stage")
if not is_login:
# If a request fails, try to login again before retrying
_LOGGER.info("implicitly logged out, logging in again")
await self.login()
# Retry once if we got a bad response, otherwise bail out
if retry:
return await self._do(action,
False,
is_login=is_login,
is_daap=is_daap)
raise exceptions.AuthenticationError("failed to login: " + str(status))
async def handle_remote_button(self, request):
"""Handle remote control buttons."""
self._verify_auth_parameters(request)
content = await request.content.read()
parsed = parser.parse(content, tag_definitions.lookup_tag)
self.last_button_pressed = self._convert_button(parsed)
self.buttons_press_count += 1
return web.Response(status=200)
def test_simple_pprint():
elem = tags.uint8_tag("uuu8", 12)
inner = tags.container_tag("conb", elem)
in_data = tags.container_tag("cona", inner)
parsed = parser.parse(in_data, lookup_tag)
assert (parser.pprint(parsed,
lookup_tag) == "cona: [container, container]\n"
" conb: [container, container 2]\n"
" uuu8: 12 [uint, uint8]\n")
def test_simple_pprint(self):
elem = tags.uint8_tag('uuu8', 12)
inner = tags.container_tag('conb', elem)
in_data = tags.container_tag('cona', inner)
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(parser.pprint(parsed, lookup_tag),
'cona: [container, container]\n' +
' conb: [container, container 2]\n' +
' uuu8: 12 [uint, uint8]\n')
def test_parse_value_in_container():
in_data = tags.container_tag(
"cona",
tags.uint8_tag("uuu8", 36) + tags.uint16_tag("uu16", 13000))
parsed = parser.parse(in_data, lookup_tag)
assert 1 == len(parsed)
inner = parser.first(parsed, "cona")
assert 2 == len(inner)
assert 36 == parser.first(inner, "uuu8")
assert 13000 == parser.first(inner, "uu16")
def test_parse_value_in_container(self):
in_data = tags.container_tag(
"cona",
tags.uint8_tag("uuu8", 36) + tags.uint16_tag("uu16", 13000))
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(1, len(parsed))
inner = parser.first(parsed, "cona")
self.assertEqual(2, len(inner))
self.assertEqual(36, parser.first(inner, "uuu8"))
self.assertEqual(13000, parser.first(inner, "uu16"))
async def test_pair_custom_pairing_guid(self):
await self._start(pin_code=PIN_CODE2, pairing_guid=PAIRING_GUID2)
url = self._pairing_url(PAIRING_CODE2)
data, _ = await utils.simple_get(url, self.loop)
# Verify content returned in pairingresponse
parsed = parser.parse(data, tag_definitions.lookup_tag)
self.assertEqual(parser.first(parsed, 'cmpa', 'cmpg'),
int(PAIRING_GUID2, 16))
def test_parse_uint_of_various_lengths():
in_data = (tags.uint8_tag("uuu8", 12) + tags.uint16_tag("uu16", 37888) +
tags.uint32_tag("uu32", 305419896) +
tags.uint64_tag("uu64", 8982983289232))
parsed = parser.parse(in_data, lookup_tag)
assert 4 == len(parsed)
assert 12 == parser.first(parsed, "uuu8")
assert 37888 == parser.first(parsed, "uu16")
assert 305419896 == parser.first(parsed, "uu32")
assert 8982983289232 == parser.first(parsed, "uu64")
def test_parse_value_in_container(self):
in_data = tags.container_tag('cona',
tags.uint8_tag('uuu8', 36) +
tags.uint16_tag('uu16', 13000))
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(1, len(parsed))
inner = parser.first(parsed, 'cona')
self.assertEqual(2, len(inner))
self.assertEqual(36, parser.first(inner, 'uuu8'))
self.assertEqual(13000, parser.first(inner, 'uu16'))
def test_parse_uint_of_various_lengths(self):
in_data = (tags.uint8_tag("uuu8", 12) +
tags.uint16_tag("uu16", 37888) +
tags.uint32_tag("uu32", 305419896) +
tags.uint64_tag("uu64", 8982983289232))
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(4, len(parsed))
self.assertEqual(12, parser.first(parsed, "uuu8"))
self.assertEqual(37888, parser.first(parsed, "uu16"))
self.assertEqual(305419896, parser.first(parsed, "uu32"))
self.assertEqual(8982983289232, parser.first(parsed, "uu64"))
def test_parse_uint_of_various_lengths(self):
in_data = tags.uint8_tag('uuu8', 12) + \
tags.uint16_tag('uu16', 37888) + \
tags.uint32_tag('uu32', 305419896) + \
tags.uint64_tag('uu64', 8982983289232)
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(4, len(parsed))
self.assertEqual(12, parser.first(parsed, 'uuu8'))
self.assertEqual(37888, parser.first(parsed, 'uu16'))
self.assertEqual(305419896, parser.first(parsed, 'uu32'))
self.assertEqual(8982983289232, parser.first(parsed, 'uu64'))
async def test_succesful_pairing(self):
await self._start()
url = self._pairing_url(PAIRING_CODE)
data, _ = await utils.simple_get(url, self.loop)
# Verify content returned in pairingresponse
parsed = parser.parse(data, tag_definitions.lookup_tag)
self.assertEqual(parser.first(parsed, 'cmpa', 'cmpg'), 1)
self.assertEqual(parser.first(parsed, 'cmpa', 'cmnm'), REMOTE_NAME)
self.assertEqual(parser.first(parsed, 'cmpa', 'cmty'), 'iPhone')
def test_simple_pprint(self):
elem = tags.uint8_tag("uuu8", 12)
inner = tags.container_tag("conb", elem)
in_data = tags.container_tag("cona", inner)
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(
parser.pprint(parsed, lookup_tag),
"cona: [container, container]\n" +
" conb: [container, container 2]\n" +
" uuu8: 12 [uint, uint8]\n",
)
def handle_set_parameter(self,
request: HttpRequest) -> Optional[HttpResponse]:
"""Handle incoming SET_PARAMETER request."""
_LOGGER.debug("Received SET_PARAMETER: %s", request)
if request.headers["Content-Type"] == "application/x-dmap-tagged":
tags = parser.parse(request.body, lookup_tag)
self.state.metadata.title = parser.first(tags, "mlit", "minm")
self.state.metadata.artist = parser.first(tags, "mlit", "asar")
self.state.metadata.album = parser.first(tags, "mlit", "asal")
return HttpResponse("RTSP", "1.0", 200, "OK",
{"CSeq": request.headers["CSeq"]}, b"")
async def test_pair_custom_pairing_guid(mock_pairing):
pairing, zeroconf, service = await mock_pairing(pin_code=PIN_CODE2,
pairing_guid=PAIRING_GUID2)
url = pairing_url(zeroconf, PAIRING_CODE2)
data, _ = await utils.simple_get(url)
await pairing.finish()
# Verify content returned in pairingresponse
parsed = parser.parse(data, tag_definitions.lookup_tag)
assert parser.first(parsed, "cmpa", "cmpg") == int(PAIRING_GUID2, 16)
assert service.credentials == PAIRING_GUID2
async def test_succesful_pairing(mock_pairing):
pairing, zeroconf, service = await mock_pairing()
url = pairing_url(zeroconf, PAIRING_CODE)
data, _ = await utils.simple_get(url)
await pairing.finish()
# Verify content returned in pairingresponse
parsed = parser.parse(data, tag_definitions.lookup_tag)
assert parser.first(parsed, "cmpa", "cmpg") == 1
assert parser.first(parsed, "cmpa", "cmnm") == REMOTE_NAME
assert parser.first(parsed, "cmpa", "cmty") == "iPhone"
assert service.credentials == PAIRING_GUID
async def perform_pairing(self, remote_name, expected_code, port):
"""Pair with a remote client.
This will perform a GET-request to the specified port and hand over
information to the client (pyatv) so that the pairing process can be
completed.
"""
server = f"http://127.0.0.1:{port}"
url = f"{server}/pairing?pairingcode={expected_code}&servicename=test"
data, _ = await utils.simple_get(url)
# Verify content returned in pairingresponse
parsed = parser.parse(data, tag_definitions.lookup_tag)
assert parser.first(parsed, "cmpa", "cmpg") == 1
assert parser.first(parsed, "cmpa", "cmnm") == remote_name
assert parser.first(parsed, "cmpa", "cmty") == "iPhone"
async def perform_pairing(self, pairing_response, port):
"""Pair with a remote client.
This will perform a GET-request to the specified port and hand over
information to the client (pyatv) so that the pairing process can be
completed.
"""
server = 'http://127.0.0.1:{}'.format(port)
url = '{}/pairing?pairingcode={}&servicename=test'.format(
server, pairing_response.pairing_code)
data, _ = await utils.simple_get(url, self.loop)
# Verify content returned in pairingresponse
parsed = parser.parse(data, tag_definitions.lookup_tag)
self.tc.assertEqual(parser.first(parsed, 'cmpa', 'cmpg'), 1)
self.tc.assertEqual(parser.first(parsed, 'cmpa', 'cmnm'),
pairing_response.remote_name)
self.tc.assertEqual(parser.first(parsed, 'cmpa', 'cmty'), 'iPhone')
async def _do(self, action, retry=True, is_login=False, is_daap=True):
resp, status = await action()
if is_daap:
resp = parser.parse(resp, lookup_tag)
self._log_response(str(action.__name__) + ': %s', resp, is_daap)
if 200 <= status < 300:
return resp
if not is_login:
# If a request fails, try to login again before retrying
_LOGGER.info('implicitly logged out, logging in again')
await self.login()
# Retry once if we got a bad response, otherwise bail out
if retry:
return (await self._do(
action, False, is_login=is_login, is_daap=is_daap))
raise exceptions.AuthenticationError(
'failed to login: ' + str(status))
def _do(self, action, retry=True, is_login=False, is_daap=True):
resp, status = yield from action()
if is_daap:
resp = parser.parse(resp, lookup_tag)
self._log_response(str(action.__name__) + ': %s', resp, is_daap)
if status >= 200 and status < 300:
return resp
# When a 403 is received we are likely logged out, so a new
# login must be performed to get a new session id
if status == 403:
_LOGGER.info('implicitly logged out, logging in again')
yield from self.login()
# Retry once if we got a bad response, otherwise bail out
if retry:
return (yield from self._do(action,
False,
is_login=is_login,
is_daap=is_daap))
else:
raise exceptions.AuthenticationError('failed to login: ' +
str(status))
def test_parse_bool(self):
in_data = tags.bool_tag("bola", True) + tags.bool_tag("bolb", False)
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(2, len(parsed))
self.assertTrue(parser.first(parsed, "bola"))
self.assertFalse(parser.first(parsed, "bolb"))
def test_parse_bytes(self):
in_data = tags.raw_tag("byte", b"\x01\xAA\xFF\x45")
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(1, len(parsed))
self.assertEqual("0x01aaff45", parser.first(parsed, "byte"))
def test_extract_simplified_container(self):
elem = tags.uint8_tag("uuu8", 12)
inner = tags.container_tag("conb", elem)
in_data = tags.container_tag("cona", inner)
parsed = parser.parse(in_data, lookup_tag)
self.assertEqual(12, parser.first(parsed, "cona", "conb", "uuu8"))
def test_ignore_value(self):
elem = tags.uint8_tag("igno", 44)
parsed = parser.parse(elem, lookup_tag)
self.assertEqual(parser.first(parsed, "igno"), None)
