thinqconnect 0.9.0__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Callable
+
+import pytest
+
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.connect_device import ConnectBaseDevice
+from thinqconnect.thinq_api import ThinQApi
+
+logger = logging.getLogger("test")
+
+
+def pytest_generate_tests(metafunc):
+    if "model_name" in metafunc.fixturenames:
+        device_type = metafunc.cls.get_device_type()
+        model_list = get_model_list(device_type)
+        metafunc.parametrize("model_name", model_list)
+
+
+def get_model_list(device_type: str) -> list[str]:
+    base_path = Path.cwd() / "tests" / "devices" / device_type.split("DEVICE_")[1].lower()
+    return [d.name for d in base_path.iterdir() if d.is_dir()]
+
+
+@pytest.fixture
+def generate_device() -> Callable[[type[ConnectBaseDevice], ThinQApi, dict, str, str, str | None], ConnectBaseDevice]:
+    def _device(
+        device_class: type[ConnectBaseDevice],
+        thinq_api: ThinQApi,
+        profile: dict,
+        device_type: str,
+        model_name: str,
+        reportable: bool = False,
+        group_id: str | None = None,
+    ) -> ConnectBaseDevice:
+        if device_type in [
+            DeviceType.WASHCOMBO_MAIN,
+            DeviceType.WASHCOMBO_MINI,
+            DeviceType.WASHTOWER_DRYER,
+            DeviceType.WASHTOWER_WASHER,
+        ]:
+            return device_class(
+                thinq_api=thinq_api,
+                device_id=profile["deviceId"],
+                device_type=device_type,
+                model_name=model_name,
+                alias=f"TEST_{device_type}",
+                reportable=reportable,
+                profile=profile["response"],
+                group_id=group_id,
+            )
+        else:
+            return device_class(
+                thinq_api=thinq_api,
+                device_id=profile["deviceId"],
+                device_type=device_type,
+                model_name=model_name,
+                alias=f"TEST_{device_type}",
+                reportable=reportable,
+                profile=profile["response"],
+            )
+
+    return _device
+
+
+@pytest.fixture
+def json_object() -> Callable[[str], dict]:
+    def _json_object(file_path: str):
+        return read_file(file_path)
+
+    return _json_object
+
+
+def read_file(file_path: str) -> dict:
+    default_dict = {}
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            sample_set = f.read()
+            return json.loads(sample_set)
+    except Exception as e:
+        logger.error(f"read file error: {e}")
+        return default_dict
+
+
+@pytest.fixture
+def test_device_profile() -> Callable[[str, ConnectBaseDevice], dict]:
+    def _device_profile(device_name: str, device: ConnectBaseDevice) -> dict:
+        profile_attr: dict[str, dict | list | None] = {
+            "properties": device.profiles.properties,
+            "writable_properties": device.profiles.writable_properties,
+            "location_properties": device.profiles.location_properties,
+            "notification": device.profiles.notification,
+            "errors": device.profiles.errors,
+        }
+        for key, value in profile_attr.items():
+            logger.info(f"test {device_name}.profiles.{key}: {value}")
+
+        test_result = dict.copy(profile_attr)
+        for properties in profile_attr["properties"].values():
+            for prop in properties:
+                test_result[prop] = device.profiles.get_property(prop)
+                logger.info(f"test {device_name}.profiles.{prop}: {test_result[prop]}")
+
+        for location, resources in profile_attr["location_properties"].items():
+            location_profiles = device.profiles.get_sub_profile(location)
+            sub_profile_attr: dict[str, dict | list | None] = {
+                "writable_properties": location_profiles.writable_properties,
+                **(
+                    {"notification": location_profiles.notification, "errors": location_profiles.errors}
+                    if location_profiles.notification or location_profiles.errors
+                    else {}
+                ),
+            }
+            for key, value in sub_profile_attr.items():
+                logger.info(f"test {device_name}.profiles.{location}.{key}: {value}")
+
+            test_result[location] = dict.copy(sub_profile_attr)
+            for properties in resources.values():
+                for prop in properties:
+                    test_result[location][prop] = location_profiles.get_property(prop)
+                    logger.info(f"test {device_name}.profiles.{location}.{prop}: {test_result[location][prop]}")
+
+        return test_result
+
+    return _device_profile
+
+
+@pytest.fixture
+def test_device_status() -> Callable[[str, ConnectBaseDevice, dict, bool], dict]:
+    def _device_status(device_name: str, device: ConnectBaseDevice, status: dict, is_update: bool = False) -> dict:
+        device_properties = device.profiles.properties
+        location_properties = device.profiles.location_properties
+        if is_update:
+            device.update_status(status=status["response"])
+        else:
+            device.set_status(status=status["response"])
+
+        test_result = {}
+        if device.profiles.errors:
+            test_result["error"] = device.get_status("error")
+            logger.info(f"test {device_name}.error: {test_result['error']}")
+
+        for properties in device_properties.values():
+            for prop in properties:
+                test_result[prop] = device.get_status(prop)
+                logger.info(f"test {device_name}.{prop}: {test_result[prop]}")
+
+        for location, resources in location_properties.items():
+            sub_device = device.get_sub_device(location)
+            test_result[location] = {}
+            if device.profiles.get_sub_profile(location).errors:
+                test_result[location]["error"] = sub_device.get_status("error")
+                logger.info(f"test {device_name}.{location}.error: {test_result[location]['error']}")
+
+            for properties in resources.values():
+                for prop in properties:
+                    test_result[location][prop] = sub_device.get_status(prop)
+                    logger.info(f"test {device_name}.{location}.{prop}: {test_result[location][prop]}")
+        return test_result
+
+    return _device_status
+
+
+@pytest.fixture
+def check_device_control() -> Callable[[str, ConnectBaseDevice], None]:
+    def _check_result(fn_name: str | None, prop_name: str) -> str:
+        if fn_name == f"set_{prop_name}":
+            return "Exist"
+        elif fn_name:
+            return f"Exist with custom name '{fn_name}'"
+        return "Not Exist"
+
+    def _check_control(device_name: str, device: ConnectBaseDevice):
+        location_properties = device.profiles.location_properties
+        writable_props = device.profiles.writable_properties
+        logger.info(f"test {device_name}.profiles.writable_properties: {device.profiles.writable_properties}")
+        for prop in writable_props:
+            logger.info(f"check {device_name}.set_{prop}: {_check_result(device.get_property_set_fn(prop), prop)}")
+
+        for location in location_properties.keys():
+            sub_device = device.get_sub_device(location)
+            writable_props = sub_device.profiles.writable_properties
+            logger.info(
+                f"test {device_name}.profiles.{location}.writable_properties: {sub_device.profiles.writable_properties}"
+            )
+            for prop in writable_props:
+                logger.info(
+                    f"check {device_name}.{location}.set_{prop}: {_check_result(sub_device.get_property_set_fn(prop), prop)}"
+                )
+
+    return _check_control

