response
stringlengths 1
33.1k
| instruction
stringlengths 22
582k
|
|---|---|
Stub copying the blueprints to the config folder. | def stub_blueprint_populate_autouse(stub_blueprint_populate: None) -> None:
"""Stub copying the blueprints to the config folder.""" |
Track calls to a mock service. | def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation") |
Create test zone. | def setup_zone(hass):
"""Create test zone."""
hass.loop.run_until_complete(
async_setup_component(
hass,
zone.DOMAIN,
{
"zone": {
"name": "test",
"latitude": HOME_LATITUDE,
"longitude": HOME_LONGITUDE,
"radius": 250,
}
},
)
) |
Get a path for storing yaml devices. | def mock_yaml_devices(hass):
"""Get a path for storing yaml devices."""
yaml_devices = hass.config.path(legacy.YAML_DEVICES)
if os.path.isfile(yaml_devices):
os.remove(yaml_devices)
yield yaml_devices
if os.path.isfile(yaml_devices):
os.remove(yaml_devices) |
Mock legacy device tracker setup. | def _mock_legacy_device_tracker_setup(
hass: HomeAssistant, mock_legacy_device_scanner: MockScanner
) -> None:
"""Mock legacy device tracker setup."""
mock_legacy_device_tracker_setup(hass, mock_legacy_device_scanner) |
Test SEE service schema allows extra keys.
Temp work around because the iOS app sends incorrect data. | def test_see_schema_allowing_ios_calls() -> None:
"""Test SEE service schema allows extra keys.
Temp work around because the iOS app sends incorrect data.
"""
device_tracker.SERVICE_SEE_PAYLOAD_SCHEMA(
{
"dev_id": "Test",
"battery": 35,
"battery_status": "Not Charging",
"gps": [10.0, 10.0],
"gps_accuracy": 300,
"hostname": "beer",
}
) |
Test module.__all__ is correctly set. | def test_all(module: ModuleType) -> None:
"""Test module.__all__ is correctly set."""
help_test_all(module) |
Test deprecated constants. | def test_deprecated_constants(
caplog: pytest.LogCaptureFixture,
enum: SourceType,
module: ModuleType,
) -> None:
"""Test deprecated constants."""
import_and_test_deprecated_constant_enum(
caplog, module, enum, "SOURCE_TYPE_", "2025.1"
) |
Test the removal of a device from a config. | def test_remove_device_from_config(hass: HomeAssistant):
"""Test the removal of a device from a config."""
yaml_devices = {
"test": {
"hide_if_away": True,
"mac": "00:11:22:33:44:55",
"name": "Test name",
"picture": "/local/test.png",
"track": True,
},
"test2": {
"hide_if_away": True,
"mac": "00:ab:cd:33:44:55",
"name": "Test2",
"picture": "/local/test2.png",
"track": True,
},
}
mopen = mock_open()
files = {legacy.YAML_DEVICES: dump(yaml_devices)}
with (
patch_yaml_files(files, True),
patch("homeassistant.components.device_tracker.legacy.open", mopen),
):
legacy.remove_device_from_config(hass, "test")
mopen().write.assert_called_once_with(
"test2:\n"
" hide_if_away: true\n"
" mac: 00:ab:cd:33:44:55\n"
" name: Test2\n"
" picture: /local/test2.png\n"
" track: true\n"
) |
Mark test as credentials invalid. | def credentials_valid() -> bool:
"""Mark test as credentials invalid."""
return True |
Mark test as maintenance mode on. | def maintenance() -> bool:
"""Mark test as maintenance mode on."""
return False |
Fixture to patch mydevolo into a desired state. | def patch_mydevolo(
credentials_valid: bool, maintenance: bool
) -> Generator[None, None, None]:
"""Fixture to patch mydevolo into a desired state."""
with (
patch(
"homeassistant.components.devolo_home_control.Mydevolo.credentials_valid",
return_value=credentials_valid,
),
patch(
"homeassistant.components.devolo_home_control.Mydevolo.maintenance",
return_value=maintenance,
),
patch(
"homeassistant.components.devolo_home_control.Mydevolo.get_gateway_ids",
return_value=["1400000000000001", "1400000000000002"],
),
):
yield |
Auto mock zeroconf. | def devolo_home_control_mock_async_zeroconf(mock_async_zeroconf):
"""Auto mock zeroconf.""" |
Configure the integration. | def configure_integration(hass: HomeAssistant) -> MockConfigEntry:
"""Configure the integration."""
config = {
"username": "test-username",
"password": "test-password",
"mydevolo_url": "https://test_mydevolo_url.test",
}
entry = MockConfigEntry(
domain=DOMAIN, data=config, entry_id="123456", unique_id="123456"
)
entry.add_to_hass(hass)
return entry |
Mock connecting to a devolo home network device. | def mock_device():
"""Mock connecting to a devolo home network device."""
device = MockDevice(ip=IP)
with patch(
"homeassistant.components.devolo_home_network.Device",
side_effect=cycle([device]),
):
yield device |
Mock connecting to a devolo home network repeater device. | def mock_repeater_device(mock_device: MockDevice):
"""Mock connecting to a devolo home network repeater device."""
mock_device.plcnet = None
return mock_device |
Mock connecting to a devolo home network device without wifi. | def mock_nonwifi_device(mock_device: MockDevice):
"""Mock connecting to a devolo home network device without wifi."""
mock_device.device.features = ["reset", "update", "led", "intmtg"]
return mock_device |
Mock setup entry and user input. | def mock_validate_input():
"""Mock setup entry and user input."""
info = {
"serial_number": DISCOVERY_INFO.properties["SN"],
"title": DISCOVERY_INFO.properties["Product"],
}
with patch(
"homeassistant.components.devolo_home_network.config_flow.validate_input",
return_value=info,
):
yield info |
Auto mock zeroconf. | def devolo_home_network_mock_async_zeroconf(mock_async_zeroconf):
"""Auto mock zeroconf.""" |
Configure the integration. | def configure_integration(hass: HomeAssistant) -> MockConfigEntry:
"""Configure the integration."""
config = {
CONF_IP_ADDRESS: IP,
CONF_PASSWORD: "test",
}
entry = MockConfigEntry(domain=DOMAIN, data=config, entry_id="123456")
entry.add_to_hass(hass)
return entry |
Test the async_redact_data helper. | def test_redact() -> None:
"""Test the async_redact_data helper."""
data = {
"key1": "value1",
"key2": ["value2_a", "value2_b"],
"key3": [["value_3a", "value_3b"], ["value_3c", "value_3d"]],
"key4": {
"key4_1": "value4_1",
"key4_2": ["value4_2a", "value4_2b"],
"key4_3": [["value4_3a", "value4_3b"], ["value4_3c", "value4_3d"]],
},
"key5": None,
"key6": "",
"key7": False,
}
to_redact = {
"key1",
"key3",
"key4_1",
"key5",
"key6",
"key7",
}
assert async_redact_data(data, to_redact) == {
"key1": REDACTED,
"key2": ["value2_a", "value2_b"],
"key3": REDACTED,
"key4": {
"key4_1": REDACTED,
"key4_2": ["value4_2a", "value4_2b"],
"key4_3": [["value4_3a", "value4_3b"], ["value4_3c", "value4_3d"]],
},
"key5": None,
"key6": "",
"key7": REDACTED,
} |
Fixture for dtutil.now. | def mock_now() -> datetime:
"""Fixture for dtutil.now."""
return dt_util.utcnow() |
Mock the DirecTV connection for Home Assistant. | def mock_connection(aioclient_mock: AiohttpClientMocker) -> None:
"""Mock the DirecTV connection for Home Assistant."""
aioclient_mock.get(
f"http://{HOST}:8080/info/getVersion",
text=load_fixture("directv/info-get-version.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/info/getLocations",
text=load_fixture("directv/info-get-locations.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/info/mode",
params={"clientAddr": "B01234567890"},
text=load_fixture("directv/info-mode-standby.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/info/mode",
params={"clientAddr": "9XXXXXXXXXX9"},
status=HTTPStatus.INTERNAL_SERVER_ERROR,
text=load_fixture("directv/info-mode-error.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/info/mode",
text=load_fixture("directv/info-mode.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/remote/processKey",
text=load_fixture("directv/remote-process-key.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/tv/tune",
text=load_fixture("directv/tv-tune.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/tv/getTuned",
params={"clientAddr": "2CA17D1CD30X"},
text=load_fixture("directv/tv-get-tuned.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/tv/getTuned",
params={"clientAddr": "A01234567890"},
text=load_fixture("directv/tv-get-tuned-music.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/tv/getTuned",
params={"clientAddr": "C01234567890"},
status=HTTPStatus.FORBIDDEN,
text=load_fixture("directv/tv-get-tuned-restricted.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
f"http://{HOST}:8080/tv/getTuned",
text=load_fixture("directv/tv-get-tuned-movie.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
) |
Set up discord notification service. | def discord_notification_service(hass: HomeAssistant) -> DiscordNotificationService:
"""Set up discord notification service."""
hass.config.allowlist_external_urls.add(URL_ATTACHMENT)
return DiscordNotificationService(hass, "token") |
Create Discord service mock from factory. | def discord_aiohttp_mock_factory(
aioclient_mock: AiohttpClientMocker,
) -> AiohttpClientMocker:
"""Create Discord service mock from factory."""
def _discord_aiohttp_mock_factory(
headers: dict[str, str] | None = None,
) -> AiohttpClientMocker:
if headers is not None:
aioclient_mock.get(
URL_ATTACHMENT, status=HTTPStatus.OK, content=CONTENT, headers=headers
)
else:
aioclient_mock.get(
URL_ATTACHMENT,
status=HTTPStatus.OK,
content=CONTENT,
)
return aioclient_mock
return _discord_aiohttp_mock_factory |
Add config entry in Home Assistant. | def create_entry(hass: HomeAssistant) -> ConfigEntry:
"""Add config entry in Home Assistant."""
entry = MockConfigEntry(
domain=DOMAIN,
data=CONF_DATA,
unique_id="1234567890",
)
entry.add_to_hass(hass)
return entry |
Create mocked discord. | def mocked_discord_info():
"""Create mocked discord."""
mocked_discord = AsyncMock()
mocked_discord.id = "1234567890"
mocked_discord.name = NAME
return patch(
"homeassistant.components.discord.config_flow.nextcord.Client.application_info",
return_value=mocked_discord,
) |
Patch discord info. | def patch_discord_login():
"""Patch discord info."""
return patch("homeassistant.components.discord.config_flow.nextcord.Client.login") |
Mock response. | def mock_exception():
"""Mock response."""
response = Mock()
response.status = 404
return nextcord.HTTPException(response, "") |
Side effect function for Discovergy mock. | def _meter_last_reading(meter_id: str) -> Reading:
"""Side effect function for Discovergy mock."""
return (
LAST_READING_GAS
if meter_id == "d81a652fe0824f9a9d336016587d3b9d"
else LAST_READING
) |
Mock the pydiscovergy client. | def mock_discovergy() -> Generator[AsyncMock, None, None]:
"""Mock the pydiscovergy client."""
with (
patch(
"homeassistant.components.discovergy.Discovergy",
autospec=True,
) as mock_discovergy,
patch(
"homeassistant.components.discovergy.config_flow.Discovergy",
new=mock_discovergy,
),
):
mock = mock_discovergy.return_value
mock.meters.return_value = GET_METERS
mock.meter_last_reading.side_effect = _meter_last_reading
yield mock |
Create fixture for adding config entry in Home Assistant. | def create_entry(hass: HomeAssistant, unique_id: str | None = None) -> MockConfigEntry:
"""Create fixture for adding config entry in Home Assistant."""
entry = MockConfigEntry(domain=DOMAIN, data=CONF_DATA, unique_id=unique_id)
entry.add_to_hass(hass)
return entry |
Add config entry in Home Assistant. | def config_entry(hass: HomeAssistant) -> MockConfigEntry:
"""Add config entry in Home Assistant."""
return create_entry(hass) |
Add config entry with unique ID in Home Assistant. | def config_entry_with_uid(hass: HomeAssistant) -> MockConfigEntry:
"""Add config entry with unique ID in Home Assistant."""
return create_entry(hass, unique_id="aabbccddeeff") |
Create mocked plug device. | def mocked_plug() -> MagicMock:
"""Create mocked plug device."""
mocked_plug = MagicMock()
mocked_plug.state = "OFF"
mocked_plug.temperature = "33"
mocked_plug.current_consumption = "50"
mocked_plug.total_consumption = "1040"
mocked_plug.authenticated = None
mocked_plug.use_legacy_protocol = False
mocked_plug.model_name = "DSP-W215"
return mocked_plug |
Create mocked legacy plug device. | def mocked_plug_legacy() -> MagicMock:
"""Create mocked legacy plug device."""
mocked_plug = MagicMock()
mocked_plug.state = "OFF"
mocked_plug.temperature = "N/A"
mocked_plug.current_consumption = "N/A"
mocked_plug.total_consumption = "N/A"
mocked_plug.authenticated = ("0123456789ABCDEF0123456789ABCDEF", "ABCDefGHiJ")
mocked_plug.use_legacy_protocol = True
mocked_plug.model_name = "DSP-W215"
return mocked_plug |
Create mocked legacy unauthenticated plug device. | def mocked_plug_legacy_no_auth(mocked_plug_legacy: MagicMock) -> MagicMock:
"""Create mocked legacy unauthenticated plug device."""
mocked_plug_legacy = deepcopy(mocked_plug_legacy)
mocked_plug_legacy.authenticated = None
return mocked_plug_legacy |
Patch D-Link Smart Plug config flow. | def patch_config_flow(mocked_plug: MagicMock):
"""Patch D-Link Smart Plug config flow."""
return patch(
"homeassistant.components.dlink.config_flow.SmartPlug",
return_value=mocked_plug,
) |
Patch D-Link Smart Plug object. | def patch_setup(mocked_plug: MagicMock):
"""Patch D-Link Smart Plug object."""
return patch(
"homeassistant.components.dlink.SmartPlug",
return_value=mocked_plug,
) |
Mock the global data used by this component.
This includes network clients and library object factories. Mocking it
prevents network use. | def domain_data_mock(hass: HomeAssistant) -> Iterable[Mock]:
"""Mock the global data used by this component.
This includes network clients and library object factories. Mocking it
prevents network use.
"""
domain_data = create_autospec(DlnaDmrData, instance=True)
domain_data.upnp_factory = create_autospec(
UpnpFactory, spec_set=True, instance=True
)
upnp_device = create_autospec(UpnpDevice, instance=True)
upnp_device.name = MOCK_DEVICE_NAME
upnp_device.udn = MOCK_DEVICE_UDN
upnp_device.device_url = MOCK_DEVICE_LOCATION
upnp_device.device_type = "urn:schemas-upnp-org:device:MediaRenderer:1"
upnp_device.available = True
upnp_device.parent_device = None
upnp_device.root_device = upnp_device
upnp_device.all_devices = [upnp_device]
upnp_device.services = {
"urn:schemas-upnp-org:service:AVTransport:1": create_autospec(
UpnpService,
instance=True,
service_type="urn:schemas-upnp-org:service:AVTransport:1",
service_id="urn:upnp-org:serviceId:AVTransport",
),
"urn:schemas-upnp-org:service:ConnectionManager:1": create_autospec(
UpnpService,
instance=True,
service_type="urn:schemas-upnp-org:service:ConnectionManager:1",
service_id="urn:upnp-org:serviceId:ConnectionManager",
),
"urn:schemas-upnp-org:service:RenderingControl:1": create_autospec(
UpnpService,
instance=True,
service_type="urn:schemas-upnp-org:service:RenderingControl:1",
service_id="urn:upnp-org:serviceId:RenderingControl",
),
}
seal(upnp_device)
domain_data.upnp_factory.async_create_device.return_value = upnp_device
hass.data[DLNA_DOMAIN] = domain_data
return domain_data |
Mock a config entry for this platform. | def config_entry_mock() -> MockConfigEntry:
"""Mock a config entry for this platform."""
return MockConfigEntry(
unique_id=MOCK_DEVICE_UDN,
domain=DLNA_DOMAIN,
data={
CONF_URL: MOCK_DEVICE_LOCATION,
CONF_DEVICE_ID: MOCK_DEVICE_UDN,
CONF_TYPE: MOCK_DEVICE_TYPE,
CONF_MAC: MOCK_MAC_ADDRESS,
},
title=MOCK_DEVICE_NAME,
options={},
) |
Mock a config entry that does not already contain a MAC address. | def config_entry_mock_no_mac() -> MockConfigEntry:
"""Mock a config entry that does not already contain a MAC address."""
return MockConfigEntry(
unique_id=MOCK_DEVICE_UDN,
domain=DLNA_DOMAIN,
data={
CONF_URL: MOCK_DEVICE_LOCATION,
CONF_DEVICE_ID: MOCK_DEVICE_UDN,
CONF_TYPE: MOCK_DEVICE_TYPE,
},
title=MOCK_DEVICE_NAME,
options={},
) |
Mock the async_upnp_client DMR device, initially connected. | def dmr_device_mock(domain_data_mock: Mock) -> Iterable[Mock]:
"""Mock the async_upnp_client DMR device, initially connected."""
with patch(
"homeassistant.components.dlna_dmr.media_player.DmrDevice", autospec=True
) as constructor:
device = constructor.return_value
device.on_event = None
device.profile_device = (
domain_data_mock.upnp_factory.async_create_device.return_value
)
device.media_image_url = "http://198.51.100.20:8200/AlbumArt/2624-17620.jpg"
device.udn = "device_udn"
device.manufacturer = "device_manufacturer"
device.model_name = "device_model_name"
device.name = "device_name"
device.preset_names = ["preset1", "preset2"]
yield device |
Mock the SSDP Scanner. | def ssdp_scanner_mock() -> Iterable[Mock]:
"""Mock the SSDP Scanner."""
with patch("homeassistant.components.ssdp.Scanner", autospec=True) as mock_scanner:
reg_callback = mock_scanner.return_value.async_register_callback
reg_callback.return_value = Mock(return_value=None)
yield mock_scanner.return_value |
Mock the SSDP Server. | def ssdp_server_mock() -> Iterable[Mock]:
"""Mock the SSDP Server."""
with patch("homeassistant.components.ssdp.Server", autospec=True):
yield |
Mock the async_get_local_ip utility function to prevent network access. | def async_get_local_ip_mock() -> Iterable[Mock]:
"""Mock the async_get_local_ip utility function to prevent network access."""
with patch(
"homeassistant.components.dlna_dmr.media_player.async_get_local_ip",
autospec=True,
) as func:
func.return_value = AddressFamily.AF_INET, LOCAL_IP
yield func |
Mock network util's async_get_source_ip. | def dlna_dmr_mock_get_source_ip(mock_get_source_ip):
"""Mock network util's async_get_source_ip.""" |
Mock the get_mac_address function to prevent network access and assist tests. | def mock_get_mac_address() -> Iterable[Mock]:
"""Mock the get_mac_address function to prevent network access and assist tests."""
with patch(
"homeassistant.components.dlna_dmr.config_flow.get_mac_address", autospec=True
) as gma_mock:
gma_mock.return_value = MOCK_MAC_ADDRESS
yield gma_mock |
Mock async_setup_entry. | def mock_setup_entry() -> Iterable[Mock]:
"""Mock async_setup_entry."""
with patch(
"homeassistant.components.dlna_dmr.async_setup_entry", return_value=True
) as setup_entry_mock:
yield setup_entry_mock |
Construct mock AiohttpNotifyServer on demand, eliminating network use.
This fixture provides a list of the constructed servers. | def aiohttp_notify_servers_mock() -> Iterable[Mock]:
"""Construct mock AiohttpNotifyServer on demand, eliminating network use.
This fixture provides a list of the constructed servers.
"""
with patch(
"homeassistant.components.dlna_dmr.data.AiohttpNotifyServer"
) as mock_constructor:
servers = []
def make_server(*_args, **_kwargs):
server = Mock(spec=AiohttpNotifyServer)
servers.append(server)
server.event_handler = Mock(spec=UpnpEventHandler)
return server
mock_constructor.side_effect = make_server
yield mock_constructor
# Every server must be stopped if it was started
for server in servers:
assert (
server.async_start_server.call_count
== server.async_stop_server.call_count
) |
Mock the UpnpFactory class to construct DMS-style UPnP devices. | def upnp_factory_mock() -> Iterable[Mock]:
"""Mock the UpnpFactory class to construct DMS-style UPnP devices."""
with patch(
"homeassistant.components.dlna_dms.dms.UpnpFactory",
autospec=True,
spec_set=True,
) as upnp_factory:
upnp_device = create_autospec(UpnpDevice, instance=True)
upnp_device.name = MOCK_DEVICE_NAME
upnp_device.udn = MOCK_DEVICE_UDN
upnp_device.device_url = MOCK_DEVICE_LOCATION
upnp_device.device_type = MOCK_DEVICE_TYPE
upnp_device.available = True
upnp_device.parent_device = None
upnp_device.root_device = upnp_device
upnp_device.all_devices = [upnp_device]
upnp_device.services = {
"urn:schemas-upnp-org:service:ContentDirectory:1": create_autospec(
UpnpService,
instance=True,
service_type="urn:schemas-upnp-org:service:ContentDirectory:1",
service_id="urn:upnp-org:serviceId:ContentDirectory",
),
"urn:schemas-upnp-org:service:ConnectionManager:1": create_autospec(
UpnpService,
instance=True,
service_type="urn:schemas-upnp-org:service:ConnectionManager:1",
service_id="urn:upnp-org:serviceId:ConnectionManager",
),
}
seal(upnp_device)
upnp_factory_instance = upnp_factory.return_value
upnp_factory_instance.async_create_device.return_value = upnp_device
yield upnp_factory_instance |
Mock the AiohttpSessionRequester to prevent network use. | def aiohttp_session_requester_mock() -> Iterable[Mock]:
"""Mock the AiohttpSessionRequester to prevent network use."""
with patch(
"homeassistant.components.dlna_dms.dms.AiohttpSessionRequester", autospec=True
) as requester_mock:
yield requester_mock |
Mock a config entry for this platform. | def config_entry_mock() -> MockConfigEntry:
"""Mock a config entry for this platform."""
return MockConfigEntry(
unique_id=MOCK_DEVICE_USN,
domain=DOMAIN,
version=CONFIG_VERSION,
data={
CONF_URL: MOCK_DEVICE_LOCATION,
CONF_DEVICE_ID: MOCK_DEVICE_USN,
CONF_SOURCE_ID: MOCK_SOURCE_ID,
},
title=MOCK_DEVICE_NAME,
) |
Mock the async_upnp_client DMS device, initially connected. | def dms_device_mock(upnp_factory_mock: Mock) -> Iterable[Mock]:
"""Mock the async_upnp_client DMS device, initially connected."""
with patch(
"homeassistant.components.dlna_dms.dms.DmsDevice", autospec=True
) as constructor:
device = constructor.return_value
device.on_event = None
device.profile_device = upnp_factory_mock.async_create_device.return_value
device.icon = MOCK_DEVICE_BASE_URL + "/icon.jpg"
device.udn = "device_udn"
device.manufacturer = "device_manufacturer"
device.model_name = "device_model_name"
device.name = "device_name"
device.get_absolute_url.side_effect = lambda url: absolute_url(
MOCK_DEVICE_BASE_URL, url
)
yield device |
Mock the SSDP Scanner. | def ssdp_scanner_mock() -> Iterable[Mock]:
"""Mock the SSDP Scanner."""
with patch("homeassistant.components.ssdp.Scanner", autospec=True) as mock_scanner:
reg_callback = mock_scanner.return_value.async_register_callback
reg_callback.return_value = Mock(return_value=None)
yield mock_scanner.return_value |
Mock the SSDP Server. | def ssdp_server_mock() -> Iterable[Mock]:
"""Mock the SSDP Server."""
with patch("homeassistant.components.ssdp.Server", autospec=True):
yield |
Avoid setting up the entire integration. | def mock_setup_entry() -> Iterable[Mock]:
"""Avoid setting up the entire integration."""
with patch(
"homeassistant.components.dlna_dms.async_setup_entry",
return_value=True,
) as mock:
yield mock |
Auto mock bluetooth. | def mock_bluetooth(enable_bluetooth):
"""Auto mock bluetooth.""" |
Create fixture for adding config entry in Home Assistant. | def create_entry(hass: HomeAssistant) -> MockConfigEntry:
"""Create fixture for adding config entry in Home Assistant."""
entry = MockConfigEntry(domain=DOMAIN, data=CONF_DATA, unique_id="123456789")
entry.add_to_hass(hass)
return entry |
Add config entry in Home Assistant. | def config_entry(hass: HomeAssistant) -> MockConfigEntry:
"""Add config entry in Home Assistant."""
return create_entry(hass) |
Mock Dremel 3D Printer connection. | def connection() -> None:
"""Mock Dremel 3D Printer connection."""
mock = requests_mock.Mocker()
mock.post(
f"http://{HOST}:80/command",
response_list=[
{"text": load_fixture("dremel_3d_printer/command_1.json")},
{"text": load_fixture("dremel_3d_printer/command_2.json")},
{"text": load_fixture("dremel_3d_printer/command_1.json")},
{"text": load_fixture("dremel_3d_printer/command_2.json")},
],
)
mock.post(
f"https://{HOST}:11134/getHomeMessage",
text=load_fixture("dremel_3d_printer/get_home_message.json"),
status_code=HTTPStatus.OK,
)
mock.start() |
Patch the async entry setup of Dremel 3D Printer. | def patch_async_setup_entry():
"""Patch the async entry setup of Dremel 3D Printer."""
return patch(
"homeassistant.components.dremel_3d_printer.async_setup_entry",
return_value=True,
) |
Config entry version 1 fixture. | def config_entry_hub() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_255",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/255/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/255/#",
CONF_DEVICE_DESC: "Hub",
CONF_DEVICE_ID: 255,
CONF_DEVICE_NAME: "Hub DROP-1_C0FFEE",
CONF_DEVICE_TYPE: "hub",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_salt() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_8",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/8/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/8/#",
CONF_DEVICE_DESC: "Salt Sensor",
CONF_DEVICE_ID: 8,
CONF_DEVICE_NAME: "Salt Sensor",
CONF_DEVICE_TYPE: "salt",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_leak() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_20",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/20/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/20/#",
CONF_DEVICE_DESC: "Leak Detector",
CONF_DEVICE_ID: 20,
CONF_DEVICE_NAME: "Leak Detector",
CONF_DEVICE_TYPE: "leak",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_softener() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_0",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/0/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/0/#",
CONF_DEVICE_DESC: "Softener",
CONF_DEVICE_ID: 0,
CONF_DEVICE_NAME: "Softener",
CONF_DEVICE_TYPE: "soft",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_filter() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_4",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/4/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/4/#",
CONF_DEVICE_DESC: "Filter",
CONF_DEVICE_ID: 4,
CONF_DEVICE_NAME: "Filter",
CONF_DEVICE_TYPE: "filt",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_protection_valve() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_78",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/78/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/78/#",
CONF_DEVICE_DESC: "Protection Valve",
CONF_DEVICE_ID: 78,
CONF_DEVICE_NAME: "Protection Valve",
CONF_DEVICE_TYPE: "pv",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_pump_controller() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_83",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/83/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/83/#",
CONF_DEVICE_DESC: "Pump Controller",
CONF_DEVICE_ID: 83,
CONF_DEVICE_NAME: "Pump Controller",
CONF_DEVICE_TYPE: "pc",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Config entry version 1 fixture. | def config_entry_ro_filter() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_255",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/95/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/95/#",
CONF_DEVICE_DESC: "RO Filter",
CONF_DEVICE_ID: 95,
CONF_DEVICE_NAME: "RO Filter",
CONF_DEVICE_TYPE: "ro",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
) |
Mock of a serial port. | def com_port():
"""Mock of a serial port."""
port = serial.tools.list_ports_common.ListPortInfo("/dev/ttyUSB1234")
port.serial_number = "1234"
port.manufacturer = "Virtual serial port"
port.device = "/dev/ttyUSB1234"
port.description = "Some serial port"
return port |
Test serial by id conversion if there's no /dev/serial/by-id. | def test_get_serial_by_id_no_dir() -> None:
"""Test serial by id conversion if there's no /dev/serial/by-id."""
p1 = patch("os.path.isdir", MagicMock(return_value=False))
p2 = patch("os.scandir")
with p1 as is_dir_mock, p2 as scan_mock:
res = config_flow.get_serial_by_id(sentinel.path)
assert res is sentinel.path
assert is_dir_mock.call_count == 1
assert scan_mock.call_count == 0 |
Test serial by id conversion. | def test_get_serial_by_id() -> None:
"""Test serial by id conversion."""
p1 = patch("os.path.isdir", MagicMock(return_value=True))
p2 = patch("os.scandir")
def _realpath(path):
if path is sentinel.matched_link:
return sentinel.path
return sentinel.serial_link_path
p3 = patch("os.path.realpath", side_effect=_realpath)
with p1 as is_dir_mock, p2 as scan_mock, p3:
res = config_flow.get_serial_by_id(sentinel.path)
assert res is sentinel.path
assert is_dir_mock.call_count == 1
assert scan_mock.call_count == 1
entry1 = MagicMock(spec_set=os.DirEntry)
entry1.is_symlink.return_value = True
entry1.path = sentinel.some_path
entry2 = MagicMock(spec_set=os.DirEntry)
entry2.is_symlink.return_value = False
entry2.path = sentinel.other_path
entry3 = MagicMock(spec_set=os.DirEntry)
entry3.is_symlink.return_value = True
entry3.path = sentinel.matched_link
scan_mock.return_value = [entry1, entry2, entry3]
res = config_flow.get_serial_by_id(sentinel.path)
assert res is sentinel.matched_link
assert is_dir_mock.call_count == 2
assert scan_mock.call_count == 2 |
Fixture that sets up DuckDNS. | def setup_duckdns(hass, aioclient_mock):
"""Fixture that sets up DuckDNS."""
aioclient_mock.get(
duckdns.UPDATE_URL, params={"domains": DOMAIN, "token": TOKEN}, text="OK"
)
hass.loop.run_until_complete(
async_setup_component(
hass, duckdns.DOMAIN, {"duckdns": {"domain": DOMAIN, "access_token": TOKEN}}
)
) |
Override async_setup_entry. | def mock_setup_entry() -> Generator[AsyncMock, None, None]:
"""Override async_setup_entry."""
with patch(
"homeassistant.components.duotecno.async_setup_entry", return_value=True
) as mock_setup_entry:
yield mock_setup_entry |
Override async_setup_entry. | def mock_setup_entry() -> Generator[AsyncMock, None, None]:
"""Override async_setup_entry."""
with patch(
"homeassistant.components.dwd_weather_warnings.async_setup_entry",
return_value=True,
) as mock_setup_entry:
yield mock_setup_entry |
Create a dynalite mock device for a platform according to a spec. | def create_mock_device(platform, spec):
"""Create a dynalite mock device for a platform according to a spec."""
device = Mock(spec=spec)
device.category = platform
device.unique_id = "UNIQUE"
device.name = "NAME"
device.device_class = "Device Class"
return device |
Mock a Dynalite device. | def mock_device():
"""Mock a Dynalite device."""
mock_dev = create_mock_device("cover", DynaliteTimeCoverWithTiltDevice)
mock_dev.device_class = CoverDeviceClass.BLIND.value
mock_dev.current_cover_position = 0
mock_dev.current_cover_tilt_position = 0
mock_dev.is_opening = False
mock_dev.is_closing = False
mock_dev.is_closed = True
def mock_init_level(target):
mock_dev.is_closed = target == 0
type(mock_dev).init_level = Mock(side_effect=mock_init_level)
return mock_dev |
Mock a Dynalite device. | def mock_device():
"""Mock a Dynalite device."""
mock_dev = create_mock_device("light", DynaliteChannelLightDevice)
mock_dev.brightness = 0
def mock_is_on():
return mock_dev.brightness != 0
type(mock_dev).is_on = PropertyMock(side_effect=mock_is_on)
def mock_init_level(target):
mock_dev.brightness = target
type(mock_dev).init_level = Mock(side_effect=mock_init_level)
return mock_dev |
Mock a Dynalite device. | def mock_device():
"""Mock a Dynalite device."""
mock_dev = create_mock_device("switch", DynalitePresetSwitchDevice)
mock_dev.is_on = False
def mock_init_level(level):
mock_dev.is_on = level
type(mock_dev).init_level = Mock(side_effect=mock_init_level)
return mock_dev |
Mock aioeafm.get_stations. | def mock_get_stations():
"""Mock aioeafm.get_stations."""
with patch("homeassistant.components.eafm.config_flow.get_stations") as patched:
yield patched |
Mock aioeafm.get_station. | def mock_get_station():
"""Mock aioeafm.get_station."""
with patch("homeassistant.components.eafm.get_station") as patched:
yield patched |
Mock setting up a config entry. | def mock_setup_entry() -> Generator[AsyncMock, None, None]:
"""Mock setting up a config entry."""
with patch(
"homeassistant.components.easyenergy.async_setup_entry", return_value=True
) as mock_setup:
yield mock_setup |
Return the default mocked config entry. | def mock_config_entry() -> MockConfigEntry:
"""Return the default mocked config entry."""
return MockConfigEntry(
title="energy",
domain=DOMAIN,
data={},
unique_id="unique_thingy",
) |
Return a mocked easyEnergy client. | def mock_easyenergy() -> Generator[MagicMock, None, None]:
"""Return a mocked easyEnergy client."""
with patch(
"homeassistant.components.easyenergy.coordinator.EasyEnergy", autospec=True
) as easyenergy_mock:
client = easyenergy_mock.return_value
client.energy_prices.return_value = Electricity.from_dict(
json.loads(load_fixture("today_energy.json", DOMAIN))
)
client.gas_prices.return_value = Gas.from_dict(
json.loads(load_fixture("today_gas.json", DOMAIN))
)
yield client |
Fixture for the config entry. | def config_entry_data(
mock_config_entry: MockConfigEntry, request: pytest.FixtureRequest
) -> dict[str, str]:
"""Fixture for the config entry."""
if "config_entry" in request.param and request.param["config_entry"] is True:
return {"config_entry": mock_config_entry.entry_id}
return request.param |
Fixture to provide a requests mocker. | def requests_mock_fixture(requests_mock):
"""Fixture to provide a requests mocker."""
requests_mock.get(
"https://api.ecobee.com/1/thermostat",
text=load_fixture("ecobee/ecobee-data.json"),
)
requests_mock.post(
"https://api.ecobee.com/token",
text=load_fixture("ecobee/ecobee-token.json"),
) |
Mock an Ecobee object. | def mock_ecobee() -> Generator[None, MagicMock]:
"""Mock an Ecobee object."""
ecobee = MagicMock()
ecobee.request_pin.return_value = True
ecobee.refresh_tokens.return_value = True
ecobee.thermostats = load_json_object_fixture("ecobee-data.json", "ecobee")[
"thermostatList"
]
ecobee.get_thermostat = lambda index: ecobee.thermostats[index]
ecobee.config = {ECOBEE_API_KEY: "mocked_key", ECOBEE_REFRESH_TOKEN: "mocked_token"}
with patch("homeassistant.components.ecobee.Ecobee", return_value=ecobee):
yield ecobee |
Set up ecobee mock. | def ecobee_fixture():
"""Set up ecobee mock."""
vals = {
"name": "Ecobee",
"modelNumber": "athenaSmart",
"identifier": "abc",
"program": {
"climates": [
{"name": "Climate1", "climateRef": "c1"},
{"name": "Climate2", "climateRef": "c2"},
{"name": "Away", "climateRef": "away"},
],
"currentClimateRef": "c1",
},
"runtime": {
"connected": True,
"actualTemperature": 300,
"actualHumidity": 15,
"desiredHeat": 400,
"desiredCool": 200,
"desiredFanMode": "on",
},
"settings": {
"hvacMode": "auto",
"heatStages": 1,
"coolStages": 1,
"fanMinOnTime": 10,
"heatCoolMinDelta": 50,
"holdAction": "nextTransition",
},
"equipmentStatus": "fan",
"events": [
{
"name": "Event1",
"running": True,
"type": "hold",
"holdClimateRef": "c1",
"startDate": "2017-02-02",
"startTime": "11:00:00",
"endDate": "2017-01-01",
"endTime": "10:00:00",
}
],
}
mock_ecobee = mock.Mock()
mock_ecobee.__getitem__ = mock.Mock(side_effect=vals.__getitem__)
mock_ecobee.__setitem__ = mock.Mock(side_effect=vals.__setitem__)
return mock_ecobee |
Set up data mock. | def data_fixture(ecobee_fixture):
"""Set up data mock."""
data = mock.Mock()
data.ecobee.get_thermostat.return_value = ecobee_fixture
return data |
Set up ecobee thermostat object. | def thermostat_fixture(data):
"""Set up ecobee thermostat object."""
thermostat = data.ecobee.get_thermostat(1)
return Thermostat(data, 1, thermostat) |
Test hold hours preference. | def test_hold_hours(ecobee_fixture, thermostat) -> None:
"""Test hold hours preference."""
ecobee_fixture["settings"]["holdAction"] = "useEndTime2hour"
assert thermostat.hold_hours() == 2
ecobee_fixture["settings"]["holdAction"] = "useEndTime4hour"
assert thermostat.hold_hours() == 4
for action in [
"nextPeriod",
"indefinite",
"askMe",
]:
ecobee_fixture["settings"]["holdAction"] = action
assert thermostat.hold_hours() is None |
Override async_setup_entry. | def mock_setup_entry() -> Generator[AsyncMock, None, None]:
"""Override async_setup_entry."""
with patch(
"homeassistant.components.ecoforest.async_setup_entry", return_value=True
) as mock_setup_entry:
yield mock_setup_entry |
Define a config entry data fixture. | def config_fixture():
"""Define a config entry data fixture."""
return {
CONF_HOST: "1.1.1.1",
CONF_USERNAME: "test-username",
CONF_PASSWORD: "test-password",
} |
Define a serial number fixture. | def serial_number_fixture():
"""Define a serial number fixture."""
return "1234" |
Define a mocked Ecoforest device fixture. | def mock_device_fixture(serial_number):
"""Define a mocked Ecoforest device fixture."""
mock = Mock(spec=Device)
mock.model = "model-version"
mock.model_name = "model-name"
mock.firmware = "firmware-version"
mock.serial_number = serial_number
mock.operation_mode = OperationMode.POWER
mock.on = False
mock.state = State.OFF
mock.power = 3
mock.temperature = 21.5
mock.alarm = Alarm.PELLETS
mock.alarm_code = "A099"
mock.environment_temperature = 23.5
mock.cpu_temperature = 36.1
mock.gas_temperature = 40.2
mock.ntc_temperature = 24.2
return mock |
Define a config entry fixture. | def config_entry_fixture(hass: HomeAssistant, config, serial_number):
"""Define a config entry fixture."""
entry = MockConfigEntry(
domain=DOMAIN,
entry_id="45a36e55aaddb2007c5f6602e0c38e72",
title=f"Ecoforest {serial_number}",
unique_id=serial_number,
data=config,
)
entry.add_to_hass(hass)
return entry |
Override async_setup_entry. | def mock_setup_entry() -> Generator[AsyncMock, None, None]:
"""Override async_setup_entry."""
with patch(
"homeassistant.components.ecovacs.async_setup_entry", return_value=True
) as async_setup_entry:
yield async_setup_entry |
Return the default mocked config entry data. | def mock_config_entry_data() -> dict[str, Any]:
"""Return the default mocked config entry data."""
return VALID_ENTRY_DATA_CLOUD |
Return the default mocked config entry. | def mock_config_entry(mock_config_entry_data: dict[str, Any]) -> MockConfigEntry:
"""Return the default mocked config entry."""
return MockConfigEntry(
title=mock_config_entry_data[CONF_USERNAME],
domain=DOMAIN,
data=mock_config_entry_data,
) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.