test: add tests

Author: chenquan-didi

ddes-open-sdk/src/test/groovy/com/xiaoju/open/sdk/didies/core/ConstantsTest.groovy

@@ -0,0 +1,113 @@
+package com.xiaoju.open.sdk.didies.core
+
+import spock.lang.Specification
+
+class ConstantsTest extends Specification {
+
+    def "VERSION should be defined"() {
+        expect:
+        Constants.VERSION == "1.0.0"
+    }
+
+    def "USER_AGENT should be defined"() {
+        expect:
+        Constants.USER_AGENT == "User-Agent"
+    }
+
+    def "DIDI_AGENT should contain version"() {
+        expect:
+        Constants.DIDI_AGENT == "didies-open-sdk-java/1.0.0"
+        Constants.DIDI_AGENT.contains(Constants.VERSION)
+    }
+
+    def "INVALID_ACCESS_TOKEN_CODE should be 401"() {
+        expect:
+        Constants.INVALID_ACCESS_TOKEN_CODE == 401
+    }
+
+    def "AUTH_URI should be defined"() {
+        expect:
+        Constants.AUTH_URI == "/river/Auth/authorize"
+    }
+
+    def "OBJECT_SUFFIX should be defined"() {
+        expect:
+        Constants.OBJECT_SUFFIX == "__obj__"
+    }
+
+    def "BASE_REQ_NAMES should be accessible"() {
+        expect:
+        Constants.BASE_REQ_NAMES != null
+    }
+
+    def "BaseReqName should contain all required fields"() {
+        expect:
+        Constants.BASE_REQ_NAMES.ACCESS_TOKEN == "access_token"
+        Constants.BASE_REQ_NAMES.CLIENT_ID == "client_id"
+        Constants.BASE_REQ_NAMES.TIMESTAMP == "timestamp"
+        Constants.BASE_REQ_NAMES.SIGN == "sign"
+        Constants.BASE_REQ_NAMES.ENCRYPT_CONTENT == "encrypt_content"
+        Constants.BASE_REQ_NAMES.ENT == "ent"
+    }
+
+    def "Constants should not be instantiable"() {
+        when:
+        def constructor = Constants.getDeclaredConstructor()
+        constructor.setAccessible(true)
+        constructor.newInstance()
+
+        then:
+        thrown(Exception) // Abstract class cannot be instantiated
+    }
+
+    def "BaseReqName should be instantiable"() {
+        when:
+        def baseReqName = new Constants.BaseReqName()
+
+        then:
+        baseReqName != null
+        baseReqName instanceof Constants.BaseReqName
+    }
+
+    def "all constant values should be immutable"() {
+        expect:
+        // These are final, so trying to reassign should not be possible
+        Constants.VERSION.getClass() == String
+        Constants.INVALID_ACCESS_TOKEN_CODE.getClass() == Integer
+    }
+
+    def "DIDI_AGENT format should be correct"() {
+        expect:
+        Constants.DIDI_AGENT.startsWith("didies-open-sdk-java/")
+        Constants.DIDI_AGENT.endsWith("/" + Constants.VERSION)
+    }
+
+    def "all BaseReqName fields should be strings"() {
+        expect:
+        Constants.BASE_REQ_NAMES.ACCESS_TOKEN instanceof String
+        Constants.BASE_REQ_NAMES.CLIENT_ID instanceof String
+        Constants.BASE_REQ_NAMES.TIMESTAMP instanceof String
+        Constants.BASE_REQ_NAMES.SIGN instanceof String
+        Constants.BASE_REQ_NAMES.ENCRYPT_CONTENT instanceof String
+        Constants.BASE_REQ_NAMES.ENT instanceof String
+    }
+
+    def "constant values should not be empty"() {
+        expect:
+        !Constants.VERSION.isEmpty()
+        !Constants.USER_AGENT.isEmpty()
+        !Constants.DIDI_AGENT.isEmpty()
+        !Constants.AUTH_URI.isEmpty()
+        !Constants.OBJECT_SUFFIX.isEmpty()
+    }
+
+    def "AUTH_URI should start with slash"() {
+        expect:
+        Constants.AUTH_URI.startsWith("/")
+    }
+
+    def "OBJECT_SUFFIX should contain double underscores"() {
+        expect:
+        Constants.OBJECT_SUFFIX.contains("__")
+    }
+}

