Merge pull request #27572 from home-assistant/rc

0.100.2

homeassistant/components/ecobee/binary_sensor.py

@@ -67,6 +67,10 @@ class EcobeeBinarySensor(BinarySensorDevice):
         """Get the latest state of the sensor."""
         await self.data.update()
         for sensor in self.data.ecobee.get_remote_sensors(self.index):
+            if sensor["name"] != self.sensor_name:
+                continue
             for item in sensor["capability"]:
-                if item["type"] == "occupancy" and self.sensor_name == sensor["name"]:
+                if item["type"] != "occupancy":
+                    continue
                 self._state = item["value"]
+                break

homeassistant/components/ecobee/sensor.py

@@ -74,7 +74,7 @@ class EcobeeSensor(Entity):
     @property
     def state(self):
         """Return the state of the sensor."""
-        if self._state in [ECOBEE_STATE_CALIBRATING, ECOBEE_STATE_UNKNOWN]:
+        if self._state in [ECOBEE_STATE_CALIBRATING, ECOBEE_STATE_UNKNOWN, "unknown"]:
             return None
 
         if self.type == "temperature":
@@ -91,6 +91,10 @@ class EcobeeSensor(Entity):
         """Get the latest state of the sensor."""
         await self.data.update()
         for sensor in self.data.ecobee.get_remote_sensors(self.index):
+            if sensor["name"] != self.sensor_name:
+                continue
             for item in sensor["capability"]:
-                if item["type"] == self.type and self.sensor_name == sensor["name"]:
+                if item["type"] != self.type:
+                    continue
                 self._state = item["value"]
+                break

homeassistant/components/google_assistant/report_state.py

@@ -1,15 +1,21 @@
 """Google Report State implementation."""
+import logging
+
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.const import MATCH_ALL
 from homeassistant.helpers.event import async_call_later
 
 from .helpers import AbstractConfig, GoogleEntity, async_get_entities
+from .error import SmartHomeError
 
 # Time to wait until the homegraph updates
 # https://github.com/actions-on-google/smart-home-nodejs/issues/196#issuecomment-439156639
 INITIAL_REPORT_DELAY = 60
 
 
+_LOGGER = logging.getLogger(__name__)
+
+
 @callback
 def async_enable_report_state(hass: HomeAssistant, google_config: AbstractConfig):
     """Enable state reporting."""
@@ -26,7 +32,11 @@ def async_enable_report_state(hass: HomeAssistant, google_config: AbstractConfig
         if not entity.is_supported():
             return
 
+        try:
             entity_data = entity.query_serialize()
+        except SmartHomeError as err:
+            _LOGGER.debug("Not reporting state for %s: %s", changed_entity, err.code)
+            return
 
         if old_state:
             old_entity = GoogleEntity(hass, google_config, old_state)

homeassistant/components/iaqualink/__init__.py

@@ -3,7 +3,7 @@ import asyncio
 from functools import wraps
 import logging
 
-from aiohttp import CookieJar
+from aiohttp import ClientTimeout
 import voluptuous as vol
 
 from iaqualink import (
@@ -85,7 +85,7 @@ async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry) -> None
     sensors = hass.data[DOMAIN][SENSOR_DOMAIN] = []
     switches = hass.data[DOMAIN][SWITCH_DOMAIN] = []
 
-    session = async_create_clientsession(hass, cookie_jar=CookieJar(unsafe=True))
+    session = async_create_clientsession(hass, timeout=ClientTimeout(total=5))
     aqualink = AqualinkClient(username, password, session)
     try:
         await aqualink.login()

homeassistant/components/mobile_app/manifest.json

@@ -7,6 +7,7 @@
     "PyNaCl==1.3.0"
   ],
   "dependencies": [
+    "cloud",
     "http",
     "webhook"
   ],

homeassistant/components/nzbget/sensor.py

@@ -34,9 +34,9 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     name = discovery_info["client_name"]
 
     devices = []
-    for sensor_type, sensor_config in SENSOR_TYPES.items():
+    for sensor_config in SENSOR_TYPES.values():
         new_sensor = NZBGetSensor(
-            nzbget_data, sensor_type, name, sensor_config[0], sensor_config[1]
+            nzbget_data, sensor_config[0], name, sensor_config[1], sensor_config[2]
         )
         devices.append(new_sensor)
 
