refactor: move mandatory field validation to serialization lifecycle

- Remove validation from DSL entry point
- Move checkInitialized to internal utility file
- Add dedicated utility tests
- Introduce validateForSerialization() in AsyncApi

Author: Varadraj75

kotlin-asyncapi-context/src/test/kotlin/com/asyncapi/kotlinasyncapi/context/service/AsyncApiExtensionTest.kt

@@ -1,9 +1,9 @@
 package com.asyncapi.kotlinasyncapi.context.service
 
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Test
 import com.asyncapi.kotlinasyncapi.model.AsyncApi
 import kotlin.script.experimental.host.toScriptSource
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
 
 internal class AsyncApiExtensionTest {
 
@@ -34,6 +34,7 @@ internal class AsyncApiExtensionTest {
                     title("titleValue")
                     version("versionValue")
                 }
+                channels { }
             }
         )
 
@@ -69,6 +70,10 @@ internal class AsyncApiExtensionTest {
         }
         val actual = extension.extend(
             AsyncApi.asyncApi {
+                info {
+                    title("titleValue")
+                    version("versionValue")
+                }
                 channels {
                     channel("oldChannelKey") {
                         description("oldDescriptionValue")
@@ -109,6 +114,7 @@ internal class AsyncApiExtensionTest {
                     title("titleValue")
                     version("versionValue")
                 }
+                channels { }
             }
         )
 

kotlin-asyncapi-core/src/main/kotlin/com/asyncapi/kotlinasyncapi/model/AsyncApi.kt

@@ -4,6 +4,7 @@ import com.asyncapi.kotlinasyncapi.model.channel.ReferencableChannelsMap
 import com.asyncapi.kotlinasyncapi.model.component.Components
 import com.asyncapi.kotlinasyncapi.model.info.Info
 import com.asyncapi.kotlinasyncapi.model.server.ReferencableServersMap
+import com.asyncapi.kotlinasyncapi.util.checkInitialized
 
 @Target(AnnotationTarget.CLASS, AnnotationTarget.TYPEALIAS)
 @DslMarker
@@ -24,31 +25,38 @@ class AsyncApi {
     fun id(value: String): String =
         value.also { id = it }
 
-    inline fun info(build: Info.() -> Unit): Info =
+    fun info(build: Info.() -> Unit): Info =
         Info().apply(build).also { info = it }
 
-    inline fun servers(build: ReferencableServersMap.() -> Unit): ReferencableServersMap =
+    fun servers(build: ReferencableServersMap.() -> Unit): ReferencableServersMap =
         ReferencableServersMap().apply(build).also { servers = it }
 
-    inline fun channels(build: ReferencableChannelsMap.() -> Unit): ReferencableChannelsMap =
+    fun channels(build: ReferencableChannelsMap.() -> Unit): ReferencableChannelsMap =
         ReferencableChannelsMap().apply(build).also { channels = it }
 
     fun defaultContentType(value: String): String =
         value.also { defaultContentType = it }
 
-    inline fun components(build: Components.() -> Unit): Components =
+    fun components(build: Components.() -> Unit): Components =
         Components().apply(build).also { components = it }
 
-    inline fun tags(build: TagsList.() -> Unit): TagsList =
+    fun tags(build: TagsList.() -> Unit): TagsList =
         TagsList().apply(build).also { tags = it }
 
-    inline fun externalDocs(build: ExternalDocumentation.() -> Unit): ExternalDocumentation =
+    fun externalDocs(build: ExternalDocumentation.() -> Unit): ExternalDocumentation =
         ExternalDocumentation().apply(build).also { externalDocs = it }
 
+    internal fun validateForSerialization() {
+        checkInitialized(
+            "info" to { info },
+            "channels" to { channels }
+        )
+    }
+
     companion object {
         const val VERSION = "2.4.0"
 
-        inline fun asyncApi(build: AsyncApi.() -> Unit): AsyncApi =
+        fun asyncApi(build: AsyncApi.() -> Unit): AsyncApi =
             AsyncApi().apply(build)
     }
-}
+}

kotlin-asyncapi-core/src/main/kotlin/com/asyncapi/kotlinasyncapi/util/ValidationUtils.kt

@@ -0,0 +1,18 @@
+package com.asyncapi.kotlinasyncapi.util
+
+internal fun <T> T.checkInitialized(
+    vararg checks: Pair<String, T.() -> Unit>
+): T = also {
+    val missing = checks.mapNotNull { (name, check) ->
+        try {
+            it.check()
+            null
+        } catch (_: UninitializedPropertyAccessException) {
+            name
+        }
+    }
+
+    check(missing.isEmpty()) {
+        "Missing required properties: ${missing.joinToString()}"
+    }
+}

kotlin-asyncapi-core/src/test/kotlin/com/asyncapi/kotlinasyncapi/model/AsyncApiTest.kt

@@ -1,11 +1,14 @@
 package com.asyncapi.kotlinasyncapi.model
 
+import com.asyncapi.kotlinasyncapi.model.info.Info
 import io.mockk.clearConstructorMockk
 import io.mockk.every
 import io.mockk.mockkConstructor
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Test
-import com.asyncapi.kotlinasyncapi.model.info.Info
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertThrows
 
 internal class AsyncApiTest {
 
@@ -43,4 +46,31 @@ internal class AsyncApiTest {
 
         TestUtils.assertJsonEquals(expected, actual)
     }
+
+    @Test
+    fun `should fail fast when mandatory fields are missing`() {
+        val api = AsyncApi.asyncApi {
+        }
+
+        val exception = assertThrows(IllegalStateException::class.java) {
+            api.validateForSerialization()
+        }
+
+        assertTrue(exception.message!!.contains("Missing required properties"))
+        assertTrue(exception.message!!.contains("info"))
+        assertTrue(exception.message!!.contains("channels"))
+    }
+
+    @Test
+    fun `should succeed when mandatory fields are initialized`() {
+        val api = AsyncApi.asyncApi {
+            info {
+                title = "Test API"
+                version = "1.0.0"
+            }
+            channels { }
+        }
+
+        assertNotNull(api)
+    }
 }

kotlin-asyncapi-core/src/test/kotlin/com/asyncapi/kotlinasyncapi/util/ValidationUtilsTest.kt

@@ -0,0 +1,55 @@
+package com.asyncapi.kotlinasyncapi.util
+
+import org.junit.jupiter.api.Assertions.assertDoesNotThrow
+import org.junit.jupiter.api.Assertions.assertThrows
+import org.junit.jupiter.api.Test
+import java.lang.IllegalStateException
+
+internal class ValidationUtilsTest {
+
+    class TestClass {
+        lateinit var requiredProperty: String
+        var optionalProperty: String? = null
+    }
+
+    @Test
+    fun `checkInitialized should pass when required property is initialized`() {
+        val instance = TestClass().apply {
+            requiredProperty = "value"
+        }
+
+        assertDoesNotThrow {
+            instance.checkInitialized(
+                "requiredProperty" to { requiredProperty }
+            )
+        }
+    }
+
+    @Test
+    fun `checkInitialized should fail when required property is not initialized`() {
+        val instance = TestClass()
+
+        val exception = assertThrows(IllegalStateException::class.java) {
+            instance.checkInitialized(
+                "requiredProperty" to { requiredProperty }
+            )
+        }
+
+        assert(exception.message!!.contains("Missing required properties: requiredProperty"))
+    }
+
+    @Test
+    fun `checkInitialized should handle multiple checks`() {
+        val instance = TestClass()
+
+        val exception = assertThrows(IllegalStateException::class.java) {
+            instance.checkInitialized(
+                "requiredProperty" to { requiredProperty },
+                "anotherMissing" to { throw UninitializedPropertyAccessException() }
+            )
+        }
+
+        assert(exception.message!!.contains("requiredProperty"))
+        assert(exception.message!!.contains("anotherMissing"))
+    }
+}