tests

tests/integration/fixtures/external_components/loop_test_component/__init__.py

@@ -0,0 +1,19 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@esphome/tests"]
+
+loop_test_component_ns = cg.esphome_ns.namespace("loop_test_component")
+LoopTestComponent = loop_test_component_ns.class_("LoopTestComponent", cg.Component)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(LoopTestComponent),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)

tests/integration/fixtures/external_components/loop_test_component/loop_test_component.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+
+namespace esphome {
+namespace loop_test_component {
+
+static const char *const TAG = "loop_test_component";
+
+class LoopTestComponent : public Component {
+ public:
+  void setup() override {
+    ESP_LOGI(TAG, "LoopTestComponent setup()");
+    this->loop_count_ = 0;
+    this->setup_disable_count_ = 0;
+    this->setup_enable_count_ = 0;
+
+    // Test 1: Try to disable/enable in setup (before calculate_looping_components_)
+    ESP_LOGI(TAG, "Test 1: Disable in setup");
+    this->disable_loop();
+    this->setup_disable_count_++;
+
+    ESP_LOGI(TAG, "Test 1: Enable in setup");
+    this->enable_loop();
+    this->setup_enable_count_++;
+  }
+
+  void loop() override {
+    this->loop_count_++;
+
+    if (this->loop_count_ <= 10 || this->loop_count_ % 10 == 0) {
+      ESP_LOGI(TAG, "Loop count: %d", this->loop_count_);
+    }
+
+    // Test 2: Disable after 50 loops
+    if (this->loop_count_ == 50) {
+      ESP_LOGI(TAG, "Test 2: Disabling loop after 50 iterations");
+      this->disable_loop();
+      this->loop_disable_count_++;
+    }
+
+    // This should not happen
+    if (this->loop_count_ > 50 && this->loop_count_ < 100) {
+      ESP_LOGE(TAG, "ERROR: Loop called after disable! Count: %d", this->loop_count_);
+    }
+
+    // Test 3: Re-enable after being disabled (shouldn't get here)
+    if (this->loop_count_ == 75) {
+      ESP_LOGE(TAG, "ERROR: This code should never execute!");
+      this->enable_loop();
+    }
+  }
+
+  // For testing from outside
+  void test_enable_from_outside() {
+    ESP_LOGI(TAG, "Test 3: Enabling from outside call");
+    this->enable_loop();
+    this->external_enable_count_++;
+  }
+
+  void test_disable_from_outside() {
+    ESP_LOGI(TAG, "Test 4: Disabling from outside call");
+    this->disable_loop();
+    this->external_disable_count_++;
+  }
+
+  // Getters for test validation
+  int get_loop_count() const { return this->loop_count_; }
+  int get_setup_disable_count() const { return this->setup_disable_count_; }
+  int get_setup_enable_count() const { return this->setup_enable_count_; }
+  int get_loop_disable_count() const { return this->loop_disable_count_; }
+  int get_external_enable_count() const { return this->external_enable_count_; }
+  int get_external_disable_count() const { return this->external_disable_count_; }
+
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+ protected:
+  int loop_count_{0};
+  int setup_disable_count_{0};
+  int setup_enable_count_{0};
+  int loop_disable_count_{0};
+  int external_enable_count_{0};
+  int external_disable_count_{0};
+};
+
+}  // namespace loop_test_component
+}  // namespace esphome

tests/integration/fixtures/external_components/loop_test_component/sensor.py

@@ -0,0 +1,63 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, ENTITY_CATEGORY_DIAGNOSTIC, STATE_CLASS_MEASUREMENT
+
+from . import LoopTestComponent
+
+DEPENDENCIES = ["loop_test_component"]
+
+CONF_LOOP_COUNT = "loop_count"
+CONF_SETUP_DISABLE_COUNT = "setup_disable_count"
+CONF_SETUP_ENABLE_COUNT = "setup_enable_count"
+CONF_LOOP_DISABLE_COUNT = "loop_disable_count"
+CONF_EXTERNAL_ENABLE_COUNT = "external_enable_count"
+CONF_EXTERNAL_DISABLE_COUNT = "external_disable_count"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(LoopTestComponent),
+        cv.Optional(CONF_LOOP_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_SETUP_DISABLE_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_SETUP_ENABLE_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_LOOP_DISABLE_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_EXTERNAL_ENABLE_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+        cv.Optional(CONF_EXTERNAL_DISABLE_COUNT): sensor.sensor_schema(
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        ),
+    }
+)
+
+
+async def to_code(config):
+    parent = await cg.get_variable(config[CONF_ID])
+
+    if CONF_LOOP_COUNT in config:
+        sens = await sensor.new_sensor(config[CONF_LOOP_COUNT])
+        cg.add(
+            parent.set_loop_count_sensor(sens)
+        )  # We'll implement this in the component
+
+    # For simplicity, let's just expose loop_count for now in the test