Fail fast when mandatory AsyncApi fields are missing

Author: Varadraj75

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

@@ -24,31 +24,53 @@ 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 }
 
     companion object {
         const val VERSION = "2.4.0"
 
-        inline fun asyncApi(build: AsyncApi.() -> Unit): AsyncApi =
-            AsyncApi().apply(build)
+        fun asyncApi(build: AsyncApi.() -> Unit): AsyncApi =
+            AsyncApi()
+                .apply(build)
+                .checkInitialized(
+                    "info" to { info },
+                    "channels" to { channels }
+                )
+    }
+}
+
+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,29 @@ internal class AsyncApiTest {
 
         TestUtils.assertJsonEquals(expected, actual)
     }
+
+    @Test
+    fun `should fail fast when mandatory fields are missing`() {
+        val exception = assertThrows(IllegalStateException::class.java) {
+            AsyncApi.asyncApi {
+            }
+        }
+
+        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)
+    }
 }