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

Rename igd to upnp

Browse Source
This commit is contained in:
Steven Looman 2018-09-17 22:08:09 +02:00
parent 6588dceadd
commit c19665fed4
13 changed files with 115 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
homeassistant/components/discovery.py
View File

@ -49,7 +49,7 @@ CONFIG_ENTRY_HANDLERS = {
'google_cast': 'cast', 'google_cast': 'cast',
SERVICE_HUE: 'hue', SERVICE_HUE: 'hue',
'sonos': 'sonos', 'sonos': 'sonos',
'igd': 'igd', 'upnp': 'igd',
} }
SERVICE_HANDLERS = { SERVICE_HANDLERS = {

34
homeassistant/components/sensor/igd.py → homeassistant/components/sensor/upnp.py
View File

@ -1,20 +1,20 @@
""" """
Support for IGD Sensors. Support for UPnP/IGD Sensors.
For more details about this platform, please refer to the documentation at For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/sensor.igd/ https://home-assistant.io/components/sensor.upnp/
""" """
# pylint: disable=invalid-name # pylint: disable=invalid-name
from datetime import datetime from datetime import datetime
import logging import logging
from homeassistant.components.igd import DOMAIN from homeassistant.components.upnp import DOMAIN
from homeassistant.helpers.entity import Entity from homeassistant.helpers.entity import Entity
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['igd'] DEPENDENCIES = ['upnp']
BYTES_RECEIVED = 'bytes_received' BYTES_RECEIVED = 'bytes_received'
BYTES_SENT = 'bytes_sent' BYTES_SENT = 'bytes_sent'
@ -47,7 +47,7 @@ KBYTE = 1024
async def async_setup_platform(hass, config, async_add_devices, async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None): discovery_info=None):
"""Set up the IGD sensors.""" """Set up the UPnP/IGD sensors."""
if discovery_info is None: if discovery_info is None:
return return
@ -56,25 +56,25 @@ async def async_setup_platform(hass, config, async_add_devices,
# raw sensors + per-second sensors # raw sensors + per-second sensors
sensors = [ sensors = [
RawIGDSensor(device, name, sensor_type) RawUPnPIGDSensor(device, name, sensor_type)
for name, sensor_type in SENSOR_TYPES.items() for name, sensor_type in SENSOR_TYPES.items()
] ]
sensors += [ sensors += [
KBytePerSecondIGDSensor(device, IN), KBytePerSecondUPnPIGDSensor(device, IN),
KBytePerSecondIGDSensor(device, OUT), KBytePerSecondUPnPIGDSensor(device, OUT),
PacketsPerSecondIGDSensor(device, IN), PacketsPerSecondUPnPIGDSensor(device, IN),
PacketsPerSecondIGDSensor(device, OUT), PacketsPerSecondUPnPIGDSensor(device, OUT),
] ]
hass.data[DOMAIN]['sensors'][udn] = sensors hass.data[DOMAIN]['sensors'][udn] = sensors
async_add_devices(sensors, True) async_add_devices(sensors, True)
return True return True
class RawIGDSensor(Entity): class RawUPnPIGDSensor(Entity):
"""Representation of a UPnP IGD sensor.""" """Representation of a UPnP/IGD sensor."""
def __init__(self, device, sensor_type_name, sensor_type): def __init__(self, device, sensor_type_name, sensor_type):
"""Initialize the IGD sensor.""" """Initialize the UPnP/IGD sensor."""
self._device = device self._device = device
self._type_name = sensor_type_name self._type_name = sensor_type_name
self._type = sensor_type self._type = sensor_type
@ -118,7 +118,7 @@ class RawIGDSensor(Entity):
self._state = await self._device.async_get_total_packets_sent() self._state = await self._device.async_get_total_packets_sent()
class PerSecondIGDSensor(Entity): class PerSecondUPnPIGDSensor(Entity):
"""Abstract representation of a X Sent/Received per second sensor.""" """Abstract representation of a X Sent/Received per second sensor."""
def __init__(self, device, direction): def __init__(self, device, direction):
@ -169,7 +169,7 @@ class PerSecondIGDSensor(Entity):
return new_value < self._last_value return new_value < self._last_value
async def async_update(self): async def async_update(self):
"""Get the latest information from the IGD.""" """Get the latest information from the UPnP/IGD."""
new_value = await self._async_fetch_value() new_value = await self._async_fetch_value()
if self._last_value is None: if self._last_value is None:
@ -189,7 +189,7 @@ class PerSecondIGDSensor(Entity):
self._last_update_time = now self._last_update_time = now
class KBytePerSecondIGDSensor(PerSecondIGDSensor): class KBytePerSecondUPnPIGDSensor(PerSecondUPnPIGDSensor):
"""Representation of a KBytes Sent/Received per second sensor.""" """Representation of a KBytes Sent/Received per second sensor."""
@property @property
@ -213,7 +213,7 @@ class KBytePerSecondIGDSensor(PerSecondIGDSensor):
return format(float(self._state / KBYTE), '.1f') return format(float(self._state / KBYTE), '.1f')
class PacketsPerSecondIGDSensor(PerSecondIGDSensor): class PacketsPerSecondUPnPIGDSensor(PerSecondUPnPIGDSensor):
"""Representation of a Packets Sent/Received per second sensor.""" """Representation of a Packets Sent/Received per second sensor."""
@property @property

15
homeassistant/components/igd/.translations/en.json → homeassistant/components/upnp/.translations/en.json
View File

@ -1,14 +1,14 @@
{ {
"config": { "config": {
"title": "IGD", "title": "UPnP/IGD",
"step": { "step": {
"init": { "init": {
"title": "IGD" "title": "UPnP/IGD"
}, },
"user": { "user": {
"title": "Configuration options for the IGD", "title": "Configuration options for the UPnP/IGD",
"data":{ "data":{
"igd": "IGD", "igd": "UPnP/IGD",
"sensors": "Add traffic sensors", "sensors": "Add traffic sensors",
"port_forward": "Enable port forward for Home Assistant" "port_forward": "Enable port forward for Home Assistant"
} }
@ -17,10 +17,9 @@
"error": { "error": {
}, },
"abort": { "abort": {
"no_devices_discovered": "No IGDs discovered", "no_devices_discovered": "No UPnP/IGDs discovered",
"already_configured": "IGD is already configured", "already_configured": "UPnP/IGD is already configured",
"no_sensors_or_port_forward": "Enable at least sensors or port forward", "no_sensors_or_port_forward": "Enable at least sensors or port forward"
"no_igds": "No IGDs discovered"
} }
} }
} }

15
homeassistant/components/igd/.translations/nl.json → homeassistant/components/upnp/.translations/nl.json
View File

@ -1,14 +1,14 @@
{ {
"config": { "config": {
"title": "IGD", "title": "UPnP/IGD",
"step": { "step": {
"init": { "init": {
"title": "IGD" "title": "UPnP/IGD"
}, },
"user": { "user": {
"title": "Extra configuratie options voor IGD", "title": "Extra configuratie options voor UPnP/IGD",
"data":{ "data":{
"igd": "IGD", "igd": "UPnP/IGD",
"sensors": "Verkeer sensors toevoegen", "sensors": "Verkeer sensors toevoegen",
"port_forward": "Maak port forward voor Home Assistant" "port_forward": "Maak port forward voor Home Assistant"
} }
@ -17,10 +17,9 @@
"error": { "error": {
}, },
"abort": { "abort": {
"no_devices_discovered": "Geen IGDs gevonden", "no_devices_discovered": "Geen UPnP/IGDs gevonden",
"already_configured": "IGD is reeds geconfigureerd", "already_configured": "UPnP/IGD is reeds geconfigureerd",
"no_sensors_or_port_forward": "Kies ten minste sensors of port forward", "no_sensors_or_port_forward": "Kies ten minste sensors of port forward"
"no_igds": "Geen IGDs gevonden"
} }
} }
} }

23
homeassistant/components/igd/__init__.py → homeassistant/components/upnp/__init__.py
View File

@ -2,9 +2,8 @@
Will open a port in your router for Home Assistant and provide statistics. Will open a port in your router for Home Assistant and provide statistics.
For more details about this component, please refer to the documentation at For more details about this component, please refer to the documentation at
https://home-assistant.io/components/igd/ https://home-assistant.io/components/upnp/
""" """
import asyncio import asyncio
from ipaddress import ip_address from ipaddress import ip_address
@ -34,7 +33,7 @@ from .device import Device
REQUIREMENTS = ['async-upnp-client==0.12.4'] REQUIREMENTS = ['async-upnp-client==0.12.4']
DEPENDENCIES = ['http'] DEPENDENCIES = ['http']
NOTIFICATION_ID = 'igd_notification' NOTIFICATION_ID = 'upnp_notification'
NOTIFICATION_TITLE = 'UPnP/IGD Setup' NOTIFICATION_TITLE = 'UPnP/IGD Setup'
CONFIG_SCHEMA = vol.Schema({ CONFIG_SCHEMA = vol.Schema({
@ -72,25 +71,25 @@ async def async_setup(hass: HomeAssistantType, config: ConfigType):
return True return True
if DISCOVERY_DOMAIN not in config: if DISCOVERY_DOMAIN not in config:
_LOGGER.warning('IGD needs discovery, please enable it') _LOGGER.warning('UPNP needs discovery, please enable it')
return False return False
# overridden local ip # overridden local ip
igd_config = config[DOMAIN] upnp_config = config[DOMAIN]
if CONF_LOCAL_IP in igd_config: if CONF_LOCAL_IP in upnp_config:
hass.data[DOMAIN]['local_ip'] = igd_config[CONF_LOCAL_IP] hass.data[DOMAIN]['local_ip'] = upnp_config[CONF_LOCAL_IP]
# determine ports # determine ports
ports = {CONF_HASS: CONF_HASS} # default, port_forward disabled by default ports = {CONF_HASS: CONF_HASS} # default, port_forward disabled by default
if CONF_PORTS in igd_config: if CONF_PORTS in upnp_config:
# copy from config # copy from config
ports = igd_config[CONF_PORTS] ports = upnp_config[CONF_PORTS]
hass.data[DOMAIN]['auto_config'] = { hass.data[DOMAIN]['auto_config'] = {
'active': True, 'active': True,
'port_forward': igd_config[CONF_ENABLE_PORT_MAPPING], 'port_forward': upnp_config[CONF_ENABLE_PORT_MAPPING],
'ports': ports, 'ports': ports,
'sensors': igd_config[CONF_ENABLE_SENSORS], 'sensors': upnp_config[CONF_ENABLE_SENSORS],
} }
return True return True
@ -104,7 +103,7 @@ async def async_setup_entry(hass: HomeAssistantType,
ensure_domain_data(hass) ensure_domain_data(hass)
data = config_entry.data data = config_entry.data
# build IGD device # build UPnP/IGD device
ssdp_description = data[CONF_SSDP_DESCRIPTION] ssdp_description = data[CONF_SSDP_DESCRIPTION]
try: try:
device = await Device.async_create_device(hass, ssdp_description) device = await Device.async_create_device(hass, ssdp_description)

28
homeassistant/components/igd/config_flow.py → homeassistant/components/upnp/config_flow.py
View File

@ -1,4 +1,4 @@
"""Config flow for IGD.""" """Config flow for UPNP."""
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant import config_entries
@ -26,13 +26,13 @@ def ensure_domain_data(hass):
@config_entries.HANDLERS.register(DOMAIN) @config_entries.HANDLERS.register(DOMAIN)
class IgdFlowHandler(data_entry_flow.FlowHandler): class UpnpFlowHandler(data_entry_flow.FlowHandler):
"""Handle a Hue config flow.""" """Handle a Hue config flow."""
VERSION = 1 VERSION = 1
@property @property
def _configured_igds(self): def _configured_upnp_igds(self):
"""Get all configured IGDs.""" """Get all configured IGDs."""
return { return {
entry.data[CONF_UDN]: { entry.data[CONF_UDN]: {
@ -42,7 +42,7 @@ class IgdFlowHandler(data_entry_flow.FlowHandler):
} }
@property @property
def _discovered_igds(self): def _discovered_upnp_igds(self):
"""Get all discovered entries.""" """Get all discovered entries."""
return self.hass.data[DOMAIN]['discovered'] return self.hass.data[DOMAIN]['discovered']
@ -57,7 +57,7 @@ class IgdFlowHandler(data_entry_flow.FlowHandler):
async def async_step_discovery(self, discovery_info): async def async_step_discovery(self, discovery_info):
""" """
Handle a discovered IGD. Handle a discovered UPnP/IGD.
This flow is triggered by the discovery component. It will check if the This flow is triggered by the discovery component. It will check if the
host is already configured and delegate to the import step if not. host is already configured and delegate to the import step if not.
@ -71,7 +71,7 @@ class IgdFlowHandler(data_entry_flow.FlowHandler):
# ensure not already discovered/configured # ensure not already discovered/configured
udn = discovery_info['udn'] udn = discovery_info['udn']
if udn in self._configured_igds: if udn in self._configured_upnp_igds:
return self.async_abort(reason='already_configured') return self.async_abort(reason='already_configured')
# auto config? # auto config?
@ -98,19 +98,19 @@ class IgdFlowHandler(data_entry_flow.FlowHandler):
# ensure not already configured # ensure not already configured
configured_names = [ configured_names = [
entry['friendly_name'] entry['friendly_name']
for udn, entry in self._discovered_igds.items() for udn, entry in self._discovered_upnp_igds.items()
if udn in self._configured_igds if udn in self._configured_upnp_igds
] ]
if user_input['name'] in configured_names: if user_input['name'] in configured_names:
return self.async_abort(reason='already_configured') return self.async_abort(reason='already_configured')
return await self._async_save_entry(user_input) return await self._async_save_entry(user_input)
# let user choose from all discovered, non-configured, IGDs # let user choose from all discovered, non-configured, UPnP/IGDs
names = [ names = [
entry['friendly_name'] entry['friendly_name']
for udn, entry in self._discovered_igds.items() for udn, entry in self._discovered_upnp_igds.items()
if udn not in self._configured_igds if udn not in self._configured_upnp_igds
] ]
if not names: if not names:
return self.async_abort(reason='no_devices_discovered') return self.async_abort(reason='no_devices_discovered')
@ -125,15 +125,15 @@ class IgdFlowHandler(data_entry_flow.FlowHandler):
) )
async def async_step_import(self, import_info): async def async_step_import(self, import_info):
"""Import a new IGD as a config entry.""" """Import a new UPnP/IGD as a config entry."""
return await self._async_save_entry(import_info) return await self._async_save_entry(import_info)
async def _async_save_entry(self, import_info): async def _async_save_entry(self, import_info):
"""Store IGD as new entry.""" """Store UPNP/IGD as new entry."""
# ensure we know the host # ensure we know the host
name = import_info['name'] name = import_info['name']
discovery_infos = [info discovery_infos = [info
for info in self._discovered_igds.values() for info in self._discovered_upnp_igds.values()
if info['friendly_name'] == name] if info['friendly_name'] == name]
if not discovery_infos: if not discovery_infos:
return self.async_abort(reason='host_not_found') return self.async_abort(reason='host_not_found')

4
homeassistant/components/igd/const.py → homeassistant/components/upnp/const.py
View File

@ -9,5 +9,5 @@ CONF_LOCAL_IP = 'local_ip'
CONF_PORTS = 'ports' CONF_PORTS = 'ports'
CONF_SSDP_DESCRIPTION = 'ssdp_description' CONF_SSDP_DESCRIPTION = 'ssdp_description'
CONF_UDN = 'udn' CONF_UDN = 'udn'
DOMAIN = 'igd' DOMAIN = 'upnp'
LOGGER = logging.getLogger('homeassistant.components.igd') LOGGER = logging.getLogger('homeassistant.components.upnp')

7
homeassistant/components/igd/device.py → homeassistant/components/upnp/device.py
View File

@ -1,5 +1,4 @@
"""Hass representation of an IGD.""" """Hass representation of an UPnP/IGD."""
import asyncio import asyncio
from ipaddress import IPv4Address from ipaddress import IPv4Address
@ -13,7 +12,7 @@ from .const import LOGGER as _LOGGER
class Device: class Device:
"""Hass representation of an IGD.""" """Hass representation of an UPnP/IGD."""
def __init__(self, igd_device): def __init__(self, igd_device):
"""Initializer.""" """Initializer."""
@ -24,7 +23,7 @@ class Device:
async def async_create_device(cls, async def async_create_device(cls,
hass: HomeAssistantType, hass: HomeAssistantType,
ssdp_description: str): ssdp_description: str):
"""Create IGD device.""" """Create UPnP/IGD device."""
# build async_upnp_client requester # build async_upnp_client requester
from async_upnp_client.aiohttp import AiohttpSessionRequester from async_upnp_client.aiohttp import AiohttpSessionRequester
session = async_get_clientsession(hass) session = async_get_clientsession(hass)

8
homeassistant/components/igd/strings.json → homeassistant/components/upnp/strings.json
View File

@ -1,14 +1,14 @@
{ {
"config": { "config": {
"title": "IGD", "title": "UPnP/IGD",
"step": { "step": {
"init": { "init": {
"title": "IGD" "title": "UPnP/IGD"
}, },
"user": { "user": {
"title": "Configuration options for the IGD", "title": "Configuration options for the UPnP/IGD",
"data":{ "data":{
"igd": "IGD", "igd": "UPnP/IGD",
"sensors": "Add traffic sensors", "sensors": "Add traffic sensors",
"port_forward": "Enable port forward for Home Assistant" "port_forward": "Enable port forward for Home Assistant"
} }

2
homeassistant/config_entries.py
View File

@ -143,7 +143,7 @@ FLOWS = [
'nest', 'nest',
'sonos', 'sonos',
'zone', 'zone',
'igd', 'upnp',
] ]

0
tests/components/igd/__init__.py → tests/components/upnp/__init__.py
View File

42
tests/components/igd/test_config_flow.py → tests/components/upnp/test_config_flow.py
View File

@ -1,16 +1,16 @@
"""Tests for IGD config flow.""" """Tests for UPnP/IGD config flow."""
from homeassistant.components import igd from homeassistant.components import upnp
from homeassistant.components.igd import config_flow as igd_config_flow from homeassistant.components.upnp import config_flow as upnp_config_flow
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
async def test_flow_none_discovered(hass): async def test_flow_none_discovered(hass):
"""Test no device discovered flow.""" """Test no device discovered flow."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'discovered': {} 'discovered': {}
} }
@ -21,12 +21,12 @@ async def test_flow_none_discovered(hass):
async def test_flow_already_configured(hass): async def test_flow_already_configured(hass):
"""Test device already configured flow.""" """Test device already configured flow."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# discovered device # discovered device
udn = 'uuid:device_1' udn = 'uuid:device_1'
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'discovered': { 'discovered': {
udn: { udn: {
'friendly_name': '192.168.1.1 (Test device)', 'friendly_name': '192.168.1.1 (Test device)',
@ -37,7 +37,7 @@ async def test_flow_already_configured(hass):
} }
# configured entry # configured entry
MockConfigEntry(domain=igd.DOMAIN, data={ MockConfigEntry(domain=upnp.DOMAIN, data={
'udn': udn, 'udn': udn,
'host': '192.168.1.1', 'host': '192.168.1.1',
}).add_to_hass(hass) }).add_to_hass(hass)
@ -53,12 +53,12 @@ async def test_flow_already_configured(hass):
async def test_flow_no_sensors_no_port_forward(hass): async def test_flow_no_sensors_no_port_forward(hass):
"""Test single device, no sensors, no port_forward.""" """Test single device, no sensors, no port_forward."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# discovered device # discovered device
udn = 'uuid:device_1' udn = 'uuid:device_1'
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'discovered': { 'discovered': {
udn: { udn: {
'friendly_name': '192.168.1.1 (Test device)', 'friendly_name': '192.168.1.1 (Test device)',
@ -69,7 +69,7 @@ async def test_flow_no_sensors_no_port_forward(hass):
} }
# configured entry # configured entry
MockConfigEntry(domain=igd.DOMAIN, data={ MockConfigEntry(domain=upnp.DOMAIN, data={
'udn': udn, 'udn': udn,
'host': '192.168.1.1', 'host': '192.168.1.1',
}).add_to_hass(hass) }).add_to_hass(hass)
@ -85,12 +85,12 @@ async def test_flow_no_sensors_no_port_forward(hass):
async def test_flow_discovered_form(hass): async def test_flow_discovered_form(hass):
"""Test single device discovered, show form flow.""" """Test single device discovered, show form flow."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# discovered device # discovered device
udn = 'uuid:device_1' udn = 'uuid:device_1'
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'discovered': { 'discovered': {
udn: { udn: {
'friendly_name': '192.168.1.1 (Test device)', 'friendly_name': '192.168.1.1 (Test device)',
@ -107,13 +107,13 @@ async def test_flow_discovered_form(hass):
async def test_flow_two_discovered_form(hass): async def test_flow_two_discovered_form(hass):
"""Test single device discovered, show form flow.""" """Test single device discovered, show form flow."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# discovered device # discovered device
udn_1 = 'uuid:device_1' udn_1 = 'uuid:device_1'
udn_2 = 'uuid:device_2' udn_2 = 'uuid:device_2'
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'discovered': { 'discovered': {
udn_1: { udn_1: {
'friendly_name': '192.168.1.1 (Test device)', 'friendly_name': '192.168.1.1 (Test device)',
@ -145,11 +145,11 @@ async def test_flow_two_discovered_form(hass):
async def test_config_entry_created(hass): async def test_config_entry_created(hass):
"""Test config entry is created.""" """Test config entry is created."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# discovered device # discovered device
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'discovered': { 'discovered': {
'uuid:device_1': { 'uuid:device_1': {
'friendly_name': '192.168.1.1 (Test device)', 'friendly_name': '192.168.1.1 (Test device)',
@ -178,11 +178,11 @@ async def test_config_entry_created(hass):
async def test_flow_discovery_auto_config_sensors(hass): async def test_flow_discovery_auto_config_sensors(hass):
"""Test creation of device with auto_config.""" """Test creation of device with auto_config."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# auto_config active # auto_config active
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'auto_config': { 'auto_config': {
'active': True, 'active': True,
'port_forward': False, 'port_forward': False,
@ -210,11 +210,11 @@ async def test_flow_discovery_auto_config_sensors(hass):
async def test_flow_discovery_auto_config_sensors_port_forward(hass): async def test_flow_discovery_auto_config_sensors_port_forward(hass):
"""Test creation of device with auto_config, with port forward.""" """Test creation of device with auto_config, with port forward."""
flow = igd_config_flow.IgdFlowHandler() flow = upnp_config_flow.UpnpFlowHandler()
flow.hass = hass flow.hass = hass
# auto_config active, with port_forward # auto_config active, with port_forward
hass.data[igd.DOMAIN] = { hass.data[upnp.DOMAIN] = {
'auto_config': { 'auto_config': {
'active': True, 'active': True,
'port_forward': True, 'port_forward': True,

54
tests/components/igd/test_init.py → tests/components/upnp/test_init.py
View File

@ -1,11 +1,11 @@
"""Test IGD setup process.""" """Test UPnP/IGD setup process."""
from ipaddress import ip_address from ipaddress import ip_address
from unittest.mock import patch, MagicMock from unittest.mock import patch, MagicMock
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.components import igd from homeassistant.components import upnp
from homeassistant.components.igd.device import Device from homeassistant.components.upnp.device import Device
from homeassistant.const import EVENT_HOMEASSISTANT_STOP from homeassistant.const import EVENT_HOMEASSISTANT_STOP
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
@ -49,9 +49,9 @@ class MockDevice(Device):
async def test_async_setup_no_auto_config(hass): async def test_async_setup_no_auto_config(hass):
"""Test async_setup.""" """Test async_setup."""
# setup component, enable auto_config # setup component, enable auto_config
await async_setup_component(hass, 'igd') await async_setup_component(hass, 'upnp')
assert hass.data[igd.DOMAIN]['auto_config'] == { assert hass.data[upnp.DOMAIN]['auto_config'] == {
'active': False, 'active': False,
'port_forward': False, 'port_forward': False,
'ports': {'hass': 'hass'}, 'ports': {'hass': 'hass'},
@ -62,9 +62,9 @@ async def test_async_setup_no_auto_config(hass):
async def test_async_setup_auto_config(hass): async def test_async_setup_auto_config(hass):
"""Test async_setup.""" """Test async_setup."""
# setup component, enable auto_config # setup component, enable auto_config
await async_setup_component(hass, 'igd', {'igd': {}, 'discovery': {}}) await async_setup_component(hass, 'upnp', {'upnp': {}, 'discovery': {}})
assert hass.data[igd.DOMAIN]['auto_config'] == { assert hass.data[upnp.DOMAIN]['auto_config'] == {
'active': True, 'active': True,
'port_forward': False, 'port_forward': False,
'ports': {'hass': 'hass'}, 'ports': {'hass': 'hass'},
@ -75,14 +75,14 @@ async def test_async_setup_auto_config(hass):
async def test_async_setup_auto_config_port_forward(hass): async def test_async_setup_auto_config_port_forward(hass):
"""Test async_setup.""" """Test async_setup."""
# setup component, enable auto_config # setup component, enable auto_config
await async_setup_component(hass, 'igd', { await async_setup_component(hass, 'upnp', {
'igd': { 'upnp': {
'port_forward': True, 'port_forward': True,
'ports': {'hass': 'hass'}, 'ports': {'hass': 'hass'},
}, },
'discovery': {}}) 'discovery': {}})
assert hass.data[igd.DOMAIN]['auto_config'] == { assert hass.data[upnp.DOMAIN]['auto_config'] == {
'active': True, 'active': True,
'port_forward': True, 'port_forward': True,
'ports': {'hass': 'hass'}, 'ports': {'hass': 'hass'},
@ -93,11 +93,11 @@ async def test_async_setup_auto_config_port_forward(hass):
async def test_async_setup_auto_config_no_sensors(hass): async def test_async_setup_auto_config_no_sensors(hass):
"""Test async_setup.""" """Test async_setup."""
# setup component, enable auto_config # setup component, enable auto_config
await async_setup_component(hass, 'igd', { await async_setup_component(hass, 'upnp', {
'igd': {'sensors': False}, 'upnp': {'sensors': False},
'discovery': {}}) 'discovery': {}})
assert hass.data[igd.DOMAIN]['auto_config'] == { assert hass.data[upnp.DOMAIN]['auto_config'] == {
'active': True, 'active': True,
'port_forward': False, 'port_forward': False,
'ports': {'hass': 'hass'}, 'ports': {'hass': 'hass'},
@ -108,7 +108,7 @@ async def test_async_setup_auto_config_no_sensors(hass):
async def test_async_setup_entry_default(hass): async def test_async_setup_entry_default(hass):
"""Test async_setup_entry.""" """Test async_setup_entry."""
udn = 'uuid:device_1' udn = 'uuid:device_1'
entry = MockConfigEntry(domain=igd.DOMAIN, data={ entry = MockConfigEntry(domain=upnp.DOMAIN, data={
'ssdp_description': 'http://192.168.1.1/desc.xml', 'ssdp_description': 'http://192.168.1.1/desc.xml',
'udn': udn, 'udn': udn,
'sensors': True, 'sensors': True,
@ -116,9 +116,9 @@ async def test_async_setup_entry_default(hass):
}) })
# ensure hass.http is available # ensure hass.http is available
await async_setup_component(hass, 'igd') await async_setup_component(hass, 'upnp')
# mock homeassistant.components.igd.device.Device # mock homeassistant.components.upnp.device.Device
mock_device = MagicMock() mock_device = MagicMock()
mock_device.udn = udn mock_device.udn = udn
mock_device.async_add_port_mappings.return_value = mock_coro() mock_device.async_add_port_mappings.return_value = mock_coro()
@ -126,18 +126,18 @@ async def test_async_setup_entry_default(hass):
with patch.object(Device, 'async_create_device') as mock_create_device: with patch.object(Device, 'async_create_device') as mock_create_device:
mock_create_device.return_value = mock_coro( mock_create_device.return_value = mock_coro(
return_value=mock_device) return_value=mock_device)
with patch('homeassistant.components.igd.device.get_local_ip', with patch('homeassistant.components.upnp.device.get_local_ip',
return_value='192.168.1.10'): return_value='192.168.1.10'):
assert await igd.async_setup_entry(hass, entry) is True assert await upnp.async_setup_entry(hass, entry) is True
# ensure device is stored/used # ensure device is stored/used
assert hass.data[igd.DOMAIN]['devices'][udn] == mock_device assert hass.data[upnp.DOMAIN]['devices'][udn] == mock_device
hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP) hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)
await hass.async_block_till_done() await hass.async_block_till_done()
# ensure cleaned up # ensure cleaned up
assert udn not in hass.data[igd.DOMAIN]['devices'] assert udn not in hass.data[upnp.DOMAIN]['devices']
# ensure no port-mapping-methods called # ensure no port-mapping-methods called
assert len(mock_device.async_add_port_mappings.mock_calls) == 0 assert len(mock_device.async_add_port_mappings.mock_calls) == 0
@ -147,7 +147,7 @@ async def test_async_setup_entry_default(hass):
async def test_async_setup_entry_port_forward(hass): async def test_async_setup_entry_port_forward(hass):
"""Test async_setup_entry.""" """Test async_setup_entry."""
udn = 'uuid:device_1' udn = 'uuid:device_1'
entry = MockConfigEntry(domain=igd.DOMAIN, data={ entry = MockConfigEntry(domain=upnp.DOMAIN, data={
'ssdp_description': 'http://192.168.1.1/desc.xml', 'ssdp_description': 'http://192.168.1.1/desc.xml',
'udn': udn, 'udn': udn,
'sensors': False, 'sensors': False,
@ -155,8 +155,8 @@ async def test_async_setup_entry_port_forward(hass):
}) })
# ensure hass.http is available # ensure hass.http is available
await async_setup_component(hass, 'igd', { await async_setup_component(hass, 'upnp', {
'igd': { 'upnp': {
'port_forward': True, 'port_forward': True,
'ports': {'hass': 'hass'}, 'ports': {'hass': 'hass'},
}, },
@ -166,12 +166,12 @@ async def test_async_setup_entry_port_forward(hass):
mock_device = MockDevice(udn) mock_device = MockDevice(udn)
with patch.object(Device, 'async_create_device') as mock_create_device: with patch.object(Device, 'async_create_device') as mock_create_device:
mock_create_device.return_value = mock_coro(return_value=mock_device) mock_create_device.return_value = mock_coro(return_value=mock_device)
with patch('homeassistant.components.igd.device.get_local_ip', with patch('homeassistant.components.upnp.device.get_local_ip',
return_value='192.168.1.10'): return_value='192.168.1.10'):
assert await igd.async_setup_entry(hass, entry) is True assert await upnp.async_setup_entry(hass, entry) is True
# ensure device is stored/used # ensure device is stored/used
assert hass.data[igd.DOMAIN]['devices'][udn] == mock_device assert hass.data[upnp.DOMAIN]['devices'][udn] == mock_device
# ensure add-port-mapping-methods called # ensure add-port-mapping-methods called
assert mock_device.added_port_mappings == [ assert mock_device.added_port_mappings == [
@ -182,7 +182,7 @@ async def test_async_setup_entry_port_forward(hass):
await hass.async_block_till_done() await hass.async_block_till_done()
# ensure cleaned up # ensure cleaned up
assert udn not in hass.data[igd.DOMAIN]['devices'] assert udn not in hass.data[upnp.DOMAIN]['devices']
# ensure delete-port-mapping-methods called # ensure delete-port-mapping-methods called
assert mock_device.removed_port_mappings == [8123] assert mock_device.removed_port_mappings == [8123]