Merge pull request #287 from simple-robot/dev/support-channel-kickout-API

改进 ChannelKickoutApi 的部分相关测试

Author: ForteScarlet

simbot-component-kook-api/src/commonMain/kotlin/love/forte/simbot/kook/api/channel/ChannelKickoutApi.kt

@@ -33,6 +33,7 @@ import kotlin.jvm.JvmStatic
  * 踢出语音频道中的用户，只能踢出在语音频道中的用户
  *
  * @author ForteScarlet
+ * @since 4.2.0
  */
 public class ChannelKickoutApi private constructor(
     channelId: String,
@@ -69,4 +70,4 @@ public class ChannelKickoutApi private constructor(
         @SerialName("user_id") 
         val userId: String
     )
-}
+}

simbot-component-kook-api/src/commonMain/kotlin/love/forte/simbot/kook/objects/User.kt

@@ -1,24 +1,30 @@
 /*
- * Copyright (c) 2023. ForteScarlet.
+ *     Copyright (c) 2023-2025. ForteScarlet.
  *
- * This file is part of simbot-component-kook.
+ *     This file is part of simbot-component-kook.
  *
- * simbot-component-kook is free software: you can redistribute it and/or modify it under the terms of
- * the GNU Lesser General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
+ *     simbot-component-kook is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
  *
- * simbot-component-kook is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Lesser General Public License for more details.
+ *     simbot-component-kook is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *     GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License along with simbot-component-kook,
- * If not, see <https://www.gnu.org/licenses/>.
+ *     You should have received a copy of the GNU Lesser General Public License
+ *     along with simbot-component-kook,
+ *     If not, see <https://www.gnu.org/licenses/>.
  */
 
 package love.forte.simbot.kook.objects
 
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import love.forte.simbot.kook.objects.SystemUser.SYSTEM_USER_ID
+import love.forte.simbot.kook.objects.SystemUser.SYSTEM_USER_IDENTIFY_NUM
+import love.forte.simbot.kook.objects.SystemUser.SYSTEM_USER_NAME
 import love.forte.simbot.kook.objects.SystemUser.id
 
 
