Merge branch 'master' into master-v2

# Conflicts:
#	core/src/test/kotlin/org/neo4j/graphql/TranslatorExceptionTests.kt
#	core/src/test/kotlin/org/neo4j/graphql/utils/AsciiDocTestSuite.kt
#	core/src/test/kotlin/org/neo4j/graphql/utils/CypherTestSuite.kt
#	core/src/test/kotlin/org/neo4j/graphql/utils/GraphQLSchemaTestSuite.kt

Author: Andy2003

core/src/test/kotlin/org/neo4j/graphql/utils/AsciiDocTestSuite.kt

@@ -1,5 +1,7 @@
 package org.neo4j.graphql.utils
 
+import demo.org.neo4j.graphql.utils.asciidoc.ast.CodeBlock
+import demo.org.neo4j.graphql.utils.asciidoc.ast.Section
 import graphql.language.InterfaceTypeDefinition
 import graphql.language.UnionTypeDefinition
 import graphql.schema.GraphQLScalarType
@@ -9,6 +11,7 @@ import graphql.schema.diff.SchemaDiffSet
 import graphql.schema.diff.reporting.CapturingReporter
 import graphql.schema.idl.*
 import org.assertj.core.api.Assertions.assertThat
+import org.bouncycastle.asn1.x500.style.RFC4519Style.title
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Assumptions
 import org.junit.jupiter.api.DynamicNode
@@ -19,48 +22,61 @@ import org.neo4j.graphql.SchemaConfig
 import org.opentest4j.AssertionFailedError
 import java.util.*
 
