814 lines
28 KiB
Python
814 lines
28 KiB
Python
"""The tests for the analytics ."""
|
|
import asyncio
|
|
from typing import Any
|
|
from unittest.mock import ANY, AsyncMock, Mock, PropertyMock, patch
|
|
|
|
import aiohttp
|
|
import pytest
|
|
|
|
from homeassistant.components.analytics.analytics import Analytics
|
|
from homeassistant.components.analytics.const import (
|
|
ANALYTICS_ENDPOINT_URL,
|
|
ANALYTICS_ENDPOINT_URL_DEV,
|
|
ATTR_BASE,
|
|
ATTR_DIAGNOSTICS,
|
|
ATTR_STATISTICS,
|
|
ATTR_USAGE,
|
|
)
|
|
from homeassistant.components.recorder import Recorder
|
|
from homeassistant.config_entries import ConfigEntryState
|
|
from homeassistant.const import ATTR_DOMAIN
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.exceptions import HomeAssistantError
|
|
from homeassistant.loader import IntegrationNotFound
|
|
from homeassistant.setup import async_setup_component
|
|
|
|
from tests.common import MockConfigEntry, MockModule, mock_integration
|
|
from tests.test_util.aiohttp import AiohttpClientMocker
|
|
|
|
MOCK_UUID = "abcdefg"
|
|
MOCK_VERSION = "1970.1.0"
|
|
MOCK_VERSION_DEV = "1970.1.0.dev0"
|
|
MOCK_VERSION_NIGHTLY = "1970.1.0.dev19700101"
|
|
|
|
|
|
def _last_call_payload(aioclient: AiohttpClientMocker) -> dict[str, Any]:
|
|
"""Return the payload of the last call."""
|
|
return aioclient.mock_calls[-1][2]
|
|
|
|
|
|
async def test_no_send(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test send when no preferences are defined."""
|
|
analytics = Analytics(hass)
|
|
with patch(
|
|
"homeassistant.components.hassio.is_hassio",
|
|
side_effect=Mock(return_value=False),
|
|
):
|
|
assert not analytics.preferences[ATTR_BASE]
|
|
|
|
await analytics.send_analytics()
|
|
|
|
assert "Nothing to submit" in caplog.text
|
|
assert len(aioclient_mock.mock_calls) == 0
|
|
|
|
|
|
async def test_load_with_supervisor_diagnostics(hass: HomeAssistant) -> None:
|
|
"""Test loading with a supervisor that has diagnostics enabled."""
|
|
analytics = Analytics(hass)
|
|
assert not analytics.preferences[ATTR_DIAGNOSTICS]
|
|
with patch(
|
|
"homeassistant.components.hassio.get_supervisor_info",
|
|
side_effect=Mock(return_value={"diagnostics": True}),
|
|
), patch(
|
|
"homeassistant.components.hassio.is_hassio",
|
|
side_effect=Mock(return_value=True),
|
|
):
|
|
await analytics.load()
|
|
assert analytics.preferences[ATTR_DIAGNOSTICS]
|
|
|
|
|
|
async def test_load_with_supervisor_without_diagnostics(hass: HomeAssistant) -> None:
|
|
"""Test loading with a supervisor that has not diagnostics enabled."""
|
|
analytics = Analytics(hass)
|
|
analytics._data.preferences[ATTR_DIAGNOSTICS] = True
|
|
|
|
assert analytics.preferences[ATTR_DIAGNOSTICS]
|
|
|
|
with patch(
|
|
"homeassistant.components.hassio.get_supervisor_info",
|
|
side_effect=Mock(return_value={"diagnostics": False}),
|
|
), patch(
|
|
"homeassistant.components.hassio.is_hassio",
|
|
side_effect=Mock(return_value=True),
|
|
):
|
|
await analytics.load()
|
|
|
|
assert not analytics.preferences[ATTR_DIAGNOSTICS]
|
|
|
|
|
|
async def test_failed_to_send(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test failed to send payload."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=400)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
|
|
with patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
assert (
|
|
f"Sending analytics failed with statuscode 400 from {ANALYTICS_ENDPOINT_URL}"
|
|
in caplog.text
|
|
)
|
|
|
|
|
|
async def test_failed_to_send_raises(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test raises when failed to send payload."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, exc=aiohttp.ClientError())
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
|
|
with patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
assert "Error sending analytics" in caplog.text
|
|
|
|
|
|
async def test_send_base(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test send base preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
|
|
with patch("uuid.UUID.hex", new_callable=PropertyMock) as hex, patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
):
|
|
hex.return_value = MOCK_UUID
|
|
await analytics.send_analytics()
|
|
|
|
assert f"'uuid': '{MOCK_UUID}'" in caplog.text
|
|
assert f"'version': '{MOCK_VERSION}'" in caplog.text
|
|
assert "'installation_type':" in caplog.text
|
|
assert "'integration_count':" not in caplog.text
|
|
assert "'integrations':" not in caplog.text
|
|
|
|
|
|
async def test_send_base_with_supervisor(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test send base preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
|
|
with patch(
|
|
"homeassistant.components.hassio.get_supervisor_info",
|
|
side_effect=Mock(
|
|
return_value={"supported": True, "healthy": True, "arch": "amd64"}
|
|
),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_os_info",
|
|
side_effect=Mock(return_value={"board": "blue", "version": "123"}),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_host_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.is_hassio",
|
|
side_effect=Mock(return_value=True),
|
|
), patch(
|
|
"uuid.UUID.hex", new_callable=PropertyMock
|
|
) as hex, patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
):
|
|
hex.return_value = MOCK_UUID
|
|
await analytics.load()
|
|
|
|
await analytics.send_analytics()
|
|
|
|
assert f"'uuid': '{MOCK_UUID}'" in caplog.text
|
|
assert f"'version': '{MOCK_VERSION}'" in caplog.text
|
|
assert (
|
|
"'supervisor': {'healthy': True, 'supported': True, 'arch': 'amd64'}"
|
|
in caplog.text
|
|
)
|
|
assert "'operating_system': {'board': 'blue', 'version': '123'}" in caplog.text
|
|
assert "'installation_type':" in caplog.text
|
|
assert "'integration_count':" not in caplog.text
|
|
assert "'integrations':" not in caplog.text
|
|
|
|
|
|
async def test_send_usage(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test send usage preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate=None)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_USAGE]
|
|
hass.config.components = ["default_config"]
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.config.load_yaml_config_file",
|
|
return_value={"default_config": {}},
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.async_get_system_info",
|
|
return_value={"installation_type": "Home Assistant Tests"},
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
assert (
|
|
"Submitted analytics to Home Assistant servers. Information submitted includes"
|
|
in caplog.text
|
|
)
|
|
assert _last_call_payload(aioclient_mock) == {
|
|
"uuid": ANY,
|
|
"version": MOCK_VERSION,
|
|
"installation_type": "Home Assistant Tests",
|
|
"certificate": False,
|
|
"integrations": ["default_config"],
|
|
"custom_integrations": [],
|
|
}
|
|
|
|
|
|
async def test_send_usage_with_supervisor(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send usage with supervisor preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate=None)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_USAGE]
|
|
hass.config.components = ["default_config"]
|
|
|
|
with patch(
|
|
"homeassistant.components.hassio.get_supervisor_info",
|
|
side_effect=Mock(
|
|
return_value={
|
|
"healthy": True,
|
|
"supported": True,
|
|
"arch": "amd64",
|
|
"addons": [{"slug": "test_addon"}],
|
|
}
|
|
),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_os_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_host_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.async_get_addon_info",
|
|
side_effect=AsyncMock(
|
|
return_value={
|
|
"slug": "test_addon",
|
|
"protected": True,
|
|
"version": "1",
|
|
"auto_update": False,
|
|
}
|
|
),
|
|
), patch(
|
|
"homeassistant.components.hassio.is_hassio",
|
|
side_effect=Mock(return_value=True),
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
):
|
|
await analytics.send_analytics()
|
|
assert (
|
|
"'addons': [{'slug': 'test_addon', 'protected': True, 'version': '1',"
|
|
" 'auto_update': False}]"
|
|
) in caplog.text
|
|
assert "'addon_count':" not in caplog.text
|
|
|
|
|
|
async def test_send_statistics(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test send statistics preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_STATISTICS: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
hass.config.components = ["default_config"]
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.config.load_yaml_config_file",
|
|
return_value={"default_config": {}},
|
|
):
|
|
await analytics.send_analytics()
|
|
assert (
|
|
"'state_count': 0, 'automation_count': 0, 'integration_count': 1,"
|
|
" 'user_count': 0"
|
|
) in caplog.text
|
|
assert "'integrations':" not in caplog.text
|
|
|
|
|
|
async def test_send_statistics_one_integration_fails(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send statistics preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_STATISTICS: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
hass.config.components = ["default_config"]
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.async_get_integrations",
|
|
return_value={"any": IntegrationNotFound("any")},
|
|
), patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
|
|
post_call = aioclient_mock.mock_calls[0]
|
|
assert "uuid" in post_call[2]
|
|
assert post_call[2]["integration_count"] == 0
|
|
|
|
|
|
async def test_send_statistics_disabled_integration(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send statistics with disabled integration."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_STATISTICS: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
hass.config.components = ["default_config"]
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.async_get_integrations",
|
|
return_value={
|
|
"disabled_integration_manifest": mock_integration(
|
|
hass,
|
|
MockModule(
|
|
"disabled_integration",
|
|
async_setup=AsyncMock(return_value=True),
|
|
partial_manifest={"disabled": "system"},
|
|
),
|
|
)
|
|
},
|
|
), patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
|
|
payload = _last_call_payload(aioclient_mock)
|
|
assert "uuid" in payload
|
|
assert payload["integration_count"] == 0
|
|
|
|
|
|
async def test_send_statistics_ignored_integration(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send statistics with ignored integration."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_STATISTICS: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
|
|
mock_config_entry = MockConfigEntry(
|
|
domain="ignored_integration",
|
|
state=ConfigEntryState.LOADED,
|
|
source="ignore",
|
|
)
|
|
mock_config_entry.add_to_hass(hass)
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.async_get_integrations",
|
|
return_value={
|
|
"ignored_integration": mock_integration(
|
|
hass,
|
|
MockModule(
|
|
"ignored_integration",
|
|
async_setup=AsyncMock(return_value=True),
|
|
partial_manifest={"config_flow": True},
|
|
),
|
|
),
|
|
},
|
|
), patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
|
|
payload = _last_call_payload(aioclient_mock)
|
|
assert "uuid" in payload
|
|
assert payload["integration_count"] == 0
|
|
|
|
|
|
async def test_send_statistics_async_get_integration_unknown_exception(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send statistics preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_STATISTICS: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
hass.config.components = ["default_config"]
|
|
|
|
with pytest.raises(ValueError), patch(
|
|
"homeassistant.components.analytics.analytics.async_get_integrations",
|
|
return_value={"any": ValueError()},
|
|
), patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
|
|
|
|
async def test_send_statistics_with_supervisor(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send statistics preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_STATISTICS: True})
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
|
|
with patch(
|
|
"homeassistant.components.hassio.get_supervisor_info",
|
|
side_effect=Mock(
|
|
return_value={
|
|
"healthy": True,
|
|
"supported": True,
|
|
"arch": "amd64",
|
|
"addons": [{"slug": "test_addon"}],
|
|
}
|
|
),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_os_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.get_host_info",
|
|
side_effect=Mock(return_value={}),
|
|
), patch(
|
|
"homeassistant.components.hassio.async_get_addon_info",
|
|
side_effect=AsyncMock(
|
|
return_value={
|
|
"slug": "test_addon",
|
|
"protected": True,
|
|
"version": "1",
|
|
"auto_update": False,
|
|
}
|
|
),
|
|
), patch(
|
|
"homeassistant.components.hassio.is_hassio",
|
|
side_effect=Mock(return_value=True),
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
):
|
|
await analytics.send_analytics()
|
|
assert "'addon_count': 1" in caplog.text
|
|
assert "'integrations':" not in caplog.text
|
|
|
|
|
|
async def test_reusing_uuid(
|
|
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
|
|
) -> None:
|
|
"""Test reusing the stored UUID."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
analytics._data.uuid = "NOT_MOCK_UUID"
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
|
|
with patch("uuid.UUID.hex", new_callable=PropertyMock) as hex, patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
):
|
|
# This is not actually called but that in itself prove the test
|
|
hex.return_value = MOCK_UUID
|
|
await analytics.send_analytics()
|
|
|
|
assert analytics.uuid == "NOT_MOCK_UUID"
|
|
|
|
|
|
async def test_custom_integrations(
|
|
hass: HomeAssistant,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
enable_custom_integrations: None,
|
|
) -> None:
|
|
"""Test sending custom integrations."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate=None)
|
|
assert await async_setup_component(hass, "test_package", {"test_package": {}})
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.config.load_yaml_config_file",
|
|
return_value={"test_package": {}},
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
payload = aioclient_mock.mock_calls[0][2]
|
|
assert payload["custom_integrations"][0][ATTR_DOMAIN] == "test_package"
|
|
|
|
|
|
async def test_dev_url(
|
|
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
|
|
) -> None:
|
|
"""Test sending payload to dev url."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL_DEV, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION_DEV
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
payload = aioclient_mock.mock_calls[0]
|
|
assert str(payload[1]) == ANALYTICS_ENDPOINT_URL_DEV
|
|
|
|
|
|
async def test_dev_url_error(
|
|
hass: HomeAssistant,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
caplog: pytest.LogCaptureFixture,
|
|
) -> None:
|
|
"""Test sending payload to dev url that returns error."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL_DEV, status=400)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION_DEV
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
payload = aioclient_mock.mock_calls[0]
|
|
assert str(payload[1]) == ANALYTICS_ENDPOINT_URL_DEV
|
|
assert (
|
|
"Sending analytics failed with statuscode 400 from"
|
|
f" {ANALYTICS_ENDPOINT_URL_DEV}"
|
|
) in caplog.text
|
|
|
|
|
|
async def test_nightly_endpoint(
|
|
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
|
|
) -> None:
|
|
"""Test sending payload to production url when running nightly."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION_NIGHTLY
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
payload = aioclient_mock.mock_calls[0]
|
|
assert str(payload[1]) == ANALYTICS_ENDPOINT_URL
|
|
|
|
|
|
async def test_send_with_no_energy(
|
|
hass: HomeAssistant,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send base preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate=None)
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
|
|
with patch("uuid.UUID.hex", new_callable=PropertyMock) as hex, patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.energy_is_configured", AsyncMock()
|
|
) as energy_is_configured:
|
|
energy_is_configured.return_value = False
|
|
hex.return_value = MOCK_UUID
|
|
await analytics.send_analytics()
|
|
|
|
postdata = aioclient_mock.mock_calls[-1][2]
|
|
|
|
assert "energy" not in postdata
|
|
|
|
|
|
async def test_send_with_no_energy_config(
|
|
recorder_mock: Recorder,
|
|
hass: HomeAssistant,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send base preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
assert await async_setup_component(hass, "energy", {})
|
|
|
|
with patch("uuid.UUID.hex", new_callable=PropertyMock) as hex, patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.energy_is_configured", AsyncMock()
|
|
) as energy_is_configured:
|
|
energy_is_configured.return_value = False
|
|
hex.return_value = MOCK_UUID
|
|
await analytics.send_analytics()
|
|
|
|
postdata = aioclient_mock.mock_calls[-1][2]
|
|
|
|
assert not postdata["energy"]["configured"]
|
|
|
|
|
|
async def test_send_with_energy_config(
|
|
recorder_mock: Recorder,
|
|
hass: HomeAssistant,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send base preferences are defined."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
assert await async_setup_component(hass, "energy", {})
|
|
|
|
with patch("uuid.UUID.hex", new_callable=PropertyMock) as hex, patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.energy_is_configured", AsyncMock()
|
|
) as energy_is_configured:
|
|
energy_is_configured.return_value = True
|
|
hex.return_value = MOCK_UUID
|
|
await analytics.send_analytics()
|
|
|
|
postdata = aioclient_mock.mock_calls[-1][2]
|
|
|
|
assert postdata["energy"]["configured"]
|
|
|
|
|
|
async def test_send_usage_with_certificate(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test send usage preferences with certificate."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate="/some/path/to/cert.pem")
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_USAGE]
|
|
|
|
with patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
|
|
await analytics.send_analytics()
|
|
|
|
assert "'certificate': True" in caplog.text
|
|
|
|
|
|
async def test_send_with_recorder(
|
|
recorder_mock: Recorder,
|
|
hass: HomeAssistant,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test recorder information."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate="/some/path/to/cert.pem")
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.config.load_yaml_config_file",
|
|
return_value={"recorder": {}},
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
postdata = _last_call_payload(aioclient_mock)
|
|
assert postdata["recorder"]["engine"] == "sqlite"
|
|
|
|
|
|
async def test_send_with_problems_loading_yaml(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test error loading YAML configuration."""
|
|
analytics = Analytics(hass)
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True, ATTR_USAGE: True})
|
|
with patch(
|
|
"homeassistant.config.load_yaml_config_file",
|
|
side_effect=HomeAssistantError("Error loading YAML file"),
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
assert "Error loading YAML file" in caplog.text
|
|
assert len(aioclient_mock.mock_calls) == 0
|
|
|
|
|
|
async def test_timeout_while_sending(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
mock_hass_config: None,
|
|
) -> None:
|
|
"""Test timeout error while sending analytics."""
|
|
analytics = Analytics(hass)
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL_DEV, exc=asyncio.TimeoutError())
|
|
|
|
await analytics.save_preferences({ATTR_BASE: True})
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION_DEV
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
assert "Timeout sending analytics" in caplog.text
|
|
|
|
|
|
async def test_not_check_config_entries_if_yaml(
|
|
hass: HomeAssistant,
|
|
caplog: pytest.LogCaptureFixture,
|
|
aioclient_mock: AiohttpClientMocker,
|
|
) -> None:
|
|
"""Test skip config entry check if defined in yaml."""
|
|
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
|
|
analytics = Analytics(hass)
|
|
hass.http = Mock(ssl_certificate="/some/path/to/cert.pem")
|
|
|
|
await analytics.save_preferences(
|
|
{ATTR_BASE: True, ATTR_STATISTICS: True, ATTR_USAGE: True}
|
|
)
|
|
assert analytics.preferences[ATTR_BASE]
|
|
assert analytics.preferences[ATTR_STATISTICS]
|
|
hass.config.components = ["default_config"]
|
|
|
|
mock_config_entry = MockConfigEntry(
|
|
domain="ignored_integration",
|
|
state=ConfigEntryState.LOADED,
|
|
source="ignore",
|
|
disabled_by="user",
|
|
)
|
|
mock_config_entry.add_to_hass(hass)
|
|
|
|
with patch(
|
|
"homeassistant.components.analytics.analytics.async_get_integrations",
|
|
return_value={
|
|
"default_config": mock_integration(
|
|
hass,
|
|
MockModule(
|
|
"default_config",
|
|
async_setup=AsyncMock(return_value=True),
|
|
partial_manifest={"config_flow": True},
|
|
),
|
|
),
|
|
},
|
|
), patch(
|
|
"homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION
|
|
), patch(
|
|
"homeassistant.config.load_yaml_config_file",
|
|
return_value={"default_config": {}},
|
|
):
|
|
await analytics.send_analytics()
|
|
|
|
payload = _last_call_payload(aioclient_mock)
|
|
assert payload["integration_count"] == 1
|
|
assert payload["integrations"] == ["default_config"]
|