[Connector-V2] adjust the format of TDengineSinkWriterTest

Author: jia zhang

seatunnel-connectors-v2/connector-tdengine/src/test/java/org/apache/seatunnel/connectors/seatunnel/tdengine/sink/TDengineSinkWriterTest.java

@@ -18,33 +18,31 @@
 
 package org.apache.seatunnel.connectors.seatunnel.tdengine.sink;
 
+import org.apache.seatunnel.shade.com.typesafe.config.Config;
+import org.apache.seatunnel.shade.com.typesafe.config.ConfigFactory;
+import org.apache.seatunnel.shade.com.typesafe.config.ConfigValueFactory;
 
-import lombok.SneakyThrows;
 import org.apache.seatunnel.api.table.type.BasicType;
 import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
 import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
-import org.apache.seatunnel.shade.com.typesafe.config.Config;
-import org.apache.seatunnel.shade.com.typesafe.config.ConfigFactory;
-import org.apache.seatunnel.shade.com.typesafe.config.ConfigValueFactory;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import java.lang.reflect.InvocationTargetException;
-import java.time.LocalDateTime;
-
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
+
+import lombok.SneakyThrows;
+
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.ResultSet;
 import java.sql.Statement;
+import java.time.LocalDateTime;
 import java.util.TimeZone;
 
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.mockStatic;
-import static org.mockito.Mockito.when;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
-public class TDengineSinkWriterTest {
+static class TDengineSinkWriterTest {
     TDengineSinkWriter writer;
 
     @SneakyThrows
@@ -53,18 +51,19 @@ public void setup() {
         SeaTunnelRowType rowType;
         Config config;
         TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
-        String[] fieldNames = new String[]{"id", "name", "description", "weight"};
+        String[] fieldNames = new String[] {"id", "name", "description", "weight"};
         SeaTunnelDataType<?>[] dataTypes =
-                new SeaTunnelDataType[]{
-                        BasicType.LONG_TYPE,
-                        BasicType.STRING_TYPE,
-                        BasicType.STRING_TYPE,
-                        BasicType.STRING_TYPE,
+                new SeaTunnelDataType[] {
+                    BasicType.LONG_TYPE,
+                    BasicType.STRING_TYPE,
+                    BasicType.STRING_TYPE,
+                    BasicType.STRING_TYPE,
                 };
         rowType = new SeaTunnelRowType(fieldNames, dataTypes);
         config =
                 ConfigFactory.empty()
-                        .withValue("url", ConfigValueFactory.fromAnyRef("jdbc:TAOS://localhost:6030/"))
+                        .withValue(
+                                "url", ConfigValueFactory.fromAnyRef("jdbc:TAOS://localhost:6030/"))
                         .withValue("database", ConfigValueFactory.fromAnyRef("test_db"))
                         .withValue("stable", ConfigValueFactory.fromAnyRef("test_stable"))
                         .withValue("username", ConfigValueFactory.fromAnyRef("root"))
@@ -77,41 +76,44 @@ public void setup() {
         ResultSet mockResultSet = Mockito.mock(ResultSet.class);
 
         // Mock ResultSet behavior
-        when(mockResultSet.next()).thenReturn(true, false); // First call returns true, second call returns false
-        when(mockResultSet.getString("note")).thenReturn("TAG");
+        Mockito.when(mockResultSet.next())
+                .thenReturn(true, false); // First call returns true, second call returns false
+        Mockito.when(mockResultSet.getString("note")).thenReturn("TAG");
 
         // Mock Statement behavior
-        when(mockStatement.executeQuery("desc test_db.test_stable")).thenReturn(mockResultSet);
+        Mockito.when(mockStatement.executeQuery("desc test_db.test_stable"))
+                .thenReturn(mockResultSet);
 
         // Mock Connection behavior
-        when(mockConnection.createStatement()).thenReturn(mockStatement);
+        Mockito.when(mockConnection.createStatement()).thenReturn(mockStatement);
 
-        // Mock DriverManager behavior
-        try (MockedStatic<DriverManager> mockedStatic = mockStatic(DriverManager.class)) {
-            mockedStatic.when(() -> DriverManager.getConnection(anyString())).thenReturn(mockConnection);
+        try (MockedStatic<DriverManager> mockedStatic = Mockito.mockStatic(DriverManager.class)) {
+            Mockito.when(DriverManager.getConnection(Mockito.anyString()))
+                    .thenReturn(mockConnection);
             writer = new TDengineSinkWriter(config, rowType);
         }
     }
 
     @Test
-    void testConvertDataTypeWithNull(){
+    void testConvertDataTypeWithNull() {
         // Prepare test data
         LocalDateTime dateTime = LocalDateTime.of(2023, 4, 14, 15, 30, 45); // 2023-04-14 15:30:45
         Object[] input = {
-                null,                          // Test for null value
-                dateTime,                      // Test for LocalDateTime
-                "test_string",                 // Test for String
-                123,                           // Test for other types (Integer)
-                45.67                          // Test for other types (Double)
+            null, // Test for null value
+            dateTime, // Test for LocalDateTime
+            "test_string", // Test for String
+            123, // Test for other types (Integer)
+            45.67 // Test for other types (Double)
         };
 
         // Expected output
         Object[] expectedOutput = {
-                null,                           // null remains unchanged
-                "'2023-04-14 15:30:45.000'",    // LocalDateTime is converted to a formatted string with the specified timezone
-                "'test_string'",                // String is wrapped in single quotes
-                123,                            // Integer remains unchanged
-                45.67                           // Double remains unchanged
+            null, // null remains unchanged
+            "'2023-04-14 15:30:45.000'", // LocalDateTime is converted to a formatted string with
+            // the specified timezone
+            "'test_string'", // String is wrapped in single quotes
+            123, // Integer remains unchanged
+            45.67 // Double remains unchanged
         };
 
         Object[] result = writer.convertDataType(input);
@@ -122,12 +124,14 @@ void testConvertDataTypeWithNull(){
         Object[] input1 = {};
         Object[] expectedOutput1 = {};
         Object[] result1 = writer.convertDataType(input1);
-        assertArrayEquals(expectedOutput1, result1, "Empty input array should return an empty output array.");
+        assertArrayEquals(
+                expectedOutput1, result1, "Empty input array should return an empty output array.");
 
         // Test for an array containing only null
         Object[] input2 = {null};
         Object[] expectedOutput2 = {null};
         Object[] result2 = writer.convertDataType(input2);
-        assertArrayEquals(expectedOutput2, result2, "Array with only null should return an array with null.");
+        assertArrayEquals(
+                expectedOutput2, result2, "Array with only null should return an array with null.");
     }
 }