evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rewite Radarr tests as in pytest style for #40879 (#41145)

Browse source
This commit is contained in:
Ronan Murray 2020-10-04 13:08:08 +01:00 • committed by GitHub
parent 27dd4ca9b3
commit fd065e7aea
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 178 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

321
tests/components/radarr/test_sensor.py
View file

@ -1,13 +1,10 @@
"""The tests for the Radarr platform."""
import unittest
import pytest
import homeassistant.components.radarr.sensor as radarr
from homeassistant.const import DATA_GIGABYTES
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
from tests.common import get_test_home_assistant
def mocked_exception(*args, **kwargs):
@ -192,32 +189,10 @@ def mocked_requests_get(*args, **kwargs):
return MockResponse({"error": "Unauthorized"}, 401)
class TestRadarrSetup(unittest.TestCase):
"""Test the Radarr platform."""
# pylint: disable=invalid-name
DEVICES = []
def add_entities(self, devices, update):
"""Mock add devices."""
for device in devices:
self.DEVICES.append(device)
def setUp(self):
"""Initialize values for this testcase class."""
self.DEVICES = []
self.hass = get_test_home_assistant()
self.hass.config.time_zone = "America/Los_Angeles"
self.addCleanup(self.tear_down_cleanup)
def tear_down_cleanup(self):
"""Stop everything that was started."""
self.hass.stop()
@patch("requests.get", side_effect=mocked_requests_get)
def test_diskspace_no_paths(self, req_mock):
"""Test getting all disk space."""
config = {
async def test_diskspace_no_paths(hass):
"""Test getting all disk space."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "2",
@ -225,19 +200,28 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": [],
"monitored_conditions": ["diskspace"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert "263.10" == device.state
assert "mdi:harddisk" == device.icon
assert DATA_GIGABYTES == device.unit_of_measurement
assert "Radarr Disk Space" == device.name
assert "263.10/465.42GB (56.53%)" == device.device_state_attributes["/data"]
}
@patch("requests.get", side_effect=mocked_requests_get)
def test_diskspace_paths(self, req_mock):
"""Test getting diskspace for included paths."""
config = {
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_disk_space")
assert entity is not None
assert "263.10" == entity.state
assert "mdi:harddisk" == entity.attributes["icon"]
assert DATA_GIGABYTES == entity.attributes["unit_of_measurement"]
assert "Radarr Disk Space" == entity.attributes["friendly_name"]
assert "263.10/465.42GB (56.53%)" == entity.attributes["/data"]
async def test_diskspace_paths(hass):
"""Test getting diskspace for included paths."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "2",
@ -245,19 +229,28 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["diskspace"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert "263.10" == device.state
assert "mdi:harddisk" == device.icon
assert DATA_GIGABYTES == device.unit_of_measurement
assert "Radarr Disk Space" == device.name
assert "263.10/465.42GB (56.53%)" == device.device_state_attributes["/data"]
}
@patch("requests.get", side_effect=mocked_requests_get)
def test_commands(self, req_mock):
"""Test getting running commands."""
config = {
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_disk_space")
assert entity is not None
assert "263.10" == entity.state
assert "mdi:harddisk" == entity.attributes["icon"]
assert DATA_GIGABYTES == entity.attributes["unit_of_measurement"]
assert "Radarr Disk Space" == entity.attributes["friendly_name"]
assert "263.10/465.42GB (56.53%)" == entity.attributes["/data"]
async def test_commands(hass):
"""Test getting running commands."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "2",
@ -265,19 +258,28 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["commands"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert 1 == device.state
assert "mdi:code-braces" == device.icon
assert "Commands" == device.unit_of_measurement
assert "Radarr Commands" == device.name
assert "pending" == device.device_state_attributes["RescanMovie"]
}
@patch("requests.get", side_effect=mocked_requests_get)
def test_movies(self, req_mock):
"""Test getting the number of movies."""
config = {
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_commands")
assert entity is not None
assert 1 == int(entity.state)
assert "mdi:code-braces" == entity.attributes["icon"]
assert "Commands" == entity.attributes["unit_of_measurement"]
assert "Radarr Commands" == entity.attributes["friendly_name"]
assert "pending" == entity.attributes["RescanMovie"]
async def test_movies(hass):
"""Test getting the number of movies."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "2",
@ -285,19 +287,28 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["movies"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert 1 == device.state
assert "mdi:television" == device.icon
assert "Movies" == device.unit_of_measurement
assert "Radarr Movies" == device.name
assert "false" == device.device_state_attributes["Assassin's Creed (2016)"]
}
@patch("requests.get", side_effect=mocked_requests_get)
def test_upcoming_multiple_days(self, req_mock):
"""Test the upcoming movies for multiple days."""
config = {
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_movies")
assert entity is not None
assert 1 == int(entity.state)
assert "mdi:television" == entity.attributes["icon"]
assert "Movies" == entity.attributes["unit_of_measurement"]
assert "Radarr Movies" == entity.attributes["friendly_name"]
assert "false" == entity.attributes["Assassin's Creed (2016)"]
async def test_upcoming_multiple_days(hass):
"""Test the upcoming movies for multiple days."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "2",
@ -305,26 +316,32 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["upcoming"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert 1 == device.state
assert "mdi:television" == device.icon
assert "Movies" == device.unit_of_measurement
assert "Radarr Upcoming" == device.name
assert (
"2017-01-27T00:00:00Z"
== device.device_state_attributes["Resident Evil (2017)"]
)
}
@pytest.mark.skip
@patch("requests.get", side_effect=mocked_requests_get)
def test_upcoming_today(self, req_mock):
"""Test filtering for a single day.
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
Radarr needs to respond with at least 2 days.
"""
config = {
entity = hass.states.get("sensor.radarr_upcoming")
assert entity is not None
assert 1 == int(entity.state)
assert "mdi:television" == entity.attributes["icon"]
assert "Movies" == entity.attributes["unit_of_measurement"]
assert "Radarr Upcoming" == entity.attributes["friendly_name"]
assert "2017-01-27T00:00:00Z" == entity.attributes["Resident Evil (2017)"]
@pytest.mark.skip
async def test_upcoming_today(hass):
"""Test filtering for a single day.
Radarr needs to respond with at least 2 days.
"""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "1",
@ -332,22 +349,25 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["upcoming"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert 1 == device.state
assert "mdi:television" == device.icon
assert "Movies" == device.unit_of_measurement
assert "Radarr Upcoming" == device.name
assert (
"2017-01-27T00:00:00Z"
== device.device_state_attributes["Resident Evil (2017)"]
)
}
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_upcoming")
assert 1 == int(entity.state)
assert "mdi:television" == entity.attributes["icon"]
assert "Movies" == entity.attributes["unit_of_measurement"]
assert "Radarr Upcoming" == entity.attributes["friendly_name"]
assert "2017-01-27T00:00:00Z" == entity.attributes["Resident Evil (2017)"]
@patch("requests.get", side_effect=mocked_requests_get)
def test_system_status(self, req_mock):
"""Test the getting of the system status."""
config = {
async def test_system_status(hass):
"""Test the getting of the system status."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "2",
@ -355,19 +375,25 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["status"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert "0.2.0.210" == device.state
assert "mdi:information" == device.icon
assert "Radarr Status" == device.name
assert "4.8.13.1" == device.device_state_attributes["osVersion"]
}
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_status")
assert entity is not None
assert "0.2.0.210" == entity.state
assert "mdi:information" == entity.attributes["icon"]
assert "Radarr Status" == entity.attributes["friendly_name"]
assert "4.8.13.1" == entity.attributes["osVersion"]
@pytest.mark.skip
@patch("requests.get", side_effect=mocked_requests_get)
def test_ssl(self, req_mock):
"""Test SSL being enabled."""
config = {
async def test_ssl(hass):
"""Test SSL being enabled."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "1",
@ -376,23 +402,26 @@ class TestRadarrSetup(unittest.TestCase):
"monitored_conditions": ["upcoming"],
"ssl": "true",
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert 1 == device.state
assert "s" == device.ssl
assert "mdi:television" == device.icon
assert "Movies" == device.unit_of_measurement
assert "Radarr Upcoming" == device.name
assert (
"2017-01-27T00:00:00Z"
== device.device_state_attributes["Resident Evil (2017)"]
)
}
with patch(
"requests.get",
side_effect=mocked_requests_get,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_upcoming")
assert entity is not None
assert 1 == int(entity.state)
assert "mdi:television" == entity.attributes["icon"]
assert "Movies" == entity.attributes["unit_of_measurement"]
assert "Radarr Upcoming" == entity.attributes["friendly_name"]
assert "2017-01-27T00:00:00Z" == entity.attributes["Resident Evil (2017)"]
@patch("requests.get", side_effect=mocked_exception)
def test_exception_handling(self, req_mock):
"""Test exception being handled."""
config = {
async def test_exception_handling(hass):
"""Test exception being handled."""
config = {
"sensor": {
"platform": "radarr",
"api_key": "foo",
"days": "1",
@ -400,7 +429,13 @@ class TestRadarrSetup(unittest.TestCase):
"include_paths": ["/data"],
"monitored_conditions": ["upcoming"],
}
radarr.setup_platform(self.hass, config, self.add_entities, None)
for device in self.DEVICES:
device.update()
assert device.state is None
}
with patch(
"requests.get",
side_effect=mocked_exception,
):
assert await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
entity = hass.states.get("sensor.radarr_upcoming")
assert entity is not None
assert "unavailable" == entity.state