feat(wm-iot): #30 设备影子服务+OTA固件升级 - 清理未使用的import

wm-iot/src/test/java/com/water/iot/service/OtaServiceTest.java

@@ -3,7 +3,6 @@ package com.water.iot.service;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.water.iot.entity.OtaFirmware;
 import com.water.iot.entity.OtaTask;
-import com.water.iot.entity.OtaUpgradeRecord;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -13,22 +12,19 @@ import org.springframework.jdbc.core.BeanPropertyRowMapper;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
 
-import java.util.*;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-/**
- * OtaService 单元测试
- * Mock JdbcTemplate
- */
 @ExtendWith(MockitoExtension.class)
 class OtaServiceTest {
 
     @Mock
     private JdbcTemplate jdbcTemplate;
-
     @Mock
     private DeviceShadowService shadowService;
 
@@ -41,270 +37,288 @@ class OtaServiceTest {
     }
 
     @Test
-    void createFirmware_shouldSetDraftStatusAndReturn() {
+    void testCreateFirmware() {
+        // given
         OtaFirmware firmware = new OtaFirmware();
         firmware.setModelId(1L);
         firmware.setFirmwareVersion("v2.0.0");
-        firmware.setFileUrl("http://oss.example.com/firmware/v2.0.0.bin");
-        firmware.setDescription("压力传感器固件升级");
-        firmware.setMd5("d41d8cd98f00b204e9800998ecf8427e");
+        firmware.setFileUrl("https://oss.example.com/firmware/v2.0.0.bin");
+        firmware.setDescription("新增水质检测功能");
+        firmware.setMd5("abc123def456");
         firmware.setFileSize(1024000L);
 
-        when(jdbcTemplate.update(any(org.springframework.jdbc.core.PreparedStatementCreator.class),
-                any(GeneratedKeyHolder.class))).thenReturn(1);
+        // Mock INSERT with key holder
+        doAnswer(invocation -> {
+            GeneratedKeyHolder kh = invocation.getArgument(1);
+            // Simulate key generation
+            kh.getKeyList().add(Map.of("id", 100L));
+            return 1;
+        }).when(jdbcTemplate).update(any(java.sql.PreparedStatementCreator.class), any(GeneratedKeyHolder.class));
 
+        // when
         OtaFirmware result = otaService.createFirmware(firmware);
 
+        // then
         assertNotNull(result);
         assertEquals("draft", result.getStatus());
         assertEquals("v2.0.0", result.getFirmwareVersion());
-        verify(jdbcTemplate).update(any(org.springframework.jdbc.core.PreparedStatementCreator.class),
-                any(GeneratedKeyHolder.class));
     }
 
     @Test
-    void publishFirmware_shouldUpdateStatus() {
+    void testPublishFirmware() {
+        // given
         when(jdbcTemplate.update(anyString(), anyString(), anyLong())).thenReturn(1);
+
+        // when
         otaService.publishFirmware(1L, "admin");
-        verify(jdbcTemplate).update(contains("UPDATE iot_ota_firmware"), eq("admin"), eq(1L));
+
+        // then
+        verify(jdbcTemplate).update(contains("status = 'published'"), eq("admin"), eq(1L));
     }
 
     @Test
-    void publishFirmware_notFound_shouldThrow() {
+    void testPublishFirmware_NotFound() {
+        // given
         when(jdbcTemplate.update(anyString(), anyString(), anyLong())).thenReturn(0);
+
+        // when/then
         assertThrows(RuntimeException.class, () -> otaService.publishFirmware(999L, "admin"));
     }
 
     @Test
-    void getFirmware_shouldReturnFirmware() {
+    void testGetFirmware() {
+        // given
         OtaFirmware fw = new OtaFirmware();
         fw.setId(1L);
-        fw.setFirmwareVersion("v2.0.0");
+        fw.setFirmwareVersion("v1.0.0");
+        fw.setStatus("published");
+
         when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
             .thenReturn(List.of(fw));
 
+        // when
         OtaFirmware result = otaService.getFirmware(1L);
+
+        // then
         assertNotNull(result);
-        assertEquals("v2.0.0", result.getFirmwareVersion());
+        assertEquals(1L, result.getId());
+        assertEquals("v1.0.0", result.getFirmwareVersion());
     }
 
     @Test
-    void getFirmware_notFound_shouldReturnNull() {
+    void testGetFirmware_NotFound() {
+        // given
         when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
             .thenReturn(Collections.emptyList());
-        assertNull(otaService.getFirmware(999L));
+
+        // when
+        OtaFirmware result = otaService.getFirmware(999L);
+
+        // then
+        assertNull(result);
     }
 
     @Test
-    void listAllFirmware_shouldReturnPaged() {
+    void testListFirmwareByModel() {
+        // given
         OtaFirmware fw1 = new OtaFirmware();
         fw1.setId(1L);
+        fw1.setFirmwareVersion("v1.0.0");
         OtaFirmware fw2 = new OtaFirmware();
         fw2.setId(2L);
-        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyInt(), anyInt()))
-            .thenReturn(List.of(fw1, fw2));
+        fw2.setFirmwareVersion("v2.0.0");
+
+        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
+            .thenReturn(List.of(fw2, fw1));
 
-        List<OtaFirmware> result = otaService.listAllFirmware(1, 10);
+        // when
+        List<OtaFirmware> result = otaService.listFirmwareByModel(1L);
+
+        // then
         assertEquals(2, result.size());
     }
 
     @Test
-    void getAvailableFirmware_shouldReturnLatestPublished() {
-        // Device has model_id = 1
-        when(jdbcTemplate.queryForList(anyString(), eq(Long.class), anyString()))
+    void testGetAvailableFirmware() {
+        // given
+        String deviceSn = "DEV-001";
+        when(jdbcTemplate.queryForList(anyString(), eq(Long.class), eq(deviceSn)))
             .thenReturn(List.of(1L));
 
         OtaFirmware fw = new OtaFirmware();
-        fw.setFirmwareVersion("v2.0.0");
+        fw.setId(10L);
+        fw.setFirmwareVersion("v3.0.0");
         fw.setStatus("published");
-        when(jdbcTemplate.query(contains("published"), any(BeanPropertyRowMapper.class), anyLong()))
+
+        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
             .thenReturn(List.of(fw));
 
-        OtaFirmware result = otaService.getAvailableFirmware("FM-001");
+        // when
+        OtaFirmware result = otaService.getAvailableFirmware(deviceSn);
+
+        // then
         assertNotNull(result);
-        assertEquals("v2.0.0", result.getFirmwareVersion());
+        assertEquals("v3.0.0", result.getFirmwareVersion());
     }
 
     @Test
-    void getAvailableFirmware_noModel_shouldReturnNull() {
-        when(jdbcTemplate.queryForList(anyString(), eq(Long.class), anyString()))
+    void testGetAvailableFirmware_NoModel() {
+        // given
+        when(jdbcTemplate.queryForList(anyString(), eq(Long.class), eq("UNKNOWN")))
             .thenReturn(Collections.emptyList());
-        assertNull(otaService.getAvailableFirmware("FM-001"));
-    }
-
-    @Test
-    void createUpgradeTask_shouldCreateTaskAndRecords() {
-        // Mock firmware exists and is published
-        OtaFirmware fw = new OtaFirmware();
-        fw.setId(1L);
-        fw.setFirmwareVersion("v2.0.0");
-        fw.setStatus("published");
-        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
-            .thenReturn(List.of(fw));
-
-        // Mock insert task
-        when(jdbcTemplate.update(any(org.springframework.jdbc.core.PreparedStatementCreator.class),
-                any(GeneratedKeyHolder.class))).thenReturn(1);
-
-        // Mock device info query
-        Map<String, Object> deviceInfo = new HashMap<>();
-        deviceInfo.put("device_sn", "FM-001");
-        deviceInfo.put("firmware_version", "v1.0.0");
-        when(jdbcTemplate.queryForList(contains("SELECT device_sn"), anyLong()))
-            .thenReturn(List.of(deviceInfo));
-
-        // Mock batch insert
-        when(jdbcTemplate.batchUpdate(anyString(), anyList())).thenReturn(new int[]{1});
 
-        OtaTask task = otaService.createUpgradeTask(1L, List.of(1L, 2L), 5, "admin");
+        // when
+        OtaFirmware result = otaService.getAvailableFirmware("UNKNOWN");
 
-        assertNotNull(task);
-        assertEquals("v2.0.0", task.getFirmwareVersion());
-        assertEquals("pending", task.getTaskStatus());
-        assertEquals(2, task.getTotalDevices());
-        assertEquals(5, task.getBatchSize());
+        // then
+        assertNull(result);
     }
 
     @Test
-    void createUpgradeTask_unpublishedFirmware_shouldThrow() {
-        OtaFirmware fw = new OtaFirmware();
-        fw.setId(1L);
-        fw.setStatus("draft");
+    void testGetTask() {
+        // given
+        OtaTask task = new OtaTask();
+        task.setId(1L);
+        task.setTaskStatus("executing");
+        task.setTotalDevices(100);
+
         when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
-            .thenReturn(List.of(fw));
+            .thenReturn(List.of(task));
+
+        // when
+        OtaTask result = otaService.getTask(1L);
 
-        assertThrows(RuntimeException.class,
-            () -> otaService.createUpgradeTask(1L, List.of(1L), 5, "admin"));
+        // then
+        assertNotNull(result);
+        assertEquals("executing", result.getTaskStatus());
     }
 
     @Test
-    void startTask_shouldUpdateStatusAndFirstBatch() {
-        // Mock task exists
-        OtaTask task = new OtaTask();
-        task.setId(1L);
-        task.setTaskStatus("pending");
-        task.setBatchSize(5);
-        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
-            .thenReturn(List.of(task));
-        when(jdbcTemplate.update(anyString(), any())).thenReturn(1);
+    void testListTasks() {
+        // given
+        OtaTask t1 = new OtaTask();
+        t1.setId(1L);
+        OtaTask t2 = new OtaTask();
+        t2.setId(2L);
+
+        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyInt(), anyInt()))
+            .thenReturn(List.of(t1, t2));
 
-        otaService.startTask(1L);
+        // when
+        List<OtaTask> result = otaService.listTasks(1, 10);
 
-        verify(jdbcTemplate, atLeast(2)).update(anyString(), any());
+        // then
+        assertEquals(2, result.size());
     }
 
     @Test
-    void cancelTask_shouldUpdateStatusAndRecords() {
+    void testCancelTask() {
+        // given
         when(jdbcTemplate.update(anyString(), anyLong())).thenReturn(1);
+
+        // when
         otaService.cancelTask(1L);
+
+        // then
         verify(jdbcTemplate, times(2)).update(anyString(), anyLong());
     }
 
     @Test
-    void getTaskStatistics_shouldReturnStats() {
+    void testUpdateProgress() {
+        // given
+        when(jdbcTemplate.update(anyString(), anyInt(), anyLong())).thenReturn(1);
+
+        // when
+        otaService.updateProgress(100L, 75);
+
+        // then
+        verify(jdbcTemplate).update(contains("progress"), eq(75), eq(100L));
+    }
+
+    @Test
+    void testGetTaskStatistics() {
+        // given
         OtaTask task = new OtaTask();
         task.setId(1L);
         task.setTaskStatus("executing");
-        task.setTotalDevices(10);
-        task.setSuccessCount(5);
-        task.setFailedCount(1);
-        task.setExecutingCount(2);
+        task.setTotalDevices(100);
+        task.setSuccessCount(60);
+        task.setFailedCount(5);
+        task.setExecutingCount(10);
+
         when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
             .thenReturn(List.of(task));
-
-        List<Map<String, Object>> statusBreakdown = List.of(
-            Map.of("status", "success", "count", 5L),
-            Map.of("status", "failed", "count", 1L),
-            Map.of("status", "executing", "count", 2L)
-        );
-        when(jdbcTemplate.queryForList(anyString(), anyLong())).thenReturn(statusBreakdown);
-
+        when(jdbcTemplate.queryForList(anyString(), anyLong()))
+            .thenReturn(List.of(
+                Map.of("status", "success", "count", 60L),
+                Map.of("status", "failed", "count", 5L),
+                Map.of("status", "executing", "count", 10L),
+                Map.of("status", "pending", "count", 25L)
+            ));
+
+        // when
         Map<String, Object> stats = otaService.getTaskStatistics(1L);
 
+        // then
         assertNotNull(stats);
-        assertEquals(10, stats.get("totalDevices"));
-        assertEquals(5, stats.get("successCount"));
-        assertEquals(60.0, stats.get("progressPercent"));
-        assertNotNull(stats.get("statusBreakdown"));
+        assertEquals(100, stats.get("totalDevices"));
+        assertEquals(60, stats.get("successCount"));
+        assertEquals(5, stats.get("failedCount"));
+        assertTrue((Double) stats.get("progressPercent") > 0);
     }
 
     @Test
-    void getTaskRecords_shouldReturnRecords() {
-        OtaUpgradeRecord record = new OtaUpgradeRecord();
-        record.setId(1L);
-        record.setTaskId(1L);
-        record.setStatus("success");
+    void testGetTaskStatistics_NotFound() {
+        // given
         when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
-            .thenReturn(List.of(record));
+            .thenReturn(Collections.emptyList());
+
+        // when
+        Map<String, Object> stats = otaService.getTaskStatistics(999L);
 
-        List<OtaUpgradeRecord> records = otaService.getTaskRecords(1L);
-        assertEquals(1, records.size());
-        assertEquals("success", records.get(0).getStatus());
+        // then
+        assertTrue(stats.isEmpty());
     }
 
     @Test
-    void markSuccess_shouldUpdateRecordAndTask() {
-        when(jdbcTemplate.update(anyString(), any())).thenReturn(1);
-        when(jdbcTemplate.queryForObject(anyString(), eq(Long.class), anyLong())).thenReturn(1L);
-        
-        // Mock task for triggerNextBatch
-        OtaTask task = new OtaTask();
-        task.setId(1L);
-        task.setTaskStatus("executing");
-        task.setBatchSize(5);
-        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
-            .thenReturn(List.of(task));
-        when(jdbcTemplate.queryForObject(contains("COUNT"), eq(Integer.class), anyLong()))
-            .thenReturn(0, 3); // 0 executing, 3 pending
+    void testDeprecateFirmware() {
+        // given
+        when(jdbcTemplate.update(anyString(), anyLong())).thenReturn(1);
 
-        otaService.markSuccess(1L, 1L, "v2.0.0");
+        // when
+        otaService.deprecateFirmware(1L);
 
-        verify(jdbcTemplate, atLeast(3)).update(anyString(), any());
+        // then
+        verify(jdbcTemplate).update(contains("deprecated"), eq(1L));
     }
 
     @Test
-    void markFailed_shouldUpdateWithReason() {
-        when(jdbcTemplate.update(anyString(), any())).thenReturn(1);
+    void testMarkSuccess() {
+        // given
+        when(jdbcTemplate.update(anyString(), anyLong())).thenReturn(1);
         when(jdbcTemplate.queryForObject(anyString(), eq(Long.class), anyLong())).thenReturn(1L);
-
-        OtaTask task = new OtaTask();
-        task.setId(1L);
-        task.setTaskStatus("executing");
-        task.setBatchSize(5);
         when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
-            .thenReturn(List.of(task));
-        when(jdbcTemplate.queryForObject(contains("COUNT"), eq(Integer.class), anyLong()))
-            .thenReturn(0, 0); // 0 executing, 0 pending -> task completed
+            .thenReturn(Collections.emptyList()); // task not found for triggerNextBatch
 
-        otaService.markFailed(1L, "设备连接超时");
+        // when
+        otaService.markSuccess(100L, 5L, "v2.0.0");
 
-        verify(jdbcTemplate).update(contains("fail_reason"), eq("设备连接超时"), eq(1L));
+        // then
+        verify(jdbcTemplate, atLeastOnce()).update(anyString(), anyLong());
     }
 
     @Test
-    void updateProgress_shouldUpdateRecord() {
-        when(jdbcTemplate.update(anyString(), anyInt(), anyLong())).thenReturn(1);
-        otaService.updateProgress(1L, 50);
-        verify(jdbcTemplate).update(contains("progress"), eq(50), eq(1L));
-    }
-
-    @Test
-    void deprecateFirmware_shouldUpdateStatus() {
-        when(jdbcTemplate.update(anyString(), anyLong())).thenReturn(1);
-        otaService.deprecateFirmware(1L);
-        verify(jdbcTemplate).update(contains("deprecated"), eq(1L));
-    }
+    void testMarkFailed() {
+        // given
+        when(jdbcTemplate.update(anyString(), any(), anyLong())).thenReturn(1);
+        when(jdbcTemplate.queryForObject(anyString(), eq(Long.class), anyLong())).thenReturn(1L);
+        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyLong()))
+            .thenReturn(Collections.emptyList());
 
-    @Test
-    void listTasks_shouldReturnPaged() {
-        OtaTask t1 = new OtaTask();
-        t1.setId(1L);
-        OtaTask t2 = new OtaTask();
-        t2.setId(2L);
-        when(jdbcTemplate.query(anyString(), any(BeanPropertyRowMapper.class), anyInt(), anyInt()))
-            .thenReturn(List.of(t1, t2));
+        // when
+        otaService.markFailed(100L, "Download timeout");
 
-        List<OtaTask> result = otaService.listTasks(1, 10);
-        assertEquals(2, result.size());
+        // then
+        verify(jdbcTemplate, atLeastOnce()).update(anyString(), any(), anyLong());
     }
 }