test(P1): 新增3个测试类覆盖动态消费者基类与子类

- AbstractDynamicMqttConsumerTest: 4个测试覆盖 deepCopyMap（null/深拷贝/嵌套/List）
- MqttDynamicConsumerTest: 6个测试覆盖 fetchTopics + insertredis
- MqttChargeStationConsumerTest: 4个测试覆盖 fetchTopics（配置/null/空白/trim）
- 测试总数 65→79，JaCoCo覆盖率 18%→25%

iot-platform/src/test/java/com/iot/platform/mqtt/AbstractDynamicMqttConsumerTest.java

@@ -0,0 +1,105 @@
+package com.iot.platform.mqtt;
+
+import com.iot.platform.config.IotProperties;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(MockitoExtension.class)
+class AbstractDynamicMqttConsumerTest {
+
+    @Mock
+    private IotProperties iotProperties;
+
+    private TestDynamicConsumer consumer;
+
+    @BeforeEach
+    void setUp() {
+        ScheduledExecutorService coreExecutor = Executors.newSingleThreadScheduledExecutor();
+        ExecutorService writeExecutor = Executors.newSingleThreadExecutor();
+        consumer = new TestDynamicConsumer(iotProperties, coreExecutor, writeExecutor);
+    }
+
+    @Test
+    @DisplayName("deepCopyMap: null 输入应返回空 Map")
+    void deepCopyMap_nullInput_returnsEmptyMap() {
+        Map<String, Object> result = consumer.deepCopyMap(null);
+        assertThat(result).isNotNull().isEmpty();
+    }
+
+    @Test
+    @DisplayName("deepCopyMap: 应返回深拷贝，修改副本不影响原图")
+    void deepCopyMap_returnsDeepCopy() {
+        Map<String, Object> original = new HashMap<>();
+        original.put("key1", "value1");
+        original.put("key2", 42);
+
+        Map<String, Object> copy = consumer.deepCopyMap(original);
+
+        assertThat(copy).containsExactlyInAnyOrderEntriesOf(original);
+        copy.put("key1", "modified");
+        assertThat(original.get("key1")).isEqualTo("value1");
+    }
+
+    @Test
+    @DisplayName("deepCopyMap: 应处理嵌套 Map")
+    void deepCopyMap_nestedMap_returnsDeepCopy() {
+        Map<String, Object> inner = new HashMap<>();
+        inner.put("innerKey", "innerValue");
+
+        Map<String, Object> original = new HashMap<>();
+        original.put("nested", inner);
+
+        Map<String, Object> copy = consumer.deepCopyMap(original);
+
+        assertThat(copy).containsKey("nested");
+        @SuppressWarnings("unchecked")
+        Map<String, Object> copiedInner = (Map<String, Object>) copy.get("nested");
+        copiedInner.put("innerKey", "modified");
+        assertThat(inner.get("innerKey")).isEqualTo("innerValue");
+    }
+
+    @Test
+    @DisplayName("deepCopyMap: 应处理包含 List 的 Map")
+    void deepCopyMap_withList_returnsDeepCopy() {
+        Map<String, Object> original = new HashMap<>();
+        original.put("list", Arrays.asList("a", "b", "c"));
+
+        Map<String, Object> copy = consumer.deepCopyMap(original);
+
+        assertThat(copy).containsKey("list");
+        @SuppressWarnings("unchecked")
+        List<String> copiedList = (List<String>) copy.get("list");
+        assertThat(copiedList).containsExactly("a", "b", "c");
+    }
+
+    /**
+     * 用于测试的匿名实现
+     */
+    static class TestDynamicConsumer extends AbstractDynamicMqttConsumer {
+        TestDynamicConsumer(IotProperties iotProperties,
+                            ScheduledExecutorService coreExecutor,
+                            ExecutorService writeExecutor) {
+            super(iotProperties, coreExecutor, writeExecutor);
+        }
+
+        @Override
+        protected List<String> fetchTopics() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        protected void processMessage(String content, String topic) {
+        }
+    }
+}

