refactor: array and counter-based version of the stubs

Author: nergal-perm

src/main/java/ewc/utilities/testableio/core/ConfigurableResponses.java renamed to src/main/java/ewc/utilities/testableio/core/SingleClientStubs.java

@@ -30,30 +30,29 @@
 import lombok.SneakyThrows;
 
 /**
- * This class provides configurable responses for HTTP-related utilities.
- * It is designed to be extended or modified to suit specific use cases.
+ * This class provides configurable responses for all the queries made by a single 'client'.
  *
  * @since 0.1
  */
-class ConfigurableResponses {
+class SingleClientStubs {
     /**
      * The storage for all the configured responses.
      */
     private final Map<String, SingleQueryResponses> responses = new HashMap<>();
 
     /**
-     * Returns the next response for the given request.
+     * Returns the next response for the given query.
      *
-     * @param request The request for which to get the next response.
+     * @param query The query for which to get the next response.
      * @return The next response object.
      */
     @SneakyThrows
-    public GenericResponse<?> nextResponseFor(final GenericRequest<?> request) {
+    public GenericResponse<?> nextResponseFor(final GenericRequest<?> query) {
         final String key;
-        if (this.responses.containsKey(ConfigurableResponses.responseKeyFor(request))) {
-            key = ConfigurableResponses.responseKeyFor(request);
+        if (this.responses.containsKey(SingleClientStubs.responseKeyFor(query))) {
+            key = SingleClientStubs.responseKeyFor(query);
         } else {
-            key = request.queryId();
+            key = query.queryId();
         }
         if (!this.responses.containsKey(key)) {
             throw new NoSuchElementException("No responses configured");
@@ -72,11 +71,11 @@ public void setDefaultResponsesFor(final String query, final SingleQueryResponse
     public void setResponsesFor(
         final String client, final String query, final SingleQueryResponses response
     ) {
-        this.responses.put(ConfigurableResponses.responseKeyFor(client, query), response);
+        this.responses.put(SingleClientStubs.responseKeyFor(client, query), response);
     }
 
     private static String responseKeyFor(final GenericRequest<?> request) {
-        return ConfigurableResponses.responseKeyFor(request.clientId(), request.queryId());
+        return SingleClientStubs.responseKeyFor(request.clientId(), request.queryId());
     }
 
     private static String responseKeyFor(final String client, final String query) {

src/main/java/ewc/utilities/testableio/core/SingleQueryResponses.java

@@ -24,10 +24,8 @@
 
 package ewc.utilities.testableio.core;
 
-import java.util.Arrays;
-import java.util.Iterator;
 import java.util.NoSuchElementException;
-import java.util.stream.Stream;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * This class provides configured responses for a single I/O opersation stub. The responses could
@@ -39,10 +37,14 @@
  */
 public class SingleQueryResponses {
     /**
-     * The iterator of configured responses. This iterator is used to provide
-     * responses sequentially.
+     * The counter providing the index of the next response to be returned.
      */
-    private final Iterator<? extends GenericResponse<?>> values;
+    private final Counter index;
+
+    /**
+     * The array of responses to be returned sequentially.
+     */
+    private final GenericResponse<?>[] values;
 
     /**
      * The short description of this instance. Used primarily for identifying the
@@ -57,7 +59,7 @@ public class SingleQueryResponses {
      * @param value The response to be returned forever.
      */
     public SingleQueryResponses(final String stub, final GenericResponse<?> value) {
-        this(Stream.generate(() -> value).iterator(), stub);
+        this(stub, new GenericResponse<?>[]{value}, new ConstantIndex());
     }
 
     /**
@@ -68,20 +70,22 @@ public SingleQueryResponses(final String stub, final GenericResponse<?> value) {
      * @param values The array of responses to be returned sequentially.
      */
     public SingleQueryResponses(final String stub, final GenericResponse<?>... values) {
-        this(Arrays.stream(values).iterator(), stub);
+        this(stub, values, new IncrementalIndex());
     }
 
     /**
      * Primary constructor.
      *
-     * @param values The iterator that returns configured responses sequentially.
-     * @param description The short description of this instance.
+     * @param stub The short description of this stub instance.
+     * @param values The array of responses to be returned sequentially.
+     * @param index The counter providing the index of the next response to be returned.
      */
     private SingleQueryResponses(
-        final Iterator<? extends GenericResponse<?>> values, final String description
+        final String stub, final GenericResponse<?>[] values, final Counter index
     ) {
+        this.index = index;
         this.values = values;
-        this.description = description;
+        this.description = stub;
     }
 
     /**
@@ -95,15 +99,79 @@ public GenericResponse<?> next() {
         if (this.values == null) {
             throw new IllegalStateException("No response to send");
         }
-        if (!this.values.hasNext()) {
+        if (this.index.isTheLast(this.values.length)) {
             throw new NoSuchElementException(
                 String.format("No more configured responses for %s", this.description)
             );
         }
-        final GenericResponse<?> value = this.values.next();
+        final GenericResponse<?> value = this.values[this.index.getAndIncrement()];
         if (value.contents() instanceof RuntimeException runtimeException) {
             throw runtimeException;
         }
         return value;
     }
+
+    /**
+     * The value of the counter. This value is used to determine the index of the response to
+     * be returned.
+     *
+     * @since 0.1
+     */
+    private interface Counter {
+        /**
+         * The value of the counter. This value is used to determine the index of the response to
+         * be returned.
+         *
+         * @return The current value of the counter.
+         */
+        int currentValue();
+
+        /**
+         * Increments the counter by one. This method is used to move to the next response in the
+         * array.
+         *
+         * @return The value of the counter before incrementing.
+         */
+        int getAndIncrement();
+
+        /**
+         * Checks if the current value of the counter is the last one in the array.
+         *
+         * @param size The size of the array of responses.
+         * @return True if the current value is the last one, false otherwise.
+         * @since 0.1
+         */
+        default boolean isTheLast(final int size) {
+            return this.currentValue() >= size;
+        }
+    }
+
+    private static final class ConstantIndex implements Counter {
+        @Override
+        public int currentValue() {
+            return 0;
+        }
+
+        @Override
+        public int getAndIncrement() {
+            return 0;
+        }
+    }
+
+    private static final class IncrementalIndex implements Counter {
+        /**
+         * The thread-safe counter providing the index of the next response to be returned.
+         */
+        private final AtomicInteger index = new AtomicInteger(0);
+
+        @Override
+        public int currentValue() {
+            return this.index.intValue();
+        }
+
+        @Override
+        public int getAndIncrement() {
+            return this.index.getAndIncrement();
+        }
+    }
 }

src/test/java/ewc/utilities/testableio/core/ConfigurableResponsesTest.java renamed to src/test/java/ewc/utilities/testableio/core/SingleClientStubsTest.java

@@ -31,21 +31,21 @@
 import org.junit.jupiter.api.Test;
 
 /**
- * This class provides unit tests for the {@link ConfigurableResponses} class.
+ * This class provides unit tests for the {@link SingleClientStubs} class.
  * It verifies the default values and behavior of the class.
  *
  * @since 0.1
  */
-final class ConfigurableResponsesTest {
+final class SingleClientStubsTest {
     @Test
     void couldBeInstantiated() {
-        final ConfigurableResponses target = new ConfigurableResponses();
+        final SingleClientStubs target = new SingleClientStubs();
         Assertions.assertThat(target).isNotNull();
     }
 
     @Test
     void throwsIfNoResponsesConfigured() {
-        final ConfigurableResponses target = new ConfigurableResponses();
+        final SingleClientStubs target = new SingleClientStubs();
         final GenericRequest<String> request = new MockRequest().assignedToClient();
         Assertions.assertThatExceptionOfType(NoSuchElementException.class)
             .isThrownBy(() -> target.nextResponseFor(request))
@@ -54,7 +54,7 @@ void throwsIfNoResponsesConfigured() {
 
     @Test
     void returnsTheResponseThatCorrespondsToTheRequest() {
-        final ConfigurableResponses target = new ConfigurableResponses();
+        final SingleClientStubs target = new SingleClientStubs();
         target.setDefaultResponsesFor(
             "getHomePage",
             new SingleQueryResponses(