improve test api builder to handle multiple documents

Author: hauner

openapi-parser/src/test/kotlin/io/openapiparser/support/ApiBuilder.kt

@@ -7,37 +7,29 @@ package io.openapiparser.support
 
 import io.openapiparser.*
 import io.openapiprocessor.jsonschema.support.Types
-import io.openapiprocessor.jsonschema.reader.StringReader
-import io.openapiprocessor.jsonschema.reader.UriReader
 import io.openapiprocessor.jsonschema.schema.Bucket
 import io.openapiprocessor.jsonschema.schema.DocumentLoader
 import io.openapiprocessor.jsonschema.schema.DocumentStore
 import io.openapiprocessor.jsonschema.schema.Resolver
 import io.openapiprocessor.jsonschema.schema.SchemaVersion
 import io.openapiprocessor.snakeyaml.SnakeYamlConverter
 import io.openapiprocessor.interfaces.Converter
-import io.openapiprocessor.interfaces.Reader
 import java.net.URI
 import io.openapiparser.model.v30.OpenApi as OpenApi30
 import io.openapiparser.model.v31.OpenApi as OpenApi31
 
 class ApiBuilder {
-    private var api: String? = null
-    private lateinit var apiUri: URI
+    private val reader = TestReader()
     private var converter: Converter = SnakeYamlConverter()
     private var documents: DocumentStore = DocumentStore()
 
-    fun withApi(api: String): ApiBuilder {
-        return withYaml("file:///any", api.trimIndent())
-    }
-
-    fun withApi(api: URI): ApiBuilder {
-        apiUri = api
+    fun withApi(apiYaml: String): ApiBuilder {
+        reader.addApi(URI("file:///openapi.yaml"), apiYaml.trimIndent())
         return this
     }
 
-    fun withResource(api: String): ApiBuilder {
-        apiUri = this::class.java.getResource(api)!!.toURI()
+    fun withApi(uri: String, apiYaml: String): ApiBuilder {
+        reader.addApi(URI(uri), apiYaml.trimIndent())
         return this
     }
 
@@ -46,59 +38,69 @@ class ApiBuilder {
         return this
     }
 
+    fun withDocument(uri: URI, document: Any): ApiBuilder {
+        documents.addId(uri, document)
+        return this
+    }
+
     fun buildParser(): OpenApiParser {
-        return OpenApiParser(documents, DocumentLoader(getReader(), converter))
+        return OpenApiParser(documents, DocumentLoader(reader, converter))
     }
 
     fun buildOpenApi30(): OpenApi30 {
+        return buildOpenApi30("file:///openapi.yaml")
+    }
+
+    fun buildOpenApi30(uri: String): OpenApi30 {
+        var source = URI(uri)
+        if (!source.isAbsolute) {
+           source =  this::class.java.getResource(uri)!!.toURI()
+        }
+
         val resolver = createResolver()
-        val result = resolver.resolve(apiUri, Resolver.Settings(SchemaVersion.Draft4))
+        val result = resolver.resolve(source, Resolver.Settings(SchemaVersion.Draft4))
 
         return OpenApi30(
             Context(result.scope, result.registry),
             Bucket(result.scope, Types.asMap(result.document)!!))
     }
 
     fun buildOpenApi31(): OpenApi31 {
+        return buildOpenApi31("file:///openapi.yaml")
+    }
+
+    fun buildOpenApi31(uri: String): OpenApi31 {
+        var source = URI(uri)
+        if (!source.isAbsolute) {
+           source =  this::class.java.getResource(uri)!!.toURI()
+        }
+
         val resolver = createResolver()
-        val result = resolver.resolve(apiUri, Resolver.Settings(SchemaVersion.Draft201909))
+        val result = resolver.resolve(source, Resolver.Settings(SchemaVersion.Draft201909))
 
         return OpenApi31(
             Context(result.scope, result.registry),
             Bucket(result.scope, Types.asMap(result.document)!!))
     }
 
     fun <T> build(clazz: Class<T>): T {
-        return build { c, n -> clazz
+        return build30 { c, n -> clazz
             .getDeclaredConstructor(Context::class.java, Bucket::class.java)
             .newInstance(c, n)
         }
     }
 
-    private fun <T> build(factory: (context: Context, bucket: Bucket) -> T): T {
+    private fun <T> build30(factory: (context: Context, bucket: Bucket) -> T): T {
         val resolver = createResolver()
-        val result = resolver.resolve(apiUri, Resolver.Settings(SchemaVersion.Draft4))
+        val result = resolver.resolve(URI("file:///openapi.yaml"), Resolver.Settings(SchemaVersion.Draft4))
 
         return factory(
             Context(result.scope, result.registry),
             Bucket(result.scope, Types.asMap(result.document)!!))
     }
 
     private fun createResolver(): Resolver {
-        return Resolver(documents, DocumentLoader(getReader(), converter))
-    }
-
-    private fun withYaml(baseUri: String, api: String): ApiBuilder {
-        this.apiUri = URI(baseUri)
-        this.api = api
-        return this
-    }
-
-    private fun getReader(): Reader {
-        if (api == null) {
-            return UriReader()
-        }
-        return StringReader(api!!)
+        return Resolver(documents, DocumentLoader(reader, converter))
     }
 }
 

openapi-parser/src/test/kotlin/io/openapiparser/support/TestReader.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor/openapi-parser
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiparser.support
+
+import io.openapiprocessor.interfaces.Reader
+import io.openapiprocessor.jsonschema.reader.UriReader
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+import java.net.URI
+import java.nio.charset.StandardCharsets
+
+class TestReader: Reader {
+    private val uriReader = UriReader()
+
+    private val apis = mutableMapOf<URI, String>()
+    private val resources = mutableSetOf<URI>()
+
+    override fun read(uri: URI): InputStream {
+        if (apis.contains(uri)) {
+            return ByteArrayInputStream(apis[uri]?.toByteArray(StandardCharsets.UTF_8))
+        }
+
+        return uriReader.read(uri)
+    }
+
+    fun addApi(uri: URI, content: String) {
+        apis[uri] = content
+    }
+}