Rewrite to use a tester, minor cleanup

2 files changed, 77 insertions, 58 deletions

diff --git a/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/RpcServerTest.java b/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/RpcServerTest.java
index 0998fdd4db2..6d964daf61b 100644
--- a/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/RpcServerTest.java
+++ b/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/RpcServerTest.java
@@ -10,9 +10,18 @@ import com.yahoo.config.model.test.MockApplicationPackage;
 import com.yahoo.config.provision.TenantName;
 import com.yahoo.config.provision.Version;
 import com.yahoo.jrt.Request;
-import com.yahoo.vespa.config.*;
-import com.yahoo.vespa.config.protocol.*;
 import com.yahoo.config.provision.ApplicationId;
+import com.yahoo.vespa.config.ConfigKey;
+import com.yahoo.vespa.config.ConfigPayload;
+import com.yahoo.vespa.config.ConfigPayloadApplier;
+import com.yahoo.vespa.config.ErrorCode;
+import com.yahoo.vespa.config.RawConfig;
+import com.yahoo.vespa.config.protocol.CompressionType;
+import com.yahoo.vespa.config.protocol.ConfigResponse;
+import com.yahoo.vespa.config.protocol.JRTClientConfigRequest;
+import com.yahoo.vespa.config.protocol.JRTClientConfigRequestV3;
+import com.yahoo.vespa.config.protocol.SlimeConfigResponse;
+import com.yahoo.vespa.config.protocol.Trace;
 import com.yahoo.vespa.config.server.application.ApplicationSet;
 import com.yahoo.vespa.config.server.ServerCache;
 import com.yahoo.vespa.config.server.application.Application;
@@ -20,7 +29,8 @@ import com.yahoo.vespa.config.server.monitoring.MetricUpdater;
 import com.yahoo.vespa.config.util.ConfigUtils;
 
 import com.yahoo.vespa.model.VespaModel;
-import org.junit.*;
+import org.junit.Rule;
+import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.xml.sax.SAXException;
 
@@ -34,43 +44,45 @@ import static org.junit.Assert.*;
 /**
  * @author Ulf Lilleengen
  */
