Integration tests

build.gradle

@@ -8,6 +8,9 @@ version = project.version
 
 repositories {
     mavenCentral()
+    maven {
+        url 'https://s3-eu-west-1.amazonaws.com/gatehillsoftware-maven/releases'
+    }
 }
 
 dependencies {
@@ -24,6 +27,14 @@ dependencies {
 
     implementation 'org.apache.logging.log4j:log4j-api:2.23.1'
     implementation 'org.apache.logging.log4j:log4j-core:2.23.1'
+
+    testImplementation platform('org.junit:junit-bom:5.10.2')
+    testImplementation  'org.junit.jupiter:junit-jupiter'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    testImplementation "io.gatehill.imposter:distro-embedded:3.38.1"
+    testImplementation "io.gatehill.imposter:imposter-server:3.38.1"
+    testImplementation "io.gatehill.imposter:config-dynamic:3.38.1"
+    testImplementation "io.gatehill.imposter:mock-openapi:3.38.1"
 }
 
 spotless {
@@ -64,3 +75,18 @@ tasks.register('bumpMajorVersion') {
         println "Version bumped to: $newVersion"
     }
 }
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+}
+
+sourceSets {
+    test {
+        java {
+            srcDirs 'src/test/integration'
+        }
+    }
+}

src/main/java/com/javadiscord/jdi/core/Discord.java

