def _http_query(self, query, timeout=None):
"""
Query Transmission through HTTP.
"""
headers = {"x-transmission-session-id": str(self.session_id)}
result = {}
request_count = 0
if timeout is None:
timeout = self._query_timeout
use_logger = is_logger_configured()
while True:
if use_logger:
LOGGER.debug(
json.dumps(
{
"url": self.url,
"headers": headers,
"query": query,
"timeout": timeout,
},
indent=2,
))
try:
result = self.http_handler.request(self.url, query, headers,
timeout)
break
except HTTPHandlerError as error:
if error.code == 409:
if use_logger:
LOGGER.info(
"Server responded with 409, trying to set session-id."
)
if request_count > 1:
raise TransmissionError(
"Session ID negotiation failed.", error)
session_id = None
for key in list(error.headers.keys()):
if key.lower() == "x-transmission-session-id":
session_id = error.headers[key]
self.session_id = session_id
headers = {
"x-transmission-session-id":
str(self.session_id)
}
if session_id is None:
if use_logger:
debug_httperror(error)
raise TransmissionError("Unknown conflict.", error)
else:
if use_logger:
debug_httperror(error)
raise TransmissionError("Request failed.", error)
request_count += 1
return result
def mock_api_connection_error():
"""Mock an api."""
with patch(
"transmissionrpc.Client",
side_effect=TransmissionError("111: Connection refused"),
):
yield
async def test_reauth_failed_connection_error(
hass: HomeAssistant, mock_api: MagicMock
) -> None:
"""Test we can't reauth due to connection error."""
entry = MockConfigEntry(
domain=transmission.DOMAIN,
data=MOCK_CONFIG_DATA,
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
transmission.DOMAIN,
context={
"source": config_entries.SOURCE_REAUTH,
"entry_id": entry.entry_id,
},
data=MOCK_CONFIG_DATA,
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "reauth_confirm"
assert result["description_placeholders"] == {"username": "******"}
mock_api.side_effect = TransmissionError("111: Connection refused")
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"password": "******",
},
)
assert result2["type"] == FlowResultType.FORM
assert result2["errors"] == {"base": "cannot_connect"}
def _http_query(self, query, timeout=None):
"""
Query Transmission through HTTP.
"""
headers = {'x-transmission-session-id': str(self.session_id)}
result = {}
request_count = 0
if timeout is None:
timeout = self._query_timeout
while True:
LOGGER.debug(
json.dumps(
{
'url': self.url,
'headers': headers,
'query': query,
'timeout': timeout
},
indent=2))
try:
result = self.http_handler.request(self.url, query, headers,
timeout)
break
except HTTPHandlerError as error:
if error.code == 409:
LOGGER.info(
'Server responded with 409, trying to set session-id.')
if request_count > 1:
raise TransmissionError(
'Session ID negotiation failed.', error)
session_id = None
for key in list(error.headers.keys()):
if key.lower() == 'x-transmission-session-id':
session_id = error.headers[key]
self.session_id = session_id
headers = {
'x-transmission-session-id':
str(self.session_id)
}
if session_id is None:
debug_httperror(error)
raise TransmissionError('Unknown conflict.', error)
else:
debug_httperror(error)
raise TransmissionError('Request failed.', error)
request_count += 1
return result
async def test_setup_failed_auth_error(hass: HomeAssistant,
mock_api: MagicMock) -> None:
"""Test integration failed due to invalid credentials error."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_CONFIG_DATA)
entry.add_to_hass(hass)
mock_api.side_effect = TransmissionError("401: Unauthorized")
await hass.config_entries.async_setup(entry.entry_id)
assert entry.state == ConfigEntryState.SETUP_ERROR
async def test_setup_failed_connection_error(hass: HomeAssistant,
mock_api: MagicMock) -> None:
"""Test integration failed due to connection error."""
entry = MockConfigEntry(domain=DOMAIN, data=MOCK_CONFIG_DATA)
entry.add_to_hass(hass)
mock_api.side_effect = TransmissionError("111: Connection refused")
await hass.config_entries.async_setup(entry.entry_id)
assert entry.state == ConfigEntryState.SETUP_RETRY
async def test_setup_failed(opp):
"""Test transmission failed due to an error."""
entry = MOCK_ENTRY
entry.add_to_opp(opp)
# test connection error raising ConfigEntryNotReady
with patch(
"transmissionrpc.Client",
side_effect=TransmissionError("111: Connection refused"),
), pytest.raises(ConfigEntryNotReady):
await transmission.async_setup_entry(opp, entry)
# test Authentication error returning false
with patch("transmissionrpc.Client",
side_effect=TransmissionError("401: Unauthorized")):
assert await transmission.async_setup_entry(opp, entry) is False
async def test_error_on_connection_failure(
hass: HomeAssistant, mock_api: MagicMock
) -> None:
"""Test we handle cannot connect error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
mock_api.side_effect = TransmissionError("111: Connection refused")
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
MOCK_CONFIG_DATA,
)
assert result2["type"] == FlowResultType.FORM
assert result2["errors"] == {"base": "cannot_connect"}
async def test_error_on_wrong_credentials(
hass: HomeAssistant, mock_api: MagicMock
) -> None:
"""Test we handle invalid credentials."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
mock_api.side_effect = TransmissionError("401: Unauthorized")
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
MOCK_CONFIG_DATA,
)
assert result2["type"] == FlowResultType.FORM
assert result2["errors"] == {
"username": "******",
"password": "******",
}
def _request(self,
method,
arguments=None,
ids=None,
require_ids=False,
timeout=None):
"""
Send json-rpc request to Transmission using http POST
"""
if not isinstance(method, string_types):
raise ValueError('request takes method as string')
if arguments is None:
arguments = {}
if not isinstance(arguments, dict):
raise ValueError('request takes arguments as dict')
ids = parse_torrent_ids(ids)
if len(ids) > 0:
arguments['ids'] = ids
elif require_ids:
raise ValueError('request require ids')
query = json.dumps({
'tag': self._sequence,
'method': method,
'arguments': arguments
})
self._sequence += 1
start = time.time()
http_data = self._http_query(query, timeout)
elapsed = time.time() - start
LOGGER.info('http request took %.3f s' % (elapsed))
try:
data = json.loads(http_data)
except ValueError as error:
LOGGER.error('Error: ' + str(error))
LOGGER.error('Request: \"%s\"' % (query))
LOGGER.error('HTTP data: \"%s\"' % (http_data))
raise
LOGGER.debug(json.dumps(data, indent=2))
if 'result' in data:
if data['result'] != 'success':
raise TransmissionError('Query failed with result \"%s\".' %
(data['result']))
else:
raise TransmissionError('Query failed without result.')
results = {}
if method == 'torrent-get':
for item in data['arguments']['torrents']:
results[item['id']] = Torrent(self, item)
if self.protocol_version == 2 and 'peers' not in item:
self.protocol_version = 1
elif method == 'torrent-add':
item = None
if 'torrent-added' in data['arguments']:
item = data['arguments']['torrent-added']
elif 'torrent-duplicate' in data['arguments']:
item = data['arguments']['torrent-duplicate']
if item:
results[item['id']] = Torrent(self, item)
else:
raise TransmissionError('Invalid torrent-add response.')
elif method == 'session-get':
self._update_session(data['arguments'])
elif method == 'session-stats':
# older versions of T has the return data in "session-stats"
if 'session-stats' in data['arguments']:
self._update_session(data['arguments']['session-stats'])
else:
self._update_session(data['arguments'])
elif method in ('port-test', 'blocklist-update', 'free-space',
'torrent-rename-path'):
results = data['arguments']
else:
return None
return results
def mock_api_authentication_error():
"""Mock an api."""
with patch(
"transmissionrpc.Client", side_effect=TransmissionError("401: Unauthorized")
):
yield
http_data = self._http_query(query, timeout)
elapsed = time.time() - start
LOGGER.info('http request took %.3f s' % (elapsed))
try:
data = json.loads(http_data)
except ValueError, error:
LOGGER.error('Error: ' + str(error))
LOGGER.error('Request: \"%s\"' % (query))
LOGGER.error('HTTP data: \"%s\"' % (http_data))
raise
LOGGER.debug(json.dumps(data, indent=2))
if 'result' in data:
if data['result'] != 'success':
raise TransmissionError('Query failed with result \"%s\".' %
(data['result']))
else:
raise TransmissionError('Query failed without result.')
results = {}
if method == 'torrent-get':
for item in data['arguments']['torrents']:
results[item['id']] = Torrent(self, item)
if self.protocol_version == 2 and 'peers' not in item:
self.protocol_version = 1
elif method == 'torrent-add':
item = data['arguments']['torrent-added']
results[item['id']] = Torrent(self, item)
elif method == 'session-get':
self._update_session(data['arguments'])
elif method == 'session-stats':
def _request(self,
method,
arguments=None,
ids=None,
require_ids=False,
timeout=None):
"""
Send json-rpc request to Transmission using http POST
"""
if not isinstance(method, str):
raise ValueError("request takes method as string")
if arguments is None:
arguments = {}
if not isinstance(arguments, dict):
raise ValueError("request takes arguments as dict")
ids = parse_torrent_ids(ids)
if ids:
arguments["ids"] = ids
elif require_ids:
raise ValueError("request require ids")
use_logger = is_logger_configured()
query = json.dumps({
"tag": self._sequence,
"method": method,
"arguments": arguments
})
self._sequence += 1
start = time.time()
http_data = self._http_query(query, timeout)
if isinstance(http_data, bytes):
http_data = str(http_data, encoding="utf-8", errors="replace")
http_data = "".join(
list(filter(lambda c: unicodedata.category(c)[0] != "C",
http_data)))
elapsed = time.time() - start
if use_logger:
LOGGER.info("http request took %.3f s", elapsed)
try:
data = json.loads(http_data)
except ValueError as error:
if use_logger:
LOGGER.error("Error: %s", str(error))
LOGGER.error('Request: "%s"', query)
LOGGER.error('HTTP data: "%s"', http_data)
raise
if use_logger:
LOGGER.debug(json.dumps(data, indent=2))
if "result" in data:
if data["result"] != "success":
raise TransmissionError('Query failed with result "%s".' %
(data["result"]))
else:
raise TransmissionError("Query failed without result.")
results = {}
if method == "torrent-get":
for item in data["arguments"]["torrents"]:
results[item["id"]] = Torrent(self, item)
if self.protocol_version == 2 and "peers" not in item:
self.protocol_version = 1
elif method == "torrent-add":
item = None
if "torrent-added" in data["arguments"]:
item = data["arguments"]["torrent-added"]
elif "torrent-duplicate" in data["arguments"]:
item = data["arguments"]["torrent-duplicate"]
if item:
results[item["id"]] = Torrent(self, item)
else:
raise TransmissionError("Invalid torrent-add response.")
elif method == "session-get":
self._update_session(data["arguments"])
elif method == "session-stats":
# older versions of T has the return data in "session-stats"
if "session-stats" in data["arguments"]:
self._update_session(data["arguments"]["session-stats"])
else:
self._update_session(data["arguments"])
elif method in (
"port-test",
"blocklist-update",
"free-space",
"torrent-rename-path",
):
results = data["arguments"]
else:
return None
return results
