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

Rewrite Wake on LAN Tests to use pytest style (#41173)

Browse Source 
Co-authored-by: Paulus Schoutsen <paulus@home-assistant.io>
This commit is contained in:
Nathan Tilley 2020-10-12 11:17:31 -04:00 committed by GitHub
parent 625bbe6238
commit feabf99f92
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 212 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

269
tests/components/wake_on_lan/test_switch.py
View File

@ -1,47 +1,34 @@
"""The tests for the wake on lan switch platform.""" """The tests for the wake on lan switch platform."""
import unittest import platform
import subprocess
import pytest
import homeassistant.components.switch as switch import homeassistant.components.switch as switch
from homeassistant.const import STATE_OFF, STATE_ON from homeassistant.const import (
from homeassistant.setup import setup_component ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.setup import async_setup_component
from tests.async_mock import Mock, patch from tests.async_mock import patch
from tests.common import get_test_home_assistant, mock_service from tests.common import async_mock_service
from tests.components.switch import common
TEST_STATE = None
def call(cmd, stdout, stderr): @pytest.fixture(autouse=True)
"""Return fake subprocess return codes.""" def mock_send_magic_packet():
if cmd[5] == "validhostname" and TEST_STATE: """Mock magic packet."""
return 0 with patch("wakeonlan.send_magic_packet") as mock_send:
return 2 yield mock_send
def system(): async def test_valid_hostname(hass):
"""Fake system call to test the windows platform."""
return "Windows"
class TestWolSwitch(unittest.TestCase):
"""Test the wol switch."""
send_magic_packet = Mock(return_value=None)
def setUp(self):
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
self.addCleanup(self.hass.stop)
@patch("wakeonlan.send_magic_packet", new=send_magic_packet)
@patch("subprocess.call", new=call)
def test_valid_hostname(self):
"""Test with valid hostname.""" """Test with valid hostname."""
global TEST_STATE assert await async_setup_component(
TEST_STATE = False hass,
assert setup_component(
self.hass,
switch.DOMAIN, switch.DOMAIN,
{ {
"switch": { "switch": {
@ -51,34 +38,38 @@ class TestWolSwitch(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
TEST_STATE = True with patch.object(subprocess, "call", return_value=0):
common.turn_on(self.hass, "switch.wake_on_lan") await hass.services.async_call(
self.hass.block_till_done() switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_ON == state.state assert STATE_ON == state.state
common.turn_off(self.hass, "switch.wake_on_lan") await hass.services.async_call(
self.hass.block_till_done() switch.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_ON == state.state assert STATE_ON == state.state
@patch("wakeonlan.send_magic_packet", new=send_magic_packet)
@patch("subprocess.call", new=call) async def test_valid_hostname_windows(hass):
@patch("platform.system", new=system)
def test_valid_hostname_windows(self):
"""Test with valid hostname on windows.""" """Test with valid hostname on windows."""
global TEST_STATE assert await async_setup_component(
TEST_STATE = False hass,
assert setup_component(
self.hass,
switch.DOMAIN, switch.DOMAIN,
{ {
"switch": { "switch": {
@ -88,30 +79,33 @@ class TestWolSwitch(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
TEST_STATE = True with patch.object(subprocess, "call", return_value=0), patch.object(
platform, "system", return_value="Windows"
):
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
common.turn_on(self.hass, "switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
self.hass.block_till_done()
state = self.hass.states.get("switch.wake_on_lan")
assert STATE_ON == state.state assert STATE_ON == state.state
@patch("wakeonlan.send_magic_packet", new=send_magic_packet)
@patch("subprocess.call", new=call)
def test_broadcast_config_ip_and_port(self):
"""Test with broadcast address and broadcast port config."""
async def test_broadcast_config_ip_and_port(hass, mock_send_magic_packet):
"""Test with broadcast address and broadcast port config."""
mac = "00-01-02-03-04-05" mac = "00-01-02-03-04-05"
broadcast_address = "255.255.255.255" broadcast_address = "255.255.255.255"
port = 999 port = 999
assert setup_component( assert await async_setup_component(
self.hass, hass,
switch.DOMAIN, switch.DOMAIN,
{ {
"switch": { "switch": {
@ -122,28 +116,33 @@ class TestWolSwitch(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
common.turn_on(self.hass, "switch.wake_on_lan") with patch.object(subprocess, "call", return_value=0):
self.hass.block_till_done()
self.send_magic_packet.assert_called_with( await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
mock_send_magic_packet.assert_called_with(
mac, ip_address=broadcast_address, port=port mac, ip_address=broadcast_address, port=port
) )
@patch("wakeonlan.send_magic_packet", new=send_magic_packet)
@patch("subprocess.call", new=call) async def test_broadcast_config_ip(hass, mock_send_magic_packet):
def test_broadcast_config_ip(self):
"""Test with only broadcast address.""" """Test with only broadcast address."""
mac = "00-01-02-03-04-05" mac = "00-01-02-03-04-05"
broadcast_address = "255.255.255.255" broadcast_address = "255.255.255.255"
assert setup_component( assert await async_setup_component(
self.hass, hass,
switch.DOMAIN, switch.DOMAIN,
{ {
"switch": { "switch": {
@ -153,53 +152,56 @@ class TestWolSwitch(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
common.turn_on(self.hass, "switch.wake_on_lan") with patch.object(subprocess, "call", return_value=0):
self.hass.block_till_done()
self.send_magic_packet.assert_called_with(mac, ip_address=broadcast_address) await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
@patch("wakeonlan.send_magic_packet", new=send_magic_packet) mock_send_magic_packet.assert_called_with(mac, ip_address=broadcast_address)
@patch("subprocess.call", new=call)
def test_broadcast_config_port(self):
async def test_broadcast_config_port(hass, mock_send_magic_packet):
"""Test with only broadcast port config.""" """Test with only broadcast port config."""
mac = "00-01-02-03-04-05" mac = "00-01-02-03-04-05"
port = 999 port = 999
assert setup_component( assert await async_setup_component(
self.hass, hass,
switch.DOMAIN, switch.DOMAIN,
{ {"switch": {"platform": "wake_on_lan", "mac": mac, "broadcast_port": port}},
"switch": {
"platform": "wake_on_lan",
"mac": mac,
"broadcast_port": port,
}
},
) )
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
common.turn_on(self.hass, "switch.wake_on_lan") with patch.object(subprocess, "call", return_value=0):
self.hass.block_till_done()
self.send_magic_packet.assert_called_with(mac, port=port) await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
@patch("wakeonlan.send_magic_packet", new=send_magic_packet) mock_send_magic_packet.assert_called_with(mac, port=port)
@patch("subprocess.call", new=call)
def test_off_script(self):
async def test_off_script(hass):
"""Test with turn off script.""" """Test with turn off script."""
global TEST_STATE
TEST_STATE = False assert await async_setup_component(
assert setup_component( hass,
self.hass,
switch.DOMAIN, switch.DOMAIN,
{ {
"switch": { "switch": {
@ -210,39 +212,44 @@ class TestWolSwitch(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
calls = mock_service(self.hass, "shell_command", "turn_off_target") calls = async_mock_service(hass, "shell_command", "turn_off_target")
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
TEST_STATE = True with patch.object(subprocess, "call", return_value=0):
common.turn_on(self.hass, "switch.wake_on_lan") await hass.services.async_call(
self.hass.block_till_done() switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_ON == state.state assert STATE_ON == state.state
assert len(calls) == 0 assert len(calls) == 0
TEST_STATE = False with patch.object(subprocess, "call", return_value=2):
common.turn_off(self.hass, "switch.wake_on_lan") await hass.services.async_call(
self.hass.block_till_done() switch.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
assert len(calls) == 1 assert len(calls) == 1
@patch("wakeonlan.send_magic_packet", new=send_magic_packet)
@patch("subprocess.call", new=call) async def test_invalid_hostname_windows(hass):
@patch("platform.system", new=system)
def test_invalid_hostname_windows(self):
"""Test with invalid hostname on windows.""" """Test with invalid hostname on windows."""
global TEST_STATE
TEST_STATE = False assert await async_setup_component(
assert setup_component( hass,
self.hass,
switch.DOMAIN, switch.DOMAIN,
{ {
"switch": { "switch": {
@ -252,15 +259,19 @@ class TestWolSwitch(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state
TEST_STATE = True with patch.object(subprocess, "call", return_value=2):
common.turn_on(self.hass, "switch.wake_on_lan") await hass.services.async_call(
self.hass.block_till_done() switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.wake_on_lan"},
blocking=True,
)
state = self.hass.states.get("switch.wake_on_lan") state = hass.states.get("switch.wake_on_lan")
assert STATE_OFF == state.state assert STATE_OFF == state.state