tests/device_test_base.py

@@ -0,0 +1,145 @@
+import abc
+import json
+import logging
+import os
+from glob import glob
+from typing import Callable
+
+import pytest
+from aiohttp import ClientSession
+from deepdiff import DeepDiff
+
+from thinqconnect.devices.connect_device import ConnectBaseDevice
+from thinqconnect.thinq_api import ThinQApi
+
+logger = logging.getLogger("test")
+
+
+class DeviceTestBase(abc.ABC):
+    @pytest.mark.asyncio
+    async def test_device(
+        self,
+        model_name: str,
+        generate_device: Callable[[type[ConnectBaseDevice], ThinQApi, dict, str, str, str | None], ConnectBaseDevice],
+        json_object: Callable[[str], dict],
+        test_device_profile: Callable[[str, ConnectBaseDevice], dict],
+        test_device_status: Callable[[str, ConnectBaseDevice, dict, bool], dict],
+        check_device_control: Callable[[str, ConnectBaseDevice], None],
+    ):
+        async with ClientSession() as session:
+            access_token, client_id = self.get_credentials()
+            thinq_api = ThinQApi(
+                session=session,
+                access_token=access_token,
+                country_code="KR",
+                client_id=client_id,
+            )
+            device = generate_device(
+                self.get_device_class(),
+                thinq_api,
+                json_object(self.get_profile_file_path(self.get_device_type(), model_name)),
+                self.get_device_type(),
+                model_name,
+            )
+
+            await self.run_device_test(
+                device,
+                json_object,
+                test_device_profile,
+                test_device_status,
+                check_device_control,
+            )
+
+    @classmethod
+    def get_credentials(cls) -> tuple[str, str]:
+        access_token = "ab3f3fa8443d91d48a2e331c6489ae0c1133acd441e539035ac1"
+        client_id = "test_client_id"
+        return (access_token, client_id)
+
+    @classmethod
+    def get_device_type_path(cls, device_type: str) -> str:
+        short_device_type = cls.get_short_device_type(device_type)
+        return f"tests/devices/{short_device_type}/"
+
+    @classmethod
+    def get_profile_file_path(cls, device_type: str, model_name: str) -> str:
+        return f"{cls.get_device_type_path(device_type)}{model_name}/profile.json"
+
+    @classmethod
+    def get_result_file_path(cls, device_type: str, model_name: str) -> str:
+        return f"{cls.get_device_type_path(device_type)}result_{model_name}.json"
+
+    @classmethod
+    def get_short_device_type(cls, device_type: str) -> str:
+        return device_type.split("DEVICE_")[1].lower()
+
+    @classmethod
+    def write_test_result(cls, device_type: str, model_name: str, test_result: dict) -> str:
+        try:
+            file_path = cls.get_result_file_path(device_type, model_name)
+            if file_exist := os.path.exists(file_path):
+                with open(file_path) as file:
+                    if file:
+                        prev_result = json.load(file)
+                        if not DeepDiff(prev_result, test_result, ignore_order=True):
+                            logger.info("Test Result is not Changed.")
+                            return
+
+            with open(file_path, "w") as file:
+                json.dump(test_result, file, indent=4)
+
+        except Exception as e:
+            logger.info(f"An error occurred: {e}")
+
+        if not file_exist:
+            logger.info(f"Test Result is Created to {file_path}")
+        else:
+            logger.info(f"Test Result is Updated to {file_path}")
+            assert False
+
+    @classmethod
+    async def run_device_test(
+        cls,
+        device: ConnectBaseDevice,
+        json_object: Callable[[str], dict],
+        test_device_profile: Callable[[str, ConnectBaseDevice], dict],
+        test_device_status: Callable[[str, ConnectBaseDevice, dict, bool], dict],
+        check_device_control: Callable[[str, ConnectBaseDevice], None],
+    ):
+        device_type = device.device_type
+        short_device_type = cls.get_short_device_type(device_type)
+        model_name = device.model_name
+        test_result = {"profile": None, "status": {}, "event": {}}
+
+        logger.info(f"{device_type} Test with model : {model_name}")
+
+        test_result["profile"] = test_device_profile(device_type, device)
+
+        status_files = glob(f"tests/devices/{short_device_type}/{model_name}/status/*.json")
+        for status_file in status_files:
+            status = json_object(status_file)
+            test_result["status"][status_file.split("/")[-1]] = test_device_status(device_type, device, status)
+
+        event_files = glob(f"tests/devices/{short_device_type}/{model_name}/event/*.json")
+
+        for event_file in sorted(event_files):
+            print(event_file.split("/")[-1])
+            event = json_object(event_file)
+            test_result["event"][event_file.split("/")[-1]] = test_device_status(
+                device_type, device, event, is_update=True
+            )
+
+        check_device_control(device_type, device)
+
+        logger.info(f"{device_type} Test with model : {model_name} is done.")
+        cls.write_test_result(device_type, model_name, test_result)
+
+    @classmethod
+    @abc.abstractmethod
+    def get_device_class(cls) -> type[ConnectBaseDevice]:
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def get_device_type(cls) -> str:
+        pass

