Update datadog test logic (#149459)

Co-authored-by: Joostlek <joostlek@outlook.com>

homeassistant/components/datadog/config_flow.py

@@ -36,14 +36,14 @@ class DatadogConfigFlow(ConfigFlow, domain=DOMAIN):
         """Handle user config flow."""
         errors: dict[str, str] = {}
         if user_input:
+            self._async_abort_entries_match(
+                {CONF_HOST: user_input[CONF_HOST], CONF_PORT: user_input[CONF_PORT]}
+            )
             # Validate connection to Datadog Agent
             success = await validate_datadog_connection(
                 self.hass,
                 user_input,
             )
-            self._async_abort_entries_match(
-                {CONF_HOST: user_input[CONF_HOST], CONF_PORT: user_input[CONF_PORT]}
-            )
             if not success:
                 errors["base"] = "cannot_connect"
             else:

tests/components/datadog/test_config_flow.py

@@ -3,7 +3,7 @@
 from unittest.mock import MagicMock, patch
 
 from homeassistant.components import datadog
-from homeassistant.config_entries import SOURCE_IMPORT
+from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_USER
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 import homeassistant.helpers.issue_registry as ir
@@ -22,7 +22,7 @@ async def test_user_flow_success(hass: HomeAssistant) -> None:
         mock_dogstatsd.return_value = mock_instance
 
         result = await hass.config_entries.flow.async_init(
-            datadog.DOMAIN, context={"source": "user"}
+            datadog.DOMAIN, context={"source": SOURCE_USER}
         )
         assert result["type"] == FlowResultType.FORM
 
@@ -42,7 +42,7 @@ async def test_user_flow_retry_after_connection_fail(hass: HomeAssistant) -> Non
         side_effect=OSError("Connection failed"),
     ):
         result = await hass.config_entries.flow.async_init(
-            datadog.DOMAIN, context={"source": "user"}
+            datadog.DOMAIN, context={"source": SOURCE_USER}
         )
 
         result2 = await hass.config_entries.flow.async_configure(
@@ -62,6 +62,34 @@ async def test_user_flow_retry_after_connection_fail(hass: HomeAssistant) -> Non
         assert result3["options"] == MOCK_OPTIONS
 
 
+async def test_user_flow_abort_already_configured_service(
+    hass: HomeAssistant,
+) -> None:
+    """Abort user-initiated config flow if the same host/port is already configured."""
+    existing_entry = MockConfigEntry(
+        domain=datadog.DOMAIN,
+        data=MOCK_DATA,
+        options=MOCK_OPTIONS,
+    )
+    existing_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        datadog.DOMAIN,
+        context={"source": SOURCE_USER},
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["errors"] == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=MOCK_CONFIG
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"
+
+
 async def test_options_flow_cannot_connect(hass: HomeAssistant) -> None:
     """Test that the options flow shows an error when connection fails."""
     mock_entry = MockConfigEntry(
@@ -221,9 +249,9 @@ async def test_import_flow_abort_already_configured_service(
 
     result = await hass.config_entries.flow.async_init(
         datadog.DOMAIN,
-        context={"source": "import"},
+        context={"source": SOURCE_IMPORT},
         data=MOCK_CONFIG,
     )
 
-    assert result["type"] == "abort"
+    assert result["type"] == FlowResultType.ABORT
     assert result["reason"] == "already_configured"

tests/components/datadog/test_init.py

@@ -8,57 +8,65 @@ from homeassistant.components.datadog import async_setup_entry
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import EVENT_LOGBOOK_ENTRY, STATE_OFF, STATE_ON, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
 
 from .common import MOCK_DATA, MOCK_OPTIONS, create_mock_state
 
-from tests.common import EVENT_STATE_CHANGED, MockConfigEntry, assert_setup_component
+from tests.common import EVENT_STATE_CHANGED, MockConfigEntry
 
 
 async def test_invalid_config(hass: HomeAssistant) -> None:
     """Test invalid configuration."""
-    with assert_setup_component(0):
+    entry = MockConfigEntry(
-        assert not await async_setup_component(
+        domain=datadog.DOMAIN,
-            hass, datadog.DOMAIN, {datadog.DOMAIN: {"host1": "host1"}}
+        data={"host1": "host1"},
-        )
+    )
+    entry.add_to_hass(hass)
+    assert not await hass.config_entries.async_setup(entry.entry_id)
 
 
 async def test_datadog_setup_full(hass: HomeAssistant) -> None:
     """Test setup with all data."""
-    config = {datadog.DOMAIN: {"host": "host", "port": 123, "rate": 1, "prefix": "foo"}}
-
     with (
-        patch(
+        patch("homeassistant.components.datadog.DogStatsd") as mock_dogstatsd,
-            "homeassistant.components.datadog.config_flow.DogStatsd"
-        ) as mock_dogstatsd,
     ):
-        assert await async_setup_component(hass, datadog.DOMAIN, config)
+        entry = MockConfigEntry(
+            domain=datadog.DOMAIN,
+            data={
+                "host": "host",
+                "port": 123,
+            },
+            options={
+                "rate": 1,
+                "prefix": "foo",
+            },
+        )
+        entry.add_to_hass(hass)
+        assert await hass.config_entries.async_setup(entry.entry_id)
+        await hass.async_block_till_done()
 
         assert mock_dogstatsd.call_count == 1
-        assert mock_dogstatsd.call_args == mock.call("host", 123)
+        assert mock_dogstatsd.call_args == mock.call(
+            host="host", port=123, namespace="foo"
+        )
 
 
 async def test_datadog_setup_defaults(hass: HomeAssistant) -> None:
     """Test setup with defaults."""
     with (
-        patch(
+        patch("homeassistant.components.datadog.DogStatsd") as mock_dogstatsd,
-            "homeassistant.components.datadog.config_flow.DogStatsd"
-        ) as mock_dogstatsd,
     ):
-        assert await async_setup_component(
+        entry = MockConfigEntry(
-            hass,
+            domain=datadog.DOMAIN,
-            datadog.DOMAIN,
+            data=MOCK_DATA,
-            {
+            options=MOCK_OPTIONS,
-                datadog.DOMAIN: {
-                    "host": "host",
-                    "port": datadog.DEFAULT_PORT,
-                    "prefix": datadog.DEFAULT_PREFIX,
-                }
-            },
         )
+        entry.add_to_hass(hass)
+        assert await hass.config_entries.async_setup(entry.entry_id)
 
         assert mock_dogstatsd.call_count == 1
-        assert mock_dogstatsd.call_args == mock.call("host", 8125)
+        assert mock_dogstatsd.call_args == mock.call(
+            host="localhost", port=8125, namespace="hass"
+        )
 
 
 async def test_logbook_entry(hass: HomeAssistant) -> None:
@@ -70,24 +78,24 @@ async def test_logbook_entry(hass: HomeAssistant) -> None:
         ),
     ):
         mock_statsd = mock_statsd_class.return_value
-
+        entry = MockConfigEntry(
-        assert await async_setup_component(
+            domain=datadog.DOMAIN,
-            hass,
+            data={
-            datadog.DOMAIN,
+                "host": datadog.DEFAULT_HOST,
-            {
+                "port": datadog.DEFAULT_PORT,
-                datadog.DOMAIN: {
+            },
-                    "host": "host",
+            options={
-                    "port": datadog.DEFAULT_PORT,
+                "rate": datadog.DEFAULT_RATE,
-                    "rate": datadog.DEFAULT_RATE,
+                "prefix": datadog.DEFAULT_PREFIX,
-                    "prefix": datadog.DEFAULT_PREFIX,
-                }
             },
         )
+        entry.add_to_hass(hass)
+        assert await hass.config_entries.async_setup(entry.entry_id)
 
         event = {
             "domain": "automation",
             "entity_id": "sensor.foo.bar",
-            "message": "foo bar biz",
+            "message": "foo bar baz",
             "name": "triggered something",
         }
         hass.bus.async_fire(EVENT_LOGBOOK_ENTRY, event)
@@ -110,18 +118,16 @@ async def test_state_changed(hass: HomeAssistant) -> None:
         ),
     ):
         mock_statsd = mock_statsd_class.return_value
-
+        entry = MockConfigEntry(
-        assert await async_setup_component(
+            domain=datadog.DOMAIN,
-            hass,
+            data={
-            datadog.DOMAIN,
+                "host": "host",
-            {
+                "port": datadog.DEFAULT_PORT,
-                datadog.DOMAIN: {
-                    "host": "host",
-                    "prefix": "ha",
-                    "rate": datadog.DEFAULT_RATE,
-                }
             },
+            options={"prefix": "ha", "rate": datadog.DEFAULT_RATE},
         )
+        entry.add_to_hass(hass)
+        assert await hass.config_entries.async_setup(entry.entry_id)
 
         valid = {"1": 1, "1.0": 1.0, STATE_ON: 1, STATE_OFF: 0}
 
@@ -191,14 +197,18 @@ async def test_unload_entry(hass: HomeAssistant) -> None:
 
 async def test_state_changed_skips_unknown(hass: HomeAssistant) -> None:
     """Test state_changed_listener skips None and unknown states."""
-    entry = MockConfigEntry(domain=datadog.DOMAIN, data=MOCK_DATA, options=MOCK_OPTIONS)
-    entry.add_to_hass(hass)
-
     with (
         patch(
             "homeassistant.components.datadog.config_flow.DogStatsd"
         ) as mock_dogstatsd,
     ):
+        entry = MockConfigEntry(
+            domain=datadog.DOMAIN,
+            data=MOCK_DATA,
+            options=MOCK_OPTIONS,
+        )
+        entry.add_to_hass(hass)
+
         await async_setup_entry(hass, entry)
 
         # Test None state