Int test for all solvers (#564)

* release notes

* [Gradle Release Plugin] - new version commit:  '3.29.0-snapshot'.

* Creating support for testing DPS really like a integration test, crating int test for solver remote happy pah

* clean code

* clean code

* configuring templates

* configuring templates

* option to get answer ip

* comptest task wont run int test

* creating task to run all tests

* adjusting ci steps

* adjusting ci

Author: mageddo

.github/workflows/ci.yml

@@ -17,8 +17,11 @@ jobs:
         with:
           java-version: '21'
 
-      - name: Build and Tests
-        run: ./gradlew build test compTest  -i
+      - name: Build and Unit Tests
+        run: ./gradlew build test -i
+
+      - name: Comp Tests
+        run: ./gradlew -x check compTest -i
 
       - name: Native Image Integration Tests
         run: ./gradlew build -x check nativeIntTest -i

RELEASE-NOTES.md

@@ -1,3 +1,7 @@
+## 3.29.0
+* Implementing an IntTest which can validate the happy path of all DPS solvers, 
+ being able to detect bugs like the fixed at 3.25.14 (6db82f50d54bd3f3aed15d7120c1963c0386abf4).
+
 ## 3.28.0
 * Specify from which source the config is coming to facilitate troubleshooting. #533
 

build.gradle

@@ -104,7 +104,7 @@ test {
 
 def compTest = tasks.register("compTest", Test) {
   useJUnitPlatform()
-  include "**/*CompTest.class", "**/*IntTest.class"
+  include "**/*CompTest.class"
   failFast = true
   testLogging {
     events "passed", "skipped", "failed"
@@ -114,6 +114,10 @@ def compTest = tasks.register("compTest", Test) {
   }
 }
 
+tasks.register("allTests", Test) {
+  dependsOn test, compTest, nativeIntTest
+}
+
 def intTest = tasks.register("intTest", Test) {
 
   dependsOn shadowJar

gradle.properties

@@ -1 +1 @@
-version=3.27.0-snapshot
+version=3.29.0-snapshot

src/main/java/com/mageddo/dns/utils/Messages.java

@@ -301,4 +301,8 @@ public static HostnameQuery toHostnameQuery(Message query) {
   public static boolean isSuccess(Message res) {
     return res.getRcode() == Rcode.NOERROR;
   }
+
+  public static String findAnswerRawIP(Message res) {
+    return findFirstAnswerRecord(res).rdataToString();
+  }
 }

src/main/java/com/mageddo/dnsproxyserver/sandbox/BinaryFromGradleTestsSandbox.java

@@ -0,0 +1,28 @@
+package com.mageddo.dnsproxyserver.sandbox;
+
+import com.mageddo.commons.exec.CommandLines;
+import com.mageddo.commons.exec.NopResultHandler;
+import com.mageddo.commons.exec.Request;
+import com.mageddo.dnsproxyserver.config.dataprovider.vo.ConfigEnv;
+import lombok.extern.slf4j.Slf4j;
+
+import java.nio.file.Path;
+import java.util.Map;
+
+@Slf4j
+public class BinaryFromGradleTestsSandbox {
+  public Instance run(Path configFile) {
+    final var commandLine = DpsBinaryExecutableFinder.buildCommandLine();
+    final var request = Request.builder()
+      .commandLine(commandLine)
+      .handler(new NopResultHandler())
+      .env(Map.of(ConfigEnv.MG_CONFIG_FILE_PATH, configFile.toString()))
+      .build();
+
+    final var result = CommandLines.exec(request)
+      .printOutToLogsInBackground();
+
+    return Instance.of(result);
+  }
+
+}

src/main/java/com/mageddo/dnsproxyserver/sandbox/DpsBinaryExecutableFinder.java

@@ -0,0 +1,84 @@
+package com.mageddo.dnsproxyserver.sandbox;
+
+import com.mageddo.utils.Runtime;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.exec.CommandLine;
+import org.apache.commons.lang3.Validate;
+import org.graalvm.nativeimage.ImageInfo;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@Slf4j
+public class DpsBinaryExecutableFinder {
+
+  public static CommandLine buildCommandLine() {
+    return new DpsBinaryExecutableFinder().buildCommandLineForBestExecutable();
+  }
+
+  private CommandLine buildCommandLineForBestExecutable() {
+    final var executablePath = this.findBestExecutablePath();
+    if (ImageInfo.inImageRuntimeCode()) {
+      return new CommandLine(executablePath.toString());
+    }
+    final var javaCommandPath = this.findJavaCommand();
+    return new CommandLine(javaCommandPath)
+      .addArgument("-jar")
+      .addArgument(executablePath.toFile().toString());
+  }
+
+  private String findJavaCommand() {
+    return ProcessHandle.current()
+      .info()
+      .command()
+      .orElseThrow(() -> new IllegalStateException("Couldn't find current java process command"))
+      ;
+  }
+
+  public static Path findPath() {
+    return new DpsBinaryExecutableFinder().findBestExecutablePath();
+  }
+
+  Path findBestExecutablePath() {
+    if (ImageInfo.inImageRuntimeCode()) {
+      return findBuiltNativeExecutablePath();
+    }
+    return findBuiltJarPath();
+  }
+
+  Path findBuiltNativeExecutablePath() {
+    final var buildPath = this.findBuildPath();
+    final var path = buildPath.resolve("native/nativeIntTestCompile/dns-proxy-server-tests");
+    Validate.isTrue(Files.exists(path), "Native executable not found at: " + path);
+    return path;
+  }
+
+  Path findBuiltJarPath() {
+    final var buildPath = this.findBuildPath();
+    final var libsPath = buildPath.resolve("libs");
+    return findFirstMatchInPath(libsPath);
+  }
+
+  @SneakyThrows
+  private Path findFirstMatchInPath(Path libsPath) {
+    try (var stream = Files.list(libsPath)) {
+      return stream
+        .filter(path -> path.toString().endsWith("-all.jar"))
+        .findFirst()
+        .orElseThrow(() -> new IllegalStateException("Unable to find fat jar at libs path"));
+    }
+  }
+
+  private Path findBuildPath() {
+    var path = Runtime.getRunningDir();
+    while (path != null) {
+      if (path.endsWith("build")) {
+        log.trace("buildPath={}", path);
+        return path;
+      }
+      path = path.getParent();
+    }
+    return null;
+  }
+}

src/main/java/com/mageddo/dnsproxyserver/sandbox/Instance.java

@@ -0,0 +1,23 @@
+package com.mageddo.dnsproxyserver.sandbox;
+
+import com.mageddo.commons.exec.Result;
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.Value;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Value
+@Builder
+public class Instance {
+
+  @NonNull
+  Result result;
+
+  public static Instance of(Result result) {
+    return Instance.builder()
+      .result(result)
+      .build()
+      ;
+  }
+}

src/main/java/com/mageddo/dnsproxyserver/sandbox/Sandbox.java

@@ -0,0 +1,9 @@
+package com.mageddo.dnsproxyserver.sandbox;
+
+import java.nio.file.Path;
+
+public class Sandbox {
+  public static Instance runFromGradleTests(Path configFile) {
+    return new BinaryFromGradleTestsSandbox().run(configFile);
+  }
+}

src/test/java/com/mageddo/dnsproxyserver/AppIntTest.java

@@ -1,22 +1,34 @@
 package com.mageddo.dnsproxyserver;
 
 import com.mageddo.commons.concurrent.Threads;
+import com.mageddo.commons.exec.ProcessesWatchDog;
 import com.mageddo.dns.utils.Messages;
 import com.mageddo.dnsproxyserver.config.application.Configs;
+import com.mageddo.dnsproxyserver.config.dataprovider.JsonConfigs;
+import com.mageddo.dnsproxyserver.config.dataprovider.vo.ConfigJson;
+import com.mageddo.dnsproxyserver.sandbox.Instance;
+import com.mageddo.dnsproxyserver.sandbox.Sandbox;
 import com.mageddo.dnsproxyserver.server.Starter;
 import com.mageddo.dnsproxyserver.solver.SimpleResolver;
 import com.mageddo.dnsproxyserver.utils.Ips;
+import com.mageddo.net.IpAddr;
 import com.mageddo.utils.Executors;
 import lombok.SneakyThrows;
+import lombok.Value;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.xbill.DNS.Message;
 import testing.templates.ConfigFlagArgsTemplates;
+import testing.templates.ConfigJsonFileTemplates;
 
+import java.nio.file.Path;
 import java.time.Duration;
+import java.util.Arrays;
+import java.util.concurrent.ExecutorService;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @Slf4j
@@ -29,12 +41,13 @@ void beforeEach() {
   }
 
   @AfterAll
-  static void afterAll(){
+  static void afterAll() {
     Starter.setMustStartFlagActive(false);
+    ProcessesWatchDog.instance().killAllProcesses();
   }
 
   @Test
-  void appMustStartAndQuerySampleWithSuccess() {
+  void appMustStartAndQuerySampleWithSuccessFromLocalDbSolver() {
 
     final var hostToQuery = "dps-sample.dev";
     final var args = ConfigFlagArgsTemplates.withRandomPortsAndNotAsDefaultDns();
@@ -51,13 +64,67 @@ void appMustStartAndQuerySampleWithSuccess() {
       assertTrue(Messages.isSuccess(res));
 
     }
+  }
+
+  @Test
+  void mustQueryRemoteSolverPassingThroughAllModulesAndGetSuccess() {
+
+    final var hostToQuery = "dps-int-test.dev";
+
+    try (final var executor = Executors.newThreadExecutor()) {
+
+      final var serverAppConfig = buildAndStartServerApp(hostToQuery);
+      final var clientApp = buildClientAppAndWait(executor, serverAppConfig.getDnsServerPort());
+
+      final var port = clientApp.getDnsServerPort();
+      final var res = queryStartedServer(port, hostToQuery);
+
+      assertTrue(Messages.isSuccess(res));
+      assertEquals("192.168.0.1", Messages.findAnswerRawIP(res));
+
+    }
 
   }
 
+  private static App buildClientAppAndWait(ExecutorService executor, Integer serverPort) {
+    final var remoteAddr = IpAddr.of("127.0.0.1", serverPort);
+    return buildAppAndWait(executor, ConfigFlagArgsTemplates.withRandomPortsAndNotAsDefaultDnsUsingRemote(remoteAddr));
+  }
+
+  private static Result buildAndStartServerApp(String hostToQuery) {
+    final var configFile = ConfigJsonFileTemplates.withRandomPortsAndNotAsDefaultDnsAndCustomLocalDBEntry(hostToQuery);
+    final var instance = Sandbox.runFromGradleTests(configFile);
+    return Result.of(configFile, instance);
+  }
+
+  private static App buildAppAndWait(ExecutorService executor, final String[] params) {
+    log.debug("app={}", Arrays.toString(params));
+    final var app = new App(params);
+    executor.submit(app::start);
+    Threads.sleep(Duration.ofSeconds(2));
+    return app;
+  }
+
   @SneakyThrows
   static Message queryStartedServer(Integer port, String host) {
     final var dnsServerAddress = Ips.getAnyLocalAddress(port);
     final var dnsClient = new SimpleResolver(dnsServerAddress);
     return dnsClient.send(Messages.aQuestion(host));
   }
+
+  @Value
+  static class Result {
+
+    private final ConfigJson config;
+    private final Instance instance;
+
+    public static Result of(Path configFile, Instance instance) {
+      return new Result(JsonConfigs.loadConfig(configFile), instance);
+    }
+
+    public Integer getDnsServerPort() {
+      return this.config.getDnsServerPort();
+    }
+
+  }
 }