tests/test_air_conditioner.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.air_conditioner import AirConditionerDevice
+
+
+class TestAirConditioner(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[AirConditionerDevice]:
+        return AirConditionerDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.AIR_CONDITIONER
+
+    async def check_control(self, device: AirConditionerDevice):
+        await device.set_current_job_mode("COOL")
+        await device.set_air_con_operation_mode("POWER_ON")
+        await device.set_air_con_operation_mode("POWER_OFF")
+        await device.set_current_job_mode("AIR_DRY")
+        await device.set_air_clean_operation_mode("START")
+        await device.set_monitoring_enabled("ON_WORKING")
+        await device.set_wind_strength("MID")
+        await device.set_relative_time_to_stop(1, 10)
+        await device.set_sleep_timer_relative_time_to_stop(1, 10)
+        await device.set_target_temperature(20)
+        await device.set_cool_target_temperature(24)
+        await device.set_power_save_enabled(False)

tests/test_air_purifier.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.air_purifier import AirPurifierDevice
+
+
+class TestAirPurifier(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[AirPurifierDevice]:
+        return AirPurifierDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.AIR_PURIFIER
+
+    async def check_control(self, device: AirPurifierDevice):
+        # NOTE: AIR_910604_WW 제어 테스트이고, 시뮬레이터 기기로 테스트 시 전원 켠 후 Mode를 Single로 변경하고 Speed를 Turbo로 변경 필요
+        await device.set_wind_strength("LOW")
+        await device.set_absolute_time_to_stop(13, 30)
+        await device.set_air_purifier_operation_mode("POWER_OFF")
+        await device.set_absolute_time_to_start(12, 30)
+        await device.set_air_purifier_operation_mode("POWER_ON")

tests/test_air_purifier_fan.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.air_purifier_fan import AirPurifierFanDevice
+
+
+class TestAirPurifierFan(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[AirPurifierFanDevice]:
+        return AirPurifierFanDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.AIR_PURIFIER_FAN
+
+    async def check_control(self, device: AirPurifierFanDevice):
+        # NOTE: 밀웜 동작 확인 불가
+        # await device.set_current_job_mode("DIRECT_CLEAN")
+        # await device.set_relative_time_to_stop(5)
+        # await device.set_wind_angle("ANGLE_45")
+        # await device.set_warm_mode("WARM_ON")
+        # await device.set_wind_temperature(35)
+
+        # NOTE: 밀웜 테스트 완료
+        await device.set_air_fan_operation_mode("POWER_ON")
+        await device.set_absolute_time_to_stop(13, 30)
+        await device.set_display_light("LEVEL_2")
+        await device.set_wind_strength("AUTO")
+        await device.set_uv_nano("ON")
+        await device.set_air_fan_operation_mode("POWER_OFF")
+        await device.set_absolute_time_to_start(12, 30)

tests/test_ceiling_fan.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.ceiling_fan import CeilingFanDevice
+
+
+class TestCeilingFan(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[CeilingFanDevice]:
+        return CeilingFanDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.CEILING_FAN
+
+    async def check_control(self, device: CeilingFanDevice):
+        await device.set_ceiling_fan_operation_mode("POWER_ON")
+        await device.set_ceiling_fan_operation_mode("POWER_OFF")
+        await device.set_wind_strength("TURBO")
+        await device.set_wind_strength("HIGH")
+        await device.set_wind_strength("LOW")
+        await device.set_wind_strength("MID")

tests/test_cooktop.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.cooktop import CooktopDevice
+
+
+class TestCooktop(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[CooktopDevice]:
+        return CooktopDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.COOKTOP
+
+    async def check_control(self, device: CooktopDevice):
+        await device.set_operation_mode("POWER_OFF")
+        await device.set_power_level("left_rear", 1)
+        # await device.set_power_level("left_rear", 15)  # negative
+        await device.set_remain_hour("right_front", 1)
+        await device.set_remain_minute("left_rear", 5)

tests/test_dehumidifier.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.dehumidifier import DehumidifierDevice
+
+
+class TestDehumidifier(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[DehumidifierDevice]:
+        return DehumidifierDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.DEHUMIDIFIER
+
+    async def check_control(self, device: DehumidifierDevice):
+        await device.set_dehumidifier_operation_mode("POWER_ON")
+        await device.set_wind_strength("LOW")
+        await device.set_dehumidifier_operation_mode("POWER_OFF")

tests/test_dish_washer.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.dish_washer import DishWasherDevice
+
+
+class TestDishWasher(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[DishWasherDevice]:
+        return DishWasherDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.DISH_WASHER
+
+    async def check_control(self, device: DishWasherDevice):
+        await device.set_dish_washer_operation_mode("START")
+        await device.set_relative_hour_to_start(1)

tests/test_dryer.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.dryer import DryerDevice
+
+
+class TestDryer(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[DryerDevice]:
+        return DryerDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.DRYER
+
+    async def check_control(self, device: DryerDevice):
+        await device.set_dryer_operation_mode("POWER_OFF")

tests/test_home_brew.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.home_brew import HomeBrewDevice
+
+
+class TestHomeBrew(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[HomeBrewDevice]:
+        return HomeBrewDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.HOME_BREW

tests/test_hood.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.hood import HoodDevice
+
+
+class TestHood(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[HoodDevice]:
+        return HoodDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.HOOD
+
+    async def check_control(self, device: HoodDevice):
+        await device.set_fan_speed(2)
+        await device.set_lamp_brightness(1)

tests/test_humidifier.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.humidifier import HumidifierDevice
+
+
+class TestHumidifier(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[HumidifierDevice]:
+        return HumidifierDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.HUMIDIFIER
+
+    async def check_control(self, device: HumidifierDevice):
+        # NOTE: 실기기 테스트 필요
+        await device.set_current_job_mode("AIR_CLEAN")
+        await device.set_humidifier_operation_mode("POWER_OFF")
+        await device.set_humidifier_operation_mode("POWER_ON")
+        await device.set_sleep_mode("SLEEP_OFF")
+        await device.set_sleep_mode("SLEEP_ON")

tests/test_kimchi_refrigerator.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.kimchi_refrigerator import KimchiRefrigeratorDevice
+
+
+class TestKimchiRefrigerator(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[KimchiRefrigeratorDevice]:
+        return KimchiRefrigeratorDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.KIMCHI_REFRIGERATOR

tests/test_microwave_oven.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from tests.device_test_base import DeviceTestBase
+from thinqconnect.const import DeviceType
+from thinqconnect.devices.microwave_oven import MicrowaveOvenDevice
+
+
+class TestMicrowaveOven(DeviceTestBase):
+    @classmethod
+    def get_device_class(cls) -> type[MicrowaveOvenDevice]:
+        return MicrowaveOvenDevice
+
+    @classmethod
+    def get_device_type(cls) -> str:
+        return DeviceType.MICROWAVE_OVEN
+
+    async def check_control(self, device: MicrowaveOvenDevice):
+        await device.set_fan_speed(2)
+        await device.set_lamp_brightness(1)