added test coverage for app.java and fixed random to be thread safe #2973

Author: skamble2

rate-limiting-pattern/pom.xml

@@ -29,6 +29,26 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.12.0</version>
+            <scope>test</scope>
+        </dependency>
+
+
+            <dependency>
+                <groupId>org.slf4j</groupId>
+                <artifactId>slf4j-api</artifactId>
+                <version>2.0.9</version>
+            </dependency>
+            <dependency>
+                <groupId>ch.qos.logback</groupId>
+                <artifactId>logback-classic</artifactId>
+                <version>1.4.11</version>
+            </dependency>
+
+
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/App.java

@@ -1,6 +1,7 @@
 package com.iluwatar.rate.limiting.pattern;
 
-import java.util.Random;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -43,66 +44,66 @@
  * variable load.
  */
 public final class App {
+  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
+
   private static final int RUN_DURATION_SECONDS = 10;
   private static final int SHUTDOWN_TIMEOUT_SECONDS = 5;
 
-  private static final AtomicInteger successfulRequests = new AtomicInteger();
-  private static final AtomicInteger throttledRequests = new AtomicInteger();
-  private static final AtomicInteger failedRequests = new AtomicInteger();
-  private static final AtomicBoolean running = new AtomicBoolean(true);
+  static final AtomicInteger successfulRequests = new AtomicInteger();
+  static final AtomicInteger throttledRequests = new AtomicInteger();
+  static final AtomicInteger failedRequests = new AtomicInteger();
+  static final AtomicBoolean running = new AtomicBoolean(true);
+  private static final String DIVIDER_LINE = "====================================";
 
   public static void main(String[] args) {
-    System.out.println("\nStarting Rate Limiter Demo");
-    System.out.println("====================================");
+    LOGGER.info("Starting Rate Limiter Demo");
+    LOGGER.info(DIVIDER_LINE);
 
     ExecutorService executor = Executors.newFixedThreadPool(3);
     ScheduledExecutorService statsPrinter = Executors.newSingleThreadScheduledExecutor();
 
     try {
-      // Explicit limiter setup for demonstration clarity
-      TokenBucketRateLimiter tb = new TokenBucketRateLimiter(2, 1); // capacity 2, refill 1/sec
-      FixedWindowRateLimiter fw = new FixedWindowRateLimiter(3, 1); // max 3 req/sec
-      AdaptiveRateLimiter ar = new AdaptiveRateLimiter(2, 6); // adaptive from 2 to 6 req/sec
+      TokenBucketRateLimiter tb = new TokenBucketRateLimiter(2, 1);
+      FixedWindowRateLimiter fw = new FixedWindowRateLimiter(3, 1);
+      AdaptiveRateLimiter ar = new AdaptiveRateLimiter(2, 6);
 
-      // Print statistics every 2 seconds
       statsPrinter.scheduleAtFixedRate(App::printStats, 2, 2, TimeUnit.SECONDS);
 
-      // Launch 3 simulated clients
       for (int i = 1; i <= 3; i++) {
         executor.submit(createClientTask(i, tb, fw, ar));
       }
 
-      // Run simulation for N seconds
       Thread.sleep(RUN_DURATION_SECONDS * 1000L);
-      System.out.println("\nShutting down the demo...");
-
+      LOGGER.info("Shutting down the demo...");
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    } finally {
       running.set(false);
-      executor.shutdown();
-      statsPrinter.shutdown();
+      shutdownExecutor(executor, "mainExecutor");
+      shutdownExecutor(statsPrinter, "statsPrinter");
+      printFinalStats();
+      LOGGER.info("Demo completed.");
+    }
+  }
 
-      if (!executor.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
-        executor.shutdownNow();
-      }
-      if (!statsPrinter.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
-        statsPrinter.shutdownNow();
+  private static void shutdownExecutor(ExecutorService service, String name) {
+    service.shutdown();
+    try {
+      if (!service.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+        service.shutdownNow();
+        LOGGER.warn("Forced shutdown of {}", name);
       }
-
     } catch (InterruptedException e) {
+      service.shutdownNow();
       Thread.currentThread().interrupt();
-    } finally {
-      printFinalStats();
-      System.out.println("Demo completed.");
     }
   }
 
-  private static Runnable createClientTask(
-      int clientId, RateLimiter s3Limiter, RateLimiter dynamoDbLimiter, RateLimiter lambdaLimiter) {
+  static Runnable createClientTask(int clientId, RateLimiter s3Limiter, RateLimiter dynamoDbLimiter, RateLimiter lambdaLimiter) {
     return () -> {
       String[] services = {"s3", "dynamodb", "lambda"};
-      String[] operations = {
-        "GetObject", "PutObject", "Query", "Scan", "PutItem", "Invoke", "ListFunctions"
-      };
-      Random random = new Random();
+      String[] operations = {"GetObject", "PutObject", "Query", "Scan", "PutItem", "Invoke", "ListFunctions"};
+      ThreadLocalRandom random = ThreadLocalRandom.current();
 
       while (running.get() && !Thread.currentThread().isInterrupted()) {
         try {
@@ -113,52 +114,55 @@ private static Runnable createClientTask(
             case "s3" -> makeRequest(clientId, s3Limiter, service, operation);
             case "dynamodb" -> makeRequest(clientId, dynamoDbLimiter, service, operation);
             case "lambda" -> makeRequest(clientId, lambdaLimiter, service, operation);
+            default -> LOGGER.warn("Unknown service: {}", service);
           }
 
-          Thread.sleep(30 + random.nextInt(50));
+          Thread.sleep(30L + random.nextInt(50));
         } catch (InterruptedException e) {
           Thread.currentThread().interrupt();
         }
       }
     };
   }
 
-  private static void makeRequest(
-      int clientId, RateLimiter limiter, String service, String operation) {
+  static void makeRequest(int clientId, RateLimiter limiter, String service, String operation) {
     try {
       limiter.check(service, operation);
       successfulRequests.incrementAndGet();
-      System.out.printf("Client %d: %s.%s - ALLOWED%n", clientId, service, operation);
+      LOGGER.info("Client {}: {}.{} - ALLOWED", clientId, service, operation);
     } catch (ThrottlingException e) {
       throttledRequests.incrementAndGet();
-      System.out.printf(
-          "Client %d: %s.%s - THROTTLED (Retry in %dms)%n",
-          clientId, service, operation, e.getRetryAfterMillis());
+      LOGGER.warn("Client {}: {}.{} - THROTTLED (Retry in {}ms)", clientId, service, operation, e.getRetryAfterMillis());
     } catch (ServiceUnavailableException e) {
       failedRequests.incrementAndGet();
-      System.out.printf("Client %d: %s.%s - SERVICE UNAVAILABLE%n", clientId, service, operation);
+      LOGGER.warn("Client {}: {}.{} - SERVICE UNAVAILABLE", clientId, service, operation);
     } catch (Exception e) {
       failedRequests.incrementAndGet();
-      System.out.printf(
-          "Client %d: %s.%s - ERROR: %s%n", clientId, service, operation, e.getMessage());
+      LOGGER.error("Client {}: {}.{} - ERROR: {}", clientId, service, operation, e.getMessage());
     }
   }
 
-  private static void printStats() {
+  static void printStats() {
     if (!running.get()) return;
-    System.out.println("\n=== Current Statistics ===");
-    System.out.printf("Successful Requests: %d%n", successfulRequests.get());
-    System.out.printf("Throttled Requests : %d%n", throttledRequests.get());
-    System.out.printf("Failed Requests    : %d%n", failedRequests.get());
-    System.out.println("==========================\n");
+    LOGGER.info("=== Current Statistics ===");
+    LOGGER.info("Successful Requests: {}", successfulRequests.get());
+    LOGGER.info("Throttled Requests : {}", throttledRequests.get());
+    LOGGER.info("Failed Requests    : {}", failedRequests.get());
+    LOGGER.info(DIVIDER_LINE);
+  }
+
+  static void printFinalStats() {
+    LOGGER.info("Final Statistics");
+    LOGGER.info(DIVIDER_LINE);
+    LOGGER.info("Successful Requests: {}", successfulRequests.get());
+    LOGGER.info("Throttled Requests : {}", throttledRequests.get());
+    LOGGER.info("Failed Requests    : {}", failedRequests.get());
+    LOGGER.info(DIVIDER_LINE);
   }
 
-  private static void printFinalStats() {
-    System.out.println("\nFinal Statistics");
-    System.out.println("==========================");
-    System.out.printf("Successful Requests: %d%n", successfulRequests.get());
-    System.out.printf("Throttled Requests : %d%n", throttledRequests.get());
-    System.out.printf("Failed Requests    : %d%n", failedRequests.get());
-    System.out.println("==========================");
+  static void resetCountersForTesting() {
+    successfulRequests.set(0);
+    throttledRequests.set(0);
+    failedRequests.set(0);
   }
 }

rate-limiting-pattern/src/test/java/com/iluwatar/rate/limiting/pattern/AppTest.java

@@ -0,0 +1,61 @@
+package com.iluwatar.rate.limiting.pattern;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for {@link App}.
+ */
+class AppTest {
+
+  private RateLimiter mockLimiter;
+
+  @BeforeEach
+  void setUp() {
+    mockLimiter = mock(RateLimiter.class);
+    AppTestUtils.resetCounters(); // Ensures counters are clean before every test
+  }
+
+  @Test
+  void shouldAllowRequest() {
+    AppTestUtils.invokeMakeRequest(1, mockLimiter, "s3", "GetObject");
+    assertEquals(1, AppTestUtils.getSuccessfulRequests().get(), "Successful count should be 1");
+    assertEquals(0, AppTestUtils.getThrottledRequests().get(), "Throttled count should be 0");
+    assertEquals(0, AppTestUtils.getFailedRequests().get(), "Failed count should be 0");
+  }
+
+  @Test
+  void shouldHandleThrottlingException() throws Exception {
+    doThrow(new ThrottlingException("s3", "PutObject", 1000)).when(mockLimiter).check(any(), any());
+    AppTestUtils.invokeMakeRequest(2, mockLimiter, "s3", "PutObject");
+    assertEquals(0, AppTestUtils.getSuccessfulRequests().get());
+    assertEquals(1, AppTestUtils.getThrottledRequests().get());
+    assertEquals(0, AppTestUtils.getFailedRequests().get());
+  }
+
+  @Test
+  void shouldHandleServiceUnavailableException() throws Exception {
+    doThrow(new ServiceUnavailableException("lambda", 500)).when(mockLimiter).check(any(), any());
+    AppTestUtils.invokeMakeRequest(3, mockLimiter, "lambda", "Invoke");
+    assertEquals(0, AppTestUtils.getSuccessfulRequests().get());
+    assertEquals(0, AppTestUtils.getThrottledRequests().get());
+    assertEquals(1, AppTestUtils.getFailedRequests().get());
+  }
+
+  @Test
+  void shouldHandleGenericException() throws Exception {
+    doThrow(new RuntimeException("Unexpected")).when(mockLimiter).check(any(), any());
+    AppTestUtils.invokeMakeRequest(4, mockLimiter, "dynamodb", "Query");
+    assertEquals(0, AppTestUtils.getSuccessfulRequests().get());
+    assertEquals(0, AppTestUtils.getThrottledRequests().get());
+    assertEquals(1, AppTestUtils.getFailedRequests().get());
+  }
+
+  @Test
+  void shouldRunMainMethodWithoutException() {
+    assertDoesNotThrow(() -> App.main(new String[] {}));
+  }
+}

rate-limiting-pattern/src/test/java/com/iluwatar/rate/limiting/pattern/AppTestUtils.java

@@ -0,0 +1,26 @@
+package com.iluwatar.rate.limiting.pattern;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AppTestUtils {
+
+  public static void invokeMakeRequest(int clientId, RateLimiter limiter, String service, String operation) {
+    App.makeRequest(clientId, limiter, service, operation);
+  }
+
+  public static void resetCounters() {
+    App.resetCountersForTesting();
+  }
+
+  public static AtomicInteger getSuccessfulRequests() {
+    return App.successfulRequests;
+  }
+
+  public static AtomicInteger getThrottledRequests() {
+    return App.throttledRequests;
+  }
+
+  public static AtomicInteger getFailedRequests() {
+    return App.failedRequests;
+  }
+}

rate-limiting-pattern/src/test/java/com/iluwatar/rate/limiting/pattern/FindCustomerRequestTest.java

@@ -43,4 +43,19 @@ void shouldExecuteUsingDefaultHelper() throws Exception {
     RateLimiter limiter = new TokenBucketRateLimiter(5, 5);
     shouldExecuteWhenUnderLimit(createOperation(limiter));
   }
+
+  @Test
+  void shouldThrowServiceUnavailableOnInterruptedException() {
+    RateLimiter noOpLimiter = (service, operation) -> {}; // no throttling
+
+    FindCustomerRequest request = new FindCustomerRequest("999", noOpLimiter) {
+      @Override
+      public String execute() throws RateLimitException {
+        Thread.currentThread().interrupt(); // Simulate thread interruption
+        return super.execute(); // Should throw ServiceUnavailableException
+      }
+    };
+
+    assertThrows(ServiceUnavailableException.class, request::execute);
+  }
 }