Add tests for DeviceFactory.create

Author: rytilahti

miio/devicefactory.py

@@ -33,11 +33,12 @@ def register(cls, integration_cls: Type[Device]):
         for model in integration_cls.supported_models:  # type: ignore
             if model in cls._supported_models:
                 _LOGGER.debug(
-                    "Got duplicate of %s for %s, previously registered by %s",
+                    "Ignoring duplicate of %s for %s, previously registered by %s",
                     model,
                     integration_cls,
                     cls._supported_models[model],
                 )
+                continue
 
             _LOGGER.debug("  * %s => %s", model, integration_cls)
             cls._supported_models[model] = integration_cls
@@ -97,7 +98,7 @@ def create(
             from .integrations.genericmiot import GenericMiot
 
             dev = GenericMiot(host, token, model=model)
-            dev.info()  # HACK: we have to force update to load the miot schema
+            dev.info()
             return dev
         if model is None:
             dev = Device(host, token)

miio/tests/test_devicefactory.py

@@ -1,6 +1,6 @@
 import pytest
 
-from miio import Device, DeviceFactory, Gateway, GenericMiot, MiotDevice
+from miio import Device, DeviceFactory, DeviceInfo, Gateway, GenericMiot, MiotDevice
 
 DEVICE_CLASSES = Device.__subclasses__() + MiotDevice.__subclasses__()  # type: ignore
 DEVICE_CLASSES.remove(MiotDevice)
@@ -39,3 +39,42 @@ class _DummyDevice(Device):
 def test_device_class_for_model_unknown():
     """Test that unknown model returns genericmiot."""
     assert DeviceFactory.class_for_model("foo.foo.xyz.invalid") == GenericMiot
+
+
+@pytest.mark.parametrize("cls", DEVICE_CLASSES)
+@pytest.mark.parametrize("force_model", [True, False])
+def test_create(cls, force_model, mocker):
+    """Test create for both forced and autodetected models."""
+    mocker.patch("miio.Device.send")
+
+    model = None
+    first_supported_model = next(iter(cls.supported_models))
+    if force_model:
+        model = first_supported_model
+
+    dummy_info = DeviceInfo({"model": first_supported_model})
+    info = mocker.patch("miio.Device.info", return_value=dummy_info)
+
+    device = DeviceFactory.create("127.0.0.1", 32 * "0", model=model)
+    device_class = DeviceFactory.class_for_model(device.model)
+    assert isinstance(device, device_class)
+
+    if force_model:
+        info.assert_not_called()
+    else:
+        info.assert_called()
+
+
+@pytest.mark.parametrize("cls", DEVICE_CLASSES)
+def test_create_force_miot(cls, mocker):
+    """Test that force_generic_miot works."""
+    mocker.patch("miio.Device.send")
+    mocker.patch("miio.Device.info")
+    class_for_model = mocker.patch("miio.DeviceFactory.class_for_model")
+
+    assert isinstance(
+        DeviceFactory.create("127.0.0.1", 32 * "0", force_generic_miot=True),
+        GenericMiot,
+    )
+
+    class_for_model.assert_not_called()