diff --git a/homeassistant/components/point/__init__.py b/homeassistant/components/point/__init__.py
index 6128b6ae162..45f58949e77 100644
--- a/homeassistant/components/point/__init__.py
+++ b/homeassistant/components/point/__init__.py
@@ -14,7 +14,7 @@ from homeassistant.const import (
     CONF_WEBHOOK_ID,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import config_validation as cv, device_registry
 from homeassistant.helpers.dispatcher import (
     async_dispatcher_connect,
     async_dispatcher_send,
@@ -307,7 +307,9 @@ class MinutPointEntity(Entity):
         """Return a device description for device registry."""
         device = self.device.device
         return {
-            "connections": {("mac", device["device_mac"])},
+            "connections": {
+                (device_registry.CONNECTION_NETWORK_MAC, device["device_mac"])
+            },
             "identifieres": device["device_id"],
             "manufacturer": "Minut",
             "model": f"Point v{device['hardware_version']}",
diff --git a/homeassistant/components/tasmota/discovery.py b/homeassistant/components/tasmota/discovery.py
index 600b2fd293e..b69307693da 100644
--- a/homeassistant/components/tasmota/discovery.py
+++ b/homeassistant/components/tasmota/discovery.py
@@ -13,6 +13,7 @@ from hatasmota.discovery import (
 
 import homeassistant.components.sensor as sensor
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dev_reg
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.entity_registry import async_entries_for_device
 
@@ -136,7 +137,9 @@ async def async_start(
 
         device_registry = await hass.helpers.device_registry.async_get_registry()
         entity_registry = await hass.helpers.entity_registry.async_get_registry()
-        device = device_registry.async_get_device(set(), {("mac", mac)})
+        device = device_registry.async_get_device(
+            set(), {(dev_reg.CONNECTION_NETWORK_MAC, mac)}
+        )
 
         if device is None:
             _LOGGER.warning("Got sensors for unknown device mac: %s", mac)
diff --git a/tests/components/deconz/test_services.py b/tests/components/deconz/test_services.py
index 249f4dbbb57..7ad9c82b08c 100644
--- a/tests/components/deconz/test_services.py
+++ b/tests/components/deconz/test_services.py
@@ -322,7 +322,8 @@ async def test_remove_orphaned_entries_service(hass, aioclient_mock):
 
     device_registry = dr.async_get(hass)
     device = device_registry.async_get_or_create(
-        config_entry_id=config_entry.entry_id, identifiers={("mac", "123")}
+        config_entry_id=config_entry.entry_id,
+        connections={(dr.CONNECTION_NETWORK_MAC, "123")},
     )
 
     assert (
diff --git a/tests/components/mqtt/test_common.py b/tests/components/mqtt/test_common.py
index 3d58cf834e9..fc8d26843d0 100644
--- a/tests/components/mqtt/test_common.py
+++ b/tests/components/mqtt/test_common.py
@@ -24,7 +24,7 @@ DEFAULT_CONFIG_DEVICE_INFO_ID = {
 }
 
 DEFAULT_CONFIG_DEVICE_INFO_MAC = {
-    "connections": [["mac", "02:5b:26:a8:dc:12"]],
+    "connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]],
     "manufacturer": "Whatever",
     "name": "Beer",
     "model": "Glass",
@@ -760,9 +760,11 @@ async def help_test_entity_device_info_with_connection(hass, mqtt_mock, domain,
     async_fire_mqtt_message(hass, f"homeassistant/{domain}/bla/config", data)
     await hass.async_block_till_done()
 
-    device = registry.async_get_device(set(), {("mac", "02:5b:26:a8:dc:12")})
+    device = registry.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
+    )
     assert device is not None
-    assert device.connections == {("mac", "02:5b:26:a8:dc:12")}
+    assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
     assert device.manufacturer == "Whatever"
     assert device.name == "Beer"
     assert device.model == "Glass"
diff --git a/tests/components/mqtt/test_device_trigger.py b/tests/components/mqtt/test_device_trigger.py
index 62ffade11f4..6d3c3b32bc3 100644
--- a/tests/components/mqtt/test_device_trigger.py
+++ b/tests/components/mqtt/test_device_trigger.py
@@ -846,7 +846,7 @@ async def test_entity_device_info_with_connection(hass, mqtt_mock):
             "type": "foo",
             "subtype": "bar",
             "device": {
-                "connections": [["mac", "02:5b:26:a8:dc:12"]],
+                "connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]],
                 "manufacturer": "Whatever",
                 "name": "Beer",
                 "model": "Glass",
@@ -857,9 +857,11 @@ async def test_entity_device_info_with_connection(hass, mqtt_mock):
     async_fire_mqtt_message(hass, "homeassistant/device_automation/bla/config", data)
     await hass.async_block_till_done()
 
-    device = registry.async_get_device(set(), {("mac", "02:5b:26:a8:dc:12")})
+    device = registry.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
+    )
     assert device is not None
-    assert device.connections == {("mac", "02:5b:26:a8:dc:12")}
+    assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
     assert device.manufacturer == "Whatever"
     assert device.name == "Beer"
     assert device.model == "Glass"
@@ -908,7 +910,7 @@ async def test_entity_device_info_update(hass, mqtt_mock):
         "subtype": "bar",
         "device": {
             "identifiers": ["helloworld"],
-            "connections": [["mac", "02:5b:26:a8:dc:12"]],
+            "connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]],
             "manufacturer": "Whatever",
             "name": "Beer",
             "model": "Glass",
@@ -1169,7 +1171,7 @@ async def test_trigger_debug_info(hass, mqtt_mock):
         "type": "foo",
         "subtype": "bar",
         "device": {
-            "connections": [["mac", "02:5b:26:a8:dc:12"]],
+            "connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]],
             "manufacturer": "Whatever",
             "name": "Beer",
             "model": "Glass",
@@ -1180,7 +1182,9 @@ async def test_trigger_debug_info(hass, mqtt_mock):
     async_fire_mqtt_message(hass, "homeassistant/device_automation/bla/config", data)
     await hass.async_block_till_done()
 
-    device = registry.async_get_device(set(), {("mac", "02:5b:26:a8:dc:12")})
+    device = registry.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
+    )
     assert device is not None
 
     debug_info_data = await debug_info.info_for_device(hass, device.id)
diff --git a/tests/components/mqtt/test_init.py b/tests/components/mqtt/test_init.py
index 15401a6d02f..ab0c58fb3b6 100644
--- a/tests/components/mqtt/test_init.py
+++ b/tests/components/mqtt/test_init.py
@@ -245,12 +245,17 @@ def test_entity_device_info_schema():
     MQTT_ENTITY_DEVICE_INFO_SCHEMA({"identifiers": ["abcd"]})
     MQTT_ENTITY_DEVICE_INFO_SCHEMA({"identifiers": "abcd"})
     # just connection
-    MQTT_ENTITY_DEVICE_INFO_SCHEMA({"connections": [["mac", "02:5b:26:a8:dc:12"]]})
+    MQTT_ENTITY_DEVICE_INFO_SCHEMA(
+        {"connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]]}
+    )
     # full device info
     MQTT_ENTITY_DEVICE_INFO_SCHEMA(
         {
             "identifiers": ["helloworld", "hello"],
-            "connections": [["mac", "02:5b:26:a8:dc:12"], ["zigbee", "zigbee_id"]],
+            "connections": [
+                [dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"],
+                [dr.CONNECTION_ZIGBEE, "zigbee_id"],
+            ],
             "manufacturer": "Whatever",
             "name": "Beer",
             "model": "Glass",
@@ -261,7 +266,10 @@ def test_entity_device_info_schema():
     MQTT_ENTITY_DEVICE_INFO_SCHEMA(
         {
             "identifiers": ["helloworld", "hello"],
-            "connections": [["mac", "02:5b:26:a8:dc:12"], ["zigbee", "zigbee_id"]],
+            "connections": [
+                [dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"],
+                [dr.CONNECTION_ZIGBEE, "zigbee_id"],
+            ],
             "manufacturer": "Whatever",
             "name": "Beer",
             "model": "Glass",
diff --git a/tests/components/mqtt/test_tag.py b/tests/components/mqtt/test_tag.py
index 98dcfa050e5..5e518c561b3 100644
--- a/tests/components/mqtt/test_tag.py
+++ b/tests/components/mqtt/test_tag.py
@@ -386,7 +386,7 @@ async def test_entity_device_info_with_connection(hass, mqtt_mock):
         {
             "topic": "test-topic",
             "device": {
-                "connections": [["mac", "02:5b:26:a8:dc:12"]],
+                "connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]],
                 "manufacturer": "Whatever",
                 "name": "Beer",
                 "model": "Glass",
@@ -397,9 +397,11 @@ async def test_entity_device_info_with_connection(hass, mqtt_mock):
     async_fire_mqtt_message(hass, "homeassistant/tag/bla/config", data)
     await hass.async_block_till_done()
 
-    device = registry.async_get_device(set(), {("mac", "02:5b:26:a8:dc:12")})
+    device = registry.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
+    )
     assert device is not None
-    assert device.connections == {("mac", "02:5b:26:a8:dc:12")}
+    assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12")}
     assert device.manufacturer == "Whatever"
     assert device.name == "Beer"
     assert device.model == "Glass"
@@ -442,7 +444,7 @@ async def test_entity_device_info_update(hass, mqtt_mock):
         "topic": "test-topic",
         "device": {
             "identifiers": ["helloworld"],
-            "connections": [["mac", "02:5b:26:a8:dc:12"]],
+            "connections": [[dr.CONNECTION_NETWORK_MAC, "02:5b:26:a8:dc:12"]],
             "manufacturer": "Whatever",
             "name": "Beer",
             "model": "Glass",
diff --git a/tests/components/sonos/test_media_player.py b/tests/components/sonos/test_media_player.py
index af8437cd417..a2eb5d26645 100644
--- a/tests/components/sonos/test_media_player.py
+++ b/tests/components/sonos/test_media_player.py
@@ -58,7 +58,7 @@ async def test_device_registry(hass, config_entry, config, soco):
     )
     assert reg_device.model == "Model Name"
     assert reg_device.sw_version == "49.2-64250"
-    assert reg_device.connections == {("mac", "00:11:22:33:44:55")}
+    assert reg_device.connections == {(dr.CONNECTION_NETWORK_MAC, "00:11:22:33:44:55")}
     assert reg_device.manufacturer == "Sonos"
     assert reg_device.suggested_area == "Zone A"
     assert reg_device.name == "Zone A"
diff --git a/tests/components/tasmota/test_common.py b/tests/components/tasmota/test_common.py
index 74e8d2a5e59..e535787411f 100644
--- a/tests/components/tasmota/test_common.py
+++ b/tests/components/tasmota/test_common.py
@@ -382,7 +382,9 @@ async def help_test_discovery_removal(
         await hass.async_block_till_done()
 
     # Verify device and entity registry entries are created
-    device_entry = device_reg.async_get_device(set(), {("mac", config1[CONF_MAC])})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, config1[CONF_MAC])}
+    )
     assert device_entry is not None
     entity_entry = entity_reg.async_get(f"{domain}.{entity_id}")
     assert entity_entry is not None
@@ -403,7 +405,9 @@ async def help_test_discovery_removal(
         await hass.async_block_till_done()
 
     # Verify entity registry entries are cleared
-    device_entry = device_reg.async_get_device(set(), {("mac", config2[CONF_MAC])})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, config2[CONF_MAC])}
+    )
     assert device_entry is not None
     entity_entry = entity_reg.async_get(f"{domain}.{entity_id}")
     assert entity_entry is None
@@ -487,14 +491,18 @@ async def help_test_discovery_device_remove(
         )
         await hass.async_block_till_done()
 
-    device = device_reg.async_get_device(set(), {("mac", config[CONF_MAC])})
+    device = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, config[CONF_MAC])}
+    )
     assert device is not None
     assert entity_reg.async_get_entity_id(domain, "tasmota", unique_id)
 
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{config[CONF_MAC]}/config", "")
     await hass.async_block_till_done()
 
-    device = device_reg.async_get_device(set(), {("mac", config[CONF_MAC])})
+    device = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, config[CONF_MAC])}
+    )
     assert device is None
     assert not entity_reg.async_get_entity_id(domain, "tasmota", unique_id)
 
diff --git a/tests/components/tasmota/test_device_trigger.py b/tests/components/tasmota/test_device_trigger.py
index 1fa1c629a33..8ef4f7df919 100644
--- a/tests/components/tasmota/test_device_trigger.py
+++ b/tests/components/tasmota/test_device_trigger.py
@@ -9,6 +9,7 @@ import pytest
 import homeassistant.components.automation as automation
 from homeassistant.components.tasmota.const import DEFAULT_PREFIX, DOMAIN
 from homeassistant.components.tasmota.device_trigger import async_attach_trigger
+from homeassistant.helpers import device_registry as dr
 from homeassistant.setup import async_setup_component
 
 from .test_common import DEFAULT_CONFIG
@@ -33,7 +34,9 @@ async def test_get_triggers_btn(hass, device_reg, entity_reg, mqtt_mock, setup_t
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     expected_triggers = [
         {
             "platform": "device",
@@ -65,7 +68,9 @@ async def test_get_triggers_swc(hass, device_reg, entity_reg, mqtt_mock, setup_t
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     expected_triggers = [
         {
             "platform": "device",
@@ -92,7 +97,9 @@ async def test_get_unknown_triggers(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -133,7 +140,9 @@ async def test_get_non_existing_triggers(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     triggers = await async_get_device_automations(hass, "trigger", device_entry.id)
     assert_lists_same(triggers, [])
 
@@ -157,7 +166,9 @@ async def test_discover_bad_triggers(
         )
         await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     triggers = await async_get_device_automations(hass, "trigger", device_entry.id)
     assert_lists_same(triggers, [])
 
@@ -189,7 +200,9 @@ async def test_discover_bad_triggers(
         )
         await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     triggers = await async_get_device_automations(hass, "trigger", device_entry.id)
     assert_lists_same(triggers, [])
 
@@ -231,7 +244,9 @@ async def test_update_remove_triggers(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     expected_triggers1 = [
         {
@@ -287,7 +302,9 @@ async def test_if_fires_on_mqtt_message_btn(
 
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -357,7 +374,9 @@ async def test_if_fires_on_mqtt_message_swc(
 
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -453,7 +472,9 @@ async def test_if_fires_on_mqtt_message_late_discover(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -527,7 +548,9 @@ async def test_if_fires_on_mqtt_message_after_update(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -604,7 +627,9 @@ async def test_no_resubscribe_same_topic(hass, device_reg, mqtt_mock, setup_tasm
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -650,7 +675,9 @@ async def test_not_fires_on_mqtt_message_after_remove_by_mqtt(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -719,7 +746,9 @@ async def test_not_fires_on_mqtt_message_after_remove_from_registry(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     assert await async_setup_component(
         hass,
@@ -774,7 +803,9 @@ async def test_attach_remove(hass, device_reg, mqtt_mock, setup_tasmota):
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     calls = []
 
@@ -829,7 +860,9 @@ async def test_attach_remove_late(hass, device_reg, mqtt_mock, setup_tasmota):
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     calls = []
 
@@ -894,7 +927,9 @@ async def test_attach_remove_late2(hass, device_reg, mqtt_mock, setup_tasmota):
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     calls = []
 
@@ -940,7 +975,9 @@ async def test_attach_remove_unknown1(hass, device_reg, mqtt_mock, setup_tasmota
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     remove = await async_attach_trigger(
         hass,
@@ -982,7 +1019,9 @@ async def test_attach_unknown_remove_device_from_registry(
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config1))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     await async_attach_trigger(
         hass,
@@ -1015,7 +1054,9 @@ async def test_attach_remove_config_entry(hass, device_reg, mqtt_mock, setup_tas
     async_fire_mqtt_message(hass, f"{DEFAULT_PREFIX}/{mac}/config", json.dumps(config))
     await hass.async_block_till_done()
 
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
 
     calls = []
 
diff --git a/tests/components/tasmota/test_discovery.py b/tests/components/tasmota/test_discovery.py
index 35be7e50e62..3e1175faa0f 100644
--- a/tests/components/tasmota/test_discovery.py
+++ b/tests/components/tasmota/test_discovery.py
@@ -5,6 +5,7 @@ from unittest.mock import patch
 
 from homeassistant.components.tasmota.const import DEFAULT_PREFIX
 from homeassistant.components.tasmota.discovery import ALREADY_DISCOVERED
+from homeassistant.helpers import device_registry as dr
 
 from .conftest import setup_tasmota_helper
 from .test_common import DEFAULT_CONFIG, DEFAULT_CONFIG_9_0_0_3
@@ -116,7 +117,9 @@ async def test_correct_config_discovery(
     await hass.async_block_till_done()
 
     # Verify device and registry entries are created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
     entity_entry = entity_reg.async_get("switch.test")
     assert entity_entry is not None
@@ -143,7 +146,9 @@ async def test_device_discover(
     await hass.async_block_till_done()
 
     # Verify device and registry entries are created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
     assert device_entry.manufacturer == "Tasmota"
     assert device_entry.model == config["md"]
@@ -166,7 +171,9 @@ async def test_device_discover_deprecated(
     await hass.async_block_till_done()
 
     # Verify device and registry entries are created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
     assert device_entry.manufacturer == "Tasmota"
     assert device_entry.model == config["md"]
@@ -192,7 +199,9 @@ async def test_device_update(
     await hass.async_block_till_done()
 
     # Verify device entry is created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
 
     # Update device parameters
@@ -208,7 +217,9 @@ async def test_device_update(
     await hass.async_block_till_done()
 
     # Verify device entry is updated
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
     assert device_entry.model == "Another model"
     assert device_entry.name == "Another name"
@@ -230,7 +241,9 @@ async def test_device_remove(
     await hass.async_block_till_done()
 
     # Verify device entry is created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
 
     async_fire_mqtt_message(
@@ -241,7 +254,9 @@ async def test_device_remove(
     await hass.async_block_till_done()
 
     # Verify device entry is removed
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
 
@@ -254,18 +269,22 @@ async def test_device_remove_stale(hass, mqtt_mock, caplog, device_reg, setup_ta
     # Create a device
     device_reg.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", mac)},
+        connections={(dr.CONNECTION_NETWORK_MAC, mac)},
     )
 
     # Verify device entry was created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
 
     # Remove the device
     device_reg.async_remove_device(device_entry.id)
 
     # Verify device entry is removed
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
 
@@ -284,7 +303,9 @@ async def test_device_rediscover(
     await hass.async_block_till_done()
 
     # Verify device entry is created
-    device_entry1 = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry1 = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry1 is not None
 
     async_fire_mqtt_message(
@@ -295,7 +316,9 @@ async def test_device_rediscover(
     await hass.async_block_till_done()
 
     # Verify device entry is removed
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
     async_fire_mqtt_message(
@@ -306,7 +329,9 @@ async def test_device_rediscover(
     await hass.async_block_till_done()
 
     # Verify device entry is created, and id is reused
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
     assert device_entry1.id == device_entry.id
 
diff --git a/tests/components/tasmota/test_init.py b/tests/components/tasmota/test_init.py
index 5b553164583..1b9c88ee4b1 100644
--- a/tests/components/tasmota/test_init.py
+++ b/tests/components/tasmota/test_init.py
@@ -5,6 +5,7 @@ from unittest.mock import call
 
 from homeassistant.components import websocket_api
 from homeassistant.components.tasmota.const import DEFAULT_PREFIX
+from homeassistant.helpers import device_registry as dr
 
 from .test_common import DEFAULT_CONFIG
 
@@ -22,14 +23,18 @@ async def test_device_remove(
     await hass.async_block_till_done()
 
     # Verify device entry is created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
 
     device_reg.async_remove_device(device_entry.id)
     await hass.async_block_till_done()
 
     # Verify device entry is removed
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
     # Verify retained discovery topic has been cleared
@@ -52,7 +57,7 @@ async def test_device_remove_non_tasmota_device(
     mac = "12:34:56:AB:CD:EF"
     device_entry = device_reg.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", mac)},
+        connections={(dr.CONNECTION_NETWORK_MAC, mac)},
     )
     assert device_entry is not None
 
@@ -60,7 +65,9 @@ async def test_device_remove_non_tasmota_device(
     await hass.async_block_till_done()
 
     # Verify device entry is removed
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
     # Verify no Tasmota discovery message was sent
@@ -76,7 +83,7 @@ async def test_device_remove_stale_tasmota_device(
     mac = "12:34:56:AB:CD:EF"
     device_entry = device_reg.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", mac)},
+        connections={(dr.CONNECTION_NETWORK_MAC, mac)},
     )
     assert device_entry is not None
 
@@ -84,7 +91,9 @@ async def test_device_remove_stale_tasmota_device(
     await hass.async_block_till_done()
 
     # Verify device entry is removed
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
     # Verify retained discovery topic has been cleared
@@ -109,7 +118,9 @@ async def test_tasmota_ws_remove_discovered_device(
     await hass.async_block_till_done()
 
     # Verify device entry is created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
 
     client = await hass_ws_client(hass)
@@ -120,7 +131,9 @@ async def test_tasmota_ws_remove_discovered_device(
     assert response["success"]
 
     # Verify device entry is cleared
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is None
 
 
@@ -135,7 +148,9 @@ async def test_tasmota_ws_remove_discovered_device_twice(
     await hass.async_block_till_done()
 
     # Verify device entry is created
-    device_entry = device_reg.async_get_device(set(), {("mac", mac)})
+    device_entry = device_reg.async_get_device(
+        set(), {(dr.CONNECTION_NETWORK_MAC, mac)}
+    )
     assert device_entry is not None
 
     client = await hass_ws_client(hass)
@@ -163,7 +178,7 @@ async def test_tasmota_ws_remove_non_tasmota_device(
 
     device_entry = device_reg.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
     assert device_entry is not None
 
diff --git a/tests/helpers/test_device_registry.py b/tests/helpers/test_device_registry.py
index 518434cf79b..037e1aec8c2 100644
--- a/tests/helpers/test_device_registry.py
+++ b/tests/helpers/test_device_registry.py
@@ -1222,11 +1222,11 @@ async def test_disable_config_entry_disables_devices(hass, registry):
 
     entry1 = registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
     entry2 = registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "34:56:AB:CD:EF:12")},
+        connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")},
         disabled_by=device_registry.DISABLED_USER,
     )
 
diff --git a/tests/helpers/test_entity_platform.py b/tests/helpers/test_entity_platform.py
index 9ab269811f9..4b5ede7ca00 100644
--- a/tests/helpers/test_entity_platform.py
+++ b/tests/helpers/test_entity_platform.py
@@ -821,7 +821,7 @@ async def test_device_info_called(hass):
                     unique_id="qwer",
                     device_info={
                         "identifiers": {("hue", "1234")},
-                        "connections": {("mac", "abcd")},
+                        "connections": {(dr.CONNECTION_NETWORK_MAC, "abcd")},
                         "manufacturer": "test-manuf",
                         "model": "test-model",
                         "name": "test-name",
@@ -849,7 +849,7 @@ async def test_device_info_called(hass):
     device = registry.async_get_device({("hue", "1234")})
     assert device is not None
     assert device.identifiers == {("hue", "1234")}
-    assert device.connections == {("mac", "abcd")}
+    assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "abcd")}
     assert device.manufacturer == "test-manuf"
     assert device.model == "test-model"
     assert device.name == "test-name"
@@ -864,7 +864,7 @@ async def test_device_info_not_overrides(hass):
     registry = dr.async_get(hass)
     device = registry.async_get_or_create(
         config_entry_id="bla",
-        connections={("mac", "abcd")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "abcd")},
         manufacturer="test-manufacturer",
         model="test-model",
     )
@@ -879,7 +879,7 @@ async def test_device_info_not_overrides(hass):
                 MockEntity(
                     unique_id="qwer",
                     device_info={
-                        "connections": {("mac", "abcd")},
+                        "connections": {(dr.CONNECTION_NETWORK_MAC, "abcd")},
                         "default_name": "default name 1",
                         "default_model": "default model 1",
                         "default_manufacturer": "default manufacturer 1",
@@ -898,7 +898,7 @@ async def test_device_info_not_overrides(hass):
     assert await entity_platform.async_setup_entry(config_entry)
     await hass.async_block_till_done()
 
-    device2 = registry.async_get_device(set(), {("mac", "abcd")})
+    device2 = registry.async_get_device(set(), {(dr.CONNECTION_NETWORK_MAC, "abcd")})
     assert device2 is not None
     assert device.id == device2.id
     assert device2.manufacturer == "test-manufacturer"
diff --git a/tests/helpers/test_entity_registry.py b/tests/helpers/test_entity_registry.py
index a1050e5fc67..9133c59d7c8 100644
--- a/tests/helpers/test_entity_registry.py
+++ b/tests/helpers/test_entity_registry.py
@@ -6,7 +6,7 @@ import pytest
 from homeassistant import config_entries
 from homeassistant.const import EVENT_HOMEASSISTANT_START, STATE_UNAVAILABLE
 from homeassistant.core import CoreState, callback, valid_entity_id
-from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from tests.common import (
     MockConfigEntry,
@@ -686,7 +686,7 @@ async def test_remove_device_removes_entities(hass, registry):
 
     device_entry = device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
 
     entry = registry.async_get_or_create(
@@ -713,13 +713,13 @@ async def test_update_device_race(hass, registry):
     # Create device
     device_entry = device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
     # Update it
     device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
         identifiers={("bridgeid", "0123")},
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
     # Add entity to the device
     entry = registry.async_get_or_create(
@@ -746,7 +746,7 @@ async def test_disable_device_disables_entities(hass, registry):
 
     device_entry = device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
 
     entry1 = registry.async_get_or_create(
@@ -811,7 +811,7 @@ async def test_disable_config_entry_disables_entities(hass, registry):
 
     device_entry = device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
 
     entry1 = registry.async_get_or_create(
@@ -877,7 +877,7 @@ async def test_disabled_entities_excluded_from_entity_list(hass, registry):
 
     device_entry = device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
 
     entry1 = registry.async_get_or_create(
diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py
index 46098917b0e..704194cd49b 100644
--- a/tests/helpers/test_template.py
+++ b/tests/helpers/test_template.py
@@ -19,7 +19,7 @@ from homeassistant.const import (
     VOLUME_LITERS,
 )
 from homeassistant.exceptions import TemplateError
-from homeassistant.helpers import template
+from homeassistant.helpers import device_registry as dr, template
 from homeassistant.setup import async_setup_component
 import homeassistant.util.dt as dt_util
 from homeassistant.util.unit_system import UnitSystem
@@ -1504,7 +1504,7 @@ async def test_device_entities(hass):
     # Test device without entities
     device_entry = device_registry.async_get_or_create(
         config_entry_id=config_entry.entry_id,
-        connections={("mac", "12:34:56:AB:CD:EF")},
+        connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
     info = render_to_info(hass, f"{{{{ device_entities('{device_entry.id}') }}}}")
     assert_result_info(info, [])