Add Cookidoo integration (#129800)

.strict-typing

@@ -137,6 +137,7 @@ homeassistant.components.co2signal.*
 homeassistant.components.command_line.*
 homeassistant.components.config.*
 homeassistant.components.configurator.*
+homeassistant.components.cookidoo.*
 homeassistant.components.counter.*
 homeassistant.components.cover.*
 homeassistant.components.cpuspeed.*

CODEOWNERS

@@ -284,6 +284,8 @@ build.json @home-assistant/supervisor
 /tests/components/control4/ @lawtancool
 /homeassistant/components/conversation/ @home-assistant/core @synesthesiam
 /tests/components/conversation/ @home-assistant/core @synesthesiam
+/homeassistant/components/cookidoo/ @miaucl
+/tests/components/cookidoo/ @miaucl
 /homeassistant/components/coolmaster/ @OnFreund
 /tests/components/coolmaster/ @OnFreund
 /homeassistant/components/counter/ @fabaff

homeassistant/components/cookidoo/__init__.py

@@ -0,0 +1,49 @@
+"""The Cookidoo integration."""
+
+from __future__ import annotations
+
+from cookidoo_api import Cookidoo, CookidooConfig, CookidooLocalizationConfig
+
+from homeassistant.const import (
+    CONF_COUNTRY,
+    CONF_EMAIL,
+    CONF_LANGUAGE,
+    CONF_PASSWORD,
+    Platform,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .coordinator import CookidooConfigEntry, CookidooDataUpdateCoordinator
+
+PLATFORMS: list[Platform] = [Platform.TODO]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: CookidooConfigEntry) -> bool:
+    """Set up Cookidoo from a config entry."""
+
+    cookidoo = Cookidoo(
+        async_get_clientsession(hass),
+        CookidooConfig(
+            email=entry.data[CONF_EMAIL],
+            password=entry.data[CONF_PASSWORD],
+            localization=CookidooLocalizationConfig(
+                country_code=entry.data[CONF_COUNTRY].lower(),
+                language=entry.data[CONF_LANGUAGE],
+            ),
+        ),
+    )
+
+    coordinator = CookidooDataUpdateCoordinator(hass, cookidoo, entry)
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: CookidooConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/cookidoo/config_flow.py

@@ -0,0 +1,167 @@
+"""Config flow for Cookidoo integration."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import logging
+from typing import Any
+
+from cookidoo_api import (
+    Cookidoo,
+    CookidooAuthException,
+    CookidooConfig,
+    CookidooLocalizationConfig,
+    CookidooRequestException,
+    get_country_options,
+    get_localization_options,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_COUNTRY, CONF_EMAIL, CONF_LANGUAGE, CONF_PASSWORD
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    CountrySelector,
+    CountrySelectorConfig,
+    LanguageSelector,
+    LanguageSelectorConfig,
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+AUTH_DATA_SCHEMA = {
+    vol.Required(CONF_EMAIL): TextSelector(
+        TextSelectorConfig(
+            type=TextSelectorType.EMAIL,
+            autocomplete="email",
+        ),
+    ),
+    vol.Required(CONF_PASSWORD): TextSelector(
+        TextSelectorConfig(
+            type=TextSelectorType.PASSWORD,
+            autocomplete="current-password",
+        ),
+    ),
+}
+
+
+class CookidooConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Cookidoo."""
+
+    COUNTRY_DATA_SCHEMA: dict
+    LANGUAGE_DATA_SCHEMA: dict
+
+    user_input: dict[str, Any]
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the user step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None and not (
+            errors := await self.validate_input(user_input)
+        ):
+            self._async_abort_entries_match({CONF_EMAIL: user_input[CONF_EMAIL]})
+            self.user_input = user_input
+            return await self.async_step_language()
+        await self.generate_country_schema()
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                data_schema=vol.Schema(
+                    {**AUTH_DATA_SCHEMA, **self.COUNTRY_DATA_SCHEMA}
+                ),
+                suggested_values=user_input,
+            ),
+            errors=errors,
+        )
+
+    async def async_step_language(
+        self,
+        language_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Async language step to set up the connection."""
+        errors: dict[str, str] = {}
+        if language_input is not None and not (
+            errors := await self.validate_input(self.user_input, language_input)
+        ):
+            return self.async_create_entry(
+                title="Cookidoo", data={**self.user_input, **language_input}
+            )
+
+        await self.generate_language_schema()
+        return self.async_show_form(
+            step_id="language",
+            data_schema=vol.Schema(self.LANGUAGE_DATA_SCHEMA),
+            errors=errors,
+        )
+
+    async def generate_country_schema(self) -> None:
+        """Generate country schema."""
+        self.COUNTRY_DATA_SCHEMA = {
+            vol.Required(CONF_COUNTRY): CountrySelector(
+                CountrySelectorConfig(
+                    countries=[
+                        country.upper() for country in await get_country_options()
+                    ],
+                )
+            )
+        }
+
+    async def generate_language_schema(self) -> None:
+        """Generate language schema."""
+        self.LANGUAGE_DATA_SCHEMA = {
+            vol.Required(CONF_LANGUAGE): LanguageSelector(
+                LanguageSelectorConfig(
+                    languages=[
+                        option.language
+                        for option in await get_localization_options(
+                            country=self.user_input[CONF_COUNTRY].lower()
+                        )
+                    ],
+                    native_name=True,
+                ),
+            ),
+        }
+
+    async def validate_input(
+        self,
+        user_input: Mapping[str, Any],
+        language_input: Mapping[str, Any] | None = None,
+    ) -> dict[str, str]:
+        """Input Helper."""
+
+        errors: dict[str, str] = {}
+
+        session = async_get_clientsession(self.hass)
+        cookidoo = Cookidoo(
+            session,
+            CookidooConfig(
+                email=user_input[CONF_EMAIL],
+                password=user_input[CONF_PASSWORD],
+                localization=CookidooLocalizationConfig(
+                    country_code=user_input[CONF_COUNTRY].lower(),
+                    language=language_input[CONF_LANGUAGE]
+                    if language_input
+                    else "de-ch",
+                ),
+            ),
+        )
+        try:
+            await cookidoo.login()
+            if language_input:
+                await cookidoo.get_additional_items()
+        except CookidooRequestException:
+            errors["base"] = "cannot_connect"
+        except CookidooAuthException:
+            errors["base"] = "invalid_auth"
+        except Exception:
+            _LOGGER.exception("Unexpected exception")
+            errors["base"] = "unknown"
+        return errors

homeassistant/components/cookidoo/const.py

@@ -0,0 +1,3 @@
+"""Constants for the Cookidoo integration."""
+
+DOMAIN = "cookidoo"

homeassistant/components/cookidoo/coordinator.py

@@ -0,0 +1,101 @@
+"""DataUpdateCoordinator for the Cookidoo integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+
+from cookidoo_api import (
+    Cookidoo,
+    CookidooAdditionalItem,
+    CookidooAuthException,
+    CookidooException,
+    CookidooIngredientItem,
+    CookidooRequestException,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_EMAIL
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+type CookidooConfigEntry = ConfigEntry[CookidooDataUpdateCoordinator]
+
+
+@dataclass
+class CookidooData:
+    """Cookidoo data type."""
+
+    ingredient_items: list[CookidooIngredientItem]
+    additional_items: list[CookidooAdditionalItem]
+
+
+class CookidooDataUpdateCoordinator(DataUpdateCoordinator[CookidooData]):
+    """A Cookidoo Data Update Coordinator."""
+
+    config_entry: CookidooConfigEntry
+
+    def __init__(
+        self, hass: HomeAssistant, cookidoo: Cookidoo, entry: CookidooConfigEntry
+    ) -> None:
+        """Initialize the Cookidoo data coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=timedelta(seconds=90),
+            config_entry=entry,
+        )
+        self.cookidoo = cookidoo
+
+    async def _async_setup(self) -> None:
+        try:
+            await self.cookidoo.login()
+        except CookidooRequestException as e:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="setup_request_exception",
+            ) from e
+        except CookidooAuthException as e:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="setup_authentication_exception",
+                translation_placeholders={
+                    CONF_EMAIL: self.config_entry.data[CONF_EMAIL]
+                },
+            ) from e
+
+    async def _async_update_data(self) -> CookidooData:
+        try:
+            ingredient_items = await self.cookidoo.get_ingredient_items()
+            additional_items = await self.cookidoo.get_additional_items()
+        except CookidooAuthException:
+            try:
+                await self.cookidoo.refresh_token()
+            except CookidooAuthException as exc:
+                raise ConfigEntryAuthFailed(
+                    translation_domain=DOMAIN,
+                    translation_key="setup_authentication_exception",
+                    translation_placeholders={
+                        CONF_EMAIL: self.config_entry.data[CONF_EMAIL]
+                    },
+                ) from exc
+            _LOGGER.debug(
+                "Authentication failed but re-authentication was successful, trying again later"
+            )
+            return self.data
+        except CookidooException as e:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_exception",
+            ) from e
+
+        return CookidooData(
+            ingredient_items=ingredient_items, additional_items=additional_items
+        )

homeassistant/components/cookidoo/entity.py

@@ -0,0 +1,30 @@
+"""Base entity for the Cookidoo integration."""
+
+from __future__ import annotations
+
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import CookidooDataUpdateCoordinator
+
+
+class CookidooBaseEntity(CoordinatorEntity[CookidooDataUpdateCoordinator]):
+    """Cookidoo base entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: CookidooDataUpdateCoordinator,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+
+        self.device_info = DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            name="Cookidoo",
+            identifiers={(DOMAIN, coordinator.config_entry.entry_id)},
+            manufacturer="Vorwerk International & Co. KmG",
+            model="Cookidoo - Thermomix® recipe portal",
+        )

homeassistant/components/cookidoo/icons.json

@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "todo": {
+      "ingredient_list": {
+        "default": "mdi:cart-plus"
+      },
+      "additional_item_list": {
+        "default": "mdi:cart-plus"
+      }
+    }
+  }
+}

