Fix previous setting briefly appearing on newer flux_led devices when turning on (#60004)

Co-authored-by: J. Nick Koston <nick@koston.org>

homeassistant/components/flux_led/light.py

@@ -280,10 +280,11 @@ class FluxLight(FluxOnOffEntity, CoordinatorEntity, LightEntity):
 
     async def _async_turn_on(self, **kwargs: Any) -> None:
         """Turn the specified or all lights on."""
-        if not self.is_on:
+        if self._device.requires_turn_on or not kwargs:
-            await self._device.async_turn_on()
+            if not self.is_on:
-        if not kwargs:
+                await self._device.async_turn_on()
-            return
+            if not kwargs:
+                return
 
         if MODE_ATTRS.intersection(kwargs):
             await self._async_set_mode(**kwargs)

tests/components/flux_led/__init__.py

@@ -66,6 +66,7 @@ def _mocked_bulb() -> AIOWifiLedBulb:
         bulb.data_receive_callback = callback
 
     bulb.device_type = DeviceType.Bulb
+    bulb.requires_turn_on = True
     bulb.async_setup = AsyncMock(side_effect=_save_setup_callback)
     bulb.effect_list = ["some_effect"]
     bulb.async_set_custom_pattern = AsyncMock()
@@ -115,6 +116,7 @@ def _mocked_switch() -> AIOWifiLedBulb:
         switch.data_receive_callback = callback
 
     switch.device_type = DeviceType.Switch
+    switch.requires_turn_on = True
     switch.async_setup = AsyncMock(side_effect=_save_setup_callback)
     switch.async_stop = AsyncMock()
     switch.async_update = AsyncMock()

tests/components/flux_led/test_light.py

@@ -226,22 +226,19 @@ async def test_rgb_light(hass: HomeAssistant) -> None:
     bulb.async_set_levels.reset_mock()
     bulb.async_turn_on.reset_mock()
 
-    await hass.services.async_call(
-        LIGHT_DOMAIN, "turn_on", {ATTR_ENTITY_ID: entity_id}, blocking=True
-    )
-    bulb.async_turn_on.assert_called_once()
-    bulb.async_turn_on.reset_mock()
-    await async_mock_device_turn_on(hass, bulb)
-    assert hass.states.get(entity_id).state == STATE_ON
-
     await hass.services.async_call(
         LIGHT_DOMAIN,
         "turn_on",
         {ATTR_ENTITY_ID: entity_id, ATTR_BRIGHTNESS: 100},
         blocking=True,
     )
+    # If its off and the device requires the turn on
+    # command before setting brightness we need to make sure its called
+    bulb.async_turn_on.assert_called_once()
     bulb.async_set_brightness.assert_called_with(100)
     bulb.async_set_brightness.reset_mock()
+    await async_mock_device_turn_on(hass, bulb)
+    assert hass.states.get(entity_id).state == STATE_ON
 
     await hass.services.async_call(
         LIGHT_DOMAIN,
@@ -284,6 +281,120 @@ async def test_rgb_light(hass: HomeAssistant) -> None:
     bulb.async_set_effect.reset_mock()
 
 
+async def test_rgb_light_auto_on(hass: HomeAssistant) -> None:
+    """Test an rgb light that does not need the turn on command sent."""
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={CONF_HOST: IP_ADDRESS, CONF_NAME: DEFAULT_ENTRY_TITLE},
+        unique_id=MAC_ADDRESS,
+    )
+    config_entry.add_to_hass(hass)
+    bulb = _mocked_bulb()
+    bulb.requires_turn_on = False
+    bulb.raw_state = bulb.raw_state._replace(model_num=0x33)  # RGB only model
+    bulb.color_modes = {FLUX_COLOR_MODE_RGB}
+    bulb.color_mode = FLUX_COLOR_MODE_RGB
+    with _patch_discovery(device=bulb), _patch_wifibulb(device=bulb):
+        await async_setup_component(hass, flux_led.DOMAIN, {flux_led.DOMAIN: {}})
+        await hass.async_block_till_done()
+
+    entity_id = "light.bulb_rgbcw_ddeeff"
+
+    state = hass.states.get(entity_id)
+    assert state.state == STATE_ON
+    attributes = state.attributes
+    assert attributes[ATTR_BRIGHTNESS] == 128
+    assert attributes[ATTR_COLOR_MODE] == "rgb"
+    assert attributes[ATTR_EFFECT_LIST] == bulb.effect_list
+    assert attributes[ATTR_SUPPORTED_COLOR_MODES] == ["rgb"]
+    assert attributes[ATTR_HS_COLOR] == (0, 100)
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN, "turn_off", {ATTR_ENTITY_ID: entity_id}, blocking=True
+    )
+    bulb.async_turn_off.assert_called_once()
+
+    await async_mock_device_turn_off(hass, bulb)
+    assert hass.states.get(entity_id).state == STATE_OFF
+
+    bulb.brightness = 0
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        "turn_on",
+        {ATTR_ENTITY_ID: entity_id, ATTR_RGB_COLOR: (10, 10, 30)},
+        blocking=True,
+    )
+    # If the bulb is off and we are using existing brightness
+    # it has to be at least 1 or the bulb won't turn on
+    bulb.async_turn_on.assert_not_called()
+    bulb.async_set_levels.assert_called_with(10, 10, 30, brightness=1)
+    bulb.async_set_levels.reset_mock()
+    bulb.async_turn_on.reset_mock()
+
+    # Should still be called with no kwargs
+    await hass.services.async_call(
+        LIGHT_DOMAIN, "turn_on", {ATTR_ENTITY_ID: entity_id}, blocking=True
+    )
+    bulb.async_turn_on.assert_called_once()
+    await async_mock_device_turn_on(hass, bulb)
+    assert hass.states.get(entity_id).state == STATE_ON
+    bulb.async_turn_on.reset_mock()
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        "turn_on",
+        {ATTR_ENTITY_ID: entity_id, ATTR_BRIGHTNESS: 100},
+        blocking=True,
+    )
+    bulb.async_turn_on.assert_not_called()
+    bulb.async_set_brightness.assert_called_with(100)
+    bulb.async_set_brightness.reset_mock()
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        "turn_on",
+        {ATTR_ENTITY_ID: entity_id, ATTR_RGB_COLOR: (10, 10, 30)},
+        blocking=True,
+    )
+    # If the bulb is on and we are using existing brightness
+    # and brightness was 0 it means we could not read it because
+    # an effect is in progress so we use 255
+    bulb.async_turn_on.assert_not_called()
+    bulb.async_set_levels.assert_called_with(10, 10, 30, brightness=255)
+    bulb.async_set_levels.reset_mock()
+
+    bulb.brightness = 128
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        "turn_on",
+        {ATTR_ENTITY_ID: entity_id, ATTR_HS_COLOR: (10, 30)},
+        blocking=True,
+    )
+    bulb.async_turn_on.assert_not_called()
+    bulb.async_set_levels.assert_called_with(255, 191, 178, brightness=128)
+    bulb.async_set_levels.reset_mock()
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        "turn_on",
+        {ATTR_ENTITY_ID: entity_id, ATTR_EFFECT: "random"},
+        blocking=True,
+    )
+    bulb.async_turn_on.assert_not_called()
+    bulb.async_set_effect.assert_called_once()
+    bulb.async_set_effect.reset_mock()
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        "turn_on",
+        {ATTR_ENTITY_ID: entity_id, ATTR_EFFECT: "purple_fade"},
+        blocking=True,
+    )
+    bulb.async_turn_on.assert_not_called()
+    bulb.async_set_effect.assert_called_with("purple_fade", 50, 50)
+    bulb.async_set_effect.reset_mock()
+
+
 async def test_rgb_cct_light(hass: HomeAssistant) -> None:
     """Test an rgb cct light."""
     config_entry = MockConfigEntry(