fix(core): device discovery now detect right protocol

plugp100/discovery/discovered_device.py

@@ -39,6 +39,26 @@ def from_dict(values: dict[str, Any]) -> "DiscoveredDevice":
             mgt_encrypt_schm=EncryptionScheme(**values.get("mgt_encrypt_schm")),
         )
 
+    @property
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "device_type": self.device_type,
+            "device_model": self.device_model,
+            "ip": self.ip,
+            "mac": self.mac,
+            "device_id": self.device_id,
+            "owner": self.owner,
+            "hw_ver": self.hw_ver,
+            "is_support_iot_cloud": self.is_support_iot_cloud,
+            "factory_default": self.factory_default,
+            "mgt_encrypt_schm": {
+                "is_support_https": self.mgt_encrypt_schm.is_support_https,
+                "encrypt_type": self.mgt_encrypt_schm.encrypt_type,
+                "http_port": self.mgt_encrypt_schm.http_port,
+                "lv": self.mgt_encrypt_schm.lv,
+            },
+        }
+
     async def get_tapo_device(
         self, credentials: AuthCredential, session: Optional[aiohttp.ClientSession] = None
     ) -> TapoDevice:

plugp100/new/device_factory.py

@@ -40,7 +40,7 @@ async def connect(
     config: DeviceConnectConfiguration, session: Optional[aiohttp.ClientSession] = None
 ):
     protocol = await _get_or_guess_protocol(config, session)
-    if config.device_type is None or config.device_model is None:
+    if config.device_type is None:
         _LOGGER.info(
             "Not enough information to detected device type and model, trying to fetching from device..."
         )
@@ -49,11 +49,9 @@ async def connect(
             .get_or_raise()
             .result
         )
-        factory = _get_device_class_from_model_type(device_info.type, device_info.model)
+        factory = _get_device_class_from_model_type(device_info.type)
     else:
-        factory = _get_device_class_from_model_type(
-            config.device_type, config.device_model
-        )
+        factory = _get_device_class_from_model_type(config.device_type)
     client = TapoClient(config.credentials, config.url, protocol, session)
     return factory(config.host, config.port, client)
 
@@ -102,9 +100,7 @@ async def _guess_protocol(
     raise InvalidAuthentication(config.host, config.device_type)
 
 
-def _get_device_class_from_model_type(
-    device_type: str, device_model: str
-) -> Type[TapoDevice]:
+def _get_device_class_from_model_type(device_type: str) -> Type[TapoDevice]:
     device_type = device_type.upper()
     if device_type == "SMART.TAPOPLUG":
         return TapoPlug

tests/fixtures/discovery.json

@@ -0,0 +1,17 @@
+{
+  "device_id": "device_id_123",
+  "owner": "owner_id",
+  "device_type": "SMART.TAPOBULB",
+  "device_model": "L530E(EU)",
+  "ip": "1.2.3.4",
+  "mac": "1a-22-33-b4-c5-66",
+  "is_support_iot_cloud": true,
+  "obd_src": "tplink",
+  "factory_default": false,
+  "mgt_encrypt_schm": {
+    "is_support_https": false,
+    "encrypt_type": "KLAP",
+    "http_port": 80,
+    "lv": 2
+  }
+}

tests/unit/test_discovery.py

@@ -0,0 +1,44 @@
+from unittest.mock import patch, AsyncMock
+
+from plugp100.common.credentials import AuthCredential
+from plugp100.discovery import DiscoveredDevice
+from plugp100.new.tapobulb import TapoBulb
+from tests.conftest import load_fixture
+
+
+def test_must_convert_discovered_device_to_dict():
+    discovery_data = load_fixture("discovery.json")
+    discovered_device = DiscoveredDevice.from_dict(discovery_data)
+    assert discovered_device is not None
+    dictionary = discovered_device.as_dict
+    assert dictionary["mgt_encrypt_schm"] == discovery_data["mgt_encrypt_schm"]
+    assert dictionary["mac"] == discovery_data["mac"]
+    assert dictionary["ip"] == discovery_data["ip"]
+    assert dictionary["device_id"] == discovery_data["device_id"]
+    assert dictionary["device_type"] == discovery_data["device_type"]
+    assert dictionary["device_model"] == discovery_data["device_model"]
+
+
+async def test_discovered_device_should_get_real_tapo_device():
+    discovered_device = DiscoveredDevice.from_dict(load_fixture("discovery.json"))
+    device = await discovered_device.get_tapo_device(
+        credentials=AuthCredential("test", "test")
+    )
+    assert device is not None
+    assert device.protocol_version == "Klap V2"
+    assert device.host == "1.2.3.4"
+    assert isinstance(device, TapoBulb)
+
+
+async def test_should_not_get_device_info_if_discovery_has_type():
+    discovered_device = DiscoveredDevice.from_dict(load_fixture("discovery.json"))
+
+    with patch(
+        "plugp100.protocol.tapo_protocol.TapoProtocol.send_request",
+        side_effect=AsyncMock(return_value=None),
+    ) as send_request:
+        device = await discovered_device.get_tapo_device(
+            credentials=AuthCredential("test", "test")
+        )
+        send_request.assert_not_called()
+        assert device is not None