diff --git a/scalabot-app/src/test/kotlin/util/ArtifactSerializerTest.kt b/scalabot-app/src/test/kotlin/util/ArtifactSerializerTest.kt
index 0ef19c4..100c5b4 100644
--- a/scalabot-app/src/test/kotlin/util/ArtifactSerializerTest.kt
+++ b/scalabot-app/src/test/kotlin/util/ArtifactSerializerTest.kt
@@ -18,13 +18,21 @@ internal class ArtifactSerializerTest {
     }
 
     @Test
-    fun serialize() {
+    fun `Basic format serialization`() {
         val gav = "org.example.software:test:1.0.0-SNAPSHOT"
         val expectArtifact = DefaultArtifact(gav)
         val actualArtifact = DefaultArtifact(ArtifactSerializer.serialize(expectArtifact, null, null).asString)
         assertEquals(expectArtifact, actualArtifact)
     }
 
+    @Test
+    fun `Full format serialization`() {
+        val gav = "org.example.software:test:war:javadoc:1.0.0-SNAPSHOT"
+        val expectArtifact = DefaultArtifact(gav)
+        val actualArtifact = DefaultArtifact(ArtifactSerializer.serialize(expectArtifact, null, null).asString)
+        assertEquals(expectArtifact, actualArtifact)
+    }
+
     @Test
     fun deserialize() {
         val gav = "org.example.software:test:1.0.0-SNAPSHOT"
diff --git a/scalabot-app/src/test/kotlin/util/SerializersKtTest.kt b/scalabot-app/src/test/kotlin/util/SerializersKtTest.kt
index bc2f4d8..591c8e8 100644
--- a/scalabot-app/src/test/kotlin/util/SerializersKtTest.kt
+++ b/scalabot-app/src/test/kotlin/util/SerializersKtTest.kt
@@ -3,19 +3,68 @@ package util
 import com.google.gson.*
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.verify
 import net.lamgc.scalabot.MavenRepositoryConfig
 import net.lamgc.scalabot.util.AuthenticationSerializer
 import net.lamgc.scalabot.util.MavenRepositoryConfigSerializer
 import net.lamgc.scalabot.util.ProxyTypeSerializer
 import org.eclipse.aether.repository.Authentication
+import org.eclipse.aether.repository.AuthenticationContext
 import org.eclipse.aether.repository.Proxy
 import org.intellij.lang.annotations.Language
 import org.junit.jupiter.api.Assertions.assertThrows
 import org.telegram.telegrambots.bots.DefaultBotOptions
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
 import java.lang.reflect.Type
 import java.net.URL
 import kotlin.test.*
 
+internal class SerializersKtTest {
+
+    private val instance: Any
+    private val method: Method
+
+    init {
+        val clazz = Class.forName("net.lamgc.scalabot.util.SerializerUtils")
+        method = clazz.getDeclaredMethod("checkJsonKey", JsonObject::class.java, String::class.java)
+        method.isAccessible = true
+        instance = clazz.getDeclaredField("INSTANCE").apply {
+            isAccessible = true
+        }.get(null)
+    }
+
+    private fun invoke(json: JsonObject, key: String): String {
+        try {
+            return method.invoke(instance, json, key) as String
+        } catch (e: InvocationTargetException) {
+            throw e.targetException
+        }
+    }
+
+    @Test
+    fun `Json key checker test`() {
+        assertThrows(JsonParseException::class.java) {
+            invoke(JsonObject(), "NOT_EXIST_KEY")
+        }
+        assertThrows(JsonParseException::class.java) {
+            invoke(JsonObject().apply { add("NULL_KEY", JsonNull.INSTANCE) }, "NULL_KEY")
+        }
+        assertThrows(JsonParseException::class.java) {
+            invoke(JsonObject().apply { add("ARRAY_KEY", JsonArray()) }, "ARRAY_KEY")
+        }
+        assertThrows(JsonParseException::class.java) {
+            invoke(JsonObject().apply { add("OBJECT_KEY", JsonObject()) }, "OBJECT_KEY")
+        }
+
+        val expectKey = "TEST"
+        val expectString = "testString"
+        val json = JsonObject().apply { addProperty(expectKey, expectString) }
+
+        assertEquals(expectString, invoke(json, expectKey))
+    }
+}
+
 internal class ProxyTypeSerializerTest {
 
     @Test
@@ -213,14 +262,63 @@ internal class MavenRepositoryConfigSerializerTest {
         assertNotNull(config.authentication)
     }
 
-    private object TestJsonDeserializationContext : JsonDeserializationContext {
+}
 
-        private val gson = GsonBuilder()
-            .registerTypeAdapter(Authentication::class.java, AuthenticationSerializer)
-            .create()
+private object TestJsonDeserializationContext : JsonDeserializationContext {
 
-        override fun <T : Any?> deserialize(json: JsonElement, typeOfT: Type): T {
-            return gson.fromJson(json, typeOfT)
+    private val gson = GsonBuilder()
+        .registerTypeAdapter(Authentication::class.java, AuthenticationSerializer)
+        .create()
+
+    override fun <T : Any?> deserialize(json: JsonElement, typeOfT: Type): T {
+        return gson.fromJson(json, typeOfT)
+    }
+}
+
+internal class AuthenticationSerializerTest {
+
+    @Test
+    fun `deserialize test`() {
+        assertThrows(JsonParseException::class.java) {
+            AuthenticationSerializer.deserialize(
+                JsonNull.INSTANCE,
+                Authentication::class.java, TestJsonDeserializationContext
+            )
+        }
+        assertThrows(JsonParseException::class.java) {
+            AuthenticationSerializer.deserialize(
+                JsonArray(),
+                Authentication::class.java, TestJsonDeserializationContext
+            )
+        }
+        assertThrows(JsonParseException::class.java) {
+            AuthenticationSerializer.deserialize(
+                JsonPrimitive("A STRING"),
+                Authentication::class.java, TestJsonDeserializationContext
+            )
+        }
+
+        val expectJsonObject = JsonObject().apply {
+            addProperty("username", "testUsername")
+            addProperty("password", "testPassword")
+        }
+
+        val mockContext = mockk<AuthenticationContext> {
+            every { put(any(), any()) }.answers { }
+        }
+
+        val result = AuthenticationSerializer.deserialize(
+            expectJsonObject,
+            Authentication::class.java, TestJsonDeserializationContext
+        )
+
+        assertNotNull(result)
+        result.fill(mockContext, "username", null)
+        result.fill(mockContext, "password", null)
+
+        verify {
+            mockContext.put("username", "testUsername")
+            mockContext.put("password", "testPassword".toCharArray())
         }
     }