@@ -21,8 +21,12 @@ public class Discord {
     private static final Executor EXECUTOR = Executors.newSingleThreadExecutor();
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
     private static final String WEBSITE = "https://javadiscord.com/";
+    private static final String BASE_URL = System.getProperty("DISCORD_BASE_URL") != null
+        ? System.getProperty("DISCORD_BASE_URL")
+        : "https://discord.com/api";
     private final String botToken;
     private final IdentifyRequest identifyRequest;
+
     private final DiscordRequestDispatcher discordRequestDispatcher;
     private final Gateway gateway;
     private final GatewaySetting gatewaySetting;
@@ -90,10 +94,14 @@ public void start() {
         EXECUTOR.execute(discordRequestDispatcher);
     }
 
+    public void startWithoutGatewayEvents() {
+        EXECUTOR.execute(discordRequestDispatcher);
+    }
+
     private static Gateway getGatewayURL(String authentication) {
         try (HttpClient httpClient = HttpClient.newBuilder().build()) {
             HttpRequest request = HttpRequest.newBuilder()
-                .uri(URI.create("https://discord.com/api/gateway/bot"))
+                .uri(URI.create(BASE_URL + "/gateway/bot"))
                 .header("Authorization", "Bot " + authentication)
                 .GET()
                 .build();
@@ -104,4 +112,12 @@ private static Gateway getGatewayURL(String authentication) {
             throw new RuntimeException(e);
         }
     }
+
+    public static String getBaseUrl() {
+        return BASE_URL;
+    }
+
+    public DiscordRequestDispatcher getDiscordRequestDispatcher() {
+        return discordRequestDispatcher;
+    }
 }

src/main/java/com/javadiscord/jdi/internal/api/DiscordRequestDispatcher.java

@@ -9,12 +9,13 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.stream.Stream;
 
+import com.javadiscord.jdi.core.Discord;
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 public class DiscordRequestDispatcher implements Runnable {
     private static final Logger LOGGER = LogManager.getLogger();
-    private static final String BASE_URL = "https://discord.com/api";
     private final BlockingQueue<DiscordRequestBuilder> queue;
     private final String botToken;
     private int numberOfRequestsSent;
@@ -63,7 +64,7 @@ private void sendRequest(DiscordRequestBuilder discordRequestBuilder) {
                     URI.create(
                         "%s%s%s"
                             .formatted(
-                                BASE_URL,
+                                Discord.getBaseUrl(),
                                 discordRequestBuilder.getPath(),
                                 discordRequestBuilder
                                     .getQueryParameters()
@@ -117,7 +118,7 @@ private void sendRequest(DiscordRequestBuilder discordRequestBuilder) {
 
         } catch (Exception e) {
             LOGGER.error(
-                "Failed to send request to {}{}", BASE_URL, discordRequestBuilder.getPath(), e
+                "Failed to send request to {}{}", Discord.getBaseUrl(), discordRequestBuilder.getPath(), e
             );
             discordRequestBuilder.setFailureError(e);
         }

src/test/integration/com/jdi/internal/api/application/EditCurrentApplicationRequestTest.java

@@ -0,0 +1,48 @@
+package com.jdi.internal.api.application;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import helpers.RestTestHelper;
+import com.javadiscord.jdi.internal.api.DiscordRequest;
+import com.javadiscord.jdi.internal.api.DiscordResponseFuture;
+import com.javadiscord.jdi.internal.api.impl.application.EditCurrentApplicationRequest;
+
+import org.junit.jupiter.api.Test;
+
+class EditCurrentApplicationRequestTest extends RestTestHelper {
+
+    @Test
+    void test() throws InterruptedException {
+        DiscordRequest request = new EditCurrentApplicationRequest(
+            "",
+            "",
+            "",
+            new Object(),
+            Map.of(),
+            0,
+            "",
+            "",
+            "",
+            new String[0]
+        );
+
+        DiscordResponseFuture response = getDiscordRequestDispatcher().queue(request);
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        response.onSuccess(
+            (r) -> {
+                assertEquals(r.status(), 200);
+                latch.countDown();
+            }
+        );
+
+        response.onError(err -> fail());
+
+        assertTrue(latch.await(5, TimeUnit.SECONDS));
+    }
+}

src/test/integration/com/jdi/internal/api/application/GetCurrentApplicationRequestTest.java

@@ -0,0 +1,31 @@
+package com.jdi.internal.api.application;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import helpers.RestTestHelper;
+import com.javadiscord.jdi.internal.api.DiscordResponseFuture;
+import com.javadiscord.jdi.internal.api.impl.application.GetCurrentApplicationRequest;
+
+import org.junit.jupiter.api.Test;
+
+class GetCurrentApplicationRequestTest extends RestTestHelper {
+
+    @Test
+    void test() throws InterruptedException {
+        DiscordResponseFuture response = getDiscordRequestDispatcher().queue(new GetCurrentApplicationRequest());
+        CountDownLatch latch = new CountDownLatch(1);
+
+        response.onSuccess(
+            (r) -> {
+                assertEquals(r.status(), 200);
+                latch.countDown();
+            }
+        );
+
+        response.onError(err -> fail());
+        assertTrue(latch.await(5, TimeUnit.SECONDS));
+    }
+}

src/test/integration/com/jdi/internal/api/automoderation/CreateAutoModerationRuleRequestTest.java

@@ -0,0 +1,29 @@
+package com.jdi.internal.api.automoderation;
+
+import java.util.List;
+import java.util.Optional;
+
+import helpers.RestTestHelper;
+import com.javadiscord.jdi.internal.api.impl.automoderation.CreateAutoModerationRuleRequest;
+
+import org.junit.jupiter.api.Test;
+
+class CreateAutoModerationRuleRequestTest extends RestTestHelper {
+
+    @Test
+    void test() throws InterruptedException {
+        sendRequestAndAssert(
+            new CreateAutoModerationRuleRequest(
+                0L,
+                "",
+                0,
+                0,
+                Optional.empty(),
+                List.of(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty()
+            ), 200
+        );
+    }
+}

src/test/integration/com/jdi/internal/api/automoderation/DeleteAutoModerationRuleRequestTest.java

@@ -0,0 +1,20 @@
+package com.jdi.internal.api.automoderation;
+
+import helpers.RestTestHelper;
+import com.javadiscord.jdi.internal.api.impl.automoderation.DeleteAutoModerationRuleRequest;
+
+import org.junit.jupiter.api.Test;
+
+class DeleteAutoModerationRuleRequestTest extends RestTestHelper {
+
+    @Test
+    void test() throws InterruptedException {
+        sendRequestAndAssert(
+            new DeleteAutoModerationRuleRequest(
+                0L,
+                0L
+            ), 204
+        );
+
+    }
+}

src/test/integration/helpers/MockServerInitializer.java

@@ -0,0 +1,28 @@
+package helpers;
+
+import java.nio.file.Paths;
+
+import com.javadiscord.jdi.core.Discord;
+
+import io.gatehill.imposter.embedded.MockEngine;
+import io.gatehill.imposter.openapi.embedded.OpenApiImposterBuilder;
+
+public class MockServerInitializer {
+    private static final String OPEN_API_SPEC = "mocks/openapi-spec.json";
+    private static final String API_VERSION = "/api/v10";
+    private static final String DISCORD_BASE_URL_ENV_VAR = "DISCORD_BASE_URL";
+    private static final Discord discord;
+
+    static {
+        MockEngine imposter = new OpenApiImposterBuilder<>()
+            .withSpecificationFile(Paths.get(OPEN_API_SPEC))
+            .startBlocking();
+        System.setProperty(DISCORD_BASE_URL_ENV_VAR, "%s%s".formatted(imposter.getBaseUrl().toString(), API_VERSION));
+        discord = new Discord("dummy-bot-token");
+        discord.startWithoutGatewayEvents();
+    }
+
+    public static Discord getDiscord() {
+        return discord;
+    }
+}

src/test/integration/helpers/RestTestHelper.java

@@ -0,0 +1,38 @@
+package helpers;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import com.javadiscord.jdi.core.Discord;
+import com.javadiscord.jdi.internal.api.DiscordRequestDispatcher;
+import com.javadiscord.jdi.internal.api.DiscordRequest;
+import com.javadiscord.jdi.internal.api.DiscordResponseFuture;
+
+public class RestTestHelper {
+    public void sendRequestAndAssert(DiscordRequest request, int expectedStatusCode) throws InterruptedException {
+        DiscordResponseFuture response = getDiscordRequestDispatcher().queue(request);
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        response.onSuccess(
+            (r) -> {
+                assertEquals(r.status(), expectedStatusCode);
+                latch.countDown();
+            }
+        );
+
+        response.onError(err -> fail());
+
+        assertTrue(latch.await(5, TimeUnit.SECONDS));
+    }
+
+    public Discord getDiscord() {
+        return MockServerInitializer.getDiscord();
+    }
+
+    public DiscordRequestDispatcher getDiscordRequestDispatcher() {
+        return getDiscord().getDiscordRequestDispatcher();
+    }
+}