@@ -141,8 +147,8 @@ public data class SimpleUser(
      * 没有 `identify_num` 的情况下，会**尝试**从 [username] 中切割 `#` 并解析出 identifyNum 的值，
      * 无法得到结果时使用空字符串。
      */
-    @SerialName("identify_num") override val identifyNum: String = username.split("#", limit = 2)
-        .let { if (it.size < 2) it[0] else "" },
+    @SerialName("identify_num") override val identifyNum: String =
+        username.substringAfter('#', ""),
     /**
      * 当前是否在线，默认为 `false`
      */

simbot-component-kook-api/src/commonTest/kotlin/love/forte/simbot/kook/api/channel/ChannelKickoutApiTest.kt

@@ -20,117 +20,267 @@
 
 package love.forte.simbot.kook.api.channel
 
+import io.ktor.client.*
+import io.ktor.client.engine.mock.*
 import io.ktor.http.*
+import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
 import love.forte.simbot.kook.Kook
+import love.forte.simbot.kook.api.ApiResult
+import love.forte.simbot.kook.api.requestResult
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
 /**
- * Tests for [ChannelKickoutApi] focusing on API structure and serialization.
- * 
+ * Comprehensive tests for [ChannelKickoutApi] focusing on API structure, serialization/deserialization,
+ * and realistic scenarios based on official documentation.
+ *
+ * Tests include JSON serialization validation, API structure verification,
+ * and response deserialization using patterns from official KOOK API documentation.
+ *
  * @author ForteScarlet
+ * @since 4.2.0
  */
 class ChannelKickoutApiTest {
     private val json = Json(Kook.DEFAULT_JSON) {
         ignoreUnknownKeys = true
+        prettyPrint = true
     }
 
     @Test
     fun testApiBasics() {
-        val channelId = "123456789"
-        val userId = "987654321"
+        val channelId = "3321010478582002"
+        val userId = "1700000"
         val api = ChannelKickoutApi.create(channelId, userId)
-        
+
         // Test API properties
         assertEquals(HttpMethod.Post, api.method)
-        assertTrue(api.url.toString().contains("channel/kickout"))
-        
+        assertEquals("https://www.kookapp.cn/api/v3/channel/kickout", api.url.toString())
+
         // Test body content
         val body = api.body
         assertNotNull(body, "Body should not be null")
     }
-    
+
     @Test
     fun testUrlConstruction() {
         val api = ChannelKickoutApi.create("test_channel", "test_user")
         val url = api.url.toString()
-        
+
         // Verify URL contains correct Kook API base and path
-        assertTrue(url.contains("kookapp.cn/api/v3"))
-        assertTrue(url.contains("channel/kickout"))
+        assertEquals("https://www.kookapp.cn/api/v3/channel/kickout", url)
     }
-    
+
     @Test
-    fun testRequestBodyNotNull() {
-        val channelId = "voice_channel_123"
-        val userId = "user_456"
+    fun testRequestBodyStructure() = runTest {
+        val channelId = "3321010478582002"
+        val userId = "1700000"
         val api = ChannelKickoutApi.create(channelId, userId)
+
+        // Capture actual request body using MockEngine
+        var capturedRequestBody: String? = null
+        val mockEngine = MockEngine { request ->
+            capturedRequestBody = request.body.toByteArray().decodeToString()
+            respond(
+                content = """{"code": 0, "message": "操作成功", "data": []}""",
+                status = HttpStatusCode.OK,
+                headers = headersOf(HttpHeaders.ContentType, "application/json")
+            )
+        }
+
+        val client = HttpClient(mockEngine)
 
-        val body = api.body
-        assertNotNull(body, "Body should not be null")
+        // Make actual request to capture serialized body
+        api.requestResult(client, "Bot test-token")
 
-        // Verify that the body object exists and is not null
-        assertTrue(body.toString().isNotEmpty())
+        // Validate the captured JSON body structure
+        assertNotNull(capturedRequestBody, "Request body should be captured")
+        val requestJson = json.parseToJsonElement(capturedRequestBody).jsonObject
+        
+        // Verify JSON structure matches expected serialization
+        assertEquals(channelId, requestJson["channel_id"]?.jsonPrimitive?.content)
+        assertEquals(userId, requestJson["user_id"]?.jsonPrimitive?.content)
+        assertEquals(2, requestJson.size)
     }
-    
+
     @Test
-    fun testMultipleApiInstances() {
-        val api1 = ChannelKickoutApi.create("channel1", "user1")
-        val api2 = ChannelKickoutApi.create("channel2", "user2")
-        
-        // Verify that different instances have different bodies
-        val body1 = api1.body
-        val body2 = api2.body
-        
-        assertNotNull(body1)
-        assertNotNull(body2)
-        
-        // Bodies should be different objects (different parameters)
-        assertTrue(body1 !== body2, "Different API instances should have different body objects")
+    fun testSuccessfulResponseDeserialization() {
+        // Based on official documentation example
+        //language=json
+        val successResponseJson = """{
+            "code": 0,
+            "message": "操作成功",
+            "data": []
+        }"""
+
+        val apiResult = json.decodeFromString(ApiResult.serializer(), successResponseJson)
+
+        assertNotNull(apiResult)
+        assertEquals(0, apiResult.code)
+        assertEquals("操作成功", apiResult.message)
+        assertNotNull(apiResult.data)
+    }
+
+    @Test
+    fun testErrorResponseDeserialization() {
+        // Test realistic error scenario - channel doesn't exist or not a voice channel
+        //language=json
+        val errorResponseJson = """{
+            "code": 40001,
+            "message": "频道不存在或不是语音频道"
+        }"""
+
+        val apiResult = json.decodeFromString(ApiResult.serializer(), errorResponseJson)
+
+        assertNotNull(apiResult)
+        assertEquals(40001, apiResult.code)
+        assertEquals("频道不存在或不是语音频道", apiResult.message)
     }
-    
+
     @Test
     fun testApiFactory() {
-        val channelId = "factory_test_channel"
-        val userId = "factory_test_user"
-        
+        val channelId = "7480000000000000"
+        val userId = "2418000000"
+
         // Test factory method
         val api = ChannelKickoutApi.create(channelId, userId)
         assertNotNull(api)
-        
+
         // Verify the created API has the correct properties
         assertEquals(HttpMethod.Post, api.method)
         assertNotNull(api.body)
         assertNotNull(api.url)
+
+        // Verify API path structure
+        val url = api.url
+        assertEquals("https://www.kookapp.cn/api/v3/channel/kickout", url.toString())
+        assertEquals(listOf("", "api", "v3", "channel", "kickout"), url.pathSegments)
     }
-    
+
     @Test
-    fun testApiPathCorrectness() {
-        val api = ChannelKickoutApi.create("test", "test")
-        val url = api.url
-        
-        // Check that the URL path is correct
-        assertTrue(url.pathSegments.contains("channel"))
-        assertTrue(url.pathSegments.contains("kickout"))
-        
-        // Verify it's a POST API
-        assertEquals(HttpMethod.Post, api.method)
+    fun testMultipleApiInstances() {
+        val api1 = ChannelKickoutApi.create("3321010478582001", "1700001")
+        val api2 = ChannelKickoutApi.create("3321010478582002", "1700002")
+
+        // Verify that different instances have different bodies
+        val body1 = api1.body
+        val body2 = api2.body
+
+        assertNotNull(body1)
+        assertNotNull(body2)
+
+        // Bodies should be different objects (different parameters)
+        assertTrue(body1 !== body2, "Different API instances should have different body objects")
+
+        // Verify they have different string representations
+        val string1 = body1.toString()
+        val string2 = body2.toString()
+        assertTrue(string1 != string2, "Different instances should have different string representations")
     }
-    
+
     @Test
-    fun testBodyNotNull() {
-        val api = ChannelKickoutApi.create("channel_test", "user_test")
+    fun testRealisticScenario() = runTest {
+        // Test with realistic IDs from documentation
+        val voiceChannelId = "3321010478582002"  // Voice channel from docs
+        val userId = "1700000"  // User ID from docs
+
+        val api = ChannelKickoutApi.create(voiceChannelId, userId)
+
+        // Verify API structure
+        assertEquals(HttpMethod.Post, api.method)
+        assertEquals("https://www.kookapp.cn/api/v3/channel/kickout", api.url.toString())
+
+        // Capture actual request body using MockEngine
+        var capturedRequestBody: String? = null
+        val mockEngine = MockEngine { request ->
+            capturedRequestBody = request.body.toByteArray().decodeToString()
+            respond(
+                content = """{"code": 0, "message": "操作成功", "data": []}""",
+                status = HttpStatusCode.OK,
+                headers = headersOf(HttpHeaders.ContentType, "application/json")
+            )
+        }
+
+        val client = HttpClient(mockEngine)
 
-        // Body should never be null for this API
-        assertNotNull(api.body)
+        // Make actual request to capture serialized body
+        api.requestResult(client, "Bot test-token")
 
-        // Multiple calls to body should return the same non-null value
-        val body1 = api.body
-        val body2 = api.body
-        assertNotNull(body1)
-        assertNotNull(body2)
+        // Validate the captured JSON body structure
+        assertNotNull(capturedRequestBody, "Request body should be captured")
+        val requestJson = json.parseToJsonElement(capturedRequestBody).jsonObject
+        
+        // Verify JSON structure matches expected serialization for realistic scenario
+        assertEquals(voiceChannelId, requestJson["channel_id"]?.jsonPrimitive?.content)
+        assertEquals(userId, requestJson["user_id"]?.jsonPrimitive?.content)
+        assertEquals(2, requestJson.size)
+    }
+
+    @Test
+    fun testParameterValidation() = runTest {
+        // Test with various parameter combinations
+        val testCases = listOf(
+            "7480000000000000" to "2418000000",  // From documentation
+            "3321010478582002" to "1700000",     // Voice channel example
+            "test_channel_123" to "test_user_456"  // Generic test case
+        )
+
+        testCases.forEach { (channelId, userId) ->
+            val api = ChannelKickoutApi.create(channelId, userId)
+
+            // Verify each API instance is properly constructed
+            assertEquals(HttpMethod.Post, api.method)
+            assertNotNull(api.body)
+            assertNotNull(api.url)
+
+            // Capture actual request body using MockEngine for each test case
+            var capturedRequestBody: String? = null
+            val mockEngine = MockEngine { request ->
+                capturedRequestBody = request.body.toByteArray().decodeToString()
+                respond(
+                    content = """{"code": 0, "message": "操作成功", "data": []}""",
+                    status = HttpStatusCode.OK,
+                    headers = headersOf(HttpHeaders.ContentType, "application/json")
+                )
+            }
+
+            val client = HttpClient(mockEngine)
+            
+            // Make actual request to capture serialized body
+            api.requestResult(client, "Bot test-token")
+            
+            // Validate the captured JSON body structure for each parameter combination
+            assertNotNull(capturedRequestBody, "Request body should be captured for channelId=$channelId, userId=$userId")
+            val requestJson = json.parseToJsonElement(capturedRequestBody).jsonObject
+            
+            // Verify JSON structure matches expected serialization
+            assertEquals(channelId, requestJson["channel_id"]?.jsonPrimitive?.content)
+            assertEquals(userId, requestJson["user_id"]?.jsonPrimitive?.content)
+            assertEquals(2, requestJson.size)
+        }
+    }
+
+    @Test
+    fun testApiResultStructureWithWrapper() {
+        // Test that API result properly handles KOOK's wrapper structure
+
+        //language=json
+        val wrappedResponseJson = """{
+            "code": 0,
+            "message": "操作成功",
+            "data": []
+        }"""
+
+        val result = json.decodeFromString(ApiResult.serializer(), wrappedResponseJson)
+
+        // Verify wrapper structure is properly handled
+        assertNotNull(result)
+        assertEquals(0, result.code)
+        assertEquals("操作成功", result.message)
+        assertNotNull(result.data)
     }
-}
+}