Add nullable types to random provider type generator (#62)

Author: andrew-kirkham

core/src/main/kotlin/io/github/serpro69/kfaker/provider/RandomProvider.kt

@@ -75,12 +75,17 @@ class RandomProvider internal constructor(random: Random) {
             } ?: throw NoSuchElementException("No suitable constructor found for $this")
 
             val params = constructor.parameters
-                .map { it.type.classifier as KClass<*> }
+                .map { it.type }
                 .map {
-                    it.predefinedTypeOrNull(config)
-                        ?: it.randomPrimitiveOrNull()
-                        ?: it.randomEnumOrNull()
-                        ?: it.randomClassInstance(config)
+                    val klass = it.classifier as KClass<*>
+                    if (it.isMarkedNullable && config.nullableGenerators.containsKey(klass)) {
+                        config.nullableGenerators[klass]?.invoke()
+                    } else {
+                        klass.predefinedTypeOrNull(config)
+                            ?: klass.randomPrimitiveOrNull()
+                            ?: klass.randomEnumOrNull()
+                            ?: klass.randomClassInstance(config)
+                    }
                 }
                 .toTypedArray()
 
@@ -140,12 +145,22 @@ class RandomProviderConfig @PublishedApi internal constructor() {
     @PublishedApi
     internal val predefinedGenerators = mutableMapOf<KClass<*>, () -> Any>()
 
+    @PublishedApi
+    internal val nullableGenerators = mutableMapOf<KClass<*>, () -> Any?>()
+
     /**
      * Configures generation for a specific type. It can override internal generators (for primitives, for example)
      */
     inline fun <reified K : Any> typeGenerator(noinline generator: () -> K) {
         predefinedGenerators[K::class] = generator
     }
+
+    /**
+     * Configures generation for a specific nullable type. It can override internal generators (for primitives, for example)
+     */
+    inline fun <reified K : Any?> nullableTypeGenerator(noinline generator: () -> K?) {
+        nullableGenerators[K::class] = generator
+    }
 }
 
 enum class FallbackStrategy {

core/src/test/kotlin/io/github/serpro69/kfaker/provider/RandomProviderTest.kt

@@ -154,6 +154,45 @@ class RandomProviderTest : DescribeSpec({
         }
     }
 
+    describe("a TestClass with non-empty constructor for nullable custom type generators") {
+        class Foo(val int: Int?)
+        class TestClass(
+            val id: UUID,
+            val int: Int?,
+            val nullableLong: Long?,
+            val notNullLong: Long,
+            val foo: Foo
+        )
+
+        val givenUuid = UUID.fromString("00000000-0000-0000-0000-000000000000")
+        val givenInt = 1
+        val givenNullableLong: Long? = null
+        val givenLong = 1L
+
+        context("creating a random instance of the class with nullable custom generators") {
+            val testClass: TestClass = randomProvider.randomClassInstance {
+                @Suppress("RemoveExplicitTypeArguments")
+                typeGenerator<UUID> { givenUuid }
+                @Suppress("RemoveExplicitTypeArguments")
+                typeGenerator<Int> { givenInt } // use the not-null type generator and verify it is used for Int?
+                nullableTypeGenerator<Long?> { givenNullableLong }
+                @Suppress("RemoveExplicitTypeArguments")
+                typeGenerator<Long> { givenLong }
+            }
+
+            it("it should be a predefined UUID and primitives with nulls") {
+                assertSoftly {
+                    testClass shouldBe instanceOf(TestClass::class)
+                    testClass.id shouldBe givenUuid
+                    testClass.int shouldBe givenInt
+                    testClass.nullableLong shouldBe givenNullableLong
+                    testClass.notNullLong shouldBe givenLong
+                    testClass.foo.int shouldBe givenInt
+                }
+            }
+        }
+    }
+
     describe("a TestClass with 3 non-default constructors") {
 
         class Foo