iot-platform/src/test/java/com/iot/platform/mqtt/MqttChargeStationConsumerTest.java

@@ -0,0 +1,86 @@
+package com.iot.platform.mqtt;
+
+import com.iot.platform.config.IotProperties;
+import com.iot.platform.service.TDengineService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MqttChargeStationConsumerTest {
+
+    @Mock
+    private IotProperties iotProperties;
+
+    @Mock
+    private IotProperties.Mqtt mqtt;
+
+    @Mock
+    private TDengineService tdengineService;
+
+    private MqttChargeStationConsumer consumer;
+
+    @BeforeEach
+    void setUp() {
+        ScheduledExecutorService coreExecutor = Executors.newSingleThreadScheduledExecutor();
+        ExecutorService writeExecutor = Executors.newSingleThreadExecutor();
+        consumer = new MqttChargeStationConsumer(iotProperties, coreExecutor, writeExecutor, tdengineService);
+    }
+
+    @Test
+    @DisplayName("fetchTopics: 应返回配置的 chargeStationTopic")
+    void fetchTopics_withConfiguredTopic_returnsTopicList() {
+        when(iotProperties.getMqtt()).thenReturn(mqtt);
+        when(mqtt.getChargeStationTopic()).thenReturn("station/ChargeStation/device/+/post/json");
+
+        List<String> result = consumer.fetchTopics();
+
+        assertThat(result).containsExactly("station/ChargeStation/device/+/post/json");
+    }
+
+    @Test
+    @DisplayName("fetchTopics: topic 为 null 时应返回空列表")
+    void fetchTopics_nullTopic_returnsEmptyList() {
+        when(iotProperties.getMqtt()).thenReturn(mqtt);
+        when(mqtt.getChargeStationTopic()).thenReturn(null);
+
+        List<String> result = consumer.fetchTopics();
+
+        assertThat(result).isEmpty();
+    }
+
+    @Test
+    @DisplayName("fetchTopics: topic 为空字符串时应返回空列表")
+    void fetchTopics_emptyTopic_returnsEmptyList() {
+        when(iotProperties.getMqtt()).thenReturn(mqtt);
+        when(mqtt.getChargeStationTopic()).thenReturn("   ");
+
+        List<String> result = consumer.fetchTopics();
+
+        assertThat(result).isEmpty();
+    }
+
+    @Test
+    @DisplayName("fetchTopics: topic 应被 trim 处理")
+    void fetchTopics_trimmedTopic_returnsTrimmedList() {
+        when(iotProperties.getMqtt()).thenReturn(mqtt);
+        when(mqtt.getChargeStationTopic()).thenReturn("  station/test  ");
+
+        List<String> result = consumer.fetchTopics();
+
+        assertThat(result).containsExactly("station/test");
+    }
+}

iot-platform/src/test/java/com/iot/platform/mqtt/MqttDynamicConsumerTest.java

