Run NATS CI without Docker; mirror Redis CI pattern

The nats_integration_test job previously relied on Testcontainers
(Docker) being preinstalled on the runner. That works for ubuntu-latest
today but isn't a guarantee for self-hosted runners or alternate
images. Mirroring how the existing redis / redis_cluster jobs install
their server binary directly:

  - Download nats-server v2.10.22 from GitHub releases, drop into
    /usr/local/bin, start with -js + JetStream dir as a background
    process and wait for the listener.
  - Set NATS_RUNNING=true and NATS_URL=nats://127.0.0.1:4222 for the
    Gradle invocation. Mirrors REDIS_RUNNING used by RedisRunning.

AbstractNatsBootIT now reads NATS_RUNNING / NATS_URL: when present, it
points the dynamic property at the external server and skips
@container instantiation entirely. Local dev without those env vars
falls back to Testcontainers, which itself skips gracefully when
Docker isn't available.

NatsBackendEndToEndIT now extends AbstractNatsBootIT instead of
duplicating the connection-URL plumbing.

Uploads /tmp/nats.log as an artifact on every CI run so failures are
debuggable without GitHub admin auth on the workflow logs.

Assisted-By: Claude Code

Author: sonus21

.github/workflows/java-ci.yaml

@@ -360,12 +360,42 @@ jobs:
       - name: Set up Gradle
         uses: gradle/actions/setup-gradle@v4
 
-      # Docker is preinstalled on ubuntu-latest runners; Testcontainers picks it up
-      # automatically. No Redis is needed for this job — every test under @Tag("nats")
-      # talks to a JetStream container via Testcontainers (or runs as a pure unit test).
+      # Install + start nats-server directly (not via Docker — mirrors how the other CI
+      # jobs install redis-server). Tests detect NATS_RUNNING and connect to localhost
+      # instead of pulling a Testcontainers image.
+      - name: Install nats-server
+        run: |
+          NATS_VERSION=v2.10.22
+          curl -sSL "https://github.com/nats-io/nats-server/releases/download/${NATS_VERSION}/nats-server-${NATS_VERSION}-linux-amd64.tar.gz" \
+            | tar -xz -C /tmp
+          sudo mv "/tmp/nats-server-${NATS_VERSION}-linux-amd64/nats-server" /usr/local/bin/nats-server
+          nats-server --version
+
+      - name: Start nats-server
+        run: |
+          mkdir -p /tmp/jetstream
+          nohup nats-server -js -sd /tmp/jetstream -p 4222 > /tmp/nats.log 2>&1 &
+          for i in $(seq 1 20); do
+            if (echo > /dev/tcp/127.0.0.1/4222) 2>/dev/null; then
+              echo "nats-server ready after ${i}s"; break
+            fi
+            sleep 1
+          done
+
       - name: Run NATS tests
+        env:
+          NATS_RUNNING: "true"
+          NATS_URL: nats://127.0.0.1:4222
         run: ./gradlew :rqueue-nats:test :rqueue-spring-boot-starter:test :rqueue-spring:test -DincludeTags=nats
 
+      - name: Upload nats-server log
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: nats-server-log
+          path: /tmp/nats.log
+          if-no-files-found: ignore
+
       - name: Upload JaCoCo exec data
         if: always()
         uses: actions/upload-artifact@v4

rqueue-spring-boot-starter/src/test/java/com/github/sonus21/rqueue/spring/boot/integration/AbstractNatsBootIT.java