homeassistant/components/cookidoo/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "cookidoo",
+  "name": "Cookidoo",
+  "codeowners": ["@miaucl"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/cookidoo",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["cookidoo-api==0.10.0"]
+}

homeassistant/components/cookidoo/quality_scale.yaml

@@ -0,0 +1,90 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: No service actions implemented
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: No service actions implemented
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions:
+    status: exempt
+    comment: No special external action required
+  entity-event-setup:
+    status: exempt
+    comment: No callbacks are implemented
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  config-entry-unloading: done
+  log-when-unavailable:
+    status: done
+    comment: Offloaded to coordinator
+  entity-unavailable:
+    status: done
+    comment: Offloaded to coordinator
+  action-exceptions:
+    status: done
+    comment: Only providing todo actions
+  reauthentication-flow: todo
+  parallel-updates: done
+  test-coverage: done
+  integration-owner: done
+  docs-installation-parameters: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options flow
+
+  # Gold
+  entity-translations: done
+  entity-device-class:
+    status: exempt
+    comment: currently no platform with device classes
+  devices: done
+  entity-category: done
+  entity-disabled-by-default:
+    status: exempt
+    comment: No disabled entities implemented
+  discovery:
+    status: exempt
+    comment: Nothing to discover
+  stale-devices:
+    status: exempt
+    comment: No stale entities possible
+  diagnostics: todo
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow: todo
+  dynamic-devices:
+    status: exempt
+    comment: No dynamic entities available
+  discovery-update-info:
+    status: exempt
+    comment: No discoverable entities implemented
+  repair-issues:
+    status: exempt
+    comment: No issues/repairs
+  docs-use-cases: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-data-update: done
+  docs-known-limitations: done
+  docs-troubleshooting: todo
+  docs-examples: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/cookidoo/strings.json

