support loading dependenices, and transpilation

martypitt · martypitt · commit 752b5824272f · 2025-08-08T16:28:51.000+01:00
diff --git a/example-projects/project-with-orbital-dependency/test-resources/env.conf b/example-projects/project-with-orbital-dependency/test-resources/env.conf
@@ -0,0 +1 @@
+"click-events-topic-name" : "click-clack"
diff --git a/example-projects/project-with-orbital-dependency/test/OverridingGlobalEnvVariablesSpec.kt b/example-projects/project-with-orbital-dependency/test/OverridingGlobalEnvVariablesSpec.kt
@@ -0,0 +1,17 @@
+import com.orbitalhq.preflight.dsl.OrbitalSpec
+import io.kotest.matchers.shouldBe
+
+class OverridingGlobalEnvVariablesSpec : OrbitalSpec({
+
+    env("click-events-topic-name", "clickstream")
+    describe("overriding global env config variables") {
+        it("should compile using the overridden env variable") {
+            schema.service("com.foo.PersonEventsKafkaService")
+                .streamOperations
+                .single()
+                .firstMetadata("com.orbitalhq.kafka.KafkaOperation")
+                .params["topic"]
+                .shouldBe("clickstream")
+        }
+    }
+})
diff --git a/example-projects/project-with-orbital-dependency/test/StreamingQuerySpec.kt b/example-projects/project-with-orbital-dependency/test/StreamingQuerySpec.kt
@@ -0,0 +1,37 @@
+import app.cash.turbine.test
+import com.orbitalhq.preflight.dsl.OrbitalSpec
+import kotlin.time.Duration.Companion.seconds
+import com.orbitalhq.expectMap
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+
+class StreamingQuerySpec : OrbitalSpec({
+    describe("Project with Orbital dependencies") {
+        it("can unit test a streaming query") {
+            runNamedQueryForStream("com.foo.StreamPersonEventsToMongo") { stubService ->
+                stubService.addResponseEmitter("clickEvents")
+                    .next(
+                        """{
+                        | "id" : "jimmy"
+                        |}
+                    """.trimMargin()
+                    )
+                stubService.addResponseReturningInputs("upsertPerson")
+            }
+                .test(5.seconds) {
+                    val next = expectMap()
+                    next.shouldNotBeNull()
+                    next.shouldBe(mapOf("personId" to "jimmy"))
+                }
+        }
+        it("resolves the env variables from env.conf") {
+            schema.service("com.foo.PersonEventsKafkaService")
+                .streamOperations
+                .single()
+                .firstMetadata("com.orbitalhq.kafka.KafkaOperation")
+                .params["topic"]
+                .shouldBe("click-clack")
+
+        }
+    }
+})
diff --git a/preflight-core/preflight-gradle-plugin/src/main/kotlin/com/orbitalhq/preflight/gradle/PreflightPlugin.kt b/preflight-core/preflight-gradle-plugin/src/main/kotlin/com/orbitalhq/preflight/gradle/PreflightPlugin.kt
@@ -33,6 +33,7 @@ class PreflightPlugin : Plugin<Project> {
         val mainSourceSet = sourceSets.getByName("main")
 
         val testSourceSet = sourceSets.maybeCreate("test")
+        testSourceSet.resources.srcDir("test-resources")
         testSourceSet.java.srcDir("test")  // top-level test directory
         testSourceSet.compileClasspath += mainSourceSet.output + mainSourceSet.compileClasspath
         testSourceSet.runtimeClasspath += mainSourceSet.output + mainSourceSet.runtimeClasspath
diff --git a/preflight-core/preflight-runtime/build.gradle.kts b/preflight-core/preflight-runtime/build.gradle.kts
@@ -3,8 +3,8 @@ plugins {
     `maven-publish`
 }
 
-val taxiVersion = "1.65.0"
-val orbitalVersion = "0.36.0-M4"
+val taxiVersion = "1.66.0-SNAPSHOT"
+val orbitalVersion = "0.36.0-M9"
 
 dependencies {
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
@@ -24,18 +24,25 @@ dependencies {
         exclude(group = "org.jooq.pro")
         exclude(group = "org.pac4j")
     }
-    api("org.opentest4j:opentest4j:1.3.0")
-    api("com.orbitalhq:taxi-playground-core:$orbitalVersion") {
-        exclude(group = "io.confluent")
-        exclude(group = "org.jooq.pro")
-        exclude(group = "org.pac4j")
-    }
     api("com.orbitalhq:taxiql-query-engine:$orbitalVersion") {
         artifact { classifier = "tests" }
         // Not published to maven central, and not needed for testing
         // as it relates to saml auth
         exclude(group = "org.pac4j")
+
+        // This might need adding (and shading), but later...
+        // Can we avoid by just using the OSS version in Preflight?
+        exclude(group = "org.jooq.pro")
+        exclude(group = "org.pac4j")
     }
+    api("org.opentest4j:opentest4j:1.3.0")
+    api("com.orbitalhq:taxi-playground-core:$orbitalVersion") {
+        exclude(group = "io.confluent")
+        exclude(group = "org.jooq.pro")
+        exclude(group = "org.pac4j")
+    }
+
+    api("app.cash.turbine:turbine-jvm:0.12.1")
     implementation("com.orbitalhq:schema-server-core:$orbitalVersion") {
         // This could become an issue - but this isn't published to maven central
         // If we end up needing this, we'll need to configure
@@ -60,6 +67,7 @@ dependencies {
     implementation("io.kotest:kotest-framework-datatest")
     implementation("io.kotest:kotest-framework-discovery")
     implementation("io.kotest:kotest-assertions-core")
+    testImplementation("io.kotest:kotest-runner-junit5")
 
 
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
@@ -68,6 +76,7 @@ dependencies {
 
 tasks.test {
     useJUnitPlatform()
+    systemProperty("kotest.framework.classpath.scanning.config.disable", "false")
 }
 
 publishing {
diff --git a/preflight-core/preflight-runtime/src/main/kotlin/com/orbitalhq/preflight/dsl/OrbitalSpec.kt b/preflight-core/preflight-runtime/src/main/kotlin/com/orbitalhq/preflight/dsl/OrbitalSpec.kt
@@ -1,8 +1,11 @@
 package com.orbitalhq.preflight.dsl
 
+import com.orbitalhq.Vyne
+import com.orbitalhq.models.TypedInstance
 import com.orbitalhq.schemas.taxi.TaxiSchema
 import com.orbitalhq.stubbing.StubService
 import io.kotest.core.spec.style.DescribeSpec
+import kotlinx.coroutines.flow.Flow
 import lang.taxi.TaxiDocument
 import lang.taxi.packages.TaxiPackageProject
 
@@ -15,10 +18,10 @@ import lang.taxi.packages.TaxiPackageProject
  * 
  * @param body The test specification body that defines the test structure
  */
-abstract class OrbitalSpec(body: OrbitalSpec.() -> Unit) : DescribeSpec() {
+abstract class OrbitalSpec(body: OrbitalSpec.() -> Unit, sourceConfig: PreflightSourceConfig = FilePathSourceConfig(), ) : DescribeSpec() {
 
     @Suppress("MemberVisibilityCanBePrivate")
-    val preflight = PreflightExtension()
+    val preflight = PreflightExtension(sourceConfig)
 
     init {
         extension(preflight)
@@ -47,14 +50,11 @@ abstract class OrbitalSpec(body: OrbitalSpec.() -> Unit) : DescribeSpec() {
             return preflight.schema
         }
 
-    /**
-     * Provides access to the Taxi Package Project - taxi's taxi.conf file,
-     * and source roots etc.
-     */
-    val taxiProject: TaxiPackageProject
-        get() {
-            return preflight.taxiProject
-        }
+    suspend fun runNamedQueryForStream(queryName: String, stubCustomizer: (StubService) -> Unit = {}):Flow<TypedInstance> =
+        preflight.runNamedQueryForStream(queryName, stubCustomizer)
+    suspend fun runNamedQueryForObject(queryName: String, stubCustomizer: (StubService) -> Unit = {}) =
+        preflight.runNamedQueryForObject(queryName, stubCustomizer)
+
     /**
      * Executes the query, and returns a raw scalar value (Int, String, Boolean, etc).
      * Optionally accepts a callback for customizing the Stub service, which allows for
diff --git a/preflight-core/preflight-runtime/src/main/kotlin/com/orbitalhq/preflight/dsl/PreflightExtension.kt b/preflight-core/preflight-runtime/src/main/kotlin/com/orbitalhq/preflight/dsl/PreflightExtension.kt
@@ -10,35 +10,94 @@ import com.orbitalhq.query.QueryResult
 import com.orbitalhq.rawObjects
 import com.orbitalhq.schemaServer.core.adaptors.taxi.TaxiSchemaSourcesAdaptor
 import com.orbitalhq.schemaServer.core.file.FileProjectSpec
+import com.orbitalhq.schemaServer.core.file.packages.FileSystemPackageLoader
 import com.orbitalhq.schemas.taxi.TaxiSchema
 import com.orbitalhq.stubbing.StubService
 import com.orbitalhq.testVyne
+import com.orbitalhq.utils.files.ReactivePollingFileSystemMonitor
+import io.kotest.assertions.AssertionFailedError
 import io.kotest.assertions.fail
 import io.kotest.assertions.withClue
+import io.kotest.core.extensions.TestCaseExtension
+import io.kotest.core.listeners.AfterTestListener
 import io.kotest.core.listeners.BeforeSpecListener
 import io.kotest.core.spec.Spec
+import io.kotest.core.test.TestCase
+import io.kotest.core.test.TestResult
+import kotlinx.coroutines.withContext
 import lang.taxi.CompilationException
 import lang.taxi.TaxiDocument
 import lang.taxi.packages.TaxiPackageLoader
-import lang.taxi.packages.TaxiPackageProject
+import lang.taxi.query.TaxiQLQueryString
+import org.taxilang.packagemanager.DefaultDependencyFetcherProvider
+import org.taxilang.packagemanager.DependencyFetcherProvider
 import java.nio.file.Path
 import java.nio.file.Paths
-import kotlin.io.path.absolute
-import com.orbitalhq.schemaServer.core.file.packages.FileSystemPackageLoader
-import com.orbitalhq.utils.files.ReactivePollingFileSystemMonitor
-import io.kotest.assertions.AssertionFailedError
-import io.kotest.core.extensions.TestCaseExtension
-import io.kotest.core.listeners.AfterTestListener
-import io.kotest.core.test.TestCase
-import io.kotest.core.test.TestResult
-import kotlinx.coroutines.withContext
-import lang.taxi.query.TaxiQLQueryString
 import java.time.Duration
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.coroutineContext
+import kotlin.io.path.absolute
+
+sealed interface PreflightSourceConfig {
+    fun loadSchema(environmentVariables: Map<String,String> = emptyMap()): TaxiSchema
+}
 
-class PreflightExtension(val projectRoot: Path = Paths.get("./")) : BeforeSpecListener, AfterTestListener,
-    TestCaseExtension {
+class FilePathSourceConfig(
+    private val projectRoot: Path = Paths.get("./"),
+    private val dependencyFetcherProvider: DependencyFetcherProvider = DefaultDependencyFetcherProvider
+) : PreflightSourceConfig {
+    override fun loadSchema(environmentVariables: Map<String, String>): TaxiSchema {
+        val loader = TaxiPackageLoader.forDirectoryContainingTaxiFile(projectRoot.absolute().normalize())
+        val taxiProject = loader.load()
+        val sourcePackage = loadSourcePackage(taxiProject.packageRootPath!!)
+
+        return withClue("Taxi project should compile without errors") {
+            val taxiSchema = try {
+                TaxiSchema.from(
+                    sourcePackage,
+                    environmentVariables = environmentVariables,
+                    onErrorBehaviour = TaxiSchema.Companion.TaxiSchemaErrorBehaviour.THROW_EXCEPTION
+                )
+            } catch (e: CompilationException) {
+                fail("Taxi project has errors: \n${e.message}")
+            }
+            taxiSchema
+        }
+    }
+
+    /**
+     * Loads a source path into a SourcePackage
+     * Uses the orbital approach of loading (using a FileSystemPackageLoader)
+     * rather than a simple TaxiPackageLoader, as we need to support transpilation of non-taxi sources
+     */
+    private fun loadSourcePackage(packageRootPath: Path): SourcePackage {
+        val spec = FileProjectSpec(path = packageRootPath)
+        val fileMonitor = ReactivePollingFileSystemMonitor(packageRootPath, Duration.ofHours(9999))
+        val converter = TaxiSchemaSourcesAdaptor(
+            dependencyFetcherProvider = dependencyFetcherProvider
+        )
+        val packageLoader = FileSystemPackageLoader(spec, converter, fileMonitor)
+        val packageMetadata = converter.buildMetadata(packageLoader)
+            .block()!!
+        val sourcePackage = converter.convert(packageMetadata, packageLoader).block()!!
+        return sourcePackage
+    }
+}
+
+class StringSourceConfig(private val source: String) : PreflightSourceConfig {
+    override fun loadSchema(environmentVariables: Map<String, String>): TaxiSchema {
+        return TaxiSchema.from(source, environmentVariables = environmentVariables)
+    }
+}
+
+fun forSchema(source: String) = StringSourceConfig(source)
+
+class PreflightExtension(private val sourceConfig: PreflightSourceConfig = FilePathSourceConfig(),
+    private val envVariableContainer: EnvVariableContainer = SpecEnvVariables.newInstance()
+    ) : BeforeSpecListener,
+    AfterTestListener,
+    TestCaseExtension,
+    EnvVariableContainer by envVariableContainer {
 
     companion object {
         val PreflightTestCaseKey = object : CoroutineContext.Key<PreflightTestCaseContext> {}
@@ -54,14 +113,7 @@ class PreflightExtension(val projectRoot: Path = Paths.get("./")) : BeforeSpecLi
     lateinit var schema: TaxiSchema
         private set
 
-    lateinit var sourcePackage: SourcePackage
-        private set
-
-    /**
-     * Provides access to the actual Taxi project (the equivalent of the
-     * taxi.conf file)
-     */
-    lateinit var taxiProject: TaxiPackageProject
+    private lateinit var sourcePackage: SourcePackage
         private set
 
     private val capturedScenarios = mutableMapOf<TestCase, CapturedQuery>()
@@ -71,10 +123,7 @@ class PreflightExtension(val projectRoot: Path = Paths.get("./")) : BeforeSpecLi
         envVariableContainer.markImmutable()
         withClue("Taxi project should compile without errors") {
             val taxiSchema = try {
-                TaxiSchema.from(
-                    sourcePackage,
-                    onErrorBehaviour = TaxiSchema.Companion.TaxiSchemaErrorBehaviour.THROW_EXCEPTION
-                )
+                sourceConfig.loadSchema(environmentVariables = envVariableContainer.envVariables)
             } catch (e: CompilationException) {
                 fail("Taxi project has errors: \n${e.message}")
             }
@@ -84,23 +133,8 @@ class PreflightExtension(val projectRoot: Path = Paths.get("./")) : BeforeSpecLi
         }
     }
 
-    /**
-     * Loads a source path into a SourcePackage
-     * Uses the orbital approach of loading (using a FileSystemPackageLoader)
-     * rather than a simple TaxiPackageLoader, as we need to support transpilation of non-taxi sources
-     */
-    private fun loadSourcePackage(packageRootPath: Path): SourcePackage {
-        val spec = FileProjectSpec(path = packageRootPath)
-        val fileMonitor = ReactivePollingFileSystemMonitor(packageRootPath, Duration.ofHours(9999))
-        val packageLoader = FileSystemPackageLoader(spec, TaxiSchemaSourcesAdaptor(), fileMonitor)
-        val converter = TaxiSchemaSourcesAdaptor()
-        val packageMetadata = converter.buildMetadata(packageLoader)
-            .block()!!
-        val sourcePackage = converter.convert(packageMetadata, packageLoader).block()!!
-        return sourcePackage
-    }
 
-    fun orbital(): Pair<Orbital, StubService> {
+    private fun orbital(): Pair<Orbital, StubService> {
         return testVyne(this.schema)
     }
 
@@ -148,7 +182,26 @@ class PreflightExtension(val projectRoot: Path = Paths.get("./")) : BeforeSpecLi
             .firstTypedInstace()
     }
 
-    suspend fun query(taxiQl: String, stubCustomizer: (StubService) -> Unit = {}): QueryResult {
+    suspend fun runNamedQueryForObject(queryName: String, stubCustomizer: (StubService) -> Unit = {}) =
+        runNamedQuery(queryName, stubCustomizer)
+            .firstTypedInstace()
+
+    suspend fun runNamedQueryForStream(queryName: String, stubCustomizer: (StubService) -> Unit = {}) =
+        runNamedQuery(queryName, stubCustomizer).results
+
+    private suspend fun runNamedQuery(queryName: String, stubCustomizer: (StubService) -> Unit = {}): QueryResult {
+        val (orbital) = orbital()
+        val savedQuery = orbital.schema.queries.singleOrNull {
+            it.name.parameterizedName == queryName || it.name.name == queryName
+        }
+        if (savedQuery == null) {
+            fail("No query named $queryName was found")
+        }
+        val taxiQl = savedQuery.sources.joinToString("\n") { it.content }
+        return query(taxiQl, stubCustomizer)
+    }
+
+    private suspend fun query(taxiQl: String, stubCustomizer: (StubService) -> Unit = {}): QueryResult {
         val (orbital, stub) = orbital()
         stubCustomizer(stub)
         val testContext = coroutineContext[PreflightTestCaseKey]
@@ -165,7 +218,7 @@ class PreflightExtension(val projectRoot: Path = Paths.get("./")) : BeforeSpecLi
         return withContext(context) {
             val testResult = execute(testCase)
             val capturedScenario = capturedScenarios[testCase]
-            if (testResult.isErrorOrFailure && capturedScenario != null) {
+            if (testResult.isFailure && capturedScenario != null) {
 
                 val failure = testResult as TestResult.Failure
                 val originalError = failure.cause as AssertionFailedError
@@ -204,4 +257,4 @@ data class CapturedQuery(
 
 data class PreflightTestCaseContext(val testCase: TestCase) : CoroutineContext.Element {
     override val key = PreflightTestCaseKey
-}
+}
diff --git a/preflight-core/preflight-runtime/src/test/kotlin/com/orbitalhq/preflight/ExamplesSpec.kt b/preflight-core/preflight-runtime/src/test/kotlin/com/orbitalhq/preflight/ExamplesSpec.kt

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+"click-events-topic-name" : "click-clack"`