@@ -26,25 +26,41 @@
 /**
  * Common Testcontainers + dynamic-property boilerplate for NATS-backed end-to-end tests.
  *
+ * <p>Mirrors the existing Redis test pattern (see {@code RedisRunning} / {@code REDIS_RUNNING}):
+ * when the {@code NATS_RUNNING} environment variable is set the tests assume an externally
+ * managed nats-server is reachable at {@code NATS_URL} (default {@code nats://127.0.0.1:4222})
+ * and skip Testcontainers entirely. CI sets {@code NATS_RUNNING=true} after starting nats-server
+ * via apt; local dev leaves it unset and falls back to Testcontainers, which itself skips
+ * gracefully when Docker isn't available.
+ *
  * <p>Subclasses declare their own {@code @SpringBootApplication} test config (typically excluding
  * Redis auto-config, see {@link NatsBackendEndToEndIT} for the reference pattern) and any
- * {@code @RqueueListener} beans they need. The container is lifecycle-managed by the
- * {@link Testcontainers} extension and shared across all tests in a single subclass.
+ * {@code @RqueueListener} beans they need.
  */
 @Testcontainers(disabledWithoutDocker = true)
 abstract class AbstractNatsBootIT {
 
+  static final boolean USE_EXTERNAL_NATS = System.getenv("NATS_RUNNING") != null;
+
+  static final String EXTERNAL_NATS_URL =
+      System.getenv().getOrDefault("NATS_URL", "nats://127.0.0.1:4222");
+
   @Container
-  static final GenericContainer<?> NATS = new GenericContainer<>(
-          DockerImageName.parse("nats:2.10-alpine"))
-      .withCommand("-js")
-      .withExposedPorts(4222)
-      .waitingFor(Wait.forLogMessage(".*Server is ready.*\\n", 1));
+  static final GenericContainer<?> NATS = USE_EXTERNAL_NATS
+      ? null
+      : new GenericContainer<>(DockerImageName.parse("nats:2.10-alpine"))
+          .withCommand("-js")
+          .withExposedPorts(4222)
+          .waitingFor(Wait.forLogMessage(".*Server is ready.*\\n", 1));
 
   @DynamicPropertySource
   static void natsProps(DynamicPropertyRegistry r) {
-    r.add(
-        "rqueue.nats.connection.url",
-        () -> "nats://" + NATS.getHost() + ":" + NATS.getMappedPort(4222));
+    if (USE_EXTERNAL_NATS) {
+      r.add("rqueue.nats.connection.url", () -> EXTERNAL_NATS_URL);
+    } else {
+      r.add(
+          "rqueue.nats.connection.url",
+          () -> "nats://" + NATS.getHost() + ":" + NATS.getMappedPort(4222));
+    }
   }
 }

rqueue-spring-boot-starter/src/test/java/com/github/sonus21/rqueue/spring/boot/integration/NatsBackendEndToEndIT.java

@@ -33,60 +33,34 @@
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.context.annotation.Import;
 import org.springframework.stereotype.Component;
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
-import org.testcontainers.containers.GenericContainer;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-import org.testcontainers.utility.DockerImageName;
 
 /**
- * End-to-end integration test wiring a Spring Boot application against a Testcontainers-managed
- * NATS JetStream instance via {@code rqueue.backend=nats}, an {@link RqueueListener}, and the
- * default {@link RqueueMessageEnqueuer}. It exercises the full intended path:
+ * End-to-end integration test wiring a Spring Boot application against a NATS JetStream
+ * instance via {@code rqueue.backend=nats}, an {@link RqueueListener}, and the default
+ * {@link RqueueMessageEnqueuer}. It exercises the full intended path:
  *
  * <pre>
  *   Enqueue -> JetStreamMessageBroker.enqueue -> JetStream stream
  *           -> BrokerMessagePoller.pop -> @RqueueListener invocation -> broker.ack
  * </pre>
  *
+ * <p>The NATS instance is supplied by {@link AbstractNatsBootIT}: when {@code NATS_RUNNING=true}
+ * (CI), the test connects to a locally running nats-server; otherwise it falls back to a
+ * Testcontainers-managed container, which itself skips gracefully without Docker.
+ *
  * <p>Boots without any Redis at all: every Redis-shaped bean (config DAOs, dashboard controllers,
  * pub/sub channel, schedulers) is gated by {@code @Conditional(RedisBackendCondition.class)} and
  * stays out of the context when {@code rqueue.backend=nats}. {@code DataRedisAutoConfiguration}
- * is excluded so Spring Boot doesn't try to wire a Lettuce client either. The whole produce-and-
- * consume loop runs through JetStream.
- *
- * <p>The {@link TestListener} is explicitly imported (rather than relying on package scan) so the
- * listener is reachable regardless of where the test harness places the {@code @SpringBootTest}'s
- * scan root.
+ * is excluded so Spring Boot doesn't try to wire a Lettuce client either.
  */
 @SpringBootTest(
     classes = NatsBackendEndToEndIT.TestApp.class,
     properties = {"rqueue.backend=nats"})
-@Testcontainers(disabledWithoutDocker = true)
 @Tag("nats")
-class NatsBackendEndToEndIT {
-
-  @Container
-  static final GenericContainer<?> NATS = new GenericContainer<>(
-          DockerImageName.parse("nats:2.10-alpine"))
-      .withCommand("-js")
-      .withExposedPorts(4222)
-      .waitingFor(Wait.forLogMessage(".*Server is ready.*\\n", 1));
-
-  @DynamicPropertySource
-  static void registerProps(DynamicPropertyRegistry r) {
-    r.add(
-        "rqueue.nats.connection.url",
-        () -> "nats://" + NATS.getHost() + ":" + NATS.getMappedPort(4222));
-  }
-
-  @Autowired
-  RqueueMessageEnqueuer enqueuer;
+class NatsBackendEndToEndIT extends AbstractNatsBootIT {
 
-  @Autowired
-  TestListener listener;
+  @Autowired RqueueMessageEnqueuer enqueuer;
+  @Autowired TestListener listener;
 
   @Test
   void enqueueIsReceivedByListener() throws Exception {