test: adds test for result entry

Author: kikin81

nibel-compiler/src/main/kotlin/nibel/compiler/generator/ComposableGenerator.kt

@@ -10,6 +10,7 @@ import nibel.compiler.template.composableEntryWithNoArgsTemplate
 import nibel.compiler.template.composableExternalEntryFactoryTemplate
 import nibel.compiler.template.composableInternalEntryFactoryTemplate
 import nibel.compiler.template.composableResultInternalEntryFactoryTemplate
+import nibel.compiler.template.composableExternalResultEntryFactoryTemplate
 import nibel.compiler.template.composableResultEntryWithArgsTemplate
 import nibel.compiler.template.composableResultEntryWithNoArgsTemplate
 
@@ -88,9 +89,14 @@ class ComposableGenerator(
                     }
                 }
                 is ExternalEntryMetadata -> {
-                    // For external entries, we still use the same factory for now
-                    // TODO: Add external result entry factory support if needed
-                    composableEntryFactory
+                    // For external result entries, create result-specific factory
+                    composableExternalResultEntryFactoryTemplate(
+                        composableHolderName = composableHolderName,
+                        destinationQualifiedName = metadata.destinationQualifiedName,
+                        hasArgs = metadata.argsQualifiedName != null,
+                        argsQualifiedName = metadata.argsQualifiedName,
+                        resultQualifiedName = resultQualifiedName,
+                    )
                 }
             }
 

nibel-compiler/src/main/kotlin/nibel/compiler/template/ComposableEntryFactoryTemplate.kt

