Merge remote-tracking branch 'origin/cover-action-bitmask' into integration

esphome/components/cover/__init__.py

@@ -299,7 +299,21 @@ COVER_CONTROL_ACTION_SCHEMA = cv.Schema(
 )
 async def cover_control_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    # Bit positions must match COVER_CONTROL_FIELDS in automation.h.
+    # CONF_STATE and CONF_POSITION both map to set_position (bit 1).
+    field_mask = 0
+    if CONF_STOP in config:
+        field_mask |= 1 << 0
+    if CONF_STATE in config or CONF_POSITION in config:
+        field_mask |= 1 << 1
+    if CONF_TILT in config:
+        field_mask |= 1 << 2
+
+    control_template_arg = cg.TemplateArguments(
+        cg.RawExpression(f"static_cast<uint16_t>({field_mask})"), *template_arg
+    )
+    var = cg.new_Pvariable(action_id, control_template_arg, paren)
     if (stop := config.get(CONF_STOP)) is not None:
         template_ = await cg.templatable(stop, args, cg.bool_)
         cg.add(var.set_stop(template_))

esphome/components/cover/automation.h

@@ -46,49 +46,89 @@ template<typename... Ts> class ToggleAction : public Action<Ts...> {
   Cover *cover_;
 };
 
-template<typename... Ts> class ControlAction : public Action<Ts...> {
+// Unique Empty<Tag> per field so [[no_unique_address]] is guaranteed to coalesce.
+namespace cover_action_detail {
+template<int Tag> struct Empty {};
+}  // namespace cover_action_detail
+
+// X-macro: (type, field_name, bit_index). Order/bits must match the
+// inline field-mask computation in cover_control_to_code in __init__.py:
+// stop=bit 0, position=bit 1 (also set by CONF_STATE), tilt=bit 2.
+#define COVER_CONTROL_FIELDS(X) \
+  X(bool, stop, 0) \
+  X(float, position, 1) \
+  X(float, tilt, 2)
+
+template<uint16_t Fields, typename... Ts> class ControlAction : public Action<Ts...> {
  public:
   explicit ControlAction(Cover *cover) : cover_(cover) {}
 
-  TEMPLATABLE_VALUE(bool, stop)
-  TEMPLATABLE_VALUE(float, position)
-  TEMPLATABLE_VALUE(float, tilt)
+#define COVER_FIELD_SETTER_(type, name, idx) \
+  template<typename V> void set_##name(V value) requires((Fields & (1 << (idx))) != 0) { this->name##_ = value; }
+#define COVER_FIELD_APPLY_(type, name, idx) \
+  if constexpr ((Fields & (1 << (idx))) != 0) \
+    call.set_##name(this->name##_.value(x...));
+#define COVER_FIELD_DECL_(type, name, idx) \
+  [[no_unique_address]] std::conditional_t<(Fields & (1 << (idx))) != 0, TemplatableFn<type, Ts...>, \
+                                           cover_action_detail::Empty<(idx)>> \
+      name##_{};
+
+  COVER_CONTROL_FIELDS(COVER_FIELD_SETTER_)
 
   void play(const Ts &...x) override {
     auto call = this->cover_->make_call();
-    if (this->stop_.has_value())
-      call.set_stop(this->stop_.value(x...));
-    if (this->position_.has_value())
-      call.set_position(this->position_.value(x...));
-    if (this->tilt_.has_value())
-      call.set_tilt(this->tilt_.value(x...));
+    COVER_CONTROL_FIELDS(COVER_FIELD_APPLY_)
     call.perform();
   }
 
  protected:
   Cover *cover_;
+  COVER_CONTROL_FIELDS(COVER_FIELD_DECL_)
 };
+#undef COVER_CONTROL_FIELDS
 
-template<typename... Ts> class CoverPublishAction : public Action<Ts...> {
+// X-macro: (type, field_name, bit_index). Order/bits must match the
+// inline bitmask built in cover_template_publish_to_code in
+// template/cover/__init__.py: position=bit 0 (also set by CONF_STATE),
+// tilt=bit 1, current_operation=bit 2.
+#define COVER_PUBLISH_FIELDS(X) \
+  X(float, position, 0) \
+  X(float, tilt, 1) \
+  X(CoverOperation, current_operation, 2)
+
+template<uint16_t Fields, typename... Ts> class CoverPublishAction : public Action<Ts...> {
  public:
   CoverPublishAction(Cover *cover) : cover_(cover) {}
-  TEMPLATABLE_VALUE(float, position)
-  TEMPLATABLE_VALUE(float, tilt)
-  TEMPLATABLE_VALUE(CoverOperation, current_operation)
+
+#define COVER_PUBLISH_SETTER_(type, name, idx) \
+  template<typename V> void set_##name(V value) requires((Fields & (1 << (idx))) != 0) { this->name##_ = value; }
+#define COVER_PUBLISH_APPLY_(type, name, idx) \
+  if constexpr ((Fields & (1 << (idx))) != 0) \
+    this->cover_->name = this->name##_.value(x...);
+#define COVER_PUBLISH_DECL_(type, name, idx) \
+  [[no_unique_address]] std::conditional_t<(Fields & (1 << (idx))) != 0, TemplatableFn<type, Ts...>, \
+                                           cover_action_detail::Empty<(idx) + 8>> \
+      name##_{};
+
+  COVER_PUBLISH_FIELDS(COVER_PUBLISH_SETTER_)
 
   void play(const Ts &...x) override {
-    if (this->position_.has_value())
-      this->cover_->position = this->position_.value(x...);
-    if (this->tilt_.has_value())
-      this->cover_->tilt = this->tilt_.value(x...);
-    if (this->current_operation_.has_value())
-      this->cover_->current_operation = this->current_operation_.value(x...);
+    COVER_PUBLISH_FIELDS(COVER_PUBLISH_APPLY_)
     this->cover_->publish_state();
   }
 
  protected:
   Cover *cover_;
+  COVER_PUBLISH_FIELDS(COVER_PUBLISH_DECL_)
+
+#undef COVER_PUBLISH_DECL_
+#undef COVER_PUBLISH_APPLY_
+#undef COVER_PUBLISH_SETTER_
+#undef COVER_FIELD_DECL_
+#undef COVER_FIELD_APPLY_
+#undef COVER_FIELD_SETTER_
 };
+#undef COVER_PUBLISH_FIELDS
 
 template<bool OPEN, typename... Ts> class CoverPositionCondition : public Condition<Ts...> {
  public:

esphome/components/template/cover/__init__.py

@@ -128,7 +128,21 @@ async def to_code(config):
 )
 async def cover_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    # Bit positions must match COVER_PUBLISH_FIELDS in cover/automation.h.
+    # CONF_STATE and CONF_POSITION both map to set_position (bit 0).
+    field_mask = 0
+    if CONF_STATE in config or CONF_POSITION in config:
+        field_mask |= 1 << 0
+    if CONF_TILT in config:
+        field_mask |= 1 << 1
+    if CONF_CURRENT_OPERATION in config:
+        field_mask |= 1 << 2
+
+    publish_template_arg = cg.TemplateArguments(
+        cg.RawExpression(f"static_cast<uint16_t>({field_mask})"), *template_arg
+    )
+    var = cg.new_Pvariable(action_id, publish_template_arg, paren)
     if CONF_STATE in config:
         template_ = await cg.templatable(config[CONF_STATE], args, cg.float_)
         cg.add(var.set_position(template_))

tests/integration/fixtures/cover_control_action.yaml

@@ -0,0 +1,111 @@
+esphome:
+  name: cover-control-action-test
+host:
+api:
+logger:
+  level: DEBUG
+
+globals:
+  - id: test_position
+    type: float
+    initial_value: "0.42"
+
+cover:
+  - platform: template
+    name: "Test Cover"
+    id: test_cover
+    has_position: true
+    optimistic: true
+    assumed_state: true
+    open_action:
+      - cover.template.publish:
+          id: test_cover
+          position: 1.0
+    close_action:
+      - cover.template.publish:
+          id: test_cover
+          position: 0.0
+    stop_action:
+      - cover.template.publish:
+          id: test_cover
+          current_operation: IDLE
+    tilt_action:
+      - lambda: |-
+          // Manually set tilt and publish
+          id(test_cover).tilt = tilt;
+          id(test_cover).publish_state();
+
+button:
+  # Test 1: cover.control with position only (mask 0b010 = 2)
+  - platform: template
+    id: btn_position
+    name: "Set Position"
+    on_press:
+      - cover.control:
+          id: test_cover
+          position: 50%
+
+  # Test 2: cover.control with tilt only (mask 0b100 = 4)
+  - platform: template
+    id: btn_tilt
+    name: "Set Tilt"
+    on_press:
+      - cover.control:
+          id: test_cover
+          tilt: 75%
+
+  # Test 3: cover.control with position + tilt (mask 0b110 = 6)
+  - platform: template
+    id: btn_pos_tilt
+    name: "Set Pos Tilt"
+    on_press:
+      - cover.control:
+          id: test_cover
+          position: 25%
+          tilt: 30%
+
+  # Test 4: cover.control with state alias (sets position bit via CONF_STATE)
+  - platform: template
+    id: btn_open_state
+    name: "Open State"
+    on_press:
+      - cover.control:
+          id: test_cover
+          state: OPEN
+
+  # Test 5: cover.control with lambda position (exercises lambda path)
+  - platform: template
+    id: btn_lambda_position
+    name: "Lambda Position"
+    on_press:
+      - cover.control:
+          id: test_cover
+          position: !lambda "return id(test_position);"
+
+  # Test 6: cover.template.publish position only (mask 0b001)
+  - platform: template
+    id: btn_publish_pos
+    name: "Publish Pos"
+    on_press:
+      - cover.template.publish:
+          id: test_cover
+          position: 0.6
+
+  # Test 7: cover.template.publish current_operation only (mask 0b100)
+  - platform: template
+    id: btn_publish_op
+    name: "Publish Op"
+    on_press:
+      - cover.template.publish:
+          id: test_cover
+          current_operation: OPENING
+
+  # Test 8: cover.control with stop only (mask 0b001 = 1) — runs after
+  # Publish Op so we can verify current_operation transitions OPENING -> IDLE
+  - platform: template
+    id: btn_stop
+    name: "Stop Cover"
+    on_press:
+      - cover.control:
+          id: test_cover
+          stop: true

tests/integration/test_cover_control_action.py

@@ -0,0 +1,92 @@
+"""Integration test for cover ControlAction and CoverPublishAction.
+
+Tests that cover.control and cover.template.publish automation actions
+work correctly with the per-instance bitmask field storage. Exercises
+multiple field combinations to cover the bitmask variants.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from aioesphomeapi import ButtonInfo, CoverInfo, CoverState, EntityState
+import pytest
+
+from .state_utils import InitialStateHelper, require_entity
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_cover_control_action(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test cover ControlAction/CoverPublishAction with constants and lambdas."""
+    loop = asyncio.get_running_loop()
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        cover_state_future: asyncio.Future[CoverState] | None = None
+
+        def on_state(state: EntityState) -> None:
+            if (
+                isinstance(state, CoverState)
+                and cover_state_future is not None
+                and not cover_state_future.done()
+            ):
+                cover_state_future.set_result(state)
+
+        async def wait_for_cover_state(timeout: float = 5.0) -> CoverState:
+            nonlocal cover_state_future
+            cover_state_future = loop.create_future()
+            try:
+                return await asyncio.wait_for(cover_state_future, timeout)
+            finally:
+                cover_state_future = None
+
+        entities, _ = await client.list_entities_services()
+        initial_state_helper = InitialStateHelper(entities)
+        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
+        await initial_state_helper.wait_for_initial_states()
+
+        require_entity(entities, "test_cover", CoverInfo)
+
+        async def press_and_wait(name: str) -> CoverState:
+            btn = require_entity(entities, name.lower().replace(" ", "_"), ButtonInfo)
+            client.button_command(btn.key)
+            return await wait_for_cover_state()
+
+        # Test 1: position only (mask 2)
+        state = await press_and_wait("Set Position")
+        assert state.position == pytest.approx(0.5, abs=0.01)
+
+        # Test 2: tilt only (mask 4)
+        state = await press_and_wait("Set Tilt")
+        assert state.tilt == pytest.approx(0.75, abs=0.01)
+
+        # Test 3: position + tilt (mask 6)
+        state = await press_and_wait("Set Pos Tilt")
+        assert state.position == pytest.approx(0.25, abs=0.01)
+        assert state.tilt == pytest.approx(0.30, abs=0.01)
+
+        # Test 4: state: OPEN (CONF_STATE alias for position 1.0)
+        state = await press_and_wait("Open State")
+        assert state.position == pytest.approx(1.0, abs=0.01)
+
+        # Test 5: lambda position (test_position global = 0.42)
+        state = await press_and_wait("Lambda Position")
+        assert state.position == pytest.approx(0.42, abs=0.01)
+
+        # Test 6: cover.template.publish position only
+        state = await press_and_wait("Publish Pos")
+        assert state.position == pytest.approx(0.6, abs=0.01)
+
+        # Test 7: cover.template.publish current_operation only
+        state = await press_and_wait("Publish Op")
+        # CoverOperation.OPENING == 1
+        assert state.current_operation == 1
+
+        # Test 8: cover.control stop only (mask 1)
+        # The template cover's stop_action publishes current_operation: IDLE
+        state = await press_and_wait("Stop Cover")
+        # CoverOperation.IDLE == 0
+        assert state.current_operation == 0