Move connect_single to SmartDevice.connect (#538)

This refactors `Discover.connect_single` by moving device instance construction into a separate device factory module.
New `SmartDevice.connect(host, *, port, timeout, credentials, device_type)` class method replaces the functionality of `connect_single`,
and also now allows constructing device instances without relying on UDP discovery for type discovery if `device_type` parameter is set.

---------

Co-authored-by: Teemu R. <tpr@iki.fi>

kasa/tests/test_cli.py

@@ -1,22 +1,11 @@
 import json
-import sys
 
 import asyncclick as click
 import pytest
 from asyncclick.testing import CliRunner
 
 from kasa import SmartDevice, TPLinkSmartHomeProtocol
-from kasa.cli import (
-    TYPE_TO_CLASS,
-    alias,
-    brightness,
-    cli,
-    emeter,
-    raw_command,
-    state,
-    sysinfo,
-    toggle,
-)
+from kasa.cli import alias, brightness, cli, emeter, raw_command, state, sysinfo, toggle
 from kasa.discover import Discover
 
 from .conftest import handle_turn_on, turn_on
@@ -154,14 +143,9 @@ async def test_credentials(discovery_data: dict, mocker):
             )
 
     mocker.patch("kasa.cli.state", new=_state)
-
-    # Get the type string parameter from the discovery_info
-    for cli_device_type in {  # noqa: B007
-        i
-        for i in TYPE_TO_CLASS
-        if TYPE_TO_CLASS[i] == Discover._get_device_class(discovery_data)
-    }:
-        break
+    cli_device_type = Discover._get_device_class(discovery_data)(
+        "any"
+    ).device_type.value
 
     runner = CliRunner()
     res = await runner.invoke(
@@ -181,6 +165,24 @@ async def test_credentials(discovery_data: dict, mocker):
     assert res.output == "Username:foo Password:bar\n"
 
 
+async def test_without_device_type(discovery_data: dict, dev, mocker):
+    """Test connecting without the device type."""
+    runner = CliRunner()
+    mocker.patch("kasa.discover.Discover.discover_single", return_value=dev)
+    res = await runner.invoke(
+        cli,
+        [
+            "--host",
+            "127.0.0.1",
+            "--username",
+            "foo",
+            "--password",
+            "bar",
+        ],
+    )
+    assert res.exit_code == 0
+
+
 @pytest.mark.parametrize("auth_param", ["--username", "--password"])
 async def test_invalid_credential_params(auth_param):
     """Test for handling only one of username or password supplied."""

kasa/tests/test_device_factory.py

@@ -0,0 +1,74 @@
+# type: ignore
+import logging
+from typing import Type
+
+import pytest  # type: ignore # https://github.com/pytest-dev/pytest/issues/3342
+
+from kasa import (
+    DeviceType,
+    SmartBulb,
+    SmartDevice,
+    SmartDeviceException,
+    SmartDimmer,
+    SmartLightStrip,
+    SmartPlug,
+)
+from kasa.device_factory import connect
+
+
+@pytest.mark.parametrize("custom_port", [123, None])
+async def test_connect(discovery_data: dict, mocker, custom_port):
+    """Make sure that connect returns an initialized SmartDevice instance."""
+    host = "127.0.0.1"
+    mocker.patch("kasa.TPLinkSmartHomeProtocol.query", return_value=discovery_data)
+
+    dev = await connect(host, port=custom_port)
+    assert issubclass(dev.__class__, SmartDevice)
+    assert dev.port == custom_port or dev.port == 9999
+
+
+@pytest.mark.parametrize("custom_port", [123, None])
+@pytest.mark.parametrize(
+    ("device_type", "klass"),
+    (
+        (DeviceType.Plug, SmartPlug),
+        (DeviceType.Bulb, SmartBulb),
+        (DeviceType.Dimmer, SmartDimmer),
+        (DeviceType.LightStrip, SmartLightStrip),
+        (DeviceType.Unknown, SmartDevice),
+    ),
+)
+async def test_connect_passed_device_type(
+    discovery_data: dict,
+    mocker,
+    device_type: DeviceType,
+    klass: Type[SmartDevice],
+    custom_port,
+):
+    """Make sure that connect with a passed device type."""
+    host = "127.0.0.1"
+    mocker.patch("kasa.TPLinkSmartHomeProtocol.query", return_value=discovery_data)
+
+    dev = await connect(host, port=custom_port, device_type=device_type)
+    assert isinstance(dev, klass)
+    assert dev.port == custom_port or dev.port == 9999
+
+
+async def test_connect_query_fails(discovery_data: dict, mocker):
+    """Make sure that connect fails when query fails."""
+    host = "127.0.0.1"
+    mocker.patch("kasa.TPLinkSmartHomeProtocol.query", side_effect=SmartDeviceException)
+
+    with pytest.raises(SmartDeviceException):
+        await connect(host)
+
+
+async def test_connect_logs_connect_time(
+    discovery_data: dict, caplog: pytest.LogCaptureFixture, mocker
+):
+    """Test that the connect time is logged when debug logging is enabled."""
+    host = "127.0.0.1"
+    mocker.patch("kasa.TPLinkSmartHomeProtocol.query", return_value=discovery_data)
+    logging.getLogger("kasa").setLevel(logging.DEBUG)
+    await connect(host)
+    assert "seconds to connect" in caplog.text

kasa/tests/test_device_type.py

@@ -0,0 +1,23 @@
+from kasa.smartdevice import DeviceType
+
+
+async def test_device_type_from_value():
+    """Make sure that every device type can be created from its value."""
+    for name in DeviceType:
+        assert DeviceType.from_value(name.value) is not None
+
+    assert DeviceType.from_value("nonexistent") is DeviceType.Unknown
+    assert DeviceType.from_value("plug") is DeviceType.Plug
+    assert DeviceType.Plug.value == "plug"
+
+    assert DeviceType.from_value("bulb") is DeviceType.Bulb
+    assert DeviceType.Bulb.value == "bulb"
+
+    assert DeviceType.from_value("dimmer") is DeviceType.Dimmer
+    assert DeviceType.Dimmer.value == "dimmer"
+
+    assert DeviceType.from_value("strip") is DeviceType.Strip
+    assert DeviceType.Strip.value == "strip"
+
+    assert DeviceType.from_value("lightstrip") is DeviceType.LightStrip
+    assert DeviceType.LightStrip.value == "lightstrip"

kasa/tests/test_discovery.py

@@ -1,7 +1,6 @@
 # type: ignore
 import re
 import socket
-import sys
 
 import pytest  # type: ignore # https://github.com/pytest-dev/pytest/issues/3342
 
@@ -111,27 +110,6 @@ async def test_discover_single_hostname(discovery_data: dict, mocker):
         x = await Discover.discover_single(host)
 
 
-@pytest.mark.parametrize("custom_port", [123, None])
-async def test_connect_single(discovery_data: dict, mocker, custom_port):
-    """Make sure that connect_single returns an initialized SmartDevice instance."""
-    host = "127.0.0.1"
-    info = {"system": {"get_sysinfo": discovery_data["system"]["get_sysinfo"]}}
-    mocker.patch("kasa.TPLinkSmartHomeProtocol.query", return_value=info)
-
-    dev = await Discover.connect_single(host, port=custom_port)
-    assert issubclass(dev.__class__, SmartDevice)
-    assert dev.port == custom_port or dev.port == 9999
-
-
-async def test_connect_single_query_fails(mocker):
-    """Make sure that connect_single fails when query fails."""
-    host = "127.0.0.1"
-    mocker.patch("kasa.TPLinkSmartHomeProtocol.query", side_effect=SmartDeviceException)
-
-    with pytest.raises(SmartDeviceException):
-        await Discover.connect_single(host)
-
-
 UNSUPPORTED = {
     "result": {
         "device_id": "xx",

kasa/tests/test_smartdevice.py

@@ -1,12 +1,12 @@
 import inspect
 from datetime import datetime
-from unittest.mock import patch
+from unittest.mock import Mock, patch
 
 import pytest  # type: ignore # https://github.com/pytest-dev/pytest/issues/3342
 
 import kasa
 from kasa import Credentials, SmartDevice, SmartDeviceException
-from kasa.smartstrip import SmartStripPlug
+from kasa.smartdevice import DeviceType
 
 from .conftest import handle_turn_on, has_emeter, no_emeter, turn_on
 from .newfakes import PLUG_SCHEMA, TZ_SCHEMA, FakeTransportProtocol
@@ -215,6 +215,28 @@ async def test_create_smart_device_with_timeout():
     assert dev.protocol.timeout == 100
 
 
+async def test_create_thin_wrapper():
+    """Make sure thin wrapper is created with the correct device type."""
+    mock = Mock()
+    with patch("kasa.device_factory.connect", return_value=mock) as connect:
+        dev = await SmartDevice.connect(
+            host="test_host",
+            port=1234,
+            timeout=100,
+            credentials=Credentials("username", "password"),
+            device_type=DeviceType.Strip,
+        )
+        assert dev is mock
+
+    connect.assert_called_once_with(
+        host="test_host",
+        port=1234,
+        timeout=100,
+        credentials=Credentials("username", "password"),
+        device_type=DeviceType.Strip,
+    )
+
+
 async def test_modules_not_supported(dev: SmartDevice):
     """Test that unsupported modules do not break the device."""
     for module in dev.modules.values():