@@ -0,0 +1,68 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "title": "Login to Cookidoo",
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "country": "Country"
+        },
+        "data_description": {
+          "email": "Email used access your Cookidoo account.",
+          "password": "Password used access your Cookidoo account.",
+          "country": "Pick your language for the Cookidoo content."
+        }
+      },
+      "language": {
+        "title": "Login to Cookidoo",
+        "data": {
+          "language": "[%key:common::config_flow::data::language%]"
+        },
+        "data_description": {
+          "language": "Pick your language for the Cookidoo content."
+        }
+      }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+    }
+  },
+  "entity": {
+    "todo": {
+      "ingredient_list": {
+        "name": "Shopping list"
+      },
+      "additional_item_list": {
+        "name": "Additional purchases"
+      }
+    }
+  },
+  "exceptions": {
+    "todo_save_item_failed": {
+      "message": "Failed to save {name} to Cookidoo shopping list"
+    },
+    "todo_update_item_failed": {
+      "message": "Failed to update {name} in Cookidoo shopping list"
+    },
+    "todo_delete_item_failed": {
+      "message": "Failed to delete {count} item(s) from Cookidoo shopping list"
+    },
+    "setup_request_exception": {
+      "message": "Failed to connect to server, try again later"
+    },
+    "setup_authentication_exception": {
+      "message": "Authentication failed for {email}, check your email and password"
+    },
+    "update_exception": {
+      "message": "Unable to connect and retrieve data from cookidoo"
+    }
+  }
+}

homeassistant/components/cookidoo/todo.py

