test: add RateLimiter unit tests

Author: objz

core/src/test/java/dev/objz/commandbridge/net/InNodeTest.java

@@ -0,0 +1,114 @@
+package dev.objz.commandbridge.net;
+
+import dev.objz.commandbridge.logging.Log;
+import dev.objz.commandbridge.net.proto.Envelope;
+import dev.objz.commandbridge.net.proto.MessageType;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class InNodeTest {
+
+    @BeforeAll
+    static void installLog() {
+        try {
+            Log.install(java.util.logging.Logger.getLogger("test"));
+        } catch (IllegalStateException ignored) {
+            // expected
+        }
+    }
+
+    private static final class CountingHandler extends InboundHandler {
+        final AtomicInteger count = new AtomicInteger(0);
+        Envelope lastEnv;
+
+        @Override
+        public void accept(Endpoint endpoint, Envelope env) {
+            count.incrementAndGet();
+            this.lastEnv = env;
+        }
+    }
+
+    @Test
+    void registersAndDispatchesByType() throws Exception {
+        InNode inNode = new InNode();
+        CountingHandler handler = new CountingHandler();
+        inNode.register(MessageType.PING, handler);
+
+        Envelope testEnv = Envelope.make(MessageType.PING, "server1", "client1", null);
+        String json = Envelope.MAPPER.writeValueAsString(testEnv);
+
+        TestEndpoint endpoint = new TestEndpoint();
+        inNode.onText(endpoint, json);
+
+        assertEquals(1, handler.count.get());
+        assertNotNull(handler.lastEnv);
+        assertEquals(MessageType.PING, handler.lastEnv.type());
+    }
+
+    @Test
+    void unhandledTypeDoesNotThrow() throws Exception {
+        InNode inNode = new InNode();
+        CountingHandler handler = new CountingHandler();
+        inNode.register(MessageType.PING, handler);
+
+        Envelope testEnv = Envelope.make(MessageType.PONG, "server1", "client1", null);
+        String json = Envelope.MAPPER.writeValueAsString(testEnv);
+
+        TestEndpoint endpoint = new TestEndpoint();
+        assertDoesNotThrow(() -> inNode.onText(endpoint, json));
+        assertEquals(0, handler.count.get());
+    }
+
+    @Test
+    void badJsonDoesNotThrow() {
+        InNode inNode = new InNode();
+        TestEndpoint endpoint = new TestEndpoint();
+
+        assertDoesNotThrow(() -> inNode.onText(endpoint, "not valid json"));
+    }
+
+    @Test
+    void tapInterceptsBeforeHandler() throws Exception {
+        InNode inNode = new InNode();
+        CountingHandler handler = new CountingHandler();
+        inNode.register(MessageType.PING, handler);
+        inNode.setInboundTap(env -> true);
+
+        Envelope testEnv = Envelope.make(MessageType.PING, "server1", "client1", null);
+        String json = Envelope.MAPPER.writeValueAsString(testEnv);
+
+        TestEndpoint endpoint = new TestEndpoint();
+        inNode.onText(endpoint, json);
+
+        assertEquals(0, handler.count.get());
+    }
+
+    @Test
+    void tapFalsePassesToHandler() throws Exception {
+        InNode inNode = new InNode();
+        CountingHandler handler = new CountingHandler();
+        inNode.register(MessageType.PING, handler);
+        inNode.setInboundTap(env -> false);
+
+        Envelope testEnv = Envelope.make(MessageType.PING, "server1", "client1", null);
+        String json = Envelope.MAPPER.writeValueAsString(testEnv);
+
+        TestEndpoint endpoint = new TestEndpoint();
+        inNode.onText(endpoint, json);
+
+        assertEquals(1, handler.count.get());
+    }
+
+    @Test
+    void nullEndpointHandledGracefully() {
+        InNode inNode = new InNode();
+
+        assertDoesNotThrow(() -> inNode.onText(null, "bad json"));
+    }
+}

core/src/test/java/dev/objz/commandbridge/util/RateLimiterTest.java

@@ -0,0 +1,67 @@
+package dev.objz.commandbridge.util;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+class RateLimiterTest {
+
+    @BeforeAll
+    static void installLog() {
+        try {
+            dev.objz.commandbridge.logging.Log.install(java.util.logging.Logger.getLogger("test"));
+        } catch (IllegalStateException ignored) {
+            // expected
+        }
+    }
+
+    @Test
+    void constructorRejectsZero() {
+        assertThrows(IllegalArgumentException.class, () -> new RateLimiter<>(0));
+    }
+
+    @Test
+    void constructorRejectsNegative() {
+        assertThrows(IllegalArgumentException.class, () -> new RateLimiter<>(-1));
+    }
+
+    @Test
+    void allowsUpToMax() {
+        RateLimiter<String> limiter = new RateLimiter<>(5);
+        for (int i = 0; i < 5; i++) {
+            assertTrue(limiter.allow("k"), "Call " + (i + 1) + " should be allowed");
+        }
+    }
+
+    @Test
+    void deniesOverMax() {
+        RateLimiter<String> limiter = new RateLimiter<>(5);
+        for (int i = 0; i < 5; i++) {
+            limiter.allow("k");
+        }
+        assertFalse(limiter.allow("k"), "6th call should be denied");
+    }
+
+    @Test
+    void independentKeys() {
+        RateLimiter<String> limiter = new RateLimiter<>(2);
+        assertTrue(limiter.allow("A"));
+        assertTrue(limiter.allow("A"));
+        assertFalse(limiter.allow("A"));
+        assertTrue(limiter.allow("B"), "Key B should still be allowed");
+        assertTrue(limiter.allow("B"));
+        assertFalse(limiter.allow("B"));
+    }
+
+    @Test
+    void windowResets() throws InterruptedException {
+        RateLimiter<String> limiter = new RateLimiter<>(1);
+        assertTrue(limiter.allow("k"), "First call should be allowed");
+        assertFalse(limiter.allow("k"), "Second call in same second should be denied");
+        Thread.sleep(1100);
+        assertTrue(limiter.allow("k"), "Call after window reset should be allowed");
+    }
+}