@@ -0,0 +1,138 @@
+package com.iot.platform.mqtt;
+
+import com.iot.platform.config.IotProperties;
+import com.iot.platform.domain.SysController;
+import com.iot.platform.service.SysControllerService;
+import com.iot.platform.service.TDengineService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.redis.core.HashOperations;
+import org.springframework.data.redis.core.SetOperations;
+import org.springframework.data.redis.core.StringRedisTemplate;
+
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MqttDynamicConsumerTest {
+
+    @Mock
+    private IotProperties iotProperties;
+
+    @Mock
+    private SysControllerService sysControllerService;
+
+    @Mock
+    private TDengineService tdengineService;
+
+    @Mock
+    private StringRedisTemplate stringRedisTemplate;
+
+    @Mock
+    private HashOperations<String, Object, Object> hashOperations;
+
+    @Mock
+    private SetOperations<String, String> setOperations;
+
+    private MqttDynamicConsumer consumer;
+
+    @BeforeEach
+    void setUp() {
+        ScheduledExecutorService coreExecutor = Executors.newSingleThreadScheduledExecutor();
+        ExecutorService writeExecutor = Executors.newSingleThreadExecutor();
+        consumer = new MqttDynamicConsumer(iotProperties, coreExecutor, writeExecutor,
+                sysControllerService, tdengineService, stringRedisTemplate);
+    }
+
+    @Test
+    @DisplayName("fetchTopics 应返回 sysControllerService.selectall() 的结果")
+    void fetchTopics_delegatesToService() {
+        List<String> expected = Arrays.asList("topic/1", "topic/2");
+        when(sysControllerService.selectall()).thenReturn(expected);
+
+        List<String> result = consumer.fetchTopics();
+
+        assertThat(result).isEqualTo(expected);
+        verify(sysControllerService).selectall();
+    }
+
+    @Test
+    @DisplayName("fetchTopics 应处理 null 返回值")
+    void fetchTopics_nullReturn_returnsNull() {
+        when(sysControllerService.selectall()).thenReturn(null);
+
+        List<String> result = consumer.fetchTopics();
+
+        assertThat(result).isNull();
+    }
+
+    @Test
+    @DisplayName("insertredis: 应写入 Redis hash 和 active devices set")
+    void insertredis_validData_writesToRedis() throws Exception {
+        when(stringRedisTemplate.opsForHash()).thenReturn(hashOperations);
+        when(stringRedisTemplate.opsForSet()).thenReturn(setOperations);
+
+        SysController controller = new SysController();
+        controller.setName("temperature");
+        when(sysControllerService.selectcontrollerpath("ctrl1/temperature")).thenReturn(controller);
+
+        Map<String, Object> weather = new HashMap<>();
+        weather.put("timestamp", "1234567890");
+        weather.put("device_id", "dev001");
+        Map<String, Object> metricData = new HashMap<>();
+        metricData.put("val", "25.5");
+        weather.put("temperature", metricData);
+
+        consumer.insertredis(weather, "ctrl1/temperature");
+
+        verify(hashOperations).putAll(eq("DSB:ctrl1:temperature"), anyMap());
+        verify(stringRedisTemplate).expire("DSB:ctrl1:temperature", 2, TimeUnit.HOURS);
+        verify(setOperations).add("DSB:active:devices", "DSB:ctrl1:temperature");
+        verify(stringRedisTemplate).expire("DSB:active:devices", 2, TimeUnit.HOURS);
+    }
+
+    @Test
+    @DisplayName("insertredis: topic 格式无效时应直接返回")
+    void insertredis_invalidTopic_returnsSilently() throws Exception {
+        consumer.insertredis(new HashMap<>(), "invalidtopic");
+
+        verifyNoInteractions(stringRedisTemplate);
+    }
+
+    @Test
+    @DisplayName("insertredis: controller 未找到时应直接返回")
+    void insertredis_controllerNotFound_returnsSilently() throws Exception {
+        when(sysControllerService.selectcontrollerpath("ctrl1/missing")).thenReturn(null);
+
+        Map<String, Object> weather = new HashMap<>();
+        consumer.insertredis(weather, "ctrl1/missing");
+
+        verifyNoInteractions(stringRedisTemplate);
+    }
+
+    @Test
+    @DisplayName("insertredis: metricData 为 null 时应直接返回")
+    void insertredis_nullMetricData_returnsSilently() throws Exception {
+        SysController controller = new SysController();
+        controller.setName("temperature");
+        when(sysControllerService.selectcontrollerpath("ctrl1/temperature")).thenReturn(controller);
+
+        Map<String, Object> weather = new HashMap<>();
+        weather.put("temperature", null);
+
+        consumer.insertredis(weather, "ctrl1/temperature");
+
+        verifyNoInteractions(stringRedisTemplate);
+    }
+}