Pass query params to API spec validator (#66)

* pass query params to api spec validation

* return empty map instead of null from param extraction

* replacing new HashMap with Collections.emptyMap

* replacing if statement with tertiary op

Author: tsiq-karold

webtau-open-api/src/main/java/com/twosigma/webtau/openapi/OpenApiSpecValidator.java

@@ -24,9 +24,12 @@
 import com.twosigma.webtau.console.ansi.Color;
 import com.twosigma.webtau.http.validation.HttpValidationResult;
 
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 
 import static com.twosigma.webtau.http.HttpUrl.extractPath;
+import static com.twosigma.webtau.http.HttpUrl.extractQueryParams;
 
 public class OpenApiSpecValidator {
     private final SwaggerRequestResponseValidator openApiValidator;
@@ -75,6 +78,8 @@ private SimpleRequest buildRequest(HttpValidationResult result) {
             result.getRequestHeader().forEachProperty(builder::withHeader);
         }
 
+        extractQueryParams(result.getFullUrl()).forEach(builder::withQueryParam);
+
         return builder.build();
     }
 }

webtau-rest/src/main/java/com/twosigma/webtau/http/HttpQueryParamsParser.java

@@ -0,0 +1,32 @@
+package com.twosigma.webtau.http;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class HttpQueryParamsParser {
+    public static Map<String, List<String>> parseQueryParams(String queryParams) {
+        String[] params = queryParams.split("&");
+
+        return Arrays.stream(params)
+                .map(p -> p.split("="))
+                .collect(Collectors.groupingBy(HttpQueryParamsParser::extractQueryKey,
+                        Collectors.mapping(HttpQueryParamsParser::extractQueryValue, Collectors.toList())));
+    }
+
+    private static String extractQueryKey(String[] splitParam) {
+        String key = splitParam[0];
+
+        int openingBraceIdx = key.indexOf('[');
+        if (openingBraceIdx >= 0 && key.contains("]")) {
+            key = key.substring(0, openingBraceIdx);
+        }
+
+        return key;
+    }
+
+    private static String extractQueryValue(String[] splitParam) {
+        return splitParam.length == 1 ? null : splitParam[1];
+    }
+}

webtau-rest/src/main/java/com/twosigma/webtau/http/HttpUrl.java

@@ -18,6 +18,7 @@
 
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.*;
 
 public class HttpUrl {
     private HttpUrl() {
@@ -42,6 +43,31 @@ public static String extractPath(String url) {
         }
     }
 
+    public static Map<String, List<String>> extractQueryParams(String url) {
+        String queryParams = isFull(url) ?
+                extractQueryParamsFromFullUrl(url) :
+                extractQueryParamsFromRelativeUrl(url);
+
+        return queryParams == null ? Collections.emptyMap() : HttpQueryParamsParser.parseQueryParams(queryParams);
+    }
+
+    private static String extractQueryParamsFromRelativeUrl(String url) {
+        int queryParamsStart = url.indexOf('?');
+        if (queryParamsStart < 0) {
+            return null;
+        } else {
+            return url.substring(queryParamsStart + 1);
+        }
+    }
+
+    private static String extractQueryParamsFromFullUrl(String url) {
+        try {
+            return new URL(url).getQuery();
+        } catch (MalformedURLException e) {
+            throw new IllegalArgumentException("invalid url: " + url, e);
+        }
+    }
+
     public static String concat(String left, String right) {
         if (left == null) {
             throw new IllegalArgumentException("passed url on the left is NULL");

webtau-rest/src/test/groovy/com/twosigma/webtau/http/HttpUrlTest.groovy

@@ -66,4 +66,28 @@ class HttpUrlTest {
             HttpUrl.extractPath('garbage://localhost:8080/relative/path').should == '/relative/path'
         } should throwException(IllegalArgumentException, 'invalid url: garbage://localhost:8080/relative/path')
     }
+
+    @Test
+    void "extract query params from a given url"() {
+        def expectedParams = [a: ['b'], c: ['d']]
+        def expectedMultiParams = [a: ['b', 'c']]
+        def expectedNullParams = [a: [null], b: ['c']]
+
+        HttpUrl.extractQueryParams('relative/path?a=b&c=d').should == expectedParams
+        HttpUrl.extractQueryParams('https://localhost:8080/relative/path?a=b&c=d').should == expectedParams
+        HttpUrl.extractQueryParams('https://localhost:8080/relative/path?a=b&a=c').should == expectedMultiParams
+        HttpUrl.extractQueryParams('https://localhost:8080/relative/path?a[0]=b&a[1]=c').should == expectedMultiParams
+
+        HttpUrl.extractQueryParams('https://localhost:8080/relative/path?a&b=c').should == expectedNullParams
+
+        HttpUrl.extractQueryParams('relative/path').should == [:]
+        HttpUrl.extractQueryParams('https://localhost:8080/relative/path').should == [:]
+    }
+
+    @Test
+    void "validates full url before before extracting query params"() {
+        code {
+            HttpUrl.extractQueryParams('garbage://localhost:8080/relative/path').should == '/relative/path'
+        } should throwException(IllegalArgumentException, 'invalid url: garbage://localhost:8080/relative/path')
+    }
 }