-class GraphQLSchemaTestSuite(fileName: String) : AsciiDocTestSuite(fileName, TEST_CASE_MARKERS) {
+class GraphQLSchemaTestSuite(fileName: String) : AsciiDocTestSuite<GraphQLSchemaTestSuite.TestCase>(
+    fileName,
+    listOf(
+        matcher("graphql", exactly = true, setter = TestCase::augmentedSchema),
+    )
+) {
 
-    override fun testFactory(
-        title: String,
-        globalBlocks: Map<String, List<ParsedBlock>>,
-        codeBlocks: Map<String, List<ParsedBlock>>,
-        ignore: Boolean
-    ): List<DynamicNode> {
-        val targetSchemaBlock = codeBlocks[GRAPHQL_MARKER]?.first()
+    data class TestCase(
+        var schema: CodeBlock,
+        var schemaConfig: CodeBlock?,
+        var augmentedSchema: CodeBlock? = null,
+    )
+
+    override fun createTestCase(section: Section): TestCase? {
+        val schema = findSetupCodeBlocks(section, "graphql", mapOf("schema" to "true")).firstOrNull() ?: return null
+        val schemaConfig = findSetupCodeBlocks(section, "json", mapOf("schema-config" to "true")).firstOrNull()
+        return TestCase(schema, schemaConfig)
+    }
+
+    override fun createTests(testCase: TestCase, section: Section, ignoreReason: String?): List<DynamicNode> {
+        val targetSchemaBlock = testCase.augmentedSchema
         targetSchemaBlock?.let {
             try {
-                it.reformattedCode = SCHEMA_PRINTER.print(createMockSchema(it.code()))
+                it.reformattedContent = SCHEMA_PRINTER.print(createMockSchema(it.content))
             } catch (ignore: Exception) {
             }
         }
+        if (targetSchemaBlock == null) {
+            return emptyList()
+        }
         val compareSchemaTest = DynamicTest.dynamicTest("compare schema", targetSchemaBlock?.uri) {
-            val configBlock = codeBlocks[SCHEMA_CONFIG_MARKER]?.first()
-            val config = configBlock?.code()?.let { MAPPER.readValue(it, SchemaConfig::class.java) } ?: SchemaConfig()
+            val configBlock = testCase.schemaConfig
+            val config = configBlock?.content?.let { MAPPER.readValue(it, SchemaConfig::class.java) } ?: SchemaConfig()
 
-            val targetSchema = targetSchemaBlock?.code()
-                ?: throw IllegalStateException("missing graphql for $title")
+            val targetSchema = targetSchemaBlock.content
 
             var augmentedSchema: GraphQLSchema? = null
             var expectedSchema: GraphQLSchema? = null
             try {
-                val schema = globalBlocks[SCHEMA_MARKER]?.first()?.code()
-                    ?: throw IllegalStateException("Schema should be defined")
+                val schema = testCase.schema.content
                 augmentedSchema = SchemaBuilder.buildSchema(schema, config, addLibraryDirectivesToSchema = false)
                 expectedSchema = createMockSchema(targetSchema)
 
                 diff(expectedSchema, augmentedSchema)
                 diff(augmentedSchema, expectedSchema)
-                targetSchemaBlock.adjustedCode = SCHEMA_PRINTER.print(augmentedSchema)
+                targetSchemaBlock.generatedContent = SCHEMA_PRINTER.print(augmentedSchema)
             } catch (e: Throwable) {
-                if (ignore) {
-                    Assumptions.assumeFalse(true, e.message)
+                if (ignoreReason != null) {
+                    Assumptions.assumeFalse(true) { "$ignoreReason ${e.message}" }
                 } else {
                     if (augmentedSchema == null) {
                         Assertions.fail<Throwable>(e)
                     }
                     val actualSchema = SCHEMA_PRINTER.print(augmentedSchema)
-                    targetSchemaBlock.adjustedCode = actualSchema
+                    targetSchemaBlock.generatedContent = actualSchema
                     throw AssertionFailedError("augmented schema differs for '$title'",
                         expectedSchema?.let { SCHEMA_PRINTER.print(it) } ?: targetSchema,
                         actualSchema,
@@ -72,6 +88,7 @@ class GraphQLSchemaTestSuite(fileName: String) : AsciiDocTestSuite(fileName, TES
         return Collections.singletonList(compareSchemaTest)
     }
 
+
     private fun createMockSchema(targetSchema: String): GraphQLSchema {
         val schemaParser = SchemaParser()
 
@@ -97,8 +114,6 @@ class GraphQLSchemaTestSuite(fileName: String) : AsciiDocTestSuite(fileName, TES
     }
 
     companion object {
-        private const val GRAPHQL_MARKER = "[source,graphql]"
-        private val TEST_CASE_MARKERS: List<String> = listOf(SCHEMA_CONFIG_MARKER, GRAPHQL_MARKER)
 
         private val SCHEMA_PRINTER = SchemaPrinter(
             SchemaPrinter.Options.defaultOptions()

core/src/test/kotlin/org/neo4j/graphql/utils/CypherTestSuite.kt

@@ -0,0 +1,142 @@
+package demo.org.neo4j.graphql.utils.asciidoc
+
+import demo.org.neo4j.graphql.utils.asciidoc.ast.*
+import java.io.File
+import java.net.URI
+import java.util.regex.Pattern
+import javax.ws.rs.core.UriBuilder
+
+class AsciiDocParser(
+    fileName: String
+) {
+
+    private val file = File(AsciiDocParser::class.java.getResource("/$fileName")?.toURI()!!)
+    private val srcLocation = File("src/test/resources/", fileName).toURI()
+
+    private var root = Document(srcLocation)
+    private var currentSection: Section = root
+    private var currentDepth: Int = 0
+
+
+    fun parse(): Document {
+        val lines = file.readLines()
+        var title: String?
+
+        var insideCodeblock = false
+        var offset = 0
+
+        val fileContent = StringBuilder()
+
+        root = Document(srcLocation)
+        currentSection = root
+        currentDepth = 0
+        var caption: String? = null
+
+        var currentCodeBlock: CodeBlock? = null
+        var content = StringBuilder()
+
+
+        loop@ for ((lineNr, line) in lines.withIndex()) {
+            fileContent.append(line).append('\n')
+
+            if (line.startsWith("#") || line.startsWith("//")) {
+                offset += line.length + 1
+                continue
+            }
+
+            val headlineMatcher = HEADLINE_PATTERN.matcher(line)
+
+            when {
+
+                headlineMatcher.matches() -> {
+                    addBlock(content)
+                    val depth = headlineMatcher.group(1).length
+                    title = headlineMatcher.group(2)
+                    val uri = UriBuilder.fromUri(srcLocation).queryParam("line", lineNr + 1).build()
+                    startSection(title, uri, depth)
+                }
+
+                line.startsWith(".") && !insideCodeblock -> {
+                    caption = line.substring(1).trim()
+                }
+
+                line.startsWith("[source,") -> {
+                    addBlock(content)
+                    val uri = UriBuilder.fromUri(srcLocation).queryParam("line", lineNr + 1).build()
+
+                    val parts = line.substring(8, line.indexOf("]")).trim().split(",")
+                    val language = parts[0]
+                    val attributes = parts.slice(1..<parts.size).map {
+                        val attributeParts = it.split("=")
+                        attributeParts[0] to attributeParts.getOrNull(1)
+                    }.toMap()
+
+                    currentCodeBlock = CodeBlock(uri, language, currentSection, attributes).also {
+                        it.caption = caption
+                        currentSection.blocks.add(it)
+                    }
+                    caption = null
+                }
+
+                line == "'''" -> {
+                    addBlock(content)
+                    currentSection.blocks.add(ThematicBreak())
+                }
+
+                line == "----" -> {
+                    insideCodeblock = !insideCodeblock
+                    if (insideCodeblock) {
+                        currentCodeBlock?.start = offset + line.length + 1
+                        content = StringBuilder()
+                    } else if (currentCodeBlock != null) {
+                        currentCodeBlock.end = offset
+                        currentCodeBlock.content = content.toString().trim()
+                        currentCodeBlock = null
+                        content = StringBuilder()
+                    }
+                }
+
+                else -> {
+                    content.append(line).append("\n")
+                }
+            }
+            offset += line.length + 1 // +1 b/c of newline
+        }
+        addBlock(content)
+        root.content = fileContent.toString()
+        return root
+    }
+
+    private fun addBlock(content: StringBuilder) {
+        val str = content.toString()
+        if (str.trim().isNotEmpty()) {
+            currentSection.let { it.blocks.add(Block(it, str)) }
+        }
+        content.clear()
+    }
+
+    private fun startSection(
+        title: String, uri: URI, depth: Int
+    ) {
+
+        val parent = when {
+            depth > currentDepth -> currentSection
+            depth == currentDepth -> currentSection.parent
+            else -> {
+                var parent = currentSection.parent
+                for (i in 0 until currentDepth - depth) {
+                    parent = parent?.parent
+                }
+                parent
+            }
+        } ?: error("cannot create sub-level on null")
+        currentSection = Section(title, uri, parent)
+            .also { parent.blocks.add(it) }
+
+        currentDepth = depth
+    }
+
+    companion object {
+        private val HEADLINE_PATTERN: Pattern = Pattern.compile("^(=+) (.*)$")
+    }
+}

core/src/test/kotlin/org/neo4j/graphql/utils/GraphQLSchemaTestSuite.kt

@@ -0,0 +1,11 @@
+package demo.org.neo4j.graphql.utils.asciidoc.ast
+
+class Block(
+    parent: StructuralNode,
+    val content: String
+) : StructuralNode(parent) {
+
+    override fun toString(): String {
+        return "Block(content='$content')"
+    }
+}

core/src/test/kotlin/org/neo4j/graphql/utils/asciidoc/AsciiDocParser.kt

@@ -0,0 +1,46 @@
+package demo.org.neo4j.graphql.utils.asciidoc.ast
+
+import java.net.URI
+
+class CodeBlock(
+    val uri: URI,
+    val language: String,
+    override val parent: Section,
+    val attributes: Map<String, String?>
+) : StructuralNode(parent) {
+
+    var caption: String? = null
+
+    var start: Int? = null
+    var end: Int? = null
+
+    lateinit var content: String
+
+    /**
+     * The content that was generated but diffs to the current content
+     */
+    var generatedContent: String? = null
+
+    /**
+     * The original content reformatted
+     */
+    var reformattedContent: String? = null
+
+    var semanticEqual = false
+
+    /**
+     * update only if other (tandem) is also updated
+     */
+    var tandemUpdate: CodeBlock? = null
+
+    val marker: String
+        get() = "[source,$language${attributes.map { ",${it.key}${it.value?.let { "=${it}" } ?: ""}" }.joinToString()}]"
+
+    override fun toString(): String {
+        return "CodeBlock(language='$language', attributes=$attributes)"
+    }
+
+    fun matches(language: String, filter: Map<String, String?> = emptyMap(), exactly: Boolean = false) =
+        this.language == language && filter.all { (k, v) -> attributes[k] == v } && (!exactly || attributes.size == filter.size)
+
+}

core/src/test/kotlin/org/neo4j/graphql/utils/asciidoc/ast/Block.kt

@@ -0,0 +1,11 @@
+package demo.org.neo4j.graphql.utils.asciidoc.ast
+
+import java.net.URI
+
+class Document(
+    uri: URI,
+) : Section(uri.path.substringAfterLast('/'), uri, null) {
+
+    lateinit var content: String
+
+}

core/src/test/kotlin/org/neo4j/graphql/utils/asciidoc/ast/CodeBlock.kt

@@ -0,0 +1,14 @@
+package demo.org.neo4j.graphql.utils.asciidoc.ast
+
+import java.net.URI
+
+open class Section(
+    val title: String,
+    val uri: URI,
+    override val parent: Section?,
+) : StructuralNode(parent) {
+
+    override fun toString(): String {
+        return "Section(title='$title')"
+    }
+}

core/src/test/kotlin/org/neo4j/graphql/utils/asciidoc/ast/Document.kt

@@ -0,0 +1,7 @@
+package demo.org.neo4j.graphql.utils.asciidoc.ast
+
+sealed class StructuralNode(
+    open val parent: StructuralNode?
+) {
+    val blocks = mutableListOf<StructuralNode>()
+}

core/src/test/kotlin/org/neo4j/graphql/utils/asciidoc/ast/Section.kt

@@ -0,0 +1,3 @@
+package demo.org.neo4j.graphql.utils.asciidoc.ast
+
+class ThematicBreak: StructuralNode(null)