@@ -0,0 +1,185 @@
+"""Todo platform for the Cookidoo integration."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cookidoo_api import (
+    CookidooAdditionalItem,
+    CookidooException,
+    CookidooIngredientItem,
+)
+
+from homeassistant.components.todo import (
+    TodoItem,
+    TodoItemStatus,
+    TodoListEntity,
+    TodoListEntityFeature,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import CookidooConfigEntry, CookidooDataUpdateCoordinator
+from .entity import CookidooBaseEntity
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: CookidooConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up the todo list from a config entry created in the integrations UI."""
+    coordinator = config_entry.runtime_data
+
+    async_add_entities(
+        [
+            CookidooIngredientsTodoListEntity(coordinator),
+            CookidooAdditionalItemTodoListEntity(coordinator),
+        ]
+    )
+
+
+class CookidooIngredientsTodoListEntity(CookidooBaseEntity, TodoListEntity):
+    """A To-do List representation of the ingredients in the Cookidoo Shopping List."""
+
+    _attr_translation_key = "ingredient_list"
+    _attr_supported_features = TodoListEntityFeature.UPDATE_TODO_ITEM
+
+    def __init__(self, coordinator: CookidooDataUpdateCoordinator) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_ingredients"
+
+    @property
+    def todo_items(self) -> list[TodoItem]:
+        """Return the todo ingredients."""
+        return [
+            TodoItem(
+                uid=item.id,
+                summary=item.name,
+                description=item.description or "",
+                status=(
+                    TodoItemStatus.COMPLETED
+                    if item.is_owned
+                    else TodoItemStatus.NEEDS_ACTION
+                ),
+            )
+            for item in self.coordinator.data.ingredient_items
+        ]
+
+    async def async_update_todo_item(self, item: TodoItem) -> None:
+        """Update an ingredient to the To-do list.
+
+        Cookidoo ingredients can be changed in state, but not in summary or description. This is currently not possible to distinguish in home assistant and just fails silently.
+        """
+        try:
+            if TYPE_CHECKING:
+                assert item.uid
+            await self.coordinator.cookidoo.edit_ingredient_items_ownership(
+                [
+                    CookidooIngredientItem(
+                        id=item.uid,
+                        name="",
+                        description="",
+                        is_owned=item.status == TodoItemStatus.COMPLETED,
+                    )
+                ]
+            )
+        except CookidooException as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="todo_update_item_failed",
+                translation_placeholders={"name": item.summary or ""},
+            ) from e
+
+        await self.coordinator.async_refresh()
+
+
+class CookidooAdditionalItemTodoListEntity(CookidooBaseEntity, TodoListEntity):
+    """A To-do List representation of the additional items in the Cookidoo Shopping List."""
+
+    _attr_translation_key = "additional_item_list"
+    _attr_supported_features = (
+        TodoListEntityFeature.CREATE_TODO_ITEM
+        | TodoListEntityFeature.UPDATE_TODO_ITEM
+        | TodoListEntityFeature.DELETE_TODO_ITEM
+    )
+
+    def __init__(self, coordinator: CookidooDataUpdateCoordinator) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_additional_items"
+
+    @property
+    def todo_items(self) -> list[TodoItem]:
+        """Return the todo items."""
+
+        return [
+            TodoItem(
+                uid=item.id,
+                summary=item.name,
+                status=(
+                    TodoItemStatus.COMPLETED
+                    if item.is_owned
+                    else TodoItemStatus.NEEDS_ACTION
+                ),
+            )
+            for item in self.coordinator.data.additional_items
+        ]
+
+    async def async_create_todo_item(self, item: TodoItem) -> None:
+        """Add an item to the To-do list."""
+
+        try:
+            if TYPE_CHECKING:
+                assert item.summary
+            await self.coordinator.cookidoo.add_additional_items([item.summary])
+        except CookidooException as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="todo_save_item_failed",
+                translation_placeholders={"name": item.summary or ""},
+            ) from e
+
+        await self.coordinator.async_refresh()
+
+    async def async_update_todo_item(self, item: TodoItem) -> None:
+        """Update an item to the To-do list."""
+
+        try:
+            if TYPE_CHECKING:
+                assert item.uid
+                assert item.summary
+            new_item = CookidooAdditionalItem(
+                id=item.uid,
+                name=item.summary,
+                is_owned=item.status == TodoItemStatus.COMPLETED,
+            )
+            await self.coordinator.cookidoo.edit_additional_items_ownership([new_item])
+            await self.coordinator.cookidoo.edit_additional_items([new_item])
+        except CookidooException as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="todo_update_item_failed",
+                translation_placeholders={"name": item.summary or ""},
+            ) from e
+
+        await self.coordinator.async_refresh()
+
+    async def async_delete_todo_items(self, uids: list[str]) -> None:
+        """Delete an item from the To-do list."""
+
+        try:
+            await self.coordinator.cookidoo.remove_additional_items(uids)
+        except CookidooException as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="todo_delete_item_failed",
+                translation_placeholders={"count": str(len(uids))},
+            ) from e
+
+        await self.coordinator.async_refresh()

homeassistant/generated/config_flows.py

@@ -113,6 +113,7 @@ FLOWS = {
         "color_extractor",
         "comelit",
         "control4",
+        "cookidoo",
         "coolmaster",
         "cpuspeed",
         "crownstone",

homeassistant/generated/integrations.json

@@ -1044,6 +1044,12 @@
       "config_flow": true,
       "iot_class": "local_polling"
     },
