feat: java.time.ZonedDateTime resolver

src/main/kotlin/dev/appoutlet/some/config/SomeConfig.kt

@@ -18,6 +18,7 @@ import dev.appoutlet.some.resolver.IntResolver
 import dev.appoutlet.some.resolver.JavaDurationResolver
 import dev.appoutlet.some.resolver.JavaInstantResolver
 import dev.appoutlet.some.resolver.JavaUuidResolver
+import dev.appoutlet.some.resolver.JavaZonedDateTimeResolver
 import dev.appoutlet.some.resolver.KotlinDurationResolver
 import dev.appoutlet.some.resolver.KotlinInstantResolver
 import dev.appoutlet.some.resolver.KotlinUuidResolver
@@ -114,6 +115,7 @@ data class SomeConfig(
             JavaUuidResolver(),
             JavaInstantResolver(random),
             JavaDurationResolver(random),
+            JavaZonedDateTimeResolver(random),
             BigDecimalResolver(random),
             BigIntegerResolver(random),
             LocalDateResolver(random),

src/main/kotlin/dev/appoutlet/some/resolver/JavaZonedDateTimeResolver.kt

@@ -0,0 +1,34 @@
+package dev.appoutlet.some.resolver
+
+import dev.appoutlet.some.core.ResolverChain
+import dev.appoutlet.some.core.TypeResolver
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.Year
+import java.time.ZoneOffset
+import java.time.ZonedDateTime
+import kotlin.random.Random
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+private const val HOURS_IN_DAY = 24
+private const val MINUTES_IN_HOUR = 60
+private const val SECONDS_IN_MINUTE = 60
+private const val START_YEAR = 1970
+private const val END_YEAR = 2100
+
+class JavaZonedDateTimeResolver(private val random: Random) : TypeResolver {
+    override fun canResolve(type: KType): Boolean {
+        return type == typeOf<ZonedDateTime>()
+    }
+
+    override fun resolve(type: KType, chain: ResolverChain): Any {
+        val year = random.nextInt(START_YEAR, END_YEAR + 1)
+        val dayOfYear = random.nextInt(1, Year.of(year).length() + 1)
+        val hour = random.nextInt(HOURS_IN_DAY)
+        val minute = random.nextInt(MINUTES_IN_HOUR)
+        val second = random.nextInt(SECONDS_IN_MINUTE)
+        val date = LocalDate.ofYearDay(year, dayOfYear)
+        return ZonedDateTime.of(date, LocalTime.of(hour, minute, second), ZoneOffset.UTC)
+    }
+}

src/test/kotlin/dev/appoutlet/some/resolver/JavaZonedDateTimeResolverTest.kt

@@ -0,0 +1,48 @@
+package dev.appoutlet.some.resolver
+
+import dev.appoutlet.some.test.defaultTestChain
+import java.time.Instant
+import java.time.ZonedDateTime
+import kotlin.random.Random
+import kotlin.reflect.typeOf
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+
+class JavaZonedDateTimeResolverTest {
+    @Test
+    fun `JavaZonedDateTimeResolver generates ZonedDateTime values`() {
+        val resolver = JavaZonedDateTimeResolver(Random.Default)
+
+        val result = resolver.resolve(typeOf<ZonedDateTime>(), defaultTestChain)
+        assertIs<ZonedDateTime>(result)
+    }
+
+    @Test
+    fun `JavaZonedDateTimeResolver generates ZonedDateTime within valid range`() {
+        val resolver = JavaZonedDateTimeResolver(Random.Default)
+        val start = ZonedDateTime.parse("1970-01-01T00:00:00Z")
+        val end = ZonedDateTime.parse("2101-01-01T00:00:00Z")
+
+        repeat(100) {
+            val result = resolver.resolve(typeOf<ZonedDateTime>(), defaultTestChain) as ZonedDateTime
+            assertTrue(result.isAfter(start) || result.isEqual(start), "ZonedDateTime should be after or at 1970-01-01")
+            assertTrue(result.isBefore(end), "ZonedDateTime should be before 2101-01-01")
+        }
+    }
+
+    @Test
+    fun `JavaZonedDateTimeResolver canResolve detects ZonedDateTime type`() {
+        val resolver = JavaZonedDateTimeResolver(Random.Default)
+        assertTrue(resolver.canResolve(typeOf<ZonedDateTime>()))
+    }
+
+    @Test
+    fun `JavaZonedDateTimeResolver rejects other types`() {
+        val resolver = JavaZonedDateTimeResolver(Random.Default)
+        assertFalse(resolver.canResolve(typeOf<String>()), "Should not resolve String")
+        assertFalse(resolver.canResolve(typeOf<Int>()), "Should not resolve Int")
+        assertFalse(resolver.canResolve(typeOf<Instant>()), "Should not resolve java.time.Instant")
+    }
+}