async def test_remove_entry_app_api_error(hass, config_entry, smartthings_mock):
"""Test raises exceptions removing the app."""
# Arrange
request_info = Mock(real_url="http://example.com")
smartthings_mock.delete_app.side_effect = ClientResponseError(
request_info=request_info, history=None, status=HTTP_INTERNAL_SERVER_ERROR
)
# Act
with pytest.raises(ClientResponseError):
await smartthings.async_remove_entry(hass, config_entry)
# Assert
assert smartthings_mock.delete_installed_app.call_count == 1
assert smartthings_mock.delete_app.call_count == 1
async def test_async_setup_raises_fails_if_auth_fails(hass: HomeAssistant):
"""Test that setup fails if auth fails during setup."""
config_entry = MockConfigEntry(
domain=DOMAIN,
data={CONF_HOST: "some host", CONF_ACCESS_TOKEN: "test-token"},
)
config_entry.add_to_hass(hass)
with patch_bond_version(
side_effect=ClientResponseError(MagicMock(), MagicMock(), status=401)
):
await hass.config_entries.async_setup(config_entry.entry_id)
assert config_entry.state is ConfigEntryState.SETUP_ERROR
async def test_unknown_api_error(hass, smartthings_mock):
"""Test an error is shown when there is an unknown API error."""
flow = SmartThingsFlowHandler()
flow.hass = hass
smartthings_mock.return_value.apps.return_value = mock_coro(
exception=ClientResponseError(None, None, status=404))
result = await flow.async_step_user({'access_token': str(uuid4())})
assert result['type'] == data_entry_flow.RESULT_TYPE_FORM
assert result['step_id'] == 'user'
assert result['errors'] == {'base': 'app_setup_error'}
async def test_token_unauthorized(hass, smartthings_mock):
"""Test an error is shown when the token is not authorized."""
flow = SmartThingsFlowHandler()
flow.hass = hass
smartthings_mock.return_value.apps.return_value = mock_coro(
exception=ClientResponseError(None, None, status=401))
result = await flow.async_step_user({'access_token': str(uuid4())})
assert result['type'] == data_entry_flow.RESULT_TYPE_FORM
assert result['step_id'] == 'user'
assert result['errors'] == {'access_token': 'token_unauthorized'}
async def test_scenes_api_errors_raise_not_ready(
hass, config_entry, app, installed_app, smartthings_mock
):
"""Test if scenes are unauthorized we continue to load platforms."""
config_entry.add_to_hass(hass)
request_info = Mock(real_url="http://example.com")
smartthings_mock.app.return_value = app
smartthings_mock.installed_app.return_value = installed_app
smartthings_mock.scenes.side_effect = ClientResponseError(
request_info=request_info, history=None, status=HTTP_INTERNAL_SERVER_ERROR
)
with pytest.raises(ConfigEntryNotReady):
await smartthings.async_setup_entry(hass, config_entry)
async def test_zeroconf_already_configured_refresh_token(
hass: core.HomeAssistant):
"""Test starting a flow from zeroconf when already configured and the token is out of date."""
entry2 = MockConfigEntry(
domain=DOMAIN,
unique_id="not-the-same-bond-id",
data={
CONF_HOST: "stored-host",
CONF_ACCESS_TOKEN: "correct-token"
},
)
entry2.add_to_hass(hass)
entry = MockConfigEntry(
domain=DOMAIN,
unique_id="already-registered-bond-id",
data={
CONF_HOST: "stored-host",
CONF_ACCESS_TOKEN: "incorrect-token"
},
)
entry.add_to_hass(hass)
with patch_bond_version(side_effect=ClientResponseError(
MagicMock(), MagicMock(), status=401)):
await hass.config_entries.async_setup(entry.entry_id)
assert entry.state is ConfigEntryState.SETUP_ERROR
with _patch_async_setup_entry() as mock_setup_entry, patch_bond_token(
return_value={"token": "discovered-token"}):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf.ZeroconfServiceInfo(
host="updated-host",
addresses=["updated-host"],
hostname="mock_hostname",
name="already-registered-bond-id.some-other-tail-info",
port=None,
properties={},
type="mock_type",
),
)
await hass.async_block_till_done()
assert result["type"] == "abort"
assert result["reason"] == "already_configured"
assert entry.data["host"] == "updated-host"
assert entry.data[CONF_ACCESS_TOKEN] == "discovered-token"
# entry2 should not get changed
assert entry2.data[CONF_ACCESS_TOKEN] == "correct-token"
assert len(mock_setup_entry.mock_calls) == 1
async def test_remove_entry_installedapp_api_error(
hass, config_entry, smartthings_mock
):
"""Test raises exceptions removing the installed app."""
# Arrange
smartthings_mock.delete_installed_app.side_effect = ClientResponseError(
None, None, status=500
)
# Act
with pytest.raises(ClientResponseError):
await smartthings.async_remove_entry(hass, config_entry)
# Assert
assert smartthings_mock.delete_installed_app.call_count == 1
assert smartthings_mock.delete_app.call_count == 0
async def test_remove_entry_app_api_error(hass, config_entry,
smartthings_mock):
"""Test raises exceptions removing the app."""
# Arrange
api = smartthings_mock.return_value
api.delete_installed_app.side_effect = lambda _: mock_coro()
api.delete_app.side_effect = lambda _: mock_coro(
exception=ClientResponseError(None, None, status=500))
# Act
with pytest.raises(ClientResponseError):
await smartthings.async_remove_entry(hass, config_entry)
# Assert
assert api.delete_installed_app.call_count == 1
assert api.delete_app.call_count == 1
async def test_recoverable_api_errors_raise_not_ready(
hass, config_entry, smartthings_mock
):
"""Test config entry not ready raised for recoverable API errors."""
config_entry.add_to_hass(hass)
request_info = Mock(real_url="http://example.com")
smartthings_mock.app.side_effect = ClientResponseError(
request_info=request_info,
history=None,
status=HTTPStatus.INTERNAL_SERVER_ERROR,
)
with pytest.raises(ConfigEntryNotReady):
await smartthings.async_setup_entry(hass, config_entry)
async def test_form_response_errors(
opp, mock_login, mock_get_devices, mock_request_info, error, message
):
"""Test we handle response errors."""
mock_login.side_effect = ClientResponseError(mock_request_info(), (), status=error)
result = await opp.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
data={"username": "******", "password": "******"},
)
assert result["type"] == "abort"
assert result["reason"] == message
async def test_token_forbidden(hass, smartthings_mock):
"""Test an error is shown when the token is forbidden."""
flow = SmartThingsFlowHandler()
flow.hass = hass
request_info = Mock(real_url="http://example.com")
smartthings_mock.apps.side_effect = ClientResponseError(
request_info=request_info, history=None, status=403)
result = await flow.async_step_user({"access_token": str(uuid4())})
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "user"
assert result["errors"] == {"access_token": "token_forbidden"}
async def test_step_pat_unknown_api_error(hass, smartthings_mock):
"""Test an error is shown when there is an unknown API error."""
flow = SmartThingsFlowHandler()
flow.hass = hass
request_info = Mock(real_url="http://example.com")
smartthings_mock.apps.side_effect = ClientResponseError(
request_info=request_info, history=None, status=HTTP_NOT_FOUND)
token = str(uuid4())
result = await flow.async_step_pat({CONF_ACCESS_TOKEN: token})
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "pat"
assert result["errors"] == {"base": "app_setup_error"}
assert result["data_schema"]({}) == {CONF_ACCESS_TOKEN: token}
async def test_if_same_site_and_not_html_head_not_supported(self, m):
exception = ClientResponseError(None, None, status=405)
self._prep_request(
m,
TEST_HOME_URL,
headexception=exception,
content_type=TYPE_JSON)
async with ClientSession() as session:
response = await self.testobj.fetch_response(
session, self.urltarget)
self.assertIs(self.urltarget, response.urltarget)
self.assertEqual(200, response.status)
self.assertIsNone(response.html)
self.assertIsNone(response.error)
self.assertEqual(TEST_EXPECTED_ELAPSED, response.elapsed)
async def test_step_pat_forbidden(hass, smartthings_mock):
"""Test an error is shown when the token is forbidden."""
flow = SmartThingsFlowHandler()
flow.hass = hass
request_info = Mock(real_url="http://example.com")
smartthings_mock.apps.side_effect = ClientResponseError(
request_info=request_info, history=None, status=HTTP_FORBIDDEN)
token = str(uuid4())
result = await flow.async_step_pat({CONF_ACCESS_TOKEN: token})
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "pat"
assert result["errors"] == {CONF_ACCESS_TOKEN: "token_forbidden"}
assert result["data_schema"]({}) == {CONF_ACCESS_TOKEN: token}
async def update(self):
resp = await self.session.get(self.url)
if resp.status == 200:
data = await resp.json()
else:
raise ClientResponseError(resp.request_info, resp.history)
self.count = data['status']['count']
for gd in data['GroundDelays']['groundDelay']:
# Define a ground delay object and append that to the list of nationwide ground delays
gdelay = GroundDelay(gd['airport'], True, gd['avgTime'],
gd['reason'])
self.ground_delays.append(gdelay)
self.ground_delay_count = data['GroundDelays']['count']
for gs in data['GroundStops']['groundStop']:
# Define a ground stop object and append that to the list of nationwide ground stops
stop = GroundStop(gs['airport'], True, gs['endTime'], gs['reason'])
self.ground_stops.append(stop)
self.ground_stop_count = data['GroundStops']['count']
for ad in data['ArriveDepartDelays']['arriveDepart']:
# Define an Arrival/Departure object and append that to the list of nationwide arrival/departure delays
ardp = ArriveDepartDelay(
ad['airport'],
True,
ad['minTime'],
ad['maxTime'],
None, # The API does not provide a trend for Arrival/Departure delays from the nationwide call so none will be passed through.
ad['reason'])
self.arrive_depart_delays.append(ardp)
self.arrive_depart_count = data['ArriveDepartDelays']['count']
for cl in data['Closures']['closure']:
# Define a closure object and append that to the list of nationwide closures
close = Closure(
cl['airport'],
True,
None, # The API does not provide a beginning time for a closure from the nationwide call so none will be passed through.
cl['reopen'],
cl['reason'])
self.closures.append(close)
self.closure_count = data['Closures']['count']
async def test_server_error(hass: HomeAssistant, mock_get_regions) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.side_effect = ClientResponseError(None, None, status=500)
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "unknown"}
async def load_resource(cls, ticker) -> str:
res = await cls.SESSION.get(
f"{cls.BASE_URL}{ticker}",
headers={
"User-Agent": cls.USER_AGENT,
"Accept": "text/html",
"Accept-Language": "en,ru;q=0.9,cs;q=0.8,la;q=0.7",
"Accept-Encoding": "gzip, deflate",
},
)
if res.status != 200 or "lookup" in res.url.path:
raise ClientResponseError(res.request_info,
res.history,
status=res.status,
message=res.reason,
headers=res.headers)
return await res.text(encoding="utf-8")
async def _get_power_log(self, device):
"""Get power log from the device."""
headers = {
'Pragma': 'no-cache',
'Cache-Control': 'no-cache',
'Expires': '-1',
'auth': device['auth'],
'Origin': 'file://',
'CPToken': self.CPToken,
'Content-Type': 'application/json',
'Charset': 'utf-8',
'User-Agent': USERAGENT,
'Host': self.host,
'Connection': 'Keep-Alive'
}
payload = {
'gw_id': device['GWID'],
'aread_ids': [0],
'from': datetime.datetime.now().strftime('%Y/%m/%d'),
'unit': 'hour',
'max_num': 24
}
print(payload)
print('url:' + 'https://' + self.host + '/api/PowerGetCTAreaLog')
async with self.session.post('https://' + self.host +
'/api/PowerGetCTAreaLog',
data=json.dumps(payload),
headers=headers) as response:
if response.status != 200:
raise ClientResponseError(
request_info=None,
history=None,
status=response.status,
message=('Get power log error. '
'status = ' + str(response.status) + ', '
'data = ' + json.dumps(payload) + ', '
'headers = ' + json.dumps(headers) + '.'))
response_json = await response.json()
print(response_json)
info = response_json.get('Areas')[0].get('kwh')
if response_json.get('status') == 'success':
return info
else:
return None
async def test_form_unexpected_error(hass: core.HomeAssistant):
"""Test we handle unexpected error gracefully."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
with patch_bond_device_ids(
side_effect=ClientResponseError(Mock(), Mock(), status=500)):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
CONF_HOST: "some host",
CONF_ACCESS_TOKEN: "test-token"
},
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "unknown"}
async def _device_status(self, device, commands):
"""Get device status."""
headers = {
'Pragma': 'no-cache',
'Cache-Control': 'no-cache',
'Expires': '-1',
'CPToken': self.CPToken,
'auth': device['auth'],
'Content-Type': 'application/json',
'Charset': 'utf-8',
'User-Agent': USERAGENT,
'Host': self.host,
'Connection': 'Keep-Alive'
}
command_list = []
for command in commands:
command_list.append(
{'CommandType': '{0:#0{1}x}'.format(command, 4)})
payload = [{
'CommandTypes': command_list,
'DeviceID': int(device['DeviceID'])
}]
async with self.session.post('https://' + self.host +
'/api/DeviceGetInfo',
data=json.dumps(payload),
headers=headers) as response:
if response.status != 200:
raise ClientResponseError(
request_info=None,
history=None,
status=response.status,
message=('Get device status error. '
'status = ' + str(response.status) + ', '
'data = ' + json.dumps(payload) + ', '
'headers = ' + json.dumps(headers) + '.'))
response_json = await response.json()
info = response_json.get('devices')[0].get('Info')
if response_json.get('status') == 'success':
return info
else:
return None
async def test_user_form_invalid_auth(hass: core.HomeAssistant):
"""Test we handle invalid auth."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
with patch_bond_version(
return_value={"bond_id": "test-bond-id"}), patch_bond_device_ids(
side_effect=ClientResponseError(Mock(), Mock(), status=401), ):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
CONF_HOST: "some host",
CONF_ACCESS_TOKEN: "test-token"
},
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "invalid_auth"}
async def test_august_api_is_failing(hass):
"""Config entry state is SETUP_RETRY when august api is failing."""
config_entry = MockConfigEntry(
domain=DOMAIN,
data=_mock_get_config()[DOMAIN],
title="August august",
)
config_entry.add_to_hass(hass)
with patch(
"yalexs.authenticator_async.AuthenticatorAsync.async_authenticate",
side_effect=ClientResponseError(None, None, status=500),
):
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert config_entry.state is ConfigEntryState.SETUP_RETRY
async def test_user_form_api_key_required(opp):
"""Test we handle an unauthorized error."""
result = await opp.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
with patch(
"openpeerpower.components.nightscout.NightscoutAPI.get_server_status",
return_value=SERVER_STATUS_STATUS_ONLY,
), patch(
"openpeerpower.components.nightscout.NightscoutAPI.get_sgvs",
side_effect=ClientResponseError(None, None, status=401),
):
result2 = await opp.config_entries.flow.async_configure(
result["flow_id"],
{CONF_URL: "https://some.url:1234"},
)
assert result2["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result2["errors"] == {"base": "invalid_auth"}
async def test_form_cannot_connect(hass):
"""Test we handle cannot connect error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
with patch(
"homeassistant.components.rituals_perfume_genie.config_flow.Account.authenticate",
side_effect=ClientResponseError(None, None, status=500),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
CONF_EMAIL: TEST_EMAIL,
CONF_PASSWORD: VALID_PASSWORD,
},
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "cannot_connect"}
async def test_form_invalid_auth(hass):
"""Test we handle invalid auth."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
with patch(
"homeassistant.components.kmtronic.config_flow.KMTronicHubAPI.async_get_status",
side_effect=ClientResponseError(None, None, status=401),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"host": "1.1.1.1",
"username": "******",
"password": "******",
},
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "invalid_auth"}
async def test_smart_by_bond_device_suggested_area(hass: HomeAssistant):
"""Test we can setup a smart by bond device and get the suggested area."""
config_entry = MockConfigEntry(
domain=DOMAIN,
data={CONF_HOST: "some host", CONF_ACCESS_TOKEN: "test-token"},
)
config_entry.add_to_hass(hass)
with patch_bond_bridge(
side_effect=ClientResponseError(Mock(), Mock(), status=404)
), patch_bond_version(
return_value={
"bondid": "test-bond-id",
"target": "test-model",
"fw_ver": "test-version",
}
), patch_start_bpup(), patch_bond_device_ids(
return_value=["bond-device-id", "device_id"]
), patch_bond_device(
return_value={
"name": "test1",
"type": DeviceType.GENERIC_DEVICE,
"location": "Den",
}
), patch_bond_device_properties(
return_value={}
), patch_bond_device_state(
return_value={}
):
assert await hass.config_entries.async_setup(config_entry.entry_id) is True
await hass.async_block_till_done()
assert config_entry.entry_id in hass.data[DOMAIN]
assert config_entry.state is ConfigEntryState.LOADED
assert config_entry.unique_id == "test-bond-id"
device_registry = dr.async_get(hass)
device = device_registry.async_get_device(identifiers={(DOMAIN, "test-bond-id")})
assert device is not None
assert device.suggested_area == "Den"
async def test_http_failure(opp):
"""Config entry state is SETUP_RETRY when august is offline."""
config_entry = MockConfigEntry(
domain=DOMAIN,
data=_mock_get_config()[DOMAIN],
title="August august",
)
config_entry.add_to_opp(opp)
assert opp.config_entries.flow.async_progress() == []
await setup.async_setup_component(opp, "persistent_notification", {})
with patch(
"yalexs.authenticator_async.AuthenticatorAsync.async_authenticate",
side_effect=ClientResponseError(None, None, status=500),
):
await opp.config_entries.async_setup(config_entry.entry_id)
await opp.async_block_till_done()
assert config_entry.state is ConfigEntryState.SETUP_RETRY
assert opp.config_entries.flow.async_progress() == []
async def request(self, method, url, data, headers, **kwargs):
try:
# print(url)
with async_timeout.timeout(TIMEOUT):
async with self._session.request(method,
url,
headers=headers,
data=data) as response:
# print(response)
if response.status == 200 or response.status == 202:
return await response.json(loads=json_loads)
else:
raise ClientResponseError(
response.request_info,
response.history,
status=response.status,
message=response.reason,
)
except TimeoutError:
raise TimeoutError("Timeout error")
except Exception:
raise
async def get_cases(session: ClientSession, *, source=DEFAULT_SOURCE):
"""Fetch Corona Virus cases."""
resp = await session.get(source.URL)
data = await resp.json(content_type=None)
if 'error' in data:
# API does not set correct status header so we manually check.
raise ClientResponseError(resp.request_info,
resp.history,
status=data['error']['code'],
message=data['error']['message'],
headers=resp.headers)
results = []
for item in data["features"]:
try:
results.append(source.from_json(item))
except KeyError:
logging.getLogger(__name__).warning("Got wrong data: %s", item)
return results
async def test_zeroconf_form_with_token_available_name_unavailable(
hass: core.HomeAssistant,
):
"""Test we get the discovery form when we can get the token but the name is unavailable."""
with patch_bond_version(
side_effect=ClientResponseError(Mock(), (), status=HTTPStatus.BAD_REQUEST)
), patch_bond_token(return_value={"token": "discovered-token"}):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf.ZeroconfServiceInfo(
host="test-host",
hostname="mock_hostname",
name="test-bond-id.some-other-tail-info",
port=None,
properties={},
type="mock_type",
),
)
await hass.async_block_till_done()
assert result["type"] == "form"
assert result["errors"] == {}
with _patch_async_setup_entry() as mock_setup_entry:
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{},
)
await hass.async_block_till_done()
assert result2["type"] == "create_entry"
assert result2["title"] == "test-bond-id"
assert result2["data"] == {
CONF_HOST: "test-host",
CONF_ACCESS_TOKEN: "discovered-token",
}
assert len(mock_setup_entry.mock_calls) == 1