-public class RpcServerTest extends TestWithRpc {
+public class RpcServerTest {
 
     @Rule
-    public TemporaryFolder folder = new TemporaryFolder();
+    public TemporaryFolder temporaryFolder = new TemporaryFolder();
 
     @Test
     public void testRpcServer() throws IOException, SAXException, InterruptedException {
-        testPrintStatistics();
-        testGetConfig();
-        testEnabled();
-        testEmptyConfigHostedVespa();
+        try (RpcTester tester = new RpcTester(temporaryFolder)) {
+            testPrintStatistics(tester);
+            testGetConfig(tester);
+            testEnabled(tester);
+            testEmptyConfigHostedVespa(tester);
+        }
     }
 
-    private void testEmptyConfigHostedVespa() throws InterruptedException, IOException {
-        rpcServer.onTenantDelete(TenantName.defaultName());
-        rpcServer.onTenantsLoaded();
+    private void testEmptyConfigHostedVespa(RpcTester tester) throws InterruptedException, IOException {
+        tester.rpcServer().onTenantDelete(TenantName.defaultName());
+        tester.rpcServer().onTenantsLoaded();
         JRTClientConfigRequest clientReq = createSimpleRequest();
-        performRequest(clientReq.getRequest());
+        tester.performRequest(clientReq.getRequest());
         assertFalse(clientReq.validateResponse());
         assertThat(clientReq.errorCode(), is(ErrorCode.APPLICATION_NOT_LOADED));
-        stopRpc();
-        createAndStartRpcServer(true);
-        rpcServer.onTenantsLoaded();
+        tester.stopRpc();
+        tester.createAndStartRpcServer();
+        tester.rpcServer().onTenantsLoaded();
         clientReq = createSimpleRequest();
-        performRequest(clientReq.getRequest());
+        tester.performRequest(clientReq.getRequest());
         assertTrue(clientReq.validateResponse());
     }
 
     private JRTClientConfigRequest createSimpleRequest() {
         ConfigKey<?> key = new ConfigKey<>(SimpletypesConfig.class, "");
-        JRTClientConfigRequest clientReq = JRTClientConfigRequestV3.createFromRaw(new RawConfig(key, SimpletypesConfig.CONFIG_DEF_MD5), 120_000, Trace.createDummy(), CompressionType.UNCOMPRESSED, Optional.empty());
+        JRTClientConfigRequest clientReq = createRequest(new RawConfig(key, SimpletypesConfig.getDefMd5()));
         assertTrue(clientReq.validateParameters());
         return clientReq;
     }
 
-    private void testEnabled() throws IOException, SAXException {
-        generationCounter.increment();
+    private void testEnabled(RpcTester tester) throws IOException, SAXException {
+        tester.generationCounter().increment();
         Application app = new Application(new VespaModel(MockApplicationPackage.createEmpty()),
                                           new ServerCache(),
                                           2L,
@@ -79,33 +91,29 @@ public class RpcServerTest extends TestWithRpc {
                                           MetricUpdater.createTestUpdater(),
                                           ApplicationId.defaultId());
         ApplicationSet appSet = ApplicationSet.fromSingle(app);
-        rpcServer.configActivated(appSet);
+        tester.rpcServer().configActivated(appSet);
         ConfigKey<?> key = new ConfigKey<>(LbServicesConfig.class, "*");
-        JRTClientConfigRequest clientReq = JRTClientConfigRequestV3.createFromRaw(new RawConfig(key, LbServicesConfig.CONFIG_DEF_MD5), 120_000, Trace.createDummy(), CompressionType.UNCOMPRESSED, Optional.empty());
+        JRTClientConfigRequest clientReq  = createRequest(new RawConfig(key, LbServicesConfig.getDefMd5()));
         assertTrue(clientReq.validateParameters());
-        performRequest(clientReq.getRequest());
+        tester.performRequest(clientReq.getRequest());
         assertFalse(clientReq.validateResponse());
         assertThat(clientReq.errorCode(), is(ErrorCode.APPLICATION_NOT_LOADED));
 
-        rpcServer.onTenantsLoaded();
-        clientReq = JRTClientConfigRequestV3.createFromRaw(new RawConfig(key, LbServicesConfig.CONFIG_DEF_MD5), 120_000, Trace.createDummy(), CompressionType.UNCOMPRESSED, Optional.empty());
+        tester.rpcServer().onTenantsLoaded();
+        clientReq = createRequest(new RawConfig(key, LbServicesConfig.getDefMd5()));
         assertTrue(clientReq.validateParameters());
-        performRequest(clientReq.getRequest());
+        tester.performRequest(clientReq.getRequest());
         boolean validResponse = clientReq.validateResponse();
         assertTrue(clientReq.errorMessage(), validResponse);
         assertThat(clientReq.errorCode(), is(0));
     }
 
-    private void testGetConfig() {
+    private void testGetConfig(RpcTester tester) {
         ConfigKey<?> key = new ConfigKey<>(SimpletypesConfig.class, "brim");
-        ((MockRequestHandler)tenantProvider.getRequestHandler()).responses.put(ApplicationId.defaultId(), createResponse(true));
-        JRTClientConfigRequest req = JRTClientConfigRequestV3.createFromRaw(new RawConfig(key, SimpletypesConfig.CONFIG_DEF_MD5),
-                                                                            120_000,
-                                                                            Trace.createDummy(),
-                                                                            CompressionType.UNCOMPRESSED,
-                                                                            Optional.empty());
+        JRTClientConfigRequest req = createRequest(new RawConfig(key, SimpletypesConfig.getDefMd5()));
+        ((MockRequestHandler)tester.tenantProvider().getRequestHandler()).responses.put(ApplicationId.defaultId(), createResponse());
         assertTrue(req.validateParameters());
-        performRequest(req.getRequest());
+        tester.performRequest(req.getRequest());
         assertThat(req.errorCode(), is(0));
         assertTrue(req.validateResponse());
         assertTrue(req.responseIsInternalRedeploy());
@@ -117,7 +125,7 @@ public class RpcServerTest extends TestWithRpc {
         assertThat(config.intval(), is(123));
     }
 
-    private ConfigResponse createResponse(boolean internalRedeploy) {
+    private ConfigResponse createResponse() {
         SimpletypesConfig.Builder builder = new SimpletypesConfig.Builder();
         builder.intval(123);
         SimpletypesConfig responseConfig = new SimpletypesConfig(builder);
@@ -128,14 +136,18 @@ public class RpcServerTest extends TestWithRpc {
         return SlimeConfigResponse.fromConfigPayload(responsePayload,
                                                      targetDef,
                                                      3L,
-                                                     internalRedeploy,
+                                                     true, /* internalRedeploy */
                                                      ConfigUtils.getMd5(responsePayload));
     }
 
-    private void testPrintStatistics() {
+    private void testPrintStatistics(RpcTester tester) {
         Request req = new Request("printStatistics");
-        rpcServer.printStatistics(req);
+        tester.rpcServer().printStatistics(req);
         assertThat(req.returnValues().get(0).asString(), is("Delayed responses queue size: 0"));
     }
 
+    private JRTClientConfigRequest createRequest(RawConfig config) {
+        return JRTClientConfigRequestV3.createFromRaw(config, 120_000, Trace.createDummy(), CompressionType.UNCOMPRESSED, Optional.empty());
+    }
+
 }
diff --git a/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/TestWithRpc.java b/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/RpcTester.java
index 845e7c0f914..3849fc899de 100644
--- a/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/TestWithRpc.java
+++ b/configserver/src/test/java/com/yahoo/vespa/config/server/rpc/RpcTester.java
@@ -17,9 +17,8 @@ import com.yahoo.vespa.config.server.host.ConfigRequestHostLivenessTracker;
 import com.yahoo.vespa.config.server.host.HostRegistries;
 import com.yahoo.vespa.config.server.monitoring.Metrics;
 import com.yahoo.vespa.config.server.tenant.MockTenantProvider;
+import com.yahoo.vespa.config.server.tenant.TenantHandlerProvider;
 import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
 import org.junit.rules.TemporaryFolder;
 
 import java.io.IOException;
@@ -36,20 +35,19 @@ import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 /**
- * Test running rpc server.
+ * Tester for running rpc server.
  *
  * @author Ulf Lilleengen
  */
-// TODO: Make this a Tester instead of a superclass
-public class TestWithRpc {
+public class RpcTester implements AutoCloseable {
 
     private final ManualClock clock = new ManualClock(Instant.ofEpochMilli(100));
     private final String myHostname = HostName.getLocalhost();
     private final HostLivenessTracker hostLivenessTracker = new ConfigRequestHostLivenessTracker(clock);
 
-    protected RpcServer rpcServer;
-    protected MockTenantProvider tenantProvider;
-    protected GenerationCounter generationCounter;
+    private RpcServer rpcServer;
+    private MockTenantProvider tenantProvider;
+    private GenerationCounter generationCounter;
     private Thread t;
     private Supervisor sup;
     private Spec spec;
@@ -57,40 +55,37 @@ public class TestWithRpc {
 
     private List<Integer> allocatedPorts;
 
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
+    private final TemporaryFolder temporaryFolder;
 
-    @Before
-    public void setupRpc() throws InterruptedException, IOException {
+    RpcTester(TemporaryFolder temporaryFolder) throws InterruptedException, IOException {
+        this.temporaryFolder = temporaryFolder;
         allocatedPorts = new ArrayList<>();
         port = allocatePort();
         spec = createSpec(port);
         tenantProvider = new MockTenantProvider();
         generationCounter = new MemoryGenerationCounter();
-        createAndStartRpcServer(false);
+        createAndStartRpcServer();
         assertFalse(hostLivenessTracker.lastRequestFrom(myHostname).isPresent());
     }
 
-    @After
-    public void teardownPortAllocator() {
+    public void close() {
         for (Integer port : allocatedPorts) {
             PortRangeAllocator.releasePort(port);
         }
     }
 
-    protected int allocatePort() throws InterruptedException {
+    private int allocatePort() throws InterruptedException {
         int port = PortRangeAllocator.findAvailablePort();
         allocatedPorts.add(port);
         return port;
     }
 
-    protected void createAndStartRpcServer(boolean hostedVespa) throws IOException {
+    void createAndStartRpcServer() throws IOException {
         ConfigserverConfig configserverConfig = new ConfigserverConfig(new ConfigserverConfig.Builder());
         rpcServer = new RpcServer(new ConfigserverConfig(new ConfigserverConfig.Builder()
                                                                  .rpcport(port)
                                                                  .numRpcThreads(1)
-                                                                 .maxgetconfigclients(1)
-                                                                 .hostedVespa(hostedVespa)),
+                                                                 .maxgetconfigclients(1)),
                                   new SuperModelRequestHandler(new TestConfigDefinitionRepo(),
                                                                configserverConfig,
                                                                new SuperModelManager(
@@ -131,10 +126,22 @@ public class TestWithRpc {
         assertThat(req.returnValues().get(0).asInt32(), is(0));
     }
 
-    protected void performRequest(Request req) {
+    void performRequest(Request req) {
         clock.advance(Duration.ofMillis(10));
         sup.connect(spec).invokeSync(req, 120.0);
         if (req.methodName().equals(RpcServer.getConfigMethodName))
             assertEquals(clock.instant(), hostLivenessTracker.lastRequestFrom(myHostname).get());
     }
+
+    RpcServer rpcServer() {
+        return rpcServer;
+    }
+
+    TenantHandlerProvider tenantProvider() {
+        return tenantProvider;
+    }
+
+    GenerationCounter generationCounter() {
+        return generationCounter;
+    }
 }