ddes-open-sdk/src/test/groovy/com/xiaoju/open/sdk/didies/core/enums/EncryptTypeEnumTest.groovy

@@ -0,0 +1,103 @@
+package com.xiaoju.open.sdk.didies.core.enums
+
+import spock.lang.Specification
+import spock.lang.Unroll
+
+class EncryptTypeEnumTest extends Specification {
+
+    def "EncryptTypeEnum should have three values"() {
+        expect:
+        EncryptTypeEnum.values().length == 3
+    }
+
+    def "EncryptTypeEnum should contain NORMAL, AES128, and AES256"() {
+        expect:
+        EncryptTypeEnum.values() as Set == [EncryptTypeEnum.NORMAL, EncryptTypeEnum.AES128, EncryptTypeEnum.AES256] as Set
+    }
+
+    @Unroll
+    def "EncryptTypeEnum #enum should have correct type value"() {
+        expect:
+        encryptType.type == expectedType
+
+        where:
+        encryptType           | expectedType
+        EncryptTypeEnum.NORMAL | 0
+        EncryptTypeEnum.AES128 | 1
+        EncryptTypeEnum.AES256 | 2
+    }
+
+    @Unroll
+    def "EncryptTypeEnum #enum should have correct description"() {
+        expect:
+        encryptType.description == expectedDescription
+
+        where:
+        encryptType           | expectedDescription
+        EncryptTypeEnum.NORMAL | "不加密"
+        EncryptTypeEnum.AES128 | "aes 128"
+        EncryptTypeEnum.AES256 | "aes 256"
+    }
+
+    def "NORMAL should have type 0"() {
+        expect:
+        EncryptTypeEnum.NORMAL.type == 0
+        EncryptTypeEnum.NORMAL.description == "不加密"
+    }
+
+    def "AES128 should have type 1"() {
+        expect:
+        EncryptTypeEnum.AES128.type == 1
+        EncryptTypeEnum.AES128.description == "aes 128"
+    }
+
+    def "AES256 should have type 2"() {
+        expect:
+        EncryptTypeEnum.AES256.type == 2
+        EncryptTypeEnum.AES256.description == "aes 256"
+    }
+
+    def "valueOf should return correct enum for valid name"() {
+        expect:
+        EncryptTypeEnum.valueOf("NORMAL") == EncryptTypeEnum.NORMAL
+        EncryptTypeEnum.valueOf("AES128") == EncryptTypeEnum.AES128
+        EncryptTypeEnum.valueOf("AES256") == EncryptTypeEnum.AES256
+    }
+
+    def "valueOf should throw exception for invalid name"() {
+        when:
+        EncryptTypeEnum.valueOf("INVALID")
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
+    def "enum values should be in correct order"() {
+        expect:
+        EncryptTypeEnum.values()[0] == EncryptTypeEnum.NORMAL
+        EncryptTypeEnum.values()[1] == EncryptTypeEnum.AES128
+        EncryptTypeEnum.values()[2] == EncryptTypeEnum.AES256
+    }
+
+    def "all enum values should have non-null type and description"() {
+        expect:
+        EncryptTypeEnum.values().every { it.type != null }
+        EncryptTypeEnum.values().every { it.description != null }
+    }
+
+    def "all types should be unique"() {
+        expect:
+        EncryptTypeEnum.values().collect { it.type }.size() ==
+            EncryptTypeEnum.values().collect { it.type }.unique().size()
+    }
+
+    @Unroll
+    def "getter methods should work for #enum"() {
+        expect:
+        encryptType.getType() != null
+        encryptType.getDescription() != null
+
+        where:
+        encryptType << EncryptTypeEnum.values()
+    }
+}

ddes-open-sdk/src/test/groovy/com/xiaoju/open/sdk/didies/core/enums/LogLevelEnumTest.groovy

@@ -0,0 +1,69 @@
+package com.xiaoju.open.sdk.didies.core.enums
+
+import spock.lang.Specification
+
+class LogLevelEnumTest extends Specification {
+
+    def "LogLevelEnum should have two values"() {
+        expect:
+        LogLevelEnum.values().length == 2
+    }
+
+    def "LogLevelEnum should contain DEBUG and INFO"() {
+        expect:
+        LogLevelEnum.values() as Set == [LogLevelEnum.DEBUG, LogLevelEnum.INFO] as Set
+    }
+
+    def "DEBUG should have correct level value"() {
+        expect:
+        LogLevelEnum.DEBUG.level == "debug"
+    }
+
+    def "INFO should have correct level value"() {
+        expect:
+        LogLevelEnum.INFO.level == "info"
+    }
+
+    def "valueOf should return correct enum for valid name"() {
+        expect:
+        LogLevelEnum.valueOf("DEBUG") == LogLevelEnum.DEBUG
+        LogLevelEnum.valueOf("INFO") == LogLevelEnum.INFO
+    }
+
+    def "valueOf should throw exception for invalid name"() {
+        when:
+        LogLevelEnum.valueOf("INVALID")
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
+    def "enum values should be in correct order"() {
+        expect:
+        LogLevelEnum.values()[0] == LogLevelEnum.DEBUG
+        LogLevelEnum.values()[1] == LogLevelEnum.INFO
+    }
+
+    def "all enum values should have non-null level"() {
+        expect:
+        LogLevelEnum.values().every { it.level != null }
+    }
+
+    def "all levels should be unique"() {
+        expect:
+        LogLevelEnum.values().collect { it.level }.size() ==
+            LogLevelEnum.values().collect { it.level }.unique().size()
+    }
+
+    def "getter method should work for all enums"() {
+        expect:
+        LogLevelEnum.DEBUG.getLevel() == "debug"
+        LogLevelEnum.INFO.getLevel() == "info"
+    }
+
+    def "level values should be lowercase"() {
+        expect:
+        LogLevelEnum.DEBUG.level == LogLevelEnum.DEBUG.level.toLowerCase()
+        LogLevelEnum.INFO.level == LogLevelEnum.INFO.level.toLowerCase()
+    }
+}

ddes-open-sdk/src/test/groovy/com/xiaoju/open/sdk/didies/core/enums/SignMethodEnumTest.groovy

@@ -0,0 +1,69 @@
+package com.xiaoju.open.sdk.didies.core.enums
+
+import spock.lang.Specification
+
+class SignMethodEnumTest extends Specification {
+
+    def "SignMethodEnum should have two values"() {
+        expect:
+        SignMethodEnum.values().length == 2
+    }
+
+    def "SignMethodEnum should contain MD5 and SHA256"() {
+        expect:
+        SignMethodEnum.values() as Set == [SignMethodEnum.MD5, SignMethodEnum.SHA256] as Set
+    }
+
+    def "MD5 should have correct signMethod value"() {
+        expect:
+        SignMethodEnum.MD5.signMethod == "MD5"
+    }
+
+    def "SHA256 should have correct signMethod value"() {
+        expect:
+        SignMethodEnum.SHA256.signMethod == "SHA256"
+    }
+
+    def "valueOf should return correct enum for valid name"() {
+        expect:
+        SignMethodEnum.valueOf("MD5") == SignMethodEnum.MD5
+        SignMethodEnum.valueOf("SHA256") == SignMethodEnum.SHA256
+    }
+
+    def "valueOf should throw exception for invalid name"() {
+        when:
+        SignMethodEnum.valueOf("INVALID")
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
+    def "enum values should be in correct order"() {
+        expect:
+        SignMethodEnum.values()[0] == SignMethodEnum.MD5
+        SignMethodEnum.values()[1] == SignMethodEnum.SHA256
+    }
+
+    def "all enum values should have non-null signMethod"() {
+        expect:
+        SignMethodEnum.values().every { it.signMethod != null }
+    }
+
+    def "all signMethods should be unique"() {
+        expect:
+        SignMethodEnum.values().collect { it.signMethod }.size() ==
+            SignMethodEnum.values().collect { it.signMethod }.unique().size()
+    }
+
+    def "getter method should work for all enums"() {
+        expect:
+        SignMethodEnum.MD5.getSignMethod() == "MD5"
+        SignMethodEnum.SHA256.getSignMethod() == "SHA256"
+    }
+
+    def "signMethod values should match standard algorithm names"() {
+        expect:
+        SignMethodEnum.MD5.signMethod.toUpperCase() == "MD5"
+        SignMethodEnum.SHA256.signMethod.toUpperCase() == "SHA256"
+    }
+}