Add greedy path variables to UriTemplate

Also see AWS documentation for greedy path variables:
https://aws.amazon.com/blogs/aws/api-gateway-update-new-features-simplify-api-development/

Author: blockvote

router/build.gradle.kts

@@ -12,6 +12,7 @@ dependencies {
     compile("com.google.guava:guava:23.0")
 
     testImplementation("org.junit.jupiter:junit-jupiter-engine:5.4.0")
+    testImplementation("org.junit.jupiter:junit-jupiter-params:5.4.0")
     testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.12")
     testImplementation("org.assertj:assertj-core:3.11.1")
     testImplementation("io.mockk:mockk:1.8.13.kotlin13")

router/src/main/kotlin/io/moia/router/UriTemplate.kt

@@ -1,5 +1,6 @@
 package io.moia.router
 
+import java.lang.IllegalArgumentException
 import java.net.URLDecoder
 import java.util.regex.Pattern
 
@@ -9,16 +10,29 @@ class UriTemplate private constructor(private val template: String) {
     private val parameterNames: List<String>
 
     init {
-        matches = URI_TEMPLATE_FORMAT.findAll(template)
+        if (INVALID_GREEDY_PATH_VARIABLE_REGEX.matches(template)) {
+            throw IllegalArgumentException("Greedy path variables (e.g. '{proxy+}' are only allowed at the end of the template")
+        }
+        matches = PATH_VARIABLE_REGEX.findAll(template)
         parameterNames = matches.map { it.groupValues[1] }.toList()
         templateRegex = template.replace(
-            URI_TEMPLATE_FORMAT,
+            PATH_VARIABLE_REGEX,
             { notMatched -> Pattern.quote(notMatched) },
-            { matched -> if (matched.groupValues[2].isBlank()) "([^/]+)" else "(${matched.groupValues[2]})" }).toRegex()
+            { matched ->
+                // check for greedy path variables, e.g. '{proxy+}'
+                if (matched.groupValues[1].endsWith("+")) {
+                    return@replace "(.+)"
+                }
+                if (matched.groupValues[2].isBlank()) "([^/]+)" else "(${matched.groupValues[2]})"
+            }
+        ).toRegex()
     }
 
     companion object {
-        private val URI_TEMPLATE_FORMAT = "\\{([^}]+?)(?::([^}]+))?}".toRegex()
+        private val PATH_VARIABLE_REGEX = "\\{([^}]+?)(?::([^}]+))?}".toRegex()
+        private val INVALID_GREEDY_PATH_VARIABLE_REGEX = ".*\\{([^}]+?)(?::([^}]+))?\\+}.+".toRegex()
+
+        // Removes query params
         fun from(template: String) = UriTemplate(template.split('?')[0].trimSlashes())
 
         fun String.trimSlashes() = "^(/)?(.*?)(/)?$".toRegex().replace(this) { result -> result.groupValues[2] }

router/src/test/kotlin/io/moia/router/RouterTest.kt

@@ -6,6 +6,7 @@ import assertk.assertions.hasSize
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
 import io.moia.router.Router.Companion.router
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 class RouterTest {
@@ -26,4 +27,19 @@ class RouterTest {
             assert(produces).containsAll("application/json", "application/x-protobuf")
         }
     }
+
+    @Test
+    fun `should handle greedy path variables successfully`() {
+        val router = router {
+            POST("/some/{proxy+}") { r: Request<Unit> ->
+                ResponseEntity.ok("""{"hello": "world", "request":"${r.body}"}""")
+            }
+        }
+        assert(router.routes).hasSize(1)
+        with(router.routes.first().requestPredicate) {
+            assert(method).isEqualTo("POST")
+            assertTrue(UriTemplate.from(pathPattern).matches("/some/sub/sub/sub/path"))
+            assert(produces).containsAll("application/json", "application/x-protobuf")
+        }
+    }
 }

router/src/test/kotlin/io/moia/router/UriTemplateTest.kt

@@ -1,49 +1,93 @@
 package io.moia.router
 
 import org.assertj.core.api.BDDAssertions.then
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
 import java.util.UUID
 
 class UriTemplateTest {
 
-    @Test
-    fun `should match without parameter`() {
-        then(UriTemplate.from("/some").matches("/some")).isTrue()
+    @ParameterizedTest
+    @MethodSource("matchTestParams")
+    fun `match template`(uriTemplate: String, matchTemplate: String, expectedResult: Boolean) {
+        then(UriTemplate.from(uriTemplate).matches(matchTemplate)).isEqualTo(expectedResult)
     }
 
-    @Test
-    fun `should not match simple`() {
-        then(UriTemplate.from("/some").matches("/some-other")).isFalse()
+    @ParameterizedTest
+    @MethodSource("extractTestParams")
+    fun `extract template`(uriTemplate: String, extractTemplate: String, expectedResult: Map<String, String>) {
+        then(UriTemplate.from(uriTemplate).extract(extractTemplate)).isEqualTo(expectedResult)
     }
 
-    @Test
-    fun `should match with parameter`() {
-        then(UriTemplate.from("/some/{id}").matches("/some/${UUID.randomUUID()}")).isTrue()
-        then(UriTemplate.from("/some/{id}/other").matches("/some/${UUID.randomUUID()}/other")).isTrue()
+    @ParameterizedTest
+    @MethodSource("notAllowedGreedyPathTemplates")
+    fun `should throw exception for greedy path variables at the wrong place`(testedValue: String) {
+        assertThrows<IllegalArgumentException>("Greedy path variables (e.g. '{proxy+}' are only allowed at the end of the template") {
+            UriTemplate.from(testedValue)
+        }
     }
 
-    @Test
-    fun `should not match with parameter`() {
-        then(UriTemplate.from("/some/{id}").matches("/some-other/${UUID.randomUUID()}")).isFalse()
-        then(UriTemplate.from("/some/{id}/other").matches("/some/${UUID.randomUUID()}/other-test")).isFalse()
-    }
-
-    @Test
-    fun `should extract parameters`() {
-        then(UriTemplate.from("/some/{first}/other/{second}").extract("/some/first-value/other/second-value"))
-            .isEqualTo(mapOf("first" to "first-value", "second" to "second-value"))
-        then(UriTemplate.from("/some").extract("/some")).isEmpty()
-    }
+    companion object {
+        @JvmStatic
+        @Suppress("unused")
+        fun matchTestParams() = listOf(
+            Arguments.of("/some", "/some", true, "should match without parameter"),
+            Arguments.of("/some", "/some-other", false, "should not match simple"),
+            Arguments.of("/some/{id}", "/some/${UUID.randomUUID()}", true, "should match with parameter-1"),
+            Arguments.of("/some/{id}/other", "/some/${UUID.randomUUID()}/other", true, "should match with parameter-2"),
+            Arguments.of("/some/{id}", "/some-other/${UUID.randomUUID()}", false, "should not match with parameter-1"),
+            Arguments.of(
+                "/some/{id}/other",
+                "/some/${UUID.randomUUID()}/other-test",
+                false,
+                "should not match with parameter-2"
+            ),
+            Arguments.of("/some?a=1", "/some", true, "should match with query parameter 1"),
+            Arguments.of("/some?a=1&b=2", "/some", true, "should match with query parameter 2"),
+            Arguments.of(
+                "/some/{id}?a=1",
+                "/some/${UUID.randomUUID()}",
+                true,
+                "should match with path parameter and query parameter 1"
+            ),
+            Arguments.of(
+                "/some/{id}/other?a=1&b=2",
+                "/some/${UUID.randomUUID()}/other",
+                true,
+                "should match with path parameter and query parameter 2"
+            ),
+            Arguments.of(
+                "/some/{proxy+}",
+                "/some/sub/sub/sub/path",
+                true,
+                "should handle greedy path variables successfully"
+            )
+        )
 
-    @Test
-    fun `should match with query parameter`() {
-        then(UriTemplate.from("/some?a=1").matches("/some")).isTrue()
-        then(UriTemplate.from("/some?a=1&b=2").matches("/some")).isTrue()
-    }
+        @JvmStatic
+        @Suppress("unused")
+        fun extractTestParams() = listOf(
+            Arguments.of("/some", "/some", emptyMap<String, String>(), "should extract parameters-1"),
+            Arguments.of(
+                "/some/{first}/other/{second}",
+                "/some/first-value/other/second-value",
+                mapOf("first" to "first-value", "second" to "second-value"),
+                "should extract parameters 2"
+            )
+        )
 
-    @Test
-    fun `should match with path parameter and query parameter`() {
-        then(UriTemplate.from("/some/{id}?a=1").matches("/some/${UUID.randomUUID()}")).isTrue()
-        then(UriTemplate.from("/some/{id}/other?a=1&b=2").matches("/some/${UUID.randomUUID()}/other")).isTrue()
+        @JvmStatic
+        @Suppress("unused")
+        fun notAllowedGreedyPathTemplates() = listOf(
+            "/some/{proxy+}/and/{variable}/error",
+            "/{proxy+}/some/and/{variable}/error",
+            "/here/some/and/{proxy+}/{variable}",
+            "/here/some/and/{proxy+}/error", // FIXME: it should throw exception
+            "/here/some/and//good/good/{proxy+}/bad/bad/bad", // FIXME: it should throw exception
+            "/{proxy+}/{id}",
+            "/{proxy+}/whatever"
+        )
     }
 }