Rewrite other tests to use WireMock

2 files changed, 131 insertions, 123 deletions

diff --git a/configserver/src/main/java/com/yahoo/vespa/config/server/application/ConfigConvergenceChecker.java b/configserver/src/main/java/com/yahoo/vespa/config/server/application/ConfigConvergenceChecker.java
index 63f48547220..df780f1703d 100644
--- a/configserver/src/main/java/com/yahoo/vespa/config/server/application/ConfigConvergenceChecker.java
+++ b/configserver/src/main/java/com/yahoo/vespa/config/server/application/ConfigConvergenceChecker.java
@@ -188,7 +188,7 @@ public class ConfigConvergenceChecker extends AbstractComponent {
         }
     }
 
-    static class ServiceResponse extends JSONResponse {
+    private static class ServiceResponse extends JSONResponse {
 
         private ServiceResponse(int status, URI uri, String hostname, Long wantedGeneration) {
             super(status);
diff --git a/configserver/src/test/java/com/yahoo/vespa/config/server/application/ConfigConvergenceCheckerTest.java b/configserver/src/test/java/com/yahoo/vespa/config/server/application/ConfigConvergenceCheckerTest.java
index aad35f29d82..0007f853864 100644
--- a/configserver/src/test/java/com/yahoo/vespa/config/server/application/ConfigConvergenceCheckerTest.java
+++ b/configserver/src/test/java/com/yahoo/vespa/config/server/application/ConfigConvergenceCheckerTest.java
@@ -1,9 +1,8 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.vespa.config.server.application;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.github.tomakehurst.wiremock.junit.WireMockRule;
+import com.github.tomakehurst.wiremock.stubbing.Scenario;
 import com.yahoo.config.model.api.Model;
 import com.yahoo.config.provision.ApplicationId;
 import com.yahoo.config.provision.ApplicationName;
@@ -11,8 +10,9 @@ import com.yahoo.config.provision.InstanceName;
 import com.yahoo.config.provision.TenantName;
 import com.yahoo.config.provision.Version;
 import com.yahoo.container.jdisc.HttpResponse;
+import com.yahoo.slime.Slime;
+import com.yahoo.vespa.config.SlimeUtils;
 import com.yahoo.vespa.config.server.ServerCache;
-import com.yahoo.vespa.config.server.http.SessionHandlerTest;
 import com.yahoo.vespa.config.server.monitoring.MetricUpdater;
 import org.junit.Before;
 import org.junit.Rule;
@@ -23,30 +23,29 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.URI;
+import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
 import static com.github.tomakehurst.wiremock.client.WireMock.get;
+import static com.github.tomakehurst.wiremock.client.WireMock.okJson;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
 import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.options;
-import static com.yahoo.vespa.config.server.application.ConfigConvergenceChecker.ServiceResponse;
 import static org.junit.Assert.assertEquals;
 
 /**
  * @author Ulf Lilleengen
+ * @author mpolden
  */
 public class ConfigConvergenceCheckerTest {
 
-    private static final ObjectMapper mapper = new ObjectMapper();
-
     private final TenantName tenant = TenantName.from("mytenant");
     private final ApplicationId appId = ApplicationId.from(tenant, ApplicationName.from("myapp"), InstanceName.from("myinstance"));
+
     private Application application;
     private ConfigConvergenceChecker checker;
-    private Map<URI, Long> currentGeneration;
+    private URI service;
 
     @Rule
     public TemporaryFolder folder = new TemporaryFolder();
@@ -56,129 +55,137 @@ public class ConfigConvergenceCheckerTest {
 
     @Before
     public void setup() {
-        Model mockModel = MockModel.createContainer("localhost", 1337);
+        service = testServer();
+        Model mockModel = MockModel.createContainer(service.getHost(), service.getPort());
         application = new Application(mockModel,
                                       new ServerCache(),
                                       3,
                                       false,
                                       Version.fromIntValues(0, 0, 0),
                                       MetricUpdater.createTestUpdater(), appId);
-        currentGeneration = new HashMap<>();
-        checker = new ConfigConvergenceChecker(
-                (client, serviceUri) -> () -> asJson("{\"config\":{\"generation\":"
-                                                     + currentGeneration.getOrDefault(serviceUri, 3L)
-                                                     + "}}"));
+        checker = new ConfigConvergenceChecker();
     }
 
     @Test
-    public void service_convergence() throws Exception {
-        ServiceResponse serviceResponse = checker.checkService(application,
-                                                               "localhost:1337",
-                                                               URI.create("http://foo:234/serviceconverge/localhost:1337"), Duration.ofSeconds(5));
-        assertEquals(200, serviceResponse.getStatus());
-        assertJsonEquals("{\n" +
-                         "  \"url\": \"http://foo:234/serviceconverge/localhost:1337\",\n" +
-                         "  \"host\": \"localhost:1337\",\n" +
-                         "  \"wantedGeneration\": 3,\n" +
-                         "  \"converged\": true,\n" +
-                         "  \"currentGeneration\": 3\n" +
-                         "}",
-                         SessionHandlerTest.getRenderedString(serviceResponse));
-
-        ServiceResponse hostMissingResponse = checker.checkService(application,
-                                                                   "notPresent:1337",
-                                                                   URI.create("http://foo:234/serviceconverge/notPresent:1337"), Duration.ofSeconds(5));
-        assertEquals(410, hostMissingResponse.getStatus());
-        assertJsonEquals("{\n" +
-                         "  \"url\": \"http://foo:234/serviceconverge/notPresent:1337\",\n" +
-                         "  \"host\": \"notPresent:1337\",\n" +
-                         "  \"wantedGeneration\": 3,\n" +
-                         "  \"problem\": \"Host:port (service) no longer part of application, refetch list of services.\"\n" +
-                         "}",
-                     SessionHandlerTest.getRenderedString(hostMissingResponse));
-    }
+    public void service_convergence() {
+        { // Known service
+            String serviceName = hostAndPort(this.service);
+            URI serviceUrl = testServer().resolve("/serviceconverge/" + serviceName);
+            wireMock.stubFor(get(urlEqualTo("/state/v1/config")).willReturn(okJson("{\"config\":{\"generation\":3}}")));
+            HttpResponse serviceResponse = checker.checkService(application, hostAndPort(this.service), serviceUrl, Duration.ofSeconds(5));
+            assertResponse("{\n" +
+                           "  \"url\": \"" + serviceUrl.toString() + "\",\n" +
+                           "  \"host\": \"" + hostAndPort(this.service) + "\",\n" +
+                           "  \"wantedGeneration\": 3,\n" +
+                           "  \"converged\": true,\n" +
+                           "  \"currentGeneration\": 3\n" +
+                           "}",
+                           200,
+                           serviceResponse);
+        }
 
-    @Test
-    public void service_list_convergence() throws Exception {
-        HttpResponse serviceListResponse = checker.servicesToCheck(application, URI.create("http://foo:234/serviceconverge"), Duration.ofSeconds(5));
-        assertEquals(200, serviceListResponse.getStatus());
-        assertJsonEquals("{\n" +
-                         "  \"services\": [\n" +
-                         "    {\n" +
-                         "      \"host\": \"localhost\",\n" +
-                         "      \"port\": 1337,\n" +
-                         "      \"type\": \"container\",\n" +
-                         "      \"url\": \"http://foo:234/serviceconverge/localhost:1337\"\n" +
-                         "    }\n" +
-                         "  ],\n" +
-                         "  \"url\": \"http://foo:234/serviceconverge\",\n" +
-                         "  \"currentGeneration\": 3,\n" +
-                         "  \"wantedGeneration\": 3,\n" +
-                         "  \"converged\": true\n" +
-                         "}",
-                         SessionHandlerTest.getRenderedString(serviceListResponse));
-
-        // Model with two hosts on different generations
-        MockModel model = new MockModel(Arrays.asList(
-                MockModel.createContainerHost("host1", 1234),
-                MockModel.createContainerHost("host2", 1234))
-        );
-        Application application = new Application(model, new ServerCache(), 4,
-                                                  false,
-                                                  Version.fromIntValues(0, 0, 0),
-                                                  MetricUpdater.createTestUpdater(), appId);
-        currentGeneration.put(URI.create("http://host2:1234"), 4L);
-        serviceListResponse = checker.servicesToCheck(application, URI.create("http://foo:234/serviceconverge"), Duration.ofSeconds(5));
-        assertEquals(200, serviceListResponse.getStatus());
-        assertJsonEquals("{\n" +
-                         "  \"services\": [\n" +
-                         "    {\n" +
-                         "      \"host\": \"host1\",\n" +
-                         "      \"port\": 1234,\n" +
-                         "      \"type\": \"container\",\n" +
-                         "      \"url\": \"http://foo:234/serviceconverge/host1:1234\"\n" +
-                         "    },\n" +
-                         "    {\n" +
-                         "      \"host\": \"host2\",\n" +
-                         "      \"port\": 1234,\n" +
-                         "      \"type\": \"container\",\n" +
-                         "      \"url\": \"http://foo:234/serviceconverge/host2:1234\"\n" +
-                         "    }\n" +
-                         "  ],\n" +
-                         "  \"url\": \"http://foo:234/serviceconverge\",\n" +
-                         "  \"currentGeneration\": 3,\n" +
-                         "  \"wantedGeneration\": 4,\n" +
-                         "  \"converged\": false\n" +
-                         "}",
-                     SessionHandlerTest.getRenderedString(serviceListResponse));
+        { // Missing service
+            String serviceName = "notPresent:1337";
+            URI serviceUrl = testServer().resolve("/serviceconverge/" + serviceName);
+            HttpResponse response = checker.checkService(application, "notPresent:1337", serviceUrl,
+                                                            Duration.ofSeconds(5));
+            assertResponse("{\n" +
+                           "  \"url\": \"" + serviceUrl.toString() + "\",\n" +
+                           "  \"host\": \"" + serviceName + "\",\n" +
+                           "  \"wantedGeneration\": 3,\n" +
+                           "  \"problem\": \"Host:port (service) no longer part of application, refetch list of services.\"\n" +
+                           "}",
+                           410,
+                           response);
+        }
     }
 
     @Test
-    public void service_convergence_timeout() throws Exception {
-        URI service = testServer();
-        Model mockModel = MockModel.createContainer(service.getHost(), service.getPort());
-        application = new Application(mockModel,
-                                      new ServerCache(),
-                                      3,
-                                      false,
-                                      Version.fromIntValues(0, 0, 0),
-                                      MetricUpdater.createTestUpdater(), appId);
-        currentGeneration = new HashMap<>();
-        ConfigConvergenceChecker checker = new ConfigConvergenceChecker();
-
-        URI api = testServer().resolve("/serviceconverge");
+    public void service_list_convergence() {
+        {
+            String serviceName = hostAndPort(this.service);
+            URI url = testServer().resolve("/serviceconverge");
+            URI serviceUrl = testServer().resolve("/serviceconverge/" + serviceName);
+            wireMock.stubFor(get(urlEqualTo("/state/v1/config")).willReturn(okJson("{\"config\":{\"generation\":3}}")));
+            HttpResponse response = checker.servicesToCheck(application, url, Duration.ofSeconds(5));
+            assertResponse("{\n" +
+                           "  \"services\": [\n" +
+                           "    {\n" +
+                           "      \"host\": \"" + serviceUrl.getHost() + "\",\n" +
+                           "      \"port\": " + serviceUrl.getPort() + ",\n" +
+                           "      \"type\": \"container\",\n" +
+                           "      \"url\": \"" + serviceUrl.toString() + "\"\n" +
+                           "    }\n" +
+                           "  ],\n" +
+                           "  \"url\": \"" + url.toString() + "\",\n" +
+                           "  \"currentGeneration\": 3,\n" +
+                           "  \"wantedGeneration\": 3,\n" +
+                           "  \"converged\": true\n" +
+                           "}",
+                           200,
+                           response);
+        }
 
-        wireMock.stubFor(get(urlEqualTo("/state/v1/config"))
-                                 .willReturn(aResponse().withFixedDelay((int) Duration.ofSeconds(10).toMillis())));
-        ServiceResponse serviceResponse = checker.checkService(application, hostAndPort(service), api, Duration.ofMillis(1));
 
-        ByteArrayOutputStream response = new ByteArrayOutputStream();
-        serviceResponse.render(response);
+        { // Model with two hosts on different generations
+            MockModel model = new MockModel(Arrays.asList(
+                    // Reuse hostname and port to avoid the need for two WireMock servers
+                    MockModel.createContainerHost(service.getHost(), service.getPort()),
+                    MockModel.createContainerHost(service.getHost(), service.getPort()))
+            );
+            Application application = new Application(model, new ServerCache(), 4,
+                                                      false,
+                                                      Version.fromIntValues(0, 0, 0),
+                                                      MetricUpdater.createTestUpdater(), appId);
+
+            String host2 = "host2";
+            wireMock.stubFor(get(urlEqualTo("/state/v1/config")).inScenario("config request")
+                                                                .whenScenarioStateIs(Scenario.STARTED)
+                                                                .willReturn(okJson("{\"config\":{\"generation\":4}}"))
+                                                                .willSetStateTo(host2));
+            wireMock.stubFor(get(urlEqualTo("/state/v1/config")).inScenario("config request")
+                                                                .whenScenarioStateIs(host2)
+                                                                .willReturn(okJson("{\"config\":{\"generation\":3}}")));
+
+            URI url = testServer().resolve("/serviceconverge");
+            URI serviceUrl = testServer().resolve("/serviceconverge/" + hostAndPort(service));
+            HttpResponse response = checker.servicesToCheck(application, url, Duration.ofSeconds(5));
+            assertResponse("{\n" +
+                             "  \"services\": [\n" +
+                             "    {\n" +
+                             "      \"host\": \"" + service.getHost() + "\",\n" +
+                             "      \"port\": " + service.getPort() + ",\n" +
+                             "      \"type\": \"container\",\n" +
+                             "      \"url\": \"" + serviceUrl.toString() + "\"\n" +
+                             "    },\n" +
+                             "    {\n" +
+                             "      \"host\": \"" + service.getHost() + "\",\n" +
+                             "      \"port\": " + service.getPort() + ",\n" +
+                             "      \"type\": \"container\",\n" +
+                             "      \"url\": \"" + serviceUrl.toString() + "\"\n" +
+                             "    }\n" +
+                             "  ],\n" +
+                             "  \"url\": \"" + url.toString() + "\",\n" +
+                             "  \"currentGeneration\": 3,\n" +
+                             "  \"wantedGeneration\": 4,\n" +
+                             "  \"converged\": false\n" +
+                             "}",
+                             200,
+                             response);
+        }
+    }
 
-        assertEquals("{\"url\":\"" + api.toString() + "\",\"host\":\"" + hostAndPort(api) +
-                     "\",\"wantedGeneration\":3,\"error\":\"java.net.SocketTimeoutException: Read timed out\"}",
-                     response.toString());
-        assertEquals(404, serviceResponse.getStatus());
+    @Test
+    public void service_convergence_timeout() {
+        URI url = testServer().resolve("/serviceconverge");
+        wireMock.stubFor(get(urlEqualTo("/state/v1/config")).willReturn(aResponse()
+                                                                                .withFixedDelay((int) Duration.ofSeconds(10).toMillis())
+                                                                                .withBody("response too slow")));
+        HttpResponse response = checker.checkService(application, hostAndPort(service), url, Duration.ofMillis(1));
+        assertResponse("{\"url\":\"" + url.toString() + "\",\"host\":\"" + hostAndPort(url) +
+                       "\",\"wantedGeneration\":3,\"error\":\"java.net.SocketTimeoutException: Read timed out\"}",
+                     404,
+                       response);
     }
 
     private URI testServer() {
@@ -189,16 +196,17 @@ public class ConfigConvergenceCheckerTest {
         return uri.getHost() + ":" + uri.getPort();
     }
 
-    private static void assertJsonEquals(String expected, String actual) {
-        assertEquals(asJson(expected), asJson(actual));
-    }
-
-    private static JsonNode asJson(String data) {
+    private static void assertResponse(String body, int status, HttpResponse response) {
+        ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
         try {
-            return mapper.readTree(data);
+            response.render(responseBody);
+            Slime expected = SlimeUtils.jsonToSlime(body.getBytes(StandardCharsets.UTF_8));
+            Slime actual = SlimeUtils.jsonToSlime(responseBody.toByteArray());
+            assertEquals(new String((SlimeUtils.toJsonBytes(expected))), new String(SlimeUtils.toJsonBytes(actual)));
         } catch (IOException e) {
             throw new UncheckedIOException(e);
         }
+        assertEquals(status, response.getStatus());
     }
 
 }