@@ -132,3 +132,32 @@ fun composableResultInternalEntryFactoryMethodTemplate(
 |            return entry
 |        }
 """.trimMargin("|")
+
+// External result entry factory template
+
+@Suppress("LongParameterList", "MaxLineLength")
+fun composableExternalResultEntryFactoryTemplate(
+    composableHolderName: String,
+    destinationQualifiedName: String,
+    hasArgs: Boolean,
+    argsQualifiedName: String?,
+    resultQualifiedName: String,
+) = """
+|    companion object: ComposableEntryFactory<$destinationQualifiedName> {
+|
+|        override fun newInstance(destination: $destinationQualifiedName): ComposableEntry<${if (hasArgs) argsQualifiedName else "*"}> {
+|            val entry = $composableHolderName(
+|                ${if (hasArgs) "args = destination.args," else ""}
+|                name = nibel.runtime.buildRouteName($composableHolderName::class.qualifiedName!!, ${if (hasArgs) "destination.args" else "null"}),
+|            )
+|            return entry
+|        }
+${
+if (hasArgs) {
+    composableResultInternalEntryFactoryMethodTemplate(composableHolderName, argsQualifiedName!!, resultQualifiedName)
+} else {
+    composableResultInternalEntryFactoryMethodTemplate(composableHolderName, resultQualifiedName)
+}
+}
+|    }
+""".trimMargin("|")

tests/build.gradle.kts

@@ -11,8 +11,12 @@ android {
 
 dependencies {
     ksp(projects.nibelCompiler)
+    kspTest(projects.nibelCompiler)
+    implementation(projects.nibelAnnotations)
+    testImplementation(projects.nibelAnnotations)
     implementation(libs.androidx.fragment)
-    implementation(libs.nibel.runtime)
+    implementation(projects.nibelRuntime)
+    testImplementation(projects.nibelRuntime)
     implementation(libs.junit)
     implementation(libs.kotest.assertions)
 }

tests/src/test/kotlin/nibel/tests/codegen/ExternalEntryCompileTest.kt

@@ -8,32 +8,76 @@ import nibel.annotations.DestinationWithNoArgs
 import nibel.annotations.ImplementationType
 import nibel.annotations.UiExternalEntry
 
+/**
+ * Compilation tests for @UiExternalEntry annotation (external entries).
+ *
+ * These tests verify that the KSP annotation processor can successfully generate entry classes
+ * for external (inter-module) navigation targets. External entries are defined in one module
+ * but can be used from other modules, requiring explicit destination declarations.
+ *
+ * Test coverage:
+ * - Fragment external entries with and without arguments
+ * - Composable external entries with and without arguments
+ * - Proper destination class generation and factory methods
+ * - Cross-module navigation support
+ *
+ * The tests pass if the annotated functions compile successfully and generate
+ * the corresponding Entry classes with proper factory companion objects.
+ */
+
+/**
+ * Destination for Fragment external entry without arguments
+ */
 object Destination1 : DestinationWithNoArgs
 
+/**
+ * Tests Fragment-based external entry without arguments.
+ * Should generate: FragmentExternalEntryWithNoArgsEntry class with factory companion
+ */
 @UiExternalEntry(ImplementationType.Fragment, Destination1::class)
 @Composable
 fun FragmentExternalEntryWithNoArgs() = Unit
 
-
+/**
+ * Destination for Fragment external entry with arguments
+ */
 data class Destination2(override val args: TestArgs) : DestinationWithArgs<TestArgs>
 
+/**
+ * Tests Fragment-based external entry with arguments.
+ * Should generate: FragmentExternalEntryWithArgsEntry class with factory companion taking TestArgs
+ */
 @UiExternalEntry(ImplementationType.Fragment, Destination2::class)
 @Composable
 fun FragmentExternalEntryWithArgs() = Unit
 
-
+/**
+ * Destination for Composable external entry without arguments
+ */
 object Destination3 : DestinationWithNoArgs
 
+/**
+ * Tests Composable-based external entry without arguments.
+ * Should generate: ComposableExternalEntryWithNoArgsEntry class extending ComposableEntry<*>
+ */
 @UiExternalEntry(ImplementationType.Composable, Destination3::class)
 @Composable
 fun ComposableExternalEntryWithNoArgs() = Unit
 
-
+/**
+ * Destination for Composable external entry with arguments
+ */
 data class Destination4(override val args: TestArgs) : DestinationWithArgs<TestArgs>
 
+/**
+ * Tests Composable-based external entry with arguments.
+ * Should generate: ComposableExternalEntryWithArgsEntry class extending ComposableEntry<TestArgs>
+ */
 @UiExternalEntry(ImplementationType.Composable, Destination4::class)
 @Composable
 fun ComposableExternalEntryWithArgs() = Unit
 
-
+/**
+ * Unused destination for completeness in test coverage
+ */
 object Destination5 : DestinationWithNoArgs

tests/src/test/kotlin/nibel/tests/codegen/ExternalEntryParamCompileTest.kt

@@ -9,8 +9,35 @@ import nibel.annotations.ImplementationType
 import nibel.annotations.UiExternalEntry
 import nibel.runtime.NavigationController
 
+/**
+ * Compilation tests for @UiExternalEntry annotation with additional parameters (external entries).
+ *
+ * These tests verify that the KSP annotation processor can successfully generate entry classes
+ * for external entries that have additional Composable function parameters beyond args.
+ * The processor should properly handle:
+ * - Navigation controller injection in cross-module scenarios
+ * - Implementation type parameters for external entries
+ * - Parameters with default values in external entry contexts
+ * - Mixed parameter types in generated ComposableContent() calls for external entries
+ *
+ * Test coverage:
+ * - External Fragment/Composable entries with and without args + additional parameters
+ * - Proper parameter passing in generated ComposableContent() for external entries
+ * - Cross-module parameter injection and factory method generation
+ *
+ * The tests pass if the annotated functions compile successfully and generate
+ * Entry classes with proper external factory companions that inject additional parameters.
+ */
+
+/**
+ * Destination for Fragment external entry without args but with parameters
+ */
 object ParamsDestination1 : DestinationWithNoArgs
 
+/**
+ * Tests Fragment-based external entry without args but with additional parameters.
+ * Should generate factory companion and proper ComposableContent() with parameter injection
+ */
 @UiExternalEntry(ImplementationType.Fragment, ParamsDestination1::class)
 @Composable
 fun FragmentExternalEntryWithNoArgsWithParams(
@@ -19,9 +46,15 @@ fun FragmentExternalEntryWithNoArgsWithParams(
     paramWithDefaultValue: String = ""
 ) = Unit
 
-
+/**
+ * Destination for Composable external entry without args but with parameters
+ */
 object ParamsDestination2 : DestinationWithNoArgs
 
+/**
+ * Tests Composable-based external entry without args but with additional parameters.
+ * Should generate factory companion and proper ComposableContent() with parameter injection
+ */
 @UiExternalEntry(ImplementationType.Composable, ParamsDestination2::class)
 @Composable
 fun ComposableExternalEntryWithNoArgsWithParams(
@@ -30,9 +63,15 @@ fun ComposableExternalEntryWithNoArgsWithParams(
     paramWithDefaultValue: String = ""
 ) = Unit
 
-
+/**
+ * Destination for Fragment external entry with args and parameters
+ */
 data class ParamsDestination3(override val args: TestArgs) : DestinationWithArgs<TestArgs>
 
+/**
+ * Tests Fragment-based external entry with args and additional parameters.
+ * Should generate factory companion and proper ComposableContent() with args and parameter injection
+ */
 @UiExternalEntry(ImplementationType.Fragment, ParamsDestination3::class)
 @Composable
 fun FragmentExternalEntryWithArgsWithParams(
@@ -42,8 +81,15 @@ fun FragmentExternalEntryWithArgsWithParams(
     paramWithDefaultValue: String = ""
 ) = Unit
 
+/**
+ * Destination for Composable external entry with args and parameters
+ */
 data class ParamsDestination4(override val args: TestArgs) : DestinationWithArgs<TestArgs>
 
+/**
+ * Tests Composable-based external entry with args and additional parameters.
+ * Should generate factory companion and proper ComposableContent() with args and parameter injection
+ */
 @UiExternalEntry(ImplementationType.Composable, ParamsDestination4::class)
 @Composable
 fun ComposableExternalEntryWithArgsWithParams(

tests/src/test/kotlin/nibel/tests/codegen/InternalEntryCompileTest.kt

@@ -6,19 +6,50 @@ import androidx.compose.runtime.Composable
 import nibel.annotations.ImplementationType
 import nibel.annotations.UiEntry
 
+/**
+ * Compilation tests for @UiEntry annotation (internal entries).
+ *
+ * These tests verify that the KSP annotation processor can successfully generate entry classes
+ * for internal (intra-module) navigation targets. Internal entries are defined in the same
+ * module where they are used and don't require external destination declarations.
+ *
+ * Test coverage:
+ * - Fragment entries with and without arguments
+ * - Composable entries with and without arguments
+ * - Proper code generation for basic internal entry patterns
+ *
+ * The tests pass if the annotated functions compile successfully and generate
+ * the corresponding Entry classes without compilation errors.
+ */
 
+/**
+ * Tests Fragment-based internal entry without arguments.
+ * Should generate: FragmentEntryWithNoArgsEntry class extending FragmentEntry
+ */
 @UiEntry(ImplementationType.Fragment)
 @Composable
 fun FragmentEntryWithNoArgs() = Unit
 
+/**
+ * Tests Fragment-based internal entry with arguments.
+ * Should generate: FragmentEntryWithArgsEntry class extending FragmentEntry with TestArgs parameter
+ */
 @UiEntry(ImplementationType.Fragment, TestArgs::class)
 @Composable
 fun FragmentEntryWithArgs() = Unit
 
+/**
+ * Tests Composable-based internal entry without arguments.
+ * Should generate: ComposableEntryWithNoArgsEntry class extending ComposableEntry<Parcelable>
+ */
 @UiEntry(ImplementationType.Composable)
 @Composable
 fun ComposableEntryWithNoArgs() = Unit
 
+/**
+ * Tests Composable-based internal entry with arguments.
+ * Should generate: ComposableEntryWithArgsEntry class extending ComposableEntry<TestArgs>
+ */
 @UiEntry(ImplementationType.Composable, TestArgs::class)
 @Composable
 fun ComposableEntryWithArgs() = Unit

tests/src/test/kotlin/nibel/tests/codegen/InternalEntryParamCompileTest.kt

@@ -7,6 +7,30 @@ import nibel.annotations.ImplementationType
 import nibel.annotations.UiEntry
 import nibel.runtime.NavigationController
 
+/**
+ * Compilation tests for @UiEntry annotation with additional parameters (internal entries).
+ *
+ * These tests verify that the KSP annotation processor can successfully generate entry classes
+ * for internal entries that have additional Composable function parameters beyond args.
+ * The processor should properly handle:
+ * - Navigation controller injection
+ * - Implementation type parameters
+ * - Parameters with default values
+ * - Mixed parameter types in generated ComposableContent() calls
+ *
+ * Test coverage:
+ * - Fragment/Composable entries with and without args + additional parameters
+ * - Proper parameter passing in generated ComposableContent() implementations
+ * - Support for default parameter values
+ *
+ * The tests pass if the annotated functions compile successfully and generate
+ * Entry classes that properly inject the additional parameters.
+ */
+
+/**
+ * Tests Fragment-based internal entry without args but with additional parameters.
+ * Should generate proper ComposableContent() that provides navigator, type, and default values
+ */
 @UiEntry(ImplementationType.Fragment)
 @Composable
 fun FragmentEntryWithNoArgsWithParams(
@@ -15,6 +39,10 @@ fun FragmentEntryWithNoArgsWithParams(
     paramWithDefaultValue: String = ""
 ) = Unit
 
+/**
+ * Tests Composable-based internal entry without args but with additional parameters.
+ * Should generate proper ComposableContent() that provides navigator, type, and default values
+ */
 @UiEntry(ImplementationType.Composable)
 @Composable
 fun ComposableEntryWithNoArgsWithParams(
@@ -23,6 +51,10 @@ fun ComposableEntryWithNoArgsWithParams(
     paramWithDefaultValue: String = ""
 ) = Unit
 
+/**
+ * Tests Fragment-based internal entry with args and additional parameters.
+ * Should generate proper ComposableContent() that provides args, navigator, type, and default values
+ */
 @UiEntry(ImplementationType.Fragment, TestArgs::class)
 @Composable
 fun FragmentEntryWithArgsWithParams(
@@ -32,6 +64,10 @@ fun FragmentEntryWithArgsWithParams(
     paramWithDefaultValue: String = ""
 ) = Unit
 
+/**
+ * Tests Composable-based internal entry with args and additional parameters.
+ * Should generate proper ComposableContent() that provides args, navigator, type, and default values
+ */
 @UiEntry(ImplementationType.Composable, TestArgs::class)
 @Composable
 fun ComposableEntryWithArgsWithParams(