@@ -50,8 +50,8 @@ class NZBGetSensor(Entity):
         self, nzbget_data, sensor_type, client_name, sensor_name, unit_of_measurement
     ):
         """Initialize a new NZBGet sensor."""
-        self._name = f"{client_name} {sensor_type}"
+        self._name = f"{client_name} {sensor_name}"
-        self.type = sensor_name
+        self.type = sensor_type
         self.client_name = client_name
         self.nzbget_data = nzbget_data
         self._state = None

homeassistant/components/songpal/manifest.json

@@ -3,7 +3,7 @@
   "name": "Songpal",
   "documentation": "https://www.home-assistant.io/integrations/songpal",
   "requirements": [
-    "python-songpal==0.0.9.1"
+    "python-songpal==0.11.1"
   ],
   "dependencies": [],
   "codeowners": [

homeassistant/components/withings/common.py

@@ -4,7 +4,7 @@ import logging
 import re
 import time
 
-import nokia
+import withings_api as withings
 from oauthlib.oauth2.rfc6749.errors import MissingTokenError
 from requests_oauthlib import TokenUpdated
 
@@ -68,7 +68,9 @@ class WithingsDataManager:
 
     service_available = None
 
-    def __init__(self, hass: HomeAssistantType, profile: str, api: nokia.NokiaApi):
+    def __init__(
+        self, hass: HomeAssistantType, profile: str, api: withings.WithingsApi
+    ):
         """Constructor."""
         self._hass = hass
         self._api = api
@@ -253,7 +255,7 @@ def create_withings_data_manager(
     """Set up the sensor config entry."""
     entry_creds = entry.data.get(const.CREDENTIALS) or {}
     profile = entry.data[const.PROFILE]
-    credentials = nokia.NokiaCredentials(
+    credentials = withings.WithingsCredentials(
         entry_creds.get("access_token"),
         entry_creds.get("token_expiry"),
         entry_creds.get("token_type"),
@@ -266,7 +268,7 @@ def create_withings_data_manager(
     def credentials_saver(credentials_param):
         _LOGGER.debug("Saving updated credentials of type %s", type(credentials_param))
 
-        # Sanitizing the data as sometimes a NokiaCredentials object
+        # Sanitizing the data as sometimes a WithingsCredentials object
         # is passed through from the API.
         cred_data = credentials_param
         if not isinstance(credentials_param, dict):
@@ -275,8 +277,8 @@ def create_withings_data_manager(
         entry.data[const.CREDENTIALS] = cred_data
         hass.config_entries.async_update_entry(entry, data={**entry.data})
 
-    _LOGGER.debug("Creating nokia api instance")
+    _LOGGER.debug("Creating withings api instance")
-    api = nokia.NokiaApi(
+    api = withings.WithingsApi(
         credentials, refresh_cb=(lambda token: credentials_saver(api.credentials))
     )
 

homeassistant/components/withings/config_flow.py

@@ -4,7 +4,7 @@ import logging
 from typing import Optional
 
 import aiohttp
-import nokia
+import withings_api as withings
 import voluptuous as vol
 
 from homeassistant import config_entries, data_entry_flow
@@ -75,7 +75,7 @@ class WithingsFlowHandler(config_entries.ConfigFlow):
             profile,
         )
 
-        return nokia.NokiaAuth(
+        return withings.WithingsAuth(
             client_id,
             client_secret,
             callback_uri,

homeassistant/components/withings/manifest.json

@@ -4,7 +4,7 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/withings",
   "requirements": [
-    "nokia==1.2.0"
+    "withings-api==2.0.0b8"
   ],
   "dependencies": [
     "api",

homeassistant/const.py

@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 100
-PATCH_VERSION = "1"
+PATCH_VERSION = "2"
 __short_version__ = "{}.{}".format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = "{}.{}".format(__short_version__, PATCH_VERSION)
 REQUIRED_PYTHON_VER = (3, 6, 0)

requirements_all.txt

@@ -865,9 +865,6 @@ niko-home-control==0.2.1
 # homeassistant.components.nilu
 niluclient==0.1.2
 
-# homeassistant.components.withings
-nokia==1.2.0
-
 # homeassistant.components.nederlandse_spoorwegen
 nsapi==2.7.4
 
@@ -1558,7 +1555,7 @@ python-ripple-api==0.0.3
 python-sochain-api==0.0.2
 
 # homeassistant.components.songpal
-python-songpal==0.0.9.1
+python-songpal==0.11.1
 
 # homeassistant.components.synologydsm
 python-synology==0.2.0
@@ -1973,6 +1970,9 @@ websockets==6.0
 # homeassistant.components.wirelesstag
 wirelesstagpy==0.4.0
 
+# homeassistant.components.withings
+withings-api==2.0.0b8
+
 # homeassistant.components.wunderlist
 wunderpy2==0.1.6
 

requirements_test_all.txt

@@ -228,9 +228,6 @@ minio==4.0.9
 # homeassistant.components.ssdp
 netdisco==2.6.0
 
-# homeassistant.components.withings
-nokia==1.2.0
-
 # homeassistant.components.iqvia
 # homeassistant.components.opencv
 # homeassistant.components.tensorflow
@@ -448,6 +445,9 @@ vultr==0.1.2
 # homeassistant.components.wake_on_lan
 wakeonlan==1.1.6
 
+# homeassistant.components.withings
+withings-api==2.0.0b8
+
 # homeassistant.components.zeroconf
 zeroconf==0.23.0
 

script/gen_requirements_all.py

@@ -185,6 +185,7 @@ TEST_REQUIREMENTS = (
     "YesssSMS",
     "zeroconf",
     "zigpy-homeassistant",
+    "withings-api",
 )
 
 IGNORE_PIN = ("colorlog>2.1,<3", "keyring>=9.3,<10.0", "urllib3")

tests/components/google_assistant/test_report_state.py

@@ -1,7 +1,7 @@
 """Test Google report state."""
 from unittest.mock import patch
 
-from homeassistant.components.google_assistant import report_state
+from homeassistant.components.google_assistant import report_state, error
 from homeassistant.util.dt import utcnow
 
 from . import BASIC_CONFIG
@@ -10,7 +10,7 @@ from . import BASIC_CONFIG
 from tests.common import mock_coro, async_fire_time_changed
 
 
-async def test_report_state(hass):
+async def test_report_state(hass, caplog):
     """Test report state works."""
     hass.states.async_set("light.ceiling", "off")
     hass.states.async_set("switch.ac", "on")
@@ -57,6 +57,19 @@ async def test_report_state(hass):
 
     assert len(mock_report.mock_calls) == 0
 
+    # Test that entities that we can't query don't report a state
+    with patch.object(
+        BASIC_CONFIG, "async_report_state", side_effect=mock_coro
+    ) as mock_report, patch(
+        "homeassistant.components.google_assistant.report_state.GoogleEntity.query_serialize",
+        side_effect=error.SmartHomeError("mock-error", "mock-msg"),
+    ):
+        hass.states.async_set("light.kitchen", "off")
+        await hass.async_block_till_done()
+
+    assert "Not reporting state for light.kitchen: mock-error"
+    assert len(mock_report.mock_calls) == 0
+
     unsub()
 
     with patch.object(

tests/components/withings/common.py

@@ -1,7 +1,7 @@
 """Common data for for the withings component tests."""
 import time
 
-import nokia
+import withings_api as withings
 
 import homeassistant.components.withings.const as const
 
@@ -92,7 +92,7 @@ def new_measure(type_str, value, unit):
     }
 
 
-def nokia_sleep_response(states):
+def withings_sleep_response(states):
     """Create a sleep response based on states."""
     data = []
     for state in states:
@@ -104,10 +104,10 @@ def nokia_sleep_response(states):
             )
         )
 
-    return nokia.NokiaSleep(new_sleep_data("aa", data))
+    return withings.WithingsSleep(new_sleep_data("aa", data))
 
 
-NOKIA_MEASURES_RESPONSE = nokia.NokiaMeasures(
+WITHINGS_MEASURES_RESPONSE = withings.WithingsMeasures(
     {
         "updatetime": "",
         "timezone": "",
@@ -174,7 +174,7 @@ NOKIA_MEASURES_RESPONSE = nokia.NokiaMeasures(
 )
 
 
-NOKIA_SLEEP_RESPONSE = nokia_sleep_response(
+WITHINGS_SLEEP_RESPONSE = withings_sleep_response(
     [
         const.MEASURE_TYPE_SLEEP_STATE_AWAKE,
         const.MEASURE_TYPE_SLEEP_STATE_LIGHT,
@@ -183,7 +183,7 @@ NOKIA_SLEEP_RESPONSE = nokia_sleep_response(
     ]
 )
 
-NOKIA_SLEEP_SUMMARY_RESPONSE = nokia.NokiaSleepSummary(
+WITHINGS_SLEEP_SUMMARY_RESPONSE = withings.WithingsSleepSummary(
     {
         "series": [
             new_sleep_summary(

tests/components/withings/conftest.py

@@ -3,7 +3,7 @@ import time
 from typing import Awaitable, Callable, List
 
 import asynctest
-import nokia
+import withings_api as withings
 import pytest
 
 import homeassistant.components.api as api
@@ -15,9 +15,9 @@ from homeassistant.const import CONF_UNIT_SYSTEM, CONF_UNIT_SYSTEM_METRIC
 from homeassistant.setup import async_setup_component
 
 from .common import (
-    NOKIA_MEASURES_RESPONSE,
+    WITHINGS_MEASURES_RESPONSE,
-    NOKIA_SLEEP_RESPONSE,
+    WITHINGS_SLEEP_RESPONSE,
-    NOKIA_SLEEP_SUMMARY_RESPONSE,
+    WITHINGS_SLEEP_SUMMARY_RESPONSE,
 )
 
 
@@ -34,17 +34,17 @@ class WithingsFactoryConfig:
         measures: List[str] = None,
         unit_system: str = None,
         throttle_interval: int = const.THROTTLE_INTERVAL,
-        nokia_request_response="DATA",
+        withings_request_response="DATA",
-        nokia_measures_response: nokia.NokiaMeasures = NOKIA_MEASURES_RESPONSE,
+        withings_measures_response: withings.WithingsMeasures = WITHINGS_MEASURES_RESPONSE,
-        nokia_sleep_response: nokia.NokiaSleep = NOKIA_SLEEP_RESPONSE,
+        withings_sleep_response: withings.WithingsSleep = WITHINGS_SLEEP_RESPONSE,
-        nokia_sleep_summary_response: nokia.NokiaSleepSummary = NOKIA_SLEEP_SUMMARY_RESPONSE,
+        withings_sleep_summary_response: withings.WithingsSleepSummary = WITHINGS_SLEEP_SUMMARY_RESPONSE,
     ) -> None:
         """Constructor."""
         self._throttle_interval = throttle_interval
-        self._nokia_request_response = nokia_request_response
+        self._withings_request_response = withings_request_response
-        self._nokia_measures_response = nokia_measures_response
+        self._withings_measures_response = withings_measures_response
-        self._nokia_sleep_response = nokia_sleep_response
+        self._withings_sleep_response = withings_sleep_response
-        self._nokia_sleep_summary_response = nokia_sleep_summary_response
+        self._withings_sleep_summary_response = withings_sleep_summary_response
         self._withings_config = {
             const.CLIENT_ID: "my_client_id",
             const.CLIENT_SECRET: "my_client_secret",
@@ -103,24 +103,24 @@ class WithingsFactoryConfig:
         return self._throttle_interval
 
     @property
-    def nokia_request_response(self):
+    def withings_request_response(self):
         """Request response."""
-        return self._nokia_request_response
+        return self._withings_request_response
 
     @property
-    def nokia_measures_response(self) -> nokia.NokiaMeasures:
+    def withings_measures_response(self) -> withings.WithingsMeasures:
         """Measures response."""
-        return self._nokia_measures_response
+        return self._withings_measures_response
 
     @property
-    def nokia_sleep_response(self) -> nokia.NokiaSleep:
+    def withings_sleep_response(self) -> withings.WithingsSleep:
         """Sleep response."""
-        return self._nokia_sleep_response
+        return self._withings_sleep_response
 
     @property
-    def nokia_sleep_summary_response(self) -> nokia.NokiaSleepSummary:
+    def withings_sleep_summary_response(self) -> withings.WithingsSleepSummary:
         """Sleep summary response."""
-        return self._nokia_sleep_summary_response
+        return self._withings_sleep_summary_response
 
 
 class WithingsFactoryData:
@@ -130,21 +130,21 @@ class WithingsFactoryData:
         self,
         hass,
         flow_id,
-        nokia_auth_get_credentials_mock,
+        withings_auth_get_credentials_mock,
-        nokia_api_request_mock,
+        withings_api_request_mock,
-        nokia_api_get_measures_mock,
+        withings_api_get_measures_mock,
-        nokia_api_get_sleep_mock,
+        withings_api_get_sleep_mock,
-        nokia_api_get_sleep_summary_mock,
+        withings_api_get_sleep_summary_mock,
         data_manager_get_throttle_interval_mock,
     ):
         """Constructor."""
         self._hass = hass
         self._flow_id = flow_id
-        self._nokia_auth_get_credentials_mock = nokia_auth_get_credentials_mock
+        self._withings_auth_get_credentials_mock = withings_auth_get_credentials_mock
-        self._nokia_api_request_mock = nokia_api_request_mock
+        self._withings_api_request_mock = withings_api_request_mock
-        self._nokia_api_get_measures_mock = nokia_api_get_measures_mock
+        self._withings_api_get_measures_mock = withings_api_get_measures_mock
-        self._nokia_api_get_sleep_mock = nokia_api_get_sleep_mock
+        self._withings_api_get_sleep_mock = withings_api_get_sleep_mock
-        self._nokia_api_get_sleep_summary_mock = nokia_api_get_sleep_summary_mock
+        self._withings_api_get_sleep_summary_mock = withings_api_get_sleep_summary_mock
         self._data_manager_get_throttle_interval_mock = (
             data_manager_get_throttle_interval_mock
         )
@@ -160,29 +160,29 @@ class WithingsFactoryData:
         return self._flow_id
 
     @property
-    def nokia_auth_get_credentials_mock(self):
+    def withings_auth_get_credentials_mock(self):
         """Get auth credentials mock."""
-        return self._nokia_auth_get_credentials_mock
+        return self._withings_auth_get_credentials_mock
 
     @property
-    def nokia_api_request_mock(self):
+    def withings_api_request_mock(self):
         """Get request mock."""
-        return self._nokia_api_request_mock
+        return self._withings_api_request_mock
 
     @property
-    def nokia_api_get_measures_mock(self):
+    def withings_api_get_measures_mock(self):
         """Get measures mock."""
-        return self._nokia_api_get_measures_mock
+        return self._withings_api_get_measures_mock
 
     @property
-    def nokia_api_get_sleep_mock(self):
+    def withings_api_get_sleep_mock(self):
         """Get sleep mock."""
-        return self._nokia_api_get_sleep_mock
+        return self._withings_api_get_sleep_mock
 
     @property
-    def nokia_api_get_sleep_summary_mock(self):
+    def withings_api_get_sleep_summary_mock(self):
         """Get sleep summary mock."""
-        return self._nokia_api_get_sleep_summary_mock
+        return self._withings_api_get_sleep_summary_mock
 
     @property
     def data_manager_get_throttle_interval_mock(self):
@@ -243,9 +243,9 @@ def withings_factory_fixture(request, hass) -> WithingsFactory:
         assert await async_setup_component(hass, http.DOMAIN, config.hass_config)
         assert await async_setup_component(hass, api.DOMAIN, config.hass_config)
 
-        nokia_auth_get_credentials_patch = asynctest.patch(
+        withings_auth_get_credentials_patch = asynctest.patch(
-            "nokia.NokiaAuth.get_credentials",
+            "withings_api.WithingsAuth.get_credentials",
-            return_value=nokia.NokiaCredentials(
+            return_value=withings.WithingsCredentials(
                 access_token="my_access_token",
                 token_expiry=time.time() + 600,
                 token_type="my_token_type",
@@ -255,28 +255,33 @@ def withings_factory_fixture(request, hass) -> WithingsFactory:
                 consumer_secret=config.withings_config.get(const.CLIENT_SECRET),
             ),
         )
-        nokia_auth_get_credentials_mock = nokia_auth_get_credentials_patch.start()
+        withings_auth_get_credentials_mock = withings_auth_get_credentials_patch.start()
 
-        nokia_api_request_patch = asynctest.patch(
+        withings_api_request_patch = asynctest.patch(
-            "nokia.NokiaApi.request", return_value=config.nokia_request_response
+            "withings_api.WithingsApi.request",
+            return_value=config.withings_request_response,
         )
-        nokia_api_request_mock = nokia_api_request_patch.start()
+        withings_api_request_mock = withings_api_request_patch.start()
 
-        nokia_api_get_measures_patch = asynctest.patch(
+        withings_api_get_measures_patch = asynctest.patch(
-            "nokia.NokiaApi.get_measures", return_value=config.nokia_measures_response
+            "withings_api.WithingsApi.get_measures",
+            return_value=config.withings_measures_response,
         )
-        nokia_api_get_measures_mock = nokia_api_get_measures_patch.start()
+        withings_api_get_measures_mock = withings_api_get_measures_patch.start()
 
-        nokia_api_get_sleep_patch = asynctest.patch(
+        withings_api_get_sleep_patch = asynctest.patch(
-            "nokia.NokiaApi.get_sleep", return_value=config.nokia_sleep_response
+            "withings_api.WithingsApi.get_sleep",
+            return_value=config.withings_sleep_response,
         )
-        nokia_api_get_sleep_mock = nokia_api_get_sleep_patch.start()
+        withings_api_get_sleep_mock = withings_api_get_sleep_patch.start()
 
-        nokia_api_get_sleep_summary_patch = asynctest.patch(
+        withings_api_get_sleep_summary_patch = asynctest.patch(
-            "nokia.NokiaApi.get_sleep_summary",
+            "withings_api.WithingsApi.get_sleep_summary",
-            return_value=config.nokia_sleep_summary_response,
+            return_value=config.withings_sleep_summary_response,
+        )
+        withings_api_get_sleep_summary_mock = (
+            withings_api_get_sleep_summary_patch.start()
         )
-        nokia_api_get_sleep_summary_mock = nokia_api_get_sleep_summary_patch.start()
 
         data_manager_get_throttle_interval_patch = asynctest.patch(
             "homeassistant.components.withings.common.WithingsDataManager"
@@ -295,11 +300,11 @@ def withings_factory_fixture(request, hass) -> WithingsFactory:
 
         patches.extend(
             [
-                nokia_auth_get_credentials_patch,
+                withings_auth_get_credentials_patch,
-                nokia_api_request_patch,
+                withings_api_request_patch,
-                nokia_api_get_measures_patch,
+                withings_api_get_measures_patch,
-                nokia_api_get_sleep_patch,
+                withings_api_get_sleep_patch,
-                nokia_api_get_sleep_summary_patch,
+                withings_api_get_sleep_summary_patch,
                 data_manager_get_throttle_interval_patch,
                 get_measures_patch,
             ]
@@ -328,11 +333,11 @@ def withings_factory_fixture(request, hass) -> WithingsFactory:
         return WithingsFactoryData(
             hass,
             flow_id,
-            nokia_auth_get_credentials_mock,
+            withings_auth_get_credentials_mock,
-            nokia_api_request_mock,
+            withings_api_request_mock,
-            nokia_api_get_measures_mock,
+            withings_api_get_measures_mock,
-            nokia_api_get_sleep_mock,
+            withings_api_get_sleep_mock,
-            nokia_api_get_sleep_summary_mock,
+            withings_api_get_sleep_summary_mock,
             data_manager_get_throttle_interval_mock,
         )
 

tests/components/withings/test_common.py

@@ -1,6 +1,6 @@
 """Tests for the Withings component."""
 from asynctest import MagicMock
-import nokia
+import withings_api as withings
 from oauthlib.oauth2.rfc6749.errors import MissingTokenError
 import pytest
 from requests_oauthlib import TokenUpdated
@@ -13,19 +13,19 @@ from homeassistant.components.withings.common import (
 from homeassistant.exceptions import PlatformNotReady
 
 
-@pytest.fixture(name="nokia_api")
+@pytest.fixture(name="withings_api")
-def nokia_api_fixture():
+def withings_api_fixture():
-    """Provide nokia api."""
+    """Provide withings api."""
-    nokia_api = nokia.NokiaApi.__new__(nokia.NokiaApi)
+    withings_api = withings.WithingsApi.__new__(withings.WithingsApi)
-    nokia_api.get_measures = MagicMock()
+    withings_api.get_measures = MagicMock()
-    nokia_api.get_sleep = MagicMock()
+    withings_api.get_sleep = MagicMock()
-    return nokia_api
+    return withings_api
 
 
 @pytest.fixture(name="data_manager")
-def data_manager_fixture(hass, nokia_api: nokia.NokiaApi):
+def data_manager_fixture(hass, withings_api: withings.WithingsApi):
     """Provide data manager."""
-    return WithingsDataManager(hass, "My Profile", nokia_api)
+    return WithingsDataManager(hass, "My Profile", withings_api)
 
 
 def test_print_service():

tests/components/withings/test_sensor.py

@@ -2,7 +2,12 @@
 from unittest.mock import MagicMock, patch
 
 import asynctest
-from nokia import NokiaApi, NokiaMeasures, NokiaSleep, NokiaSleepSummary
+from withings_api import (
+    WithingsApi,
+    WithingsMeasures,
+    WithingsSleep,
+    WithingsSleepSummary,
+)
 import pytest
 
 from homeassistant.components.withings import DOMAIN
@@ -15,7 +20,7 @@ from homeassistant.helpers.entity_component import async_update_entity
 from homeassistant.helpers.typing import HomeAssistantType
 from homeassistant.util import slugify
 
-from .common import nokia_sleep_response
+from .common import withings_sleep_response
 from .conftest import WithingsFactory, WithingsFactoryConfig
 
 
@@ -120,9 +125,9 @@ async def test_health_sensor_state_none(
     data = await withings_factory(
         WithingsFactoryConfig(
             measures=measure,
-            nokia_measures_response=None,
+            withings_measures_response=None,
-            nokia_sleep_response=None,
+            withings_sleep_response=None,
-            nokia_sleep_summary_response=None,
+            withings_sleep_summary_response=None,
         )
     )
 
@@ -153,9 +158,9 @@ async def test_health_sensor_state_empty(
     data = await withings_factory(
         WithingsFactoryConfig(
             measures=measure,
-            nokia_measures_response=NokiaMeasures({"measuregrps": []}),
+            withings_measures_response=WithingsMeasures({"measuregrps": []}),
-            nokia_sleep_response=NokiaSleep({"series": []}),
+            withings_sleep_response=WithingsSleep({"series": []}),
-            nokia_sleep_summary_response=NokiaSleepSummary({"series": []}),
+            withings_sleep_summary_response=WithingsSleepSummary({"series": []}),
         )
     )
 
@@ -201,7 +206,8 @@ async def test_sleep_state_throttled(
 
     data = await withings_factory(
         WithingsFactoryConfig(
-            measures=[measure], nokia_sleep_response=nokia_sleep_response(sleep_states)
+            measures=[measure],
+            withings_sleep_response=withings_sleep_response(sleep_states),
         )
     )
 
@@ -257,16 +263,16 @@ async def test_async_setup_entry_credentials_saver(hass: HomeAssistantType):
         "expires_in": "2",
     }
 
-    original_nokia_api = NokiaApi
+    original_withings_api = WithingsApi
-    nokia_api_instance = None
+    withings_api_instance = None
 
-    def new_nokia_api(*args, **kwargs):
+    def new_withings_api(*args, **kwargs):
-        nonlocal nokia_api_instance
+        nonlocal withings_api_instance
-        nokia_api_instance = original_nokia_api(*args, **kwargs)
+        withings_api_instance = original_withings_api(*args, **kwargs)
-        nokia_api_instance.request = MagicMock()
+        withings_api_instance.request = MagicMock()
-        return nokia_api_instance
+        return withings_api_instance
 
-    nokia_api_patch = patch("nokia.NokiaApi", side_effect=new_nokia_api)
+    withings_api_patch = patch("withings_api.WithingsApi", side_effect=new_withings_api)
     session_patch = patch("requests_oauthlib.OAuth2Session")
     client_patch = patch("oauthlib.oauth2.WebApplicationClient")
     update_entry_patch = patch.object(
@@ -275,7 +281,7 @@ async def test_async_setup_entry_credentials_saver(hass: HomeAssistantType):
         wraps=hass.config_entries.async_update_entry,
     )
 
-    with session_patch, client_patch, nokia_api_patch, update_entry_patch:
+    with session_patch, client_patch, withings_api_patch, update_entry_patch:
         async_add_entities = MagicMock()
         hass.config_entries.async_update_entry = MagicMock()
         config_entry = ConfigEntry(
@@ -298,7 +304,7 @@ async def test_async_setup_entry_credentials_saver(hass: HomeAssistantType):
 
         await async_setup_entry(hass, config_entry, async_add_entities)
 
-        nokia_api_instance.set_token(expected_creds)
+        withings_api_instance.set_token(expected_creds)
 
         new_creds = config_entry.data[const.CREDENTIALS]
         assert new_creds["access_token"] == "my_access_token2"