Merge pull request #55 from bennesp/add-tests

bennesp · web-flow · commit f5b6388df02b · 2023-08-25T11:58:03.000+02:00
Add tests
diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml
@@ -0,0 +1,20 @@
+name: Run tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches: [master]
+  workflow_dispatch: {}
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Run tests
+        run: ./gradlew test
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -1,3 +1,5 @@
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+
 plugins {
     kotlin("jvm") version "1.9.0"
 }
@@ -13,6 +15,7 @@ repositories {
 dependencies {
     @Suppress("LocalVariableName")
     val ktor_version = "2.3.3"
+
     @Suppress("LocalVariableName")
     val logback_version = "1.4.11"
 
@@ -59,6 +62,11 @@ configurations.all {
 
 tasks.test {
     useJUnitPlatform()
+    maxParallelForks = 4
+
+    testLogging {
+        events(TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED)
+    }
 }
 
 tasks.jar {
diff --git a/src/main/kotlin/it/bennes/jsonSchemaGenerator/Routes.kt b/src/main/kotlin/it/bennes/jsonSchemaGenerator/Routes.kt
@@ -3,11 +3,11 @@ package it.bennes.jsonSchemaGenerator
 import it.bennes.jsonSchemaGenerator.encoding.Encoding
 import it.bennes.jsonSchemaGenerator.exceptions.BadRequestException
 import it.bennes.jsonSchemaGenerator.formats.Format
-import io.ktor.client.request.*
 import io.ktor.client.statement.*
 import io.ktor.server.application.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
+import it.bennes.jsonSchemaGenerator.model.JsonSchemaInferrer
 import it.bennes.jsonSchemaGenerator.model.Request
 
 fun Route.main() {
@@ -25,42 +25,55 @@ fun Route.main() {
             HttpClient.get(url).bodyAsText()
         } else data ?: throw BadRequestException("No url or data provided")
 
-        // Decode data
-        val encoder = Encoding.fromString(encoding)
-        val decodedContent = try {
-            encoder.decoder.decode(content)
-        } catch (e: Exception) {
-            throw BadRequestException("error during decoding: ${e.message}")
-        }
-
         // Generate schema
-        //   1. Parse data
-        val schemaService = SchemaService(Format.fromString(inputFormat), Format.fromString(outputFormat))
-        val parsedContent = schemaService.parse(decodedContent)
+        val schemaAsString = generateSchemaAsString(encoding, content, inputFormat, outputFormat, selector, generate)
 
-        //   2. Select data, if selector is provided
-        val selectedContent = if (selector != null) {
-            val node = parsedContent.at(selector)
-            if (node.isMissingNode) {
-                throw BadRequestException("selector did not match any node")
-            }
-            node
-        } else {
-            parsedContent
-        }
+        // Respond with the schema to the client
+        call.respond(schemaAsString)
 
-        //   3. Generate schema, if generate is true
-        val schema = if (generate) {
-            schemaService.generate(selectedContent)
-        } else {
-            selectedContent
-        }
+    }
+}
 
-        //   4. Encode schema
-        val schemaAsString = schemaService.toString(schema)
+private fun generateSchemaAsString(
+    encoding: String,
+    content: String,
+    inputFormat: String,
+    outputFormat: String,
+    selector: String?,
+    generate: Boolean,
+): String {
+    // Generate schema
+    //   1. Decode data
+    val encoder = Encoding.fromString(encoding)
+    val decodedContent = try {
+        encoder.decoder.decode(content)
+    } catch (e: Exception) {
+        throw BadRequestException("error during decoding: ${e.message}")
+    }
 
-        //   5. Respond with the schema to the client
-        call.respond(schemaAsString)
+    //   2. Parse data
+    val inferrer = JsonSchemaInferrer()
+    val schemaService = SchemaService(inferrer, Format.fromString(inputFormat), Format.fromString(outputFormat))
+    val parsedContent = schemaService.parse(decodedContent)
+
+    //   3. Select data, if selector is provided
+    val selectedContent = if (selector != null) {
+        val node = parsedContent.at(selector)
+        if (node.isMissingNode) {
+            throw BadRequestException("selector did not match any node")
+        }
+        node
+    } else {
+        parsedContent
+    }
 
+    //   4. Generate schema, if generate is true
+    val schema = if (generate) {
+        schemaService.generate(selectedContent)
+    } else {
+        selectedContent
     }
+
+    //   5. Encode schema
+    return schemaService.toString(schema)
 }
diff --git a/src/main/kotlin/it/bennes/jsonSchemaGenerator/SchemaService.kt b/src/main/kotlin/it/bennes/jsonSchemaGenerator/SchemaService.kt
@@ -2,13 +2,12 @@ package it.bennes.jsonSchemaGenerator
 
 import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.ObjectMapper
-import com.saasquatch.jsonschemainferrer.JsonSchemaInferrer
 import it.bennes.jsonSchemaGenerator.formats.Format
+import it.bennes.jsonSchemaGenerator.model.JsonSchemaInferrer
 
-class SchemaService(inputFormat: Format, outputFormat: Format) {
+class SchemaService(private val inferrer: JsonSchemaInferrer, inputFormat: Format, outputFormat: Format) {
     private var inputMapper = ObjectMapper(inputFormat.factory)
     private var outputMapper = ObjectMapper(outputFormat.factory)
-    private val inferrer = JsonSchemaInferrer.newBuilder().build()
 
     fun parse(input: String): JsonNode = inputMapper.readTree(input)
 
diff --git a/src/main/kotlin/it/bennes/jsonSchemaGenerator/model/JsonSchemaInferrer.kt b/src/main/kotlin/it/bennes/jsonSchemaGenerator/model/JsonSchemaInferrer.kt
@@ -0,0 +1,15 @@
+package it.bennes.jsonSchemaGenerator.model
+
+import com.fasterxml.jackson.databind.JsonNode
+import com.saasquatch.jsonschemainferrer.JsonSchemaInferrer
+
+interface IJsonSchemaInferrer {
+    fun inferForSample(content: JsonNode): JsonNode
+}
+
+class JsonSchemaInferrer : IJsonSchemaInferrer {
+    private val inferrer: JsonSchemaInferrer = JsonSchemaInferrer.newBuilder().build()
+    override fun inferForSample(content: JsonNode): JsonNode {
+        return inferrer.inferForSample(content)
+    }
+}
diff --git a/src/main/kotlin/it/bennes/jsonSchemaGenerator/model/Request.kt b/src/main/kotlin/it/bennes/jsonSchemaGenerator/model/Request.kt
@@ -40,7 +40,7 @@ data class Request(
                     || address.isSiteLocalAddress
                     || address.isMulticastAddress
                 ) {
-                    throw BadRequestException("url must not be localhost")
+                    throw BadRequestException("url must not be local")
                 }
                 uri.toString()
             } else null
@@ -54,19 +54,19 @@ data class Request(
             val inputFormat = if ("input" in p) {
                 p["input"]!!
             } else {
-                Format.Yaml.name
+                Format.Yaml.name.lowercase()
             }
 
             val outputFormat = if ("output" in p) {
                 p["output"]!!
             } else {
-                Format.Json.name
+                Format.Json.name.lowercase()
             }
 
             val encoding = if ("encoding" in p) {
                 p["encoding"]!!
             } else {
-                Encoding.Nop.name
+                Encoding.Nop.name.lowercase()
             }
 
             val generate = if ("generate" in p) {
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/SchemaServiceTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/SchemaServiceTest.kt
@@ -0,0 +1,59 @@
+package it.bennes.jsonSchemaGenerator
+
+import com.fasterxml.jackson.core.JsonParseException
+import it.bennes.jsonSchemaGenerator.formats.Format
+import it.bennes.jsonSchemaGenerator.model.JsonSchemaInferrer
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+
+class SchemaServiceTest {
+
+    @Test
+    fun `valid parse`() {
+        val schemaService = SchemaService(JsonSchemaInferrer(), Format.Json, Format.Json)
+        val expected = """{"a":1}"""
+        val actual = schemaService.parse(expected)
+
+        assertEquals(expected, actual.toString())
+    }
+
+    @Test
+    fun `invalid parse`() {
+        val schemaService = SchemaService(JsonSchemaInferrer(), Format.Json, Format.Json)
+        val expected = """{"a":1"""
+        assertFailsWith<JsonParseException> {
+            schemaService.parse(expected)
+        }
+    }
+
+    @Test
+    fun `valid simple generate`() {
+        val schemaService = SchemaService(JsonSchemaInferrer(), Format.Json, Format.Json)
+        val input = """{"a":1}"""
+        val expected = """{"${"$"}schema":"http://json-schema.org/draft-04/schema#","type":"object","properties":{"a":{"type":"integer"}}}"""
+        val actual = schemaService.generate(schemaService.parse(input))
+
+        assertEquals(expected, actual.toString())
+    }
+
+    @Test
+    fun `invalid generate`() {
+        val schemaService = SchemaService(JsonSchemaInferrer(), Format.Json, Format.Json)
+        val input = """{"a":1"""
+        assertFailsWith<JsonParseException> {
+            schemaService.generate(schemaService.parse(input))
+        }
+    }
+
+    @Test
+    fun `test parse and toString to be reversible`() {
+        val schemaService = SchemaService(JsonSchemaInferrer(), Format.Json, Format.Json)
+        val input = """{"a":1}"""
+        val expected = """{"a":1}"""
+        val actual = schemaService.toString(schemaService.parse(input))
+
+        assertEquals(expected, actual)
+    }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/Base64DecoderTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/Base64DecoderTest.kt
@@ -0,0 +1,22 @@
+package it.bennes.jsonSchemaGenerator.encoding
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+class Base64DecoderTest {
+
+    @Test
+    fun `test decode with valid input`() {
+        val decoder = Base64Decoder()
+        assertEquals("This is a test", decoder.decode("VGhpcyBpcyBhIHRlc3Q="))
+    }
+
+    @Test
+    fun `test decode with invalid input`() {
+        val decoder = Base64Decoder()
+        assertFailsWith<IllegalArgumentException> {
+            decoder.decode("This is a test")
+        }
+    }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/EncodingTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/EncodingTest.kt
@@ -0,0 +1,29 @@
+package it.bennes.jsonSchemaGenerator.encoding
+
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.Test
+
+class EncodingTest {
+
+    @Test
+    fun `test fromString with valid input`() {
+        assertEquals(Encoding.Nop, Encoding.fromString("nop"))
+        assertEquals(Encoding.Base64, Encoding.fromString("base64"))
+        assertEquals(Encoding.Hex, Encoding.fromString("hex"))
+    }
+
+    @Test
+    fun `test fromString with invalid input`() {
+        assertFailsWith<IllegalArgumentException> {
+            Encoding.fromString("invalid")
+        }
+    }
+
+    @Test
+    fun `test decoder instances`() {
+        assertEquals(NopDecoder::class, Encoding.Nop.decoder::class)
+        assertEquals(Base64Decoder::class, Encoding.Base64.decoder::class)
+        assertEquals(HexDecoder::class, Encoding.Hex.decoder::class)
+    }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/HexDecoderTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/HexDecoderTest.kt
@@ -0,0 +1,24 @@
+package it.bennes.jsonSchemaGenerator.encoding
+
+
+import java.lang.IllegalArgumentException
+import kotlin.test.assertEquals
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+class HexDecoderTest {
+
+    @Test
+    fun `test decode with valid input`() {
+        val decoder = HexDecoder()
+        assertEquals("This is a test", decoder.decode("5468697320697320612074657374"))
+    }
+
+    @Test
+    fun `test decode with invalid input`() {
+        val decoder = HexDecoder()
+        assertFailsWith<IllegalArgumentException> {
+            decoder.decode("This is a test")
+        }
+    }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/NopDecoderTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/encoding/NopDecoderTest.kt
@@ -0,0 +1,13 @@
+package it.bennes.jsonSchemaGenerator.encoding
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class NopDecoderTest {
+
+    @Test
+    fun decode() {
+        val decoder = NopDecoder()
+        assertEquals("This is a test", decoder.decode("This is a test"))
+    }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/exceptions/BadRequestExceptionTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/exceptions/BadRequestExceptionTest.kt
@@ -0,0 +1,15 @@
+package it.bennes.jsonSchemaGenerator.exceptions
+
+import io.ktor.http.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class BadRequestExceptionTest {
+
+        @Test
+        fun `test constructor`() {
+            val exception = BadRequestException("message")
+            assertEquals("message", exception.message)
+            assertEquals(HttpStatusCode.BadRequest, exception.statusCode)
+        }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/exceptions/HTTPExceptionTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/exceptions/HTTPExceptionTest.kt
@@ -0,0 +1,14 @@
+package it.bennes.jsonSchemaGenerator.exceptions
+
+import io.ktor.http.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class HTTPExceptionTest {
+    @Test
+    fun `test constructor`() {
+        val exception = HTTPException(HttpStatusCode.NotFound, "not found")
+        assertEquals("not found", exception.message)
+        assertEquals(HttpStatusCode.NotFound, exception.statusCode)
+    }
+}
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/formats/FormatTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/formats/FormatTest.kt
diff --git a/src/test/kotlin/it/bennes/jsonSchemaGenerator/model/RequestTest.kt b/src/test/kotlin/it/bennes/jsonSchemaGenerator/model/RequestTest.kt
