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

Add test fixture ignore_translations_for_mock_domains (#139235)

Browse Source 
* Add test fixture ignore_translations_for_mock_domains

* Fix fixture

* Avoid unnecessary attempt to get integration

* Really fix fixture

* Add forgotten parameter

* Address review comment
This commit is contained in:
Erik Montnemery 2025-02-25 20:10:29 +01:00 committed by GitHub
parent ef46552146
commit 51c09c2aa4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 164 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
tests/components/application_credentials/test_init.py
View File

@ -423,10 +423,7 @@ async def test_import_named_credential(
]
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.config.abort.missing_credentials"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_config_flow_no_credentials(hass: HomeAssistant) -> None:
"""Test config flow base case with no credentials registered."""
result = await hass.config_entries.flow.async_init(
@ -436,10 +433,7 @@ async def test_config_flow_no_credentials(hass: HomeAssistant) -> None:
assert result.get("reason") == "missing_credentials"
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.config.abort.missing_credentials"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_config_flow_other_domain(
hass: HomeAssistant,
ws_client: ClientFixture,
@ -567,10 +561,7 @@ async def test_config_flow_multiple_entries(
)
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.config.abort.missing_credentials"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_config_flow_create_delete_credential(
hass: HomeAssistant,
ws_client: ClientFixture,
@ -616,10 +607,7 @@ async def test_config_flow_with_config_credential(
assert result["data"].get("auth_implementation") == TEST_DOMAIN
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.config.abort.missing_configuration"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
@pytest.mark.parametrize("mock_application_credentials_integration", [None])
async def test_import_without_setup(hass: HomeAssistant, config_credential) -> None:
"""Test import of credentials without setting up the integration."""
@ -635,10 +623,7 @@ async def test_import_without_setup(hass: HomeAssistant, config_credential) -> N
assert result.get("reason") == "missing_configuration"
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.config.abort.missing_configuration"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
@pytest.mark.parametrize("mock_application_credentials_integration", [None])
async def test_websocket_without_platform(
hass: HomeAssistant, ws_client: ClientFixture

25
tests/components/config/test_config_entries.py
View File

@ -400,10 +400,7 @@ async def test_available_flows(
############################
@pytest.mark.parametrize(
"ignore_translations",
["component.test.config.error.Should be unique."],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_initialize_flow(hass: HomeAssistant, client: TestClient) -> None:
"""Test we can initialize a flow."""
mock_platform(hass, "test.config_flow", None)
@ -513,10 +510,7 @@ async def test_initialize_flow_unauth(
assert resp.status == HTTPStatus.UNAUTHORIZED
@pytest.mark.parametrize(
"ignore_translations",
["component.test.config.abort.bla"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_abort(hass: HomeAssistant, client: TestClient) -> None:
"""Test a flow that aborts."""
mock_platform(hass, "test.config_flow", None)
@ -826,10 +820,7 @@ async def test_get_progress_index_unauth(
assert response["error"]["code"] == "unauthorized"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.config.error.Should be unique."],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_get_progress_flow(hass: HomeAssistant, client: TestClient) -> None:
"""Test we can query the API for same result as we get from init a flow."""
mock_platform(hass, "test.config_flow", None)
@ -863,10 +854,7 @@ async def test_get_progress_flow(hass: HomeAssistant, client: TestClient) -> Non
assert data == data2
@pytest.mark.parametrize(
"ignore_translations",
["component.test.config.error.Should be unique."],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_get_progress_flow_unauth(
hass: HomeAssistant, client: TestClient, hass_admin_user: MockUser
) -> None:
@ -2870,10 +2858,7 @@ async def test_flow_with_multiple_schema_errors_base(
}
@pytest.mark.parametrize(
"ignore_translations",
["component.test.config.abort.reconfigure_successful"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@pytest.mark.usefixtures("freezer")
async def test_supports_reconfigure(
hass: HomeAssistant,

93
tests/components/conftest.py
View File

@ -22,6 +22,7 @@ from aiohasupervisor.models import (
import pytest
import voluptuous as vol
from homeassistant import components, loader
from homeassistant.components import repairs
from homeassistant.config_entries import (
DISCOVERY_SOURCES,
@ -605,6 +606,7 @@ def _validate_translation_placeholders(
async def _validate_translation(
hass: HomeAssistant,
translation_errors: dict[str, str],
ignore_translations_for_mock_domains: set[str],
category: str,
component: str,
key: str,
@ -614,7 +616,25 @@ async def _validate_translation(
) -> None:
"""Raise if translation doesn't exist."""
full_key = f"component.{component}.{category}.{key}"
if component in ignore_translations_for_mock_domains:
try:
integration = await loader.async_get_integration(hass, component)
except loader.IntegrationNotFound:
return
component_paths = components.__path__
if not any(
Path(f"{component_path}/{component}") == integration.file_path
for component_path in component_paths
):
return
# If the integration exists, translation errors should be ignored via the
# ignore_missing_translations fixture instead of the
# ignore_translations_for_mock_domains fixture.
translation_errors[full_key] = f"The integration '{component}' exists"
return
translations = await async_get_translations(hass, "en", category, [component])
if (translation := translations.get(full_key)) is not None:
_validate_translation_placeholders(
full_key, translation, description_placeholders, translation_errors
@ -625,6 +645,18 @@ async def _validate_translation(
return
if translation_errors.get(full_key) in {"used", "unused"}:
# If the does not integration exist, translation errors should be ignored
# via the ignore_translations_for_mock_domains fixture instead of the
# ignore_missing_translations fixture.
try:
await loader.async_get_integration(hass, component)
except loader.IntegrationNotFound:
translation_errors[full_key] = (
f"Translation not found for {component}: `{category}.{key}`. "
f"The integration '{component}' does not exist."
)
return
# This translation key is in the ignore list, mark it as used
translation_errors[full_key] = "used"
return
@ -636,11 +668,22 @@ async def _validate_translation(
@pytest.fixture
def ignore_translations() -> str | list[str]:
"""Ignore specific translations.
def ignore_missing_translations() -> str | list[str]:
"""Ignore specific missing translations.
Override or parametrize this fixture with a fixture that returns,
a list of translation that should be ignored.
Override or parametrize this fixture with a fixture that returns
a list of missing translation that should be ignored.
"""
return []
@pytest.fixture
def ignore_translations_for_mock_domains() -> str | list[str]:
"""Don't validate translations for specific domains.
Override or parametrize this fixture with a fixture that returns
a list of domains for which translations should not be validated.
This should only be used when testing mocked integrations.
"""
return []
@ -673,6 +716,7 @@ async def _check_step_or_section_translations(
translation_prefix: str,
description_placeholders: dict[str, str],
data_schema: vol.Schema | None,
ignore_translations_for_mock_domains: set[str],
) -> None:
# neither title nor description are required
# - title defaults to integration name
@ -681,6 +725,7 @@ async def _check_step_or_section_translations(
await _validate_translation(
hass,
translation_errors,
ignore_translations_for_mock_domains,
category,
integration,
f"{translation_prefix}.{header}",
@ -702,6 +747,7 @@ async def _check_step_or_section_translations(
f"{translation_prefix}.sections.{data_key}",
description_placeholders,
data_value.schema,
ignore_translations_for_mock_domains,
)
continue
iqs_config_flow = _get_integration_quality_scale_rule(
@ -712,6 +758,7 @@ async def _check_step_or_section_translations(
await _validate_translation(
hass,
translation_errors,
ignore_translations_for_mock_domains,
category,
integration,
f"{translation_prefix}.{header}.{data_key}",
@ -725,6 +772,7 @@ async def _check_config_flow_result_translations(
flow: FlowHandler,
result: FlowResult[FlowContext, str],
translation_errors: dict[str, str],
ignore_translations_for_mock_domains: set[str],
) -> None:
if result["type"] is FlowResultType.CREATE_ENTRY:
# No need to check translations for a completed flow
@ -760,6 +808,7 @@ async def _check_config_flow_result_translations(
f"{key_prefix}step.{step_id}",
result["description_placeholders"],
result["data_schema"],
ignore_translations_for_mock_domains,
)
if errors := result.get("errors"):
@ -767,6 +816,7 @@ async def _check_config_flow_result_translations(
await _validate_translation(
flow.hass,
translation_errors,
ignore_translations_for_mock_domains,
category,
integration,
f"{key_prefix}error.{error}",
@ -782,6 +832,7 @@ async def _check_config_flow_result_translations(
await _validate_translation(
flow.hass,
translation_errors,
ignore_translations_for_mock_domains,
category,
integration,
f"{key_prefix}abort.{result['reason']}",
@ -793,6 +844,7 @@ async def _check_create_issue_translations(
issue_registry: ir.IssueRegistry,
issue: ir.IssueEntry,
translation_errors: dict[str, str],
ignore_translations_for_mock_domains: set[str],
) -> None:
if issue.translation_key is None:
# `translation_key` is only None on dismissed issues
@ -800,6 +852,7 @@ async def _check_create_issue_translations(
await _validate_translation(
issue_registry.hass,
translation_errors,
ignore_translations_for_mock_domains,
"issues",
issue.domain,
f"{issue.translation_key}.title",
@ -810,6 +863,7 @@ async def _check_create_issue_translations(
await _validate_translation(
issue_registry.hass,
translation_errors,
ignore_translations_for_mock_domains,
"issues",
issue.domain,
f"{issue.translation_key}.description",
@ -831,6 +885,7 @@ async def _check_exception_translation(
exception: HomeAssistantError,
translation_errors: dict[str, str],
request: pytest.FixtureRequest,
ignore_translations_for_mock_domains: set[str],
) -> None:
if exception.translation_key is None:
if (
@ -844,6 +899,7 @@ async def _check_exception_translation(
await _validate_translation(
hass,
translation_errors,
ignore_translations_for_mock_domains,
"exceptions",
exception.translation_domain,
f"{exception.translation_key}.message",
@ -853,7 +909,9 @@ async def _check_exception_translation(
@pytest.fixture(autouse=True)
async def check_translations(
ignore_translations: str | list[str], request: pytest.FixtureRequest
ignore_missing_translations: str | list[str],
ignore_translations_for_mock_domains: str | list[str],
request: pytest.FixtureRequest,
) -> AsyncGenerator[None]:
"""Check that translation requirements are met.
@ -862,11 +920,16 @@ async def check_translations(
- issue registry entries
- action (service) exceptions
"""
if not isinstance(ignore_translations, list):
ignore_translations = [ignore_translations]
if not isinstance(ignore_missing_translations, list):
ignore_missing_translations = [ignore_missing_translations]
if not isinstance(ignore_translations_for_mock_domains, list):
ignored_domains = {ignore_translations_for_mock_domains}
else:
ignored_domains = set(ignore_translations_for_mock_domains)
# Set all ignored translation keys to "unused"
translation_errors = {k: "unused" for k in ignore_translations}
translation_errors = {k: "unused" for k in ignore_missing_translations}
translation_coros = set()
@ -881,7 +944,7 @@ async def check_translations(
) -> FlowResult:
result = await _original_flow_manager_async_handle_step(self, flow, *args)
await _check_config_flow_result_translations(
self, flow, result, translation_errors
self, flow, result, translation_errors, ignored_domains
)
return result
@ -892,7 +955,9 @@ async def check_translations(
self, domain, issue_id, *args, **kwargs
)
translation_coros.add(
_check_create_issue_translations(self, result, translation_errors)
_check_create_issue_translations(
self, result, translation_errors, ignored_domains
)
)
return result
@ -920,7 +985,11 @@ async def check_translations(
except HomeAssistantError as err:
translation_coros.add(
_check_exception_translation(
self._hass, err, translation_errors, request
self._hass,
err,
translation_errors,
request,
ignored_domains,
)
)
raise
@ -950,7 +1019,7 @@ async def check_translations(
# Some ignored translations were not used
pytest.fail(
f"Unused ignore translations: {', '.join(unused_ignore)}. "
"Please remove them from the ignore_translations fixture."
"Please remove them from the ignore_missing_translations fixture."
)
for description in translation_errors.values():
if description != "used":

68
tests/components/homeassistant_hardware/test_config_flow_failures.py
View File

@ -35,8 +35,8 @@ async def fixture_mock_supervisor_client(supervisor_client: AsyncMock):
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.unsupported_firmware"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
@pytest.mark.parametrize(
"next_step",
@ -69,8 +69,8 @@ async def test_config_flow_cannot_probe_firmware(
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.not_hassio"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_not_hassio_wrong_firmware(
hass: HomeAssistant,
@ -98,8 +98,8 @@ async def test_config_flow_zigbee_not_hassio_wrong_firmware(
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_already_running"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_flasher_addon_already_running(
hass: HomeAssistant,
@ -136,8 +136,8 @@ async def test_config_flow_zigbee_flasher_addon_already_running(
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_info_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_flasher_addon_info_fails(hass: HomeAssistant) -> None:
"""Test failure case when flasher addon cannot be installed."""
@ -173,8 +173,8 @@ async def test_config_flow_zigbee_flasher_addon_info_fails(hass: HomeAssistant)
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_install_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_flasher_addon_install_fails(
hass: HomeAssistant,
@ -207,8 +207,8 @@ async def test_config_flow_zigbee_flasher_addon_install_fails(
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_set_config_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_flasher_addon_set_config_fails(
hass: HomeAssistant,
@ -245,8 +245,8 @@ async def test_config_flow_zigbee_flasher_addon_set_config_fails(
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_start_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_flasher_run_fails(hass: HomeAssistant) -> None:
"""Test failure case when flasher addon fails to run."""
@ -310,8 +310,8 @@ async def test_config_flow_zigbee_flasher_uninstall_fails(hass: HomeAssistant) -
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.unsupported_firmware"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_zigbee_confirmation_fails(hass: HomeAssistant) -> None:
"""Test the config flow failing due to Zigbee firmware not being detected."""
@ -346,8 +346,8 @@ async def test_config_flow_zigbee_confirmation_fails(hass: HomeAssistant) -> Non
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.not_hassio_thread"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_not_hassio(hass: HomeAssistant) -> None:
"""Test when the stick is used with a non-hassio setup and Thread is selected."""
@ -373,8 +373,8 @@ async def test_config_flow_thread_not_hassio(hass: HomeAssistant) -> None:
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_info_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_addon_info_fails(hass: HomeAssistant) -> None:
"""Test failure case when flasher addon cannot be installed."""
@ -401,8 +401,8 @@ async def test_config_flow_thread_addon_info_fails(hass: HomeAssistant) -> None:
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.otbr_addon_already_running"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_addon_already_running(hass: HomeAssistant) -> None:
"""Test failure case when the Thread addon is already running."""
@ -440,8 +440,8 @@ async def test_config_flow_thread_addon_already_running(hass: HomeAssistant) ->
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_install_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_addon_install_fails(hass: HomeAssistant) -> None:
"""Test failure case when flasher addon cannot be installed."""
@ -471,8 +471,8 @@ async def test_config_flow_thread_addon_install_fails(hass: HomeAssistant) -> No
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_set_config_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_addon_set_config_fails(hass: HomeAssistant) -> None:
"""Test failure case when flasher addon cannot be configured."""
@ -502,8 +502,8 @@ async def test_config_flow_thread_addon_set_config_fails(hass: HomeAssistant) ->
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.addon_start_failed"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_flasher_run_fails(hass: HomeAssistant) -> None:
"""Test failure case when flasher addon fails to run."""
@ -567,8 +567,8 @@ async def test_config_flow_thread_flasher_uninstall_fails(hass: HomeAssistant) -
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.config.abort.unsupported_firmware"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_config_flow_thread_confirmation_fails(hass: HomeAssistant) -> None:
"""Test the config flow failing due to OpenThread firmware not being detected."""
@ -609,8 +609,8 @@ async def test_config_flow_thread_confirmation_fails(hass: HomeAssistant) -> Non
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.options.abort.zha_still_using_stick"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_options_flow_zigbee_to_thread_zha_configured(
hass: HomeAssistant,
@ -657,8 +657,8 @@ async def test_options_flow_zigbee_to_thread_zha_configured(
@pytest.mark.parametrize(
"ignore_translations",
["component.test_firmware_domain.options.abort.otbr_still_using_stick"],
"ignore_translations_for_mock_domains",
["test_firmware_domain"],
)
async def test_options_flow_thread_to_zigbee_otbr_configured(
hass: HomeAssistant,

60
tests/components/homeassistant_hardware/test_silabs_multiprotocol_addon.py
View File

@ -450,10 +450,7 @@ async def test_option_flow_install_multi_pan_addon_zha_other_radio(
}
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.not_hassio"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_non_hassio(
hass: HomeAssistant,
) -> None:
@ -766,10 +763,7 @@ async def test_option_flow_addon_installed_same_device_do_not_uninstall_multi_pa
assert result["type"] is FlowResultType.CREATE_ENTRY
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_already_running"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_flasher_already_running_failure(
hass: HomeAssistant,
addon_info,
@ -881,10 +875,7 @@ async def test_option_flow_addon_installed_same_device_flasher_already_installed
assert result["type"] is FlowResultType.CREATE_ENTRY
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_install_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_flasher_install_failure(
hass: HomeAssistant,
addon_info,
@ -951,10 +942,7 @@ async def test_option_flow_flasher_install_failure(
assert result["reason"] == "addon_install_failed"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_start_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_flasher_addon_flash_failure(
hass: HomeAssistant,
addon_info,
@ -1017,10 +1005,7 @@ async def test_option_flow_flasher_addon_flash_failure(
assert result["description_placeholders"]["addon_name"] == "Silicon Labs Flasher"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.zha_migration_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@patch(
"homeassistant.components.zha.radio_manager.ZhaMultiPANMigrationHelper.async_initiate_migration",
side_effect=Exception("Boom!"),
@ -1082,10 +1067,7 @@ async def test_option_flow_uninstall_migration_initiate_failure(
mock_initiate_migration.assert_called_once()
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.zha_migration_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@patch(
"homeassistant.components.zha.radio_manager.ZhaMultiPANMigrationHelper.async_finish_migration",
side_effect=Exception("Boom!"),
@ -1187,10 +1169,7 @@ async def test_option_flow_do_not_install_multi_pan_addon(
assert result["type"] is FlowResultType.CREATE_ENTRY
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_install_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_install_multi_pan_addon_install_fails(
hass: HomeAssistant,
addon_store_info,
@ -1234,10 +1213,7 @@ async def test_option_flow_install_multi_pan_addon_install_fails(
assert result["reason"] == "addon_install_failed"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_start_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_install_multi_pan_addon_start_fails(
hass: HomeAssistant,
addon_store_info,
@ -1299,10 +1275,7 @@ async def test_option_flow_install_multi_pan_addon_start_fails(
assert result["reason"] == "addon_start_failed"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_set_config_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_install_multi_pan_addon_set_options_fails(
hass: HomeAssistant,
addon_store_info,
@ -1346,10 +1319,7 @@ async def test_option_flow_install_multi_pan_addon_set_options_fails(
assert result["reason"] == "addon_set_config_failed"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.addon_info_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_option_flow_addon_info_fails(
hass: HomeAssistant,
addon_store_info,
@ -1373,10 +1343,7 @@ async def test_option_flow_addon_info_fails(
assert result["reason"] == "addon_info_failed"
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.zha_migration_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@patch(
"homeassistant.components.zha.radio_manager.ZhaMultiPANMigrationHelper.async_initiate_migration",
side_effect=Exception("Boom!"),
@ -1432,10 +1399,7 @@ async def test_option_flow_install_multi_pan_addon_zha_migration_fails_step_1(
set_addon_options.assert_not_called()
@pytest.mark.parametrize(
"ignore_translations",
["component.test.options.abort.zha_migration_failed"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@patch(
"homeassistant.components.zha.radio_manager.ZhaMultiPANMigrationHelper.async_finish_migration",
side_effect=Exception("Boom!"),

2
tests/components/onkyo/test_config_flow.py
View File

@ -620,7 +620,7 @@ async def test_import_success(
@pytest.mark.parametrize(
"ignore_translations",
"ignore_missing_translations",
[
[ # The schema is dynamically created from input sources and listening modes
"component.onkyo.options.step.names.sections.input_sources.data.TV",

30
tests/components/repairs/test_init.py
View File

@ -21,16 +21,7 @@ from tests.common import mock_platform
from tests.typing import WebSocketGenerator
@pytest.mark.parametrize(
"ignore_translations",
[
[
"component.test.issues.even_worse.title",
"component.test.issues.even_worse.description",
"component.test.issues.abc_123.title",
]
],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@pytest.mark.freeze_time("2022-07-19 07:53:05")
async def test_create_update_issue(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator
@ -170,14 +161,7 @@ async def test_create_issue_invalid_version(
assert msg["result"] == {"issues": []}
@pytest.mark.parametrize(
"ignore_translations",
[
[
"component.test.issues.abc_123.title",
]
],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@pytest.mark.freeze_time("2022-07-19 07:53:05")
async def test_ignore_issue(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator
@ -347,10 +331,7 @@ async def test_ignore_issue(
}
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.issues.abc_123.title"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
@pytest.mark.freeze_time("2022-07-19 07:53:05")
async def test_delete_issue(
hass: HomeAssistant,
@ -505,10 +486,7 @@ async def test_non_compliant_platform(
assert list(hass.data[DOMAIN]["platforms"].keys()) == ["fake_integration"]
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.issues.abc_123.title"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
@pytest.mark.freeze_time("2022-07-21 08:22:00")
async def test_sync_methods(
hass: HomeAssistant,

68
tests/components/repairs/test_websocket_api.py
View File

@ -151,10 +151,7 @@ async def mock_repairs_integration(hass: HomeAssistant) -> None:
)
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.issues.abc_123.title"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_dismiss_issue(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator
) -> None:
@ -238,10 +235,7 @@ async def test_dismiss_issue(
}
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.issues.abc_123.title"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_fix_non_existing_issue(
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
@ -289,19 +283,19 @@ async def test_fix_non_existing_issue(
@pytest.mark.parametrize(
("domain", "step", "description_placeholders", "ignore_translations"),
(
"domain",
"step",
"description_placeholders",
"ignore_translations_for_mock_domains",
),
[
(
"fake_integration",
"custom_step",
None,
["component.fake_integration.issues.abc_123.title"],
),
("fake_integration", "custom_step", None, ["fake_integration"]),
(
"fake_integration_default_handler",
"confirm",
{"abc": "123"},
["component.fake_integration_default_handler.issues.abc_123.title"],
["fake_integration_default_handler"],
),
],
)
@ -398,10 +392,7 @@ async def test_fix_issue_unauth(
assert resp.status == HTTPStatus.UNAUTHORIZED
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.issues.abc_123.title"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_get_progress_unauth(
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
@ -433,10 +424,7 @@ async def test_get_progress_unauth(
assert resp.status == HTTPStatus.UNAUTHORIZED
@pytest.mark.parametrize(
"ignore_translations",
["component.fake_integration.issues.abc_123.title"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_step_unauth(
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
@ -468,16 +456,7 @@ async def test_step_unauth(
assert resp.status == HTTPStatus.UNAUTHORIZED
@pytest.mark.parametrize(
"ignore_translations",
[
[
"component.test.issues.even_worse.title",
"component.test.issues.even_worse.description",
"component.test.issues.abc_123.title",
]
],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@pytest.mark.freeze_time("2022-07-19 07:53:05")
async def test_list_issues(
hass: HomeAssistant,
@ -569,15 +548,7 @@ async def test_list_issues(
}
@pytest.mark.parametrize(
"ignore_translations",
[
[
"component.fake_integration.issues.abc_123.title",
"component.fake_integration.issues.abc_123.fix_flow.abort.not_given",
]
],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["fake_integration"])
async def test_fix_issue_aborted(
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
@ -639,16 +610,7 @@ async def test_fix_issue_aborted(
assert msg["result"]["issues"][0] == first_issue
@pytest.mark.parametrize(
"ignore_translations",
[
[
"component.test.issues.abc_123.title",
"component.test.issues.even_worse.title",
"component.test.issues.even_worse.description",
]
],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@pytest.mark.freeze_time("2022-07-19 07:53:05")
async def test_get_issue_data(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator

5
tests/components/sensor/test_recorder.py
View File

@ -5449,12 +5449,11 @@ async def test_exclude_attributes(hass: HomeAssistant) -> None:
assert ATTR_FRIENDLY_NAME in states[0].attributes
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
@pytest.mark.parametrize(
"ignore_translations",
"ignore_missing_translations",
[
[
"component.test.issues..title",
"component.test.issues..description",
"component.sensor.issues..title",
"component.sensor.issues..description",
]

2
tests/components/synology_dsm/test_repairs.py
View File

@ -256,7 +256,7 @@ async def test_missing_backup_no_shares(
@pytest.mark.parametrize(
"ignore_translations",
"ignore_missing_translations",
["component.synology_dsm.issues.other_issue.title"],
)
async def test_other_fixable_issues(

9
tests/components/websocket_api/test_commands.py
View File

@ -540,10 +540,7 @@ async def test_call_service_schema_validation_error(
assert len(calls) == 0
@pytest.mark.parametrize(
"ignore_translations",
["component.test.exceptions.custom_error.message"],
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_call_service_error(
hass: HomeAssistant, websocket_client: MockHAClientWebSocket
) -> None:
@ -2394,9 +2391,7 @@ async def test_execute_script(
),
],
)
@pytest.mark.parametrize(
"ignore_translations", ["component.test.exceptions.test_error.message"]
)
@pytest.mark.parametrize("ignore_translations_for_mock_domains", ["test"])
async def test_execute_script_err_localization(
hass: HomeAssistant,
websocket_client: MockHAClientWebSocket,

2
tests/components/workday/test_repairs.py
View File

@ -430,7 +430,7 @@ async def test_bad_date_holiday(
@pytest.mark.parametrize(
"ignore_translations",
"ignore_missing_translations",
["component.workday.issues.issue_1.title"],
)
async def test_other_fixable_issues(

2
tests/components/zwave_js/test_repairs.py
View File

@ -180,7 +180,7 @@ async def test_device_config_file_changed_ignore_step(
@pytest.mark.parametrize(
"ignore_translations",
"ignore_missing_translations",
["component.zwave_js.issues.invalid_issue.title"],
)
async def test_invalid_issue(