+    "cookidoo": {
+      "name": "Cookidoo",
+      "integration_type": "service",
+      "config_flow": true,
+      "iot_class": "cloud_polling"
+    },
     "coolmaster": {
       "name": "CoolMasterNet",
       "integration_type": "hub",

mypy.ini

@@ -1124,6 +1124,16 @@ disallow_untyped_defs = true
 warn_return_any = true
 warn_unreachable = true
 
+[mypy-homeassistant.components.cookidoo.*]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+warn_return_any = true
+warn_unreachable = true
+
 [mypy-homeassistant.components.counter.*]
 check_untyped_defs = true
 disallow_incomplete_defs = true

requirements_all.txt

@@ -704,6 +704,9 @@ connect-box==0.3.1
 # homeassistant.components.xiaomi_miio
 construct==2.10.68
 
+# homeassistant.components.cookidoo
+cookidoo-api==0.10.0
+
 # homeassistant.components.backup
 # homeassistant.components.utility_meter
 cronsim==2.6

requirements_test_all.txt

@@ -600,6 +600,9 @@ colorthief==0.2.1
 # homeassistant.components.xiaomi_miio
 construct==2.10.68
 
+# homeassistant.components.cookidoo
+cookidoo-api==0.10.0
+
 # homeassistant.components.backup
 # homeassistant.components.utility_meter
 cronsim==2.6

tests/components/cookidoo/__init__.py

@@ -0,0 +1,15 @@
+"""Tests for the Cookidoo integration."""
+
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
+
+
+async def setup_integration(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+) -> None:
+    """Mock setup of the cookidoo integration."""
+    cookidoo_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(cookidoo_config_entry.entry_id)
+    await hass.async_block_till_done()

tests/components/cookidoo/conftest.py

@@ -0,0 +1,76 @@
+"""Common fixtures for the Cookidoo tests."""
+
+from collections.abc import Generator
+from typing import cast
+from unittest.mock import AsyncMock, patch
+
+from cookidoo_api import (
+    CookidooAdditionalItem,
+    CookidooAuthResponse,
+    CookidooIngredientItem,
+)
+import pytest
+
+from homeassistant.components.cookidoo.const import DOMAIN
+from homeassistant.const import CONF_COUNTRY, CONF_EMAIL, CONF_LANGUAGE, CONF_PASSWORD
+
+from tests.common import MockConfigEntry, load_json_object_fixture
+
+EMAIL = "test-email"
+PASSWORD = "test-password"
+COUNTRY = "CH"
+LANGUAGE = "de-CH"
+
+
+@pytest.fixture
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Override async_setup_entry."""
+    with patch(
+        "homeassistant.components.cookidoo.async_setup_entry", return_value=True
+    ) as mock_setup_entry:
+        yield mock_setup_entry
+
+
+@pytest.fixture
+def mock_cookidoo_client() -> Generator[AsyncMock]:
+    """Mock a Cookidoo client."""
+    with (
+        patch(
+            "homeassistant.components.cookidoo.Cookidoo",
+            autospec=True,
+        ) as mock_client,
+        patch(
+            "homeassistant.components.cookidoo.config_flow.Cookidoo",
+            new=mock_client,
+        ),
+    ):
+        client = mock_client.return_value
+        client.login.return_value = cast(CookidooAuthResponse, {"name": "Cookidoo"})
+        client.get_ingredient_items.return_value = [
+            CookidooIngredientItem(**item)
+            for item in load_json_object_fixture("ingredient_items.json", DOMAIN)[
+                "data"
+            ]
+        ]
+        client.get_additional_items.return_value = [
+            CookidooAdditionalItem(**item)
+            for item in load_json_object_fixture("additional_items.json", DOMAIN)[
+                "data"
+            ]
+        ]
+        yield client
+
+
+@pytest.fixture(name="cookidoo_config_entry")
+def mock_cookidoo_config_entry() -> MockConfigEntry:
+    """Mock cookidoo configuration entry."""
+    return MockConfigEntry(
+        domain=DOMAIN,
+        data={
+            CONF_EMAIL: EMAIL,
+            CONF_PASSWORD: PASSWORD,
+            CONF_COUNTRY: COUNTRY,
+            CONF_LANGUAGE: LANGUAGE,
+        },
+        entry_id="01JBVVVJ87F6G5V0QJX6HBC94T",
+    )

tests/components/cookidoo/fixtures/additional_items.json

@@ -0,0 +1,9 @@
+{
+  "data": [
+    {
+      "id": "unique_id_tomaten",
+      "name": "Tomaten",
+      "is_owned": false
+    }
+  ]
+}

tests/components/cookidoo/fixtures/ingredient_items.json

@@ -0,0 +1,10 @@
+{
+  "data": [
+    {
+      "id": "unique_id_mehl",
+      "name": "Mehl",
+      "description": "200 g",
+      "is_owned": false
+    }
+  ]
+}

tests/components/cookidoo/snapshots/test_todo.ambr

@@ -0,0 +1,95 @@
+# serializer version: 1
+# name: test_todo[todo.cookidoo_additional_purchases-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'todo',
+    'entity_category': None,
+    'entity_id': 'todo.cookidoo_additional_purchases',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Additional purchases',
+    'platform': 'cookidoo',
+    'previous_unique_id': None,
+    'supported_features': <TodoListEntityFeature: 7>,
+    'translation_key': 'additional_item_list',
+    'unique_id': '01JBVVVJ87F6G5V0QJX6HBC94T_additional_items',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_todo[todo.cookidoo_additional_purchases-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Cookidoo Additional purchases',
+      'supported_features': <TodoListEntityFeature: 7>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'todo.cookidoo_additional_purchases',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '1',
+  })
+# ---
+# name: test_todo[todo.cookidoo_shopping_list-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'todo',
+    'entity_category': None,
+    'entity_id': 'todo.cookidoo_shopping_list',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Shopping list',
+    'platform': 'cookidoo',
+    'previous_unique_id': None,
+    'supported_features': <TodoListEntityFeature: 4>,
+    'translation_key': 'ingredient_list',
+    'unique_id': '01JBVVVJ87F6G5V0QJX6HBC94T_ingredients',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_todo[todo.cookidoo_shopping_list-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Cookidoo Shopping list',
+      'supported_features': <TodoListEntityFeature: 4>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'todo.cookidoo_shopping_list',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '1',
+  })
+# ---

tests/components/cookidoo/test_config_flow.py

@@ -0,0 +1,182 @@
+"""Test the Cookidoo config flow."""
+
+from unittest.mock import AsyncMock
+
+from cookidoo_api.exceptions import (
+    CookidooAuthException,
+    CookidooException,
+    CookidooRequestException,
+)
+import pytest
+
+from homeassistant.components.cookidoo.const import DOMAIN
+from homeassistant.config_entries import SOURCE_USER
+from homeassistant.const import CONF_COUNTRY, CONF_EMAIL, CONF_LANGUAGE, CONF_PASSWORD
+from homeassistant.core import HomeAssistant
+from homeassistant.data_entry_flow import FlowResultType
+
+from .conftest import COUNTRY, EMAIL, LANGUAGE, PASSWORD
+
+from tests.common import MockConfigEntry
+
+MOCK_DATA_USER_STEP = {
+    CONF_EMAIL: EMAIL,
+    CONF_PASSWORD: PASSWORD,
+    CONF_COUNTRY: COUNTRY,
+}
+
+MOCK_DATA_LANGUAGE_STEP = {
+    CONF_LANGUAGE: LANGUAGE,
+}
+
+
+async def test_flow_user_success(
+    hass: HomeAssistant, mock_setup_entry: AsyncMock, mock_cookidoo_client: AsyncMock
+) -> None:
+    """Test we get the user flow and create entry with success."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["handler"] == "cookidoo"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_USER_STEP,
+    )
+
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "language"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_LANGUAGE_STEP,
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "Cookidoo"
+    assert result["data"] == {**MOCK_DATA_USER_STEP, **MOCK_DATA_LANGUAGE_STEP}
+    assert len(mock_setup_entry.mock_calls) == 1
+
+
+@pytest.mark.parametrize(
+    ("raise_error", "text_error"),
+    [
+        (CookidooRequestException(), "cannot_connect"),
+        (CookidooAuthException(), "invalid_auth"),
+        (CookidooException(), "unknown"),
+        (IndexError(), "unknown"),
+    ],
+)
+async def test_flow_user_init_data_unknown_error_and_recover_on_step_1(
+    hass: HomeAssistant,
+    mock_cookidoo_client: AsyncMock,
+    raise_error: Exception,
+    text_error: str,
+) -> None:
+    """Test unknown errors."""
+    mock_cookidoo_client.login.side_effect = raise_error
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_USER_STEP,
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"]["base"] == text_error
+
+    # Recover
+    mock_cookidoo_client.login.side_effect = None
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_USER_STEP,
+    )
+
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "language"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_LANGUAGE_STEP,
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["result"].title == "Cookidoo"
+
+    assert result["data"] == {**MOCK_DATA_USER_STEP, **MOCK_DATA_LANGUAGE_STEP}
+
+
+@pytest.mark.parametrize(
+    ("raise_error", "text_error"),
+    [
+        (CookidooRequestException(), "cannot_connect"),
+        (CookidooAuthException(), "invalid_auth"),
+        (CookidooException(), "unknown"),
+        (IndexError(), "unknown"),
+    ],
+)
+async def test_flow_user_init_data_unknown_error_and_recover_on_step_2(
+    hass: HomeAssistant,
+    mock_cookidoo_client: AsyncMock,
+    raise_error: Exception,
+    text_error: str,
+) -> None:
+    """Test unknown errors."""
+    mock_cookidoo_client.get_additional_items.side_effect = raise_error
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_USER_STEP,
+    )
+
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "language"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_LANGUAGE_STEP,
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"]["base"] == text_error
+
+    # Recover
+    mock_cookidoo_client.get_additional_items.side_effect = None
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_LANGUAGE_STEP,
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["result"].title == "Cookidoo"
+
+    assert result["data"] == {**MOCK_DATA_USER_STEP, **MOCK_DATA_LANGUAGE_STEP}
+
+
+async def test_flow_user_init_data_already_configured(
+    hass: HomeAssistant,
+    mock_cookidoo_client: AsyncMock,
+    cookidoo_config_entry: MockConfigEntry,
+) -> None:
+    """Test we abort user data set when entry is already configured."""
+
+    cookidoo_config_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": "user"}
+    )
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=MOCK_DATA_USER_STEP,
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"

