jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-25 06:07:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor sonarr tests (#64886)

Browse Source
This commit is contained in:
Chris Talkington 2022-01-31 16:59:18 -06:00 committed by GitHub
parent 0f88790303
commit 70da08499a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 310 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
tests/components/sonarr/__init__.py
View File

@ -1,244 +1,13 @@
"""Tests for the Sonarr component.""" """Tests for the Sonarr component."""
from http import HTTPStatus from homeassistant.components.sonarr.const import CONF_BASE_PATH
from socket import gaierror as SocketGIAError from homeassistant.const import CONF_API_KEY, CONF_HOST, CONF_PORT, CONF_SSL
from unittest.mock import patch
from homeassistant.components.sonarr.const import (
CONF_BASE_PATH,
CONF_UPCOMING_DAYS,
CONF_WANTED_MAX_ITEMS,
DEFAULT_UPCOMING_DAYS,
DEFAULT_WANTED_MAX_ITEMS,
DOMAIN,
)
from homeassistant.const import (
CONF_API_KEY,
CONF_HOST,
CONF_PORT,
CONF_SSL,
CONF_VERIFY_SSL,
CONTENT_TYPE_JSON,
)
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry, load_fixture
from tests.test_util.aiohttp import AiohttpClientMocker
HOST = "192.168.1.189"
PORT = 8989
BASE_PATH = "/api"
API_KEY = "MOCK_API_KEY"
MOCK_REAUTH_INPUT = {CONF_API_KEY: "test-api-key-reauth"} MOCK_REAUTH_INPUT = {CONF_API_KEY: "test-api-key-reauth"}
MOCK_USER_INPUT = { MOCK_USER_INPUT = {
CONF_HOST: HOST, CONF_HOST: "192.168.1.189",
CONF_PORT: PORT, CONF_PORT: 8989,
CONF_BASE_PATH: BASE_PATH, CONF_BASE_PATH: "/api",
CONF_SSL: False, CONF_SSL: False,
CONF_API_KEY: API_KEY, CONF_API_KEY: "MOCK_API_KEY",
} }
def mock_connection(
aioclient_mock: AiohttpClientMocker,
host: str = HOST,
port: str = PORT,
base_path: str = BASE_PATH,
error: bool = False,
invalid_auth: bool = False,
server_error: bool = False,
) -> None:
"""Mock Sonarr connection."""
if error:
mock_connection_error(
aioclient_mock,
host=host,
port=port,
base_path=base_path,
)
return
if invalid_auth:
mock_connection_invalid_auth(
aioclient_mock,
host=host,
port=port,
base_path=base_path,
)
return
if server_error:
mock_connection_server_error(
aioclient_mock,
host=host,
port=port,
base_path=base_path,
)
return
sonarr_url = f"http://{host}:{port}{base_path}"
aioclient_mock.get(
f"{sonarr_url}/system/status",
text=load_fixture("sonarr/system-status.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"{sonarr_url}/diskspace",
text=load_fixture("sonarr/diskspace.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"{sonarr_url}/calendar",
text=load_fixture("sonarr/calendar.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"{sonarr_url}/command",
text=load_fixture("sonarr/command.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"{sonarr_url}/queue",
text=load_fixture("sonarr/queue.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"{sonarr_url}/series",
text=load_fixture("sonarr/series.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"{sonarr_url}/wanted/missing",
text=load_fixture("sonarr/wanted-missing.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
def mock_connection_error(
aioclient_mock: AiohttpClientMocker,
host: str = HOST,
port: str = PORT,
base_path: str = BASE_PATH,
) -> None:
"""Mock Sonarr connection errors."""
sonarr_url = f"http://{host}:{port}{base_path}"
aioclient_mock.get(f"{sonarr_url}/system/status", exc=SocketGIAError)
aioclient_mock.get(f"{sonarr_url}/diskspace", exc=SocketGIAError)
aioclient_mock.get(f"{sonarr_url}/calendar", exc=SocketGIAError)
aioclient_mock.get(f"{sonarr_url}/command", exc=SocketGIAError)
aioclient_mock.get(f"{sonarr_url}/queue", exc=SocketGIAError)
aioclient_mock.get(f"{sonarr_url}/series", exc=SocketGIAError)
aioclient_mock.get(f"{sonarr_url}/missing/wanted", exc=SocketGIAError)
def mock_connection_invalid_auth(
aioclient_mock: AiohttpClientMocker,
host: str = HOST,
port: str = PORT,
base_path: str = BASE_PATH,
) -> None:
"""Mock Sonarr invalid auth errors."""
sonarr_url = f"http://{host}:{port}{base_path}"
aioclient_mock.get(f"{sonarr_url}/system/status", status=HTTPStatus.FORBIDDEN)
aioclient_mock.get(f"{sonarr_url}/diskspace", status=HTTPStatus.FORBIDDEN)
aioclient_mock.get(f"{sonarr_url}/calendar", status=HTTPStatus.FORBIDDEN)
aioclient_mock.get(f"{sonarr_url}/command", status=HTTPStatus.FORBIDDEN)
aioclient_mock.get(f"{sonarr_url}/queue", status=HTTPStatus.FORBIDDEN)
aioclient_mock.get(f"{sonarr_url}/series", status=HTTPStatus.FORBIDDEN)
aioclient_mock.get(f"{sonarr_url}/missing/wanted", status=HTTPStatus.FORBIDDEN)
def mock_connection_server_error(
aioclient_mock: AiohttpClientMocker,
host: str = HOST,
port: str = PORT,
base_path: str = BASE_PATH,
) -> None:
"""Mock Sonarr server errors."""
sonarr_url = f"http://{host}:{port}{base_path}"
aioclient_mock.get(
f"{sonarr_url}/system/status", status=HTTPStatus.INTERNAL_SERVER_ERROR
)
aioclient_mock.get(
f"{sonarr_url}/diskspace", status=HTTPStatus.INTERNAL_SERVER_ERROR
)
aioclient_mock.get(
f"{sonarr_url}/calendar", status=HTTPStatus.INTERNAL_SERVER_ERROR
)
aioclient_mock.get(f"{sonarr_url}/command", status=HTTPStatus.INTERNAL_SERVER_ERROR)
aioclient_mock.get(f"{sonarr_url}/queue", status=HTTPStatus.INTERNAL_SERVER_ERROR)
aioclient_mock.get(f"{sonarr_url}/series", status=HTTPStatus.INTERNAL_SERVER_ERROR)
aioclient_mock.get(
f"{sonarr_url}/missing/wanted", status=HTTPStatus.INTERNAL_SERVER_ERROR
)
async def setup_integration(
hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker,
host: str = HOST,
port: str = PORT,
base_path: str = BASE_PATH,
api_key: str = API_KEY,
unique_id: str = None,
skip_entry_setup: bool = False,
connection_error: bool = False,
invalid_auth: bool = False,
server_error: bool = False,
) -> MockConfigEntry:
"""Set up the Sonarr integration in Home Assistant."""
entry = MockConfigEntry(
domain=DOMAIN,
unique_id=unique_id,
data={
CONF_HOST: host,
CONF_PORT: port,
CONF_BASE_PATH: base_path,
CONF_SSL: False,
CONF_VERIFY_SSL: False,
CONF_API_KEY: api_key,
CONF_UPCOMING_DAYS: DEFAULT_UPCOMING_DAYS,
CONF_WANTED_MAX_ITEMS: DEFAULT_WANTED_MAX_ITEMS,
},
options={
CONF_UPCOMING_DAYS: DEFAULT_UPCOMING_DAYS,
CONF_WANTED_MAX_ITEMS: DEFAULT_WANTED_MAX_ITEMS,
},
)
entry.add_to_hass(hass)
mock_connection(
aioclient_mock,
host=host,
port=port,
base_path=base_path,
error=connection_error,
invalid_auth=invalid_auth,
server_error=server_error,
)
if not skip_entry_setup:
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
return entry
def _patch_async_setup_entry(return_value=True):
"""Patch the async entry setup of sonarr."""
return patch(
"homeassistant.components.sonarr.async_setup_entry",
return_value=return_value,
)

159
tests/components/sonarr/conftest.py Normal file
View File

@ -0,0 +1,159 @@
"""Fixtures for Sonarr integration tests."""
from collections.abc import Generator
import json
from unittest.mock import MagicMock, patch
import pytest
from sonarr.models import (
Application,
CommandItem,
Episode,
QueueItem,
SeriesItem,
WantedResults,
)
from homeassistant.components.sonarr.const import (
CONF_BASE_PATH,
CONF_UPCOMING_DAYS,
CONF_WANTED_MAX_ITEMS,
DEFAULT_UPCOMING_DAYS,
DEFAULT_WANTED_MAX_ITEMS,
DOMAIN,
)
from homeassistant.const import (
CONF_API_KEY,
CONF_HOST,
CONF_PORT,
CONF_SSL,
CONF_VERIFY_SSL,
)
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry, load_fixture
def sonarr_calendar():
"""Generate a response for the calendar method."""
results = json.loads(load_fixture("sonarr/calendar.json"))
return [Episode.from_dict(result) for result in results]
def sonarr_commands():
"""Generate a response for the commands method."""
results = json.loads(load_fixture("sonarr/command.json"))
return [CommandItem.from_dict(result) for result in results]
def sonarr_queue():
"""Generate a response for the queue method."""
results = json.loads(load_fixture("sonarr/queue.json"))
return [QueueItem.from_dict(result) for result in results]
def sonarr_series():
"""Generate a response for the series method."""
results = json.loads(load_fixture("sonarr/series.json"))
return [SeriesItem.from_dict(result) for result in results]
def sonarr_wanted():
"""Generate a response for the wanted method."""
results = json.loads(load_fixture("sonarr/wanted-missing.json"))
return WantedResults.from_dict(results)
@pytest.fixture
def mock_config_entry() -> MockConfigEntry:
"""Return the default mocked config entry."""
return MockConfigEntry(
title="Sonarr",
domain=DOMAIN,
data={
CONF_HOST: "192.168.1.189",
CONF_PORT: 8989,
CONF_BASE_PATH: "/api",
CONF_SSL: False,
CONF_VERIFY_SSL: False,
CONF_API_KEY: "MOCK_API_KEY",
CONF_UPCOMING_DAYS: DEFAULT_UPCOMING_DAYS,
CONF_WANTED_MAX_ITEMS: DEFAULT_WANTED_MAX_ITEMS,
},
options={
CONF_UPCOMING_DAYS: DEFAULT_UPCOMING_DAYS,
CONF_WANTED_MAX_ITEMS: DEFAULT_WANTED_MAX_ITEMS,
},
unique_id=None,
)
@pytest.fixture
def mock_setup_entry() -> Generator[None, None, None]:
"""Mock setting up a config entry."""
with patch("homeassistant.components.sonarr.async_setup_entry", return_value=True):
yield
@pytest.fixture
def mock_sonarr_config_flow(
request: pytest.FixtureRequest,
) -> Generator[None, MagicMock, None]:
"""Return a mocked Sonarr client."""
fixture: str = "sonarr/app.json"
if hasattr(request, "param") and request.param:
fixture = request.param
app = Application(json.loads(load_fixture(fixture)))
with patch(
"homeassistant.components.sonarr.config_flow.Sonarr", autospec=True
) as sonarr_mock:
client = sonarr_mock.return_value
client.host = "192.168.1.189"
client.port = 8989
client.base_path = "/api"
client.tls = False
client.app = app
client.update.return_value = app
client.calendar.return_value = sonarr_calendar()
client.commands.return_value = sonarr_commands()
client.queue.return_value = sonarr_queue()
client.series.return_value = sonarr_series()
client.wanted.return_value = sonarr_wanted()
yield client
@pytest.fixture
def mock_sonarr(request: pytest.FixtureRequest) -> Generator[None, MagicMock, None]:
"""Return a mocked Sonarr client."""
fixture: str = "sonarr/app.json"
if hasattr(request, "param") and request.param:
fixture = request.param
app = Application(json.loads(load_fixture(fixture)))
with patch("homeassistant.components.sonarr.Sonarr", autospec=True) as sonarr_mock:
client = sonarr_mock.return_value
client.host = "192.168.1.189"
client.port = 8989
client.base_path = "/api"
client.tls = False
client.app = app
client.update.return_value = app
client.calendar.return_value = sonarr_calendar()
client.commands.return_value = sonarr_commands()
client.queue.return_value = sonarr_queue()
client.series.return_value = sonarr_series()
client.wanted.return_value = sonarr_wanted()
yield client
@pytest.fixture
async def init_integration(
hass: HomeAssistant, mock_config_entry: MockConfigEntry, mock_sonarr: MagicMock
) -> MockConfigEntry:
"""Set up the Sonarr integration for testing."""
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
return mock_config_entry

28
tests/components/sonarr/fixtures/app.json Normal file
View File

@ -0,0 +1,28 @@
{
"info": {
"version": "2.0.0.1121",
"buildTime": "2014-02-08T20:49:36.5560392Z",
"isDebug": false,
"isProduction": true,
"isAdmin": true,
"isUserInteractive": false,
"startupPath": "C:\\ProgramData\\NzbDrone\\bin",
"appData": "C:\\ProgramData\\NzbDrone",
"osVersion": "6.2.9200.0",
"isMono": false,
"isLinux": false,
"isWindows": true,
"branch": "develop",
"authentication": false,
"startOfWeek": 0,
"urlBase": ""
},
"diskspace": [
{
"path": "C:\\",
"label": "",
"freeSpace": 282500067328,
"totalSpace": 499738734592
}
]
}

18
tests/components/sonarr/fixtures/system-status.json
View File

@ -1,18 +0,0 @@
{
"version": "2.0.0.1121",
"buildTime": "2014-02-08T20:49:36.5560392Z",
"isDebug": false,
"isProduction": true,
"isAdmin": true,
"isUserInteractive": false,
"startupPath": "C:\\ProgramData\\NzbDrone\\bin",
"appData": "C:\\ProgramData\\NzbDrone",
"osVersion": "6.2.9200.0",
"isMono": false,
"isLinux": false,
"isWindows": true,
"branch": "develop",
"authentication": false,
"startOfWeek": 0,
"urlBase": ""
}

121
tests/components/sonarr/test_config_flow.py
View File

@ -1,5 +1,7 @@
"""Test the Sonarr config flow.""" """Test the Sonarr config flow."""
from unittest.mock import patch from unittest.mock import MagicMock, patch
from sonarr import SonarrAccessRestricted, SonarrError
from homeassistant.components.sonarr.const import ( from homeassistant.components.sonarr.const import (
CONF_UPCOMING_DAYS, CONF_UPCOMING_DAYS,
@ -17,17 +19,8 @@ from homeassistant.data_entry_flow import (
RESULT_TYPE_FORM, RESULT_TYPE_FORM,
) )
from tests.components.sonarr import ( from tests.common import MockConfigEntry
HOST, from tests.components.sonarr import MOCK_REAUTH_INPUT, MOCK_USER_INPUT
MOCK_REAUTH_INPUT,
MOCK_USER_INPUT,
_patch_async_setup_entry,
mock_connection,
mock_connection_error,
mock_connection_invalid_auth,
setup_integration,
)
from tests.test_util.aiohttp import AiohttpClientMocker
async def test_show_user_form(hass: HomeAssistant) -> None: async def test_show_user_form(hass: HomeAssistant) -> None:
@ -42,10 +35,10 @@ async def test_show_user_form(hass: HomeAssistant) -> None:
async def test_cannot_connect( async def test_cannot_connect(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant, mock_sonarr_config_flow: MagicMock
) -> None: ) -> None:
"""Test we show user form on connection error.""" """Test we show user form on connection error."""
mock_connection_error(aioclient_mock) mock_sonarr_config_flow.update.side_effect = SonarrError
user_input = MOCK_USER_INPUT.copy() user_input = MOCK_USER_INPUT.copy()
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
@ -60,10 +53,10 @@ async def test_cannot_connect(
async def test_invalid_auth( async def test_invalid_auth(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant, mock_sonarr_config_flow: MagicMock
) -> None: ) -> None:
"""Test we show user form on invalid auth.""" """Test we show user form on invalid auth."""
mock_connection_invalid_auth(aioclient_mock) mock_sonarr_config_flow.update.side_effect = SonarrAccessRestricted
user_input = MOCK_USER_INPUT.copy() user_input = MOCK_USER_INPUT.copy()
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
@ -78,30 +71,30 @@ async def test_invalid_auth(
async def test_unknown_error( async def test_unknown_error(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant, mock_sonarr_config_flow: MagicMock
) -> None: ) -> None:
"""Test we show user form on unknown error.""" """Test we show user form on unknown error."""
mock_sonarr_config_flow.update.side_effect = Exception
user_input = MOCK_USER_INPUT.copy() user_input = MOCK_USER_INPUT.copy()
with patch( result = await hass.config_entries.flow.async_init(
"homeassistant.components.sonarr.config_flow.Sonarr.update", DOMAIN,
side_effect=Exception, context={CONF_SOURCE: SOURCE_USER},
): data=user_input,
result = await hass.config_entries.flow.async_init( )
DOMAIN,
context={CONF_SOURCE: SOURCE_USER},
data=user_input,
)
assert result["type"] == RESULT_TYPE_ABORT assert result["type"] == RESULT_TYPE_ABORT
assert result["reason"] == "unknown" assert result["reason"] == "unknown"
async def test_full_reauth_flow_implementation( async def test_full_reauth_flow_implementation(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_sonarr_config_flow: MagicMock,
mock_setup_entry: None,
init_integration: MockConfigEntry,
) -> None: ) -> None:
"""Test the manual reauth flow from start to finish.""" """Test the manual reauth flow from start to finish."""
entry = await setup_integration(hass, aioclient_mock, skip_entry_setup=True) entry = init_integration
assert entry
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, DOMAIN,
@ -124,26 +117,23 @@ async def test_full_reauth_flow_implementation(
assert result["step_id"] == "user" assert result["step_id"] == "user"
user_input = MOCK_REAUTH_INPUT.copy() user_input = MOCK_REAUTH_INPUT.copy()
with _patch_async_setup_entry() as mock_setup_entry: result = await hass.config_entries.flow.async_configure(
result = await hass.config_entries.flow.async_configure( result["flow_id"], user_input=user_input
result["flow_id"], user_input=user_input )
) await hass.async_block_till_done()
await hass.async_block_till_done()
assert result["type"] == RESULT_TYPE_ABORT assert result["type"] == RESULT_TYPE_ABORT
assert result["reason"] == "reauth_successful" assert result["reason"] == "reauth_successful"
assert entry.data[CONF_API_KEY] == "test-api-key-reauth" assert entry.data[CONF_API_KEY] == "test-api-key-reauth"
mock_setup_entry.assert_called_once()
async def test_full_user_flow_implementation( async def test_full_user_flow_implementation(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_sonarr_config_flow: MagicMock,
mock_setup_entry: None,
) -> None: ) -> None:
"""Test the full manual user flow from start to finish.""" """Test the full manual user flow from start to finish."""
mock_connection(aioclient_mock)
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, DOMAIN,
context={CONF_SOURCE: SOURCE_USER}, context={CONF_SOURCE: SOURCE_USER},
@ -154,25 +144,24 @@ async def test_full_user_flow_implementation(
user_input = MOCK_USER_INPUT.copy() user_input = MOCK_USER_INPUT.copy()
with _patch_async_setup_entry(): result = await hass.config_entries.flow.async_configure(
result = await hass.config_entries.flow.async_configure( result["flow_id"],
result["flow_id"], user_input=user_input,
user_input=user_input, )
)
assert result["type"] == RESULT_TYPE_CREATE_ENTRY assert result["type"] == RESULT_TYPE_CREATE_ENTRY
assert result["title"] == HOST assert result["title"] == "192.168.1.189"
assert result["data"] assert result["data"]
assert result["data"][CONF_HOST] == HOST assert result["data"][CONF_HOST] == "192.168.1.189"
async def test_full_user_flow_advanced_options( async def test_full_user_flow_advanced_options(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_sonarr_config_flow: MagicMock,
mock_setup_entry: None,
) -> None: ) -> None:
"""Test the full manual user flow with advanced options.""" """Test the full manual user flow with advanced options."""
mock_connection(aioclient_mock)
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={CONF_SOURCE: SOURCE_USER, "show_advanced_options": True} DOMAIN, context={CONF_SOURCE: SOURCE_USER, "show_advanced_options": True}
) )
@ -185,24 +174,27 @@ async def test_full_user_flow_advanced_options(
CONF_VERIFY_SSL: True, CONF_VERIFY_SSL: True,
} }
with _patch_async_setup_entry(): result = await hass.config_entries.flow.async_configure(
result = await hass.config_entries.flow.async_configure( result["flow_id"],
result["flow_id"], user_input=user_input,
user_input=user_input, )
)
assert result["type"] == RESULT_TYPE_CREATE_ENTRY assert result["type"] == RESULT_TYPE_CREATE_ENTRY
assert result["title"] == HOST assert result["title"] == "192.168.1.189"
assert result["data"] assert result["data"]
assert result["data"][CONF_HOST] == HOST assert result["data"][CONF_HOST] == "192.168.1.189"
assert result["data"][CONF_VERIFY_SSL] assert result["data"][CONF_VERIFY_SSL]
async def test_options_flow(hass, aioclient_mock: AiohttpClientMocker): @patch("homeassistant.components.sonarr.PLATFORMS", [])
async def test_options_flow(
hass: HomeAssistant,
mock_setup_entry: None,
init_integration: MockConfigEntry,
):
"""Test updating options.""" """Test updating options."""
with patch("homeassistant.components.sonarr.PLATFORMS", []): entry = init_integration
entry = await setup_integration(hass, aioclient_mock)
assert entry.options[CONF_UPCOMING_DAYS] == DEFAULT_UPCOMING_DAYS assert entry.options[CONF_UPCOMING_DAYS] == DEFAULT_UPCOMING_DAYS
assert entry.options[CONF_WANTED_MAX_ITEMS] == DEFAULT_WANTED_MAX_ITEMS assert entry.options[CONF_WANTED_MAX_ITEMS] == DEFAULT_WANTED_MAX_ITEMS
@ -212,12 +204,11 @@ async def test_options_flow(hass, aioclient_mock: AiohttpClientMocker):
assert result["type"] == RESULT_TYPE_FORM assert result["type"] == RESULT_TYPE_FORM
assert result["step_id"] == "init" assert result["step_id"] == "init"
with _patch_async_setup_entry(): result = await hass.config_entries.options.async_configure(
result = await hass.config_entries.options.async_configure( result["flow_id"],
result["flow_id"], user_input={CONF_UPCOMING_DAYS: 2, CONF_WANTED_MAX_ITEMS: 100},
user_input={CONF_UPCOMING_DAYS: 2, CONF_WANTED_MAX_ITEMS: 100}, )
) await hass.async_block_till_done()
await hass.async_block_till_done()
assert result["type"] == RESULT_TYPE_CREATE_ENTRY assert result["type"] == RESULT_TYPE_CREATE_ENTRY
assert result["data"][CONF_UPCOMING_DAYS] == 2 assert result["data"][CONF_UPCOMING_DAYS] == 2

61
tests/components/sonarr/test_init.py
View File

@ -1,60 +1,79 @@
"""Tests for the Sonsrr integration.""" """Tests for the Sonsrr integration."""
from unittest.mock import patch from unittest.mock import MagicMock, patch
from sonarr import SonarrAccessRestricted, SonarrError
from homeassistant.components.sonarr.const import DOMAIN from homeassistant.components.sonarr.const import DOMAIN
from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntryState from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntryState
from homeassistant.const import CONF_SOURCE from homeassistant.const import CONF_SOURCE
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from tests.components.sonarr import setup_integration from tests.common import MockConfigEntry
from tests.test_util.aiohttp import AiohttpClientMocker
async def test_config_entry_not_ready( async def test_config_entry_not_ready(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_config_entry: MockConfigEntry,
mock_sonarr: MagicMock,
) -> None: ) -> None:
"""Test the configuration entry not ready.""" """Test the configuration entry not ready."""
entry = await setup_integration(hass, aioclient_mock, connection_error=True) mock_sonarr.update.side_effect = SonarrError
assert entry.state is ConfigEntryState.SETUP_RETRY
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.SETUP_RETRY
async def test_config_entry_reauth( async def test_config_entry_reauth(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_config_entry: MockConfigEntry,
mock_sonarr: MagicMock,
) -> None: ) -> None:
"""Test the configuration entry needing to be re-authenticated.""" """Test the configuration entry needing to be re-authenticated."""
with patch.object(hass.config_entries.flow, "async_init") as mock_flow_init: mock_sonarr.update.side_effect = SonarrAccessRestricted
entry = await setup_integration(hass, aioclient_mock, invalid_auth=True)
assert entry.state is ConfigEntryState.SETUP_ERROR with patch.object(hass.config_entries.flow, "async_init") as mock_flow_init:
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.SETUP_ERROR
mock_flow_init.assert_called_once_with( mock_flow_init.assert_called_once_with(
DOMAIN, DOMAIN,
context={ context={
CONF_SOURCE: SOURCE_REAUTH, CONF_SOURCE: SOURCE_REAUTH,
"entry_id": entry.entry_id, "entry_id": mock_config_entry.entry_id,
"unique_id": entry.unique_id, "unique_id": mock_config_entry.unique_id,
"title_placeholders": {"name": entry.title}, "title_placeholders": {"name": mock_config_entry.title},
}, },
data=entry.data, data=mock_config_entry.data,
) )
async def test_unload_config_entry( async def test_unload_config_entry(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_config_entry: MockConfigEntry,
mock_sonarr: MagicMock,
) -> None: ) -> None:
"""Test the configuration entry unloading.""" """Test the configuration entry unloading."""
mock_config_entry.add_to_hass(hass)
with patch( with patch(
"homeassistant.components.sonarr.sensor.async_setup_entry", "homeassistant.components.sonarr.sensor.async_setup_entry",
return_value=True, return_value=True,
): ):
entry = await setup_integration(hass, aioclient_mock) await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert hass.data[DOMAIN] assert hass.data[DOMAIN]
assert entry.entry_id in hass.data[DOMAIN] assert mock_config_entry.state is ConfigEntryState.LOADED
assert entry.state is ConfigEntryState.LOADED assert mock_config_entry.entry_id in hass.data[DOMAIN]
await hass.config_entries.async_unload(entry.entry_id) await hass.config_entries.async_unload(mock_config_entry.entry_id)
await hass.async_block_till_done() await hass.async_block_till_done()
assert entry.entry_id not in hass.data[DOMAIN] assert mock_config_entry.state is ConfigEntryState.NOT_LOADED
assert entry.state is ConfigEntryState.NOT_LOADED assert mock_config_entry.entry_id not in hass.data[DOMAIN]

39
tests/components/sonarr/test_sensor.py
View File

@ -1,8 +1,9 @@
"""Tests for the Sonarr sensor platform.""" """Tests for the Sonarr sensor platform."""
from datetime import timedelta from datetime import timedelta
from unittest.mock import patch from unittest.mock import MagicMock, patch
import pytest import pytest
from sonarr import SonarrError
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.components.sonarr.const import DOMAIN from homeassistant.components.sonarr.const import DOMAIN
@ -16,18 +17,18 @@ from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from tests.common import async_fire_time_changed from tests.common import MockConfigEntry, async_fire_time_changed
from tests.components.sonarr import mock_connection, setup_integration
from tests.test_util.aiohttp import AiohttpClientMocker
UPCOMING_ENTITY_ID = f"{SENSOR_DOMAIN}.sonarr_upcoming" UPCOMING_ENTITY_ID = f"{SENSOR_DOMAIN}.sonarr_upcoming"
async def test_sensors( async def test_sensors(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_config_entry: MockConfigEntry,
mock_sonarr: MagicMock,
) -> None: ) -> None:
"""Test the creation and values of the sensors.""" """Test the creation and values of the sensors."""
entry = await setup_integration(hass, aioclient_mock, skip_entry_setup=True) entry = mock_config_entry
registry = er.async_get(hass) registry = er.async_get(hass)
# Pre-create registry entries for disabled by default sensors # Pre-create registry entries for disabled by default sensors
@ -48,6 +49,7 @@ async def test_sensors(
disabled_by=None, disabled_by=None,
) )
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id) await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -104,10 +106,11 @@ async def test_sensors(
), ),
) )
async def test_disabled_by_default_sensors( async def test_disabled_by_default_sensors(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, entity_id: str hass: HomeAssistant,
init_integration: MockConfigEntry,
entity_id: str,
) -> None: ) -> None:
"""Test the disabled by default sensors.""" """Test the disabled by default sensors."""
await setup_integration(hass, aioclient_mock)
registry = er.async_get(hass) registry = er.async_get(hass)
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
@ -120,19 +123,22 @@ async def test_disabled_by_default_sensors(
async def test_availability( async def test_availability(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker hass: HomeAssistant,
mock_config_entry: MockConfigEntry,
mock_sonarr: MagicMock,
) -> None: ) -> None:
"""Test entity availability.""" """Test entity availability."""
now = dt_util.utcnow() now = dt_util.utcnow()
mock_config_entry.add_to_hass(hass)
with patch("homeassistant.util.dt.utcnow", return_value=now): with patch("homeassistant.util.dt.utcnow", return_value=now):
await setup_integration(hass, aioclient_mock) await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert hass.states.get(UPCOMING_ENTITY_ID).state == "1" assert hass.states.get(UPCOMING_ENTITY_ID).state == "1"
# state to unavailable # state to unavailable
aioclient_mock.clear_requests() mock_sonarr.calendar.side_effect = SonarrError
mock_connection(aioclient_mock, error=True)
future = now + timedelta(minutes=1) future = now + timedelta(minutes=1)
with patch("homeassistant.util.dt.utcnow", return_value=future): with patch("homeassistant.util.dt.utcnow", return_value=future):
@ -142,8 +148,7 @@ async def test_availability(
assert hass.states.get(UPCOMING_ENTITY_ID).state == STATE_UNAVAILABLE assert hass.states.get(UPCOMING_ENTITY_ID).state == STATE_UNAVAILABLE
# state to available # state to available
aioclient_mock.clear_requests() mock_sonarr.calendar.side_effect = None
mock_connection(aioclient_mock)
future += timedelta(minutes=1) future += timedelta(minutes=1)
with patch("homeassistant.util.dt.utcnow", return_value=future): with patch("homeassistant.util.dt.utcnow", return_value=future):
@ -153,8 +158,7 @@ async def test_availability(
assert hass.states.get(UPCOMING_ENTITY_ID).state == "1" assert hass.states.get(UPCOMING_ENTITY_ID).state == "1"
# state to unavailable # state to unavailable
aioclient_mock.clear_requests() mock_sonarr.calendar.side_effect = SonarrError
mock_connection(aioclient_mock, invalid_auth=True)
future += timedelta(minutes=1) future += timedelta(minutes=1)
with patch("homeassistant.util.dt.utcnow", return_value=future): with patch("homeassistant.util.dt.utcnow", return_value=future):
@ -164,8 +168,7 @@ async def test_availability(
assert hass.states.get(UPCOMING_ENTITY_ID).state == STATE_UNAVAILABLE assert hass.states.get(UPCOMING_ENTITY_ID).state == STATE_UNAVAILABLE
# state to available # state to available
aioclient_mock.clear_requests() mock_sonarr.calendar.side_effect = None
mock_connection(aioclient_mock)
future += timedelta(minutes=1) future += timedelta(minutes=1)
with patch("homeassistant.util.dt.utcnow", return_value=future): with patch("homeassistant.util.dt.utcnow", return_value=future):