tests/components/cookidoo/test_init.py

@@ -0,0 +1,102 @@
+"""Unit tests for the cookidoo integration."""
+
+from unittest.mock import AsyncMock
+
+from cookidoo_api import CookidooAuthException, CookidooRequestException
+import pytest
+
+from homeassistant.components.cookidoo.const import DOMAIN
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import HomeAssistant
+
+from . import setup_integration
+
+from tests.common import MockConfigEntry
+
+
+@pytest.mark.usefixtures("mock_cookidoo_client")
+async def test_load_unload(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+) -> None:
+    """Test loading and unloading of the config entry."""
+    await setup_integration(hass, cookidoo_config_entry)
+
+    entries = hass.config_entries.async_entries(DOMAIN)
+    assert len(entries) == 1
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    assert await hass.config_entries.async_unload(cookidoo_config_entry.entry_id)
+    assert cookidoo_config_entry.state is ConfigEntryState.NOT_LOADED
+
+
+@pytest.mark.parametrize(
+    ("exception", "status"),
+    [
+        (CookidooRequestException, ConfigEntryState.SETUP_RETRY),
+        (CookidooAuthException, ConfigEntryState.SETUP_RETRY),
+    ],
+)
+async def test_init_failure(
+    hass: HomeAssistant,
+    mock_cookidoo_client: AsyncMock,
+    status: ConfigEntryState,
+    exception: Exception,
+    cookidoo_config_entry: MockConfigEntry,
+) -> None:
+    """Test an initialization error on integration load."""
+    mock_cookidoo_client.login.side_effect = exception
+    await setup_integration(hass, cookidoo_config_entry)
+    assert cookidoo_config_entry.state == status
+
+
+@pytest.mark.parametrize(
+    "cookidoo_method",
+    [
+        "get_ingredient_items",
+        "get_additional_items",
+    ],
+)
+async def test_config_entry_not_ready(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+    cookidoo_method: str,
+) -> None:
+    """Test config entry not ready."""
+    getattr(
+        mock_cookidoo_client, cookidoo_method
+    ).side_effect = CookidooRequestException()
+    cookidoo_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(cookidoo_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert cookidoo_config_entry.state is ConfigEntryState.SETUP_RETRY
+
+
+@pytest.mark.parametrize(
+    ("exception", "status"),
+    [
+        (None, ConfigEntryState.LOADED),
+        (CookidooRequestException, ConfigEntryState.SETUP_RETRY),
+        (CookidooAuthException, ConfigEntryState.SETUP_ERROR),
+    ],
+)
+async def test_config_entry_not_ready_auth_error(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+    exception: Exception | None,
+    status: ConfigEntryState,
+) -> None:
+    """Test config entry not ready from authentication error."""
+
+    mock_cookidoo_client.get_ingredient_items.side_effect = CookidooAuthException
+    mock_cookidoo_client.refresh_token.side_effect = exception
+
+    cookidoo_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(cookidoo_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert cookidoo_config_entry.state is status

tests/components/cookidoo/test_todo.py

@@ -0,0 +1,292 @@
+"""Test for todo platform of the Cookidoo integration."""
+
+from collections.abc import Generator
+import re
+from unittest.mock import AsyncMock, patch
+
+from cookidoo_api import (
+    CookidooAdditionalItem,
+    CookidooIngredientItem,
+    CookidooRequestException,
+)
+import pytest
+from syrupy.assertion import SnapshotAssertion
+
+from homeassistant.components.todo import (
+    ATTR_ITEM,
+    ATTR_RENAME,
+    ATTR_STATUS,
+    DOMAIN as TODO_DOMAIN,
+    TodoItemStatus,
+    TodoServices,
+)
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import ATTR_ENTITY_ID, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import entity_registry as er
+
+from . import setup_integration
+
+from tests.common import MockConfigEntry, snapshot_platform
+
+
+@pytest.fixture(autouse=True)
+def todo_only() -> Generator[None]:
+    """Enable only the todo platform."""
+    with patch(
+        "homeassistant.components.cookidoo.PLATFORMS",
+        [Platform.TODO],
+    ):
+        yield
+
+
+@pytest.mark.usefixtures("mock_cookidoo_client")
+async def test_todo(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    snapshot: SnapshotAssertion,
+    entity_registry: er.EntityRegistry,
+) -> None:
+    """Snapshot test states of todo platform."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    await snapshot_platform(
+        hass, entity_registry, snapshot, cookidoo_config_entry.entry_id
+    )
+
+
+async def test_update_ingredient(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test update ingredient item."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    await hass.services.async_call(
+        TODO_DOMAIN,
+        TodoServices.UPDATE_ITEM,
+        service_data={
+            ATTR_ITEM: "unique_id_mehl",
+            ATTR_STATUS: TodoItemStatus.COMPLETED,
+        },
+        target={ATTR_ENTITY_ID: "todo.cookidoo_shopping_list"},
+        blocking=True,
+    )
+
+    mock_cookidoo_client.edit_ingredient_items_ownership.assert_called_once_with(
+        [
+            CookidooIngredientItem(
+                id="unique_id_mehl",
+                name="",
+                description="",
+                is_owned=True,
+            )
+        ],
+    )
+
+
+async def test_update_ingredient_exception(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test update ingredient with exception."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    mock_cookidoo_client.edit_ingredient_items_ownership.side_effect = (
+        CookidooRequestException
+    )
+    with pytest.raises(
+        HomeAssistantError, match="Failed to update Mehl in Cookidoo shopping list"
+    ):
+        await hass.services.async_call(
+            TODO_DOMAIN,
+            TodoServices.UPDATE_ITEM,
+            service_data={
+                ATTR_ITEM: "unique_id_mehl",
+                ATTR_STATUS: TodoItemStatus.COMPLETED,
+            },
+            target={ATTR_ENTITY_ID: "todo.cookidoo_shopping_list"},
+            blocking=True,
+        )
+
+
+async def test_add_additional_item(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test add additional item to list."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    await hass.services.async_call(
+        TODO_DOMAIN,
+        TodoServices.ADD_ITEM,
+        service_data={ATTR_ITEM: "Äpfel"},
+        target={ATTR_ENTITY_ID: "todo.cookidoo_additional_purchases"},
+        blocking=True,
+    )
+
+    mock_cookidoo_client.add_additional_items.assert_called_once_with(
+        ["Äpfel"],
+    )
+
+
+async def test_add_additional_item_exception(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test add additional item to list with exception."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    mock_cookidoo_client.add_additional_items.side_effect = CookidooRequestException
+    with pytest.raises(
+        HomeAssistantError, match="Failed to save Äpfel to Cookidoo shopping list"
+    ):
+        await hass.services.async_call(
+            TODO_DOMAIN,
+            TodoServices.ADD_ITEM,
+            service_data={ATTR_ITEM: "Äpfel"},
+            target={ATTR_ENTITY_ID: "todo.cookidoo_additional_purchases"},
+            blocking=True,
+        )
+
+
+async def test_update_additional_item(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test update additional item."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    await hass.services.async_call(
+        TODO_DOMAIN,
+        TodoServices.UPDATE_ITEM,
+        service_data={
+            ATTR_ITEM: "unique_id_tomaten",
+            ATTR_RENAME: "Peperoni",
+            ATTR_STATUS: TodoItemStatus.COMPLETED,
+        },
+        target={ATTR_ENTITY_ID: "todo.cookidoo_additional_purchases"},
+        blocking=True,
+    )
+
+    mock_cookidoo_client.edit_additional_items_ownership.assert_called_once_with(
+        [
+            CookidooAdditionalItem(
+                id="unique_id_tomaten",
+                name="Peperoni",
+                is_owned=True,
+            )
+        ],
+    )
+    mock_cookidoo_client.edit_additional_items.assert_called_once_with(
+        [
+            CookidooAdditionalItem(
+                id="unique_id_tomaten",
+                name="Peperoni",
+                is_owned=True,
+            )
+        ],
+    )
+
+
+async def test_update_additional_item_exception(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test update additional item with exception."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    mock_cookidoo_client.edit_additional_items_ownership.side_effect = (
+        CookidooRequestException
+    )
+    mock_cookidoo_client.edit_additional_items.side_effect = CookidooRequestException
+    with pytest.raises(
+        HomeAssistantError, match="Failed to update Peperoni in Cookidoo shopping list"
+    ):
+        await hass.services.async_call(
+            TODO_DOMAIN,
+            TodoServices.UPDATE_ITEM,
+            service_data={
+                ATTR_ITEM: "unique_id_tomaten",
+                ATTR_RENAME: "Peperoni",
+                ATTR_STATUS: TodoItemStatus.COMPLETED,
+            },
+            target={ATTR_ENTITY_ID: "todo.cookidoo_additional_purchases"},
+            blocking=True,
+        )
+
+
+async def test_delete_additional_items(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test delete additional item."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+
+    await hass.services.async_call(
+        TODO_DOMAIN,
+        TodoServices.REMOVE_ITEM,
+        service_data={ATTR_ITEM: "unique_id_tomaten"},
+        target={ATTR_ENTITY_ID: "todo.cookidoo_additional_purchases"},
+        blocking=True,
+    )
+
+    mock_cookidoo_client.remove_additional_items.assert_called_once_with(
+        ["unique_id_tomaten"]
+    )
+
+
+async def test_delete_additional_items_exception(
+    hass: HomeAssistant,
+    cookidoo_config_entry: MockConfigEntry,
+    mock_cookidoo_client: AsyncMock,
+) -> None:
+    """Test delete additional item."""
+
+    await setup_integration(hass, cookidoo_config_entry)
+
+    assert cookidoo_config_entry.state is ConfigEntryState.LOADED
+    mock_cookidoo_client.remove_additional_items.side_effect = CookidooRequestException
+    with pytest.raises(
+        HomeAssistantError,
+        match=re.escape("Failed to delete 1 item(s) from Cookidoo shopping list"),
+    ):
+        await hass.services.async_call(
+            TODO_DOMAIN,
+            TodoServices.REMOVE_ITEM,
+            service_data={ATTR_ITEM: "unique_id_tomaten"},
+            target={ATTR_ENTITY_ID: "todo.cookidoo_additional_purchases"},
+            blocking=True,
+        )