feat: change usage limit consumption to one service

Author: Pedro González Marcos

space-client/src/main/java/io/github/pgmarc/space/FeaturesEndpoint.java

@@ -3,7 +3,7 @@
 import io.github.pgmarc.space.deserializers.ErrorDeserializer;
 import io.github.pgmarc.space.deserializers.FeatureEvaluationDeserializer;
 import io.github.pgmarc.space.exceptions.SpaceApiException;
-import io.github.pgmarc.space.features.Consumption;
+import io.github.pgmarc.space.features.UsageLimitConsumption;
 import io.github.pgmarc.space.features.FeatureEvaluationResult;
 import io.github.pgmarc.space.serializers.ConsumptionSerializer;
 import okhttp3.*;
@@ -56,11 +56,11 @@ public FeatureEvaluationResult evaluate(String userId, String service, String fe
         return res;
     }
 
-    public FeatureEvaluationResult evaluateOptimistically(String userId, String service, String featureId, Consumption consumption)
+    public FeatureEvaluationResult evaluateOptimistically(String userId, String service, String featureId, UsageLimitConsumption usageLimitConsumption)
         throws IOException {
         HttpUrl url = this.baseUrl.newBuilder().addEncodedPathSegment(userId)
             .addEncodedPathSegment(formatFeatureId(service, featureId)).build();
-        RequestBody body = RequestBody.create(consumptionSerializer.toJson(consumption).toString(), JSON);
+        RequestBody body = RequestBody.create(consumptionSerializer.toJson(usageLimitConsumption).toString(), JSON);
         Request request = new Request(url, requiredHeaders ,"POST" , body);
 
         FeatureEvaluationResult res = null;

space-client/src/main/java/io/github/pgmarc/space/features/Consumption.java

@@ -0,0 +1,96 @@
+package io.github.pgmarc.space.features;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+public final class UsageLimitConsumption {
+
+    private final Set<Item<? extends  Number>> items;
+
+    private UsageLimitConsumption(Builder builder) {
+        this.items = Collections.unmodifiableSet(builder.items);
+    }
+
+    public Set<Item<? extends  Number>> getConsumption() {
+        return items;
+    }
+
+    public static Builder builder(String service) {
+        Objects.requireNonNull(service, "service name must not be null");
+        return new Builder(service);
+    }
+
+    public static final class Builder {
+
+        private final String service;
+        private final Set<Item<? extends  Number>> items = new HashSet<>();
+
+        private Builder(String service) {
+            this.service = service.toLowerCase();
+        }
+
+        private void validateFeatureId(String usageLimit) {
+            Objects.requireNonNull(usageLimit, "usage limit name must not be null");
+        }
+
+        public Builder addInt(String usageLimit, int quantity) {
+            validateFeatureId(usageLimit);
+            this.items.add(new Item<>(service, usageLimit, quantity));
+            return this;
+        }
+
+        public Builder addLong(String usageLimit, long quantity) {
+            validateFeatureId(usageLimit);
+            this.items.add(new Item<>(service, usageLimit, quantity));
+            return this;
+        }
+
+        public Builder addFloat(String usageLimit, float quantity) {
+            validateFeatureId(usageLimit);
+            this.items.add(new Item<>(service, usageLimit, quantity));
+            return this;
+        }
+
+        public Builder addDouble(String usageLimit, double quantity) {
+            validateFeatureId(usageLimit);
+            this.items.add(new Item<>(service, usageLimit, quantity));
+            return this;
+        }
+
+        public UsageLimitConsumption build() {
+            if (service.isBlank()) {
+                throw new IllegalStateException("service name must not be blank");
+            }
+            if (items.isEmpty()) {
+                throw new IllegalStateException("usage limits consumption must not be empty");
+            }
+            return new UsageLimitConsumption(this);
+        }
+    }
+
+    public static final class Item<T> {
+        private final String serviceName;
+        private final String usageLimit;
+        private final T quantity;
+
+        private Item(String serviceName, String usageLimit, T quantity) {
+            this.serviceName = serviceName;
+            this.usageLimit = usageLimit;
+            this.quantity = quantity;
+        }
+
+        public String getServiceName() {
+            return  serviceName;
+        }
+
+        public String getUsageLimit() {
+            return  usageLimit;
+        }
+
+        public T getQuantity() {
+            return quantity;
+        }
+    }
+}

space-client/src/main/java/io/github/pgmarc/space/features/UsageLimitConsumption.java

@@ -1,20 +1,20 @@
 package io.github.pgmarc.space.serializers;
 
-import io.github.pgmarc.space.features.Consumption;
+import io.github.pgmarc.space.features.UsageLimitConsumption;
 import org.json.JSONObject;
 
-public final class ConsumptionSerializer implements JsonSerializable<Consumption> {
+public final class ConsumptionSerializer implements JsonSerializable<UsageLimitConsumption> {
 
-    private static String formatConsumptionKey(String serviceName, String usageLimitName) {
-        return serviceName.toLowerCase() + "-" + usageLimitName;
+    private static String formatUsageLimitConsumptionKey(String serviceName, String usageLimitName) {
+        return serviceName + "-" + usageLimitName;
     }
 
     @Override
-    public JSONObject toJson(Consumption consumption) {
+    public JSONObject toJson(UsageLimitConsumption usageLimitConsumption) {
 
         JSONObject jsonObject = new JSONObject();
-        for (Consumption.Item<?> item: consumption.getConsumption()) {
-            jsonObject.put(formatConsumptionKey(item.getServiceName(), item.getUsageLimit()), item.getQuantity());
+        for (UsageLimitConsumption.Item<? extends  Number> item: usageLimitConsumption.getConsumption()) {
+            jsonObject.put(formatUsageLimitConsumptionKey(item.getServiceName(), item.getUsageLimit()), item.getQuantity());
         }
 
         return jsonObject;

space-client/src/main/java/io/github/pgmarc/space/serializers/ConsumptionSerializer.java

@@ -2,7 +2,7 @@
 
 import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
 import com.github.tomakehurst.wiremock.junit5.WireMockTest;
-import io.github.pgmarc.space.features.Consumption;
+import io.github.pgmarc.space.features.UsageLimitConsumption;
 import io.github.pgmarc.space.features.FeatureEvaluationResult;
 import okhttp3.HttpUrl;
 import okhttp3.OkHttpClient;
@@ -73,8 +73,8 @@ void givenConsumptionShouldEvaluateOptimistically() {
         String usageLimit = "featureALimit";
 
         try {
-            Consumption consumption = Consumption.builder().addInt(service, usageLimit, 100).build();
-            FeatureEvaluationResult res = endpoint.evaluateOptimistically(userId, service, feature, consumption);
+            UsageLimitConsumption usageLimitConsumption = UsageLimitConsumption.builder(service).addInt(usageLimit, 100).build();
+            FeatureEvaluationResult res = endpoint.evaluateOptimistically(userId, service, feature, usageLimitConsumption);
             assertThat(res.isAvailable()).isTrue();
             assertThat(res.getConsumed(usageLimit)).hasValue(100);
             assertThat(res.getLimit(usageLimit)).hasValue(500);

space-client/src/test/java/io/github/pgmarc/space/FeaturesEndpointTest.java

@@ -0,0 +1,53 @@
+package io.github.pgmarc.space.features;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class UsageLimitConsumptionTest {
+
+    @Test
+    void givenConsumptionServiceNameMustBeLowerCase() {
+
+        String service = "Petclinic";
+        UsageLimitConsumption usageLimitConsumption = UsageLimitConsumption.builder(service)
+            .addInt("intLimit", Integer.MAX_VALUE)
+            .addLong("longLimit", Long.MAX_VALUE)
+            .addFloat("floatLimit", Float.MAX_VALUE)
+            .addDouble("doubleLimit", Double.MAX_VALUE)
+            .build();
+        assertThat(usageLimitConsumption.getConsumption())
+            .allMatch( item -> item.getServiceName().equals(service.toLowerCase()));
+    }
+
+    @Test
+    void givenNullServiceNameShouldThrow() {
+
+        assertThatExceptionOfType(NullPointerException.class)
+            .isThrownBy(() -> UsageLimitConsumption.builder(null))
+            .withMessage("service name must not be null");
+    }
+
+    @Test
+    void givenEmptyServiceNameShouldThrow() {
+
+        UsageLimitConsumption.Builder builder = UsageLimitConsumption.builder("");
+
+        assertThatExceptionOfType(IllegalStateException.class)
+            .isThrownBy(builder::build)
+            .withMessage("service name must not be blank");
+    }
+
+    @Test
+    void givenEmptyUsageLimitConsumptionShouldThrow() {
+
+        UsageLimitConsumption.Builder builder = UsageLimitConsumption.builder("Petclinic");
+
+        assertThatExceptionOfType(IllegalStateException.class)
+            .isThrownBy(builder::build)
+            .withMessage("usage limits consumption must not be empty");
+    }
+
+
+
+}

space-client/src/test/java/io/github/pgmarc/space/features/UsageLimitConsumptionTest.java

@@ -1,12 +1,12 @@
 package io.github.pgmarc.space.serializers;
 
-import io.github.pgmarc.space.features.Consumption;
+import io.github.pgmarc.space.features.UsageLimitConsumption;
 import org.json.JSONObject;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.*;
 
-class ConsumptionSerializerTest {
+class UsageLimitConsumptionSerializerTest {
 
     private final ConsumptionSerializer serializer = new ConsumptionSerializer();
 
@@ -19,20 +19,20 @@ void givenConsumptionShouldSerialize() {
         float barConsumption = 0.1f;
         double consumedSeconds = (double) Float.MAX_VALUE + 1;
 
-        Consumption consumption = Consumption.builder()
-            .addInt(service, "maxPets", petsRegistered)
-            .addLong(service, "fooLimit", fooConsumption)
-            .addDouble(service, "maxSeconds", consumedSeconds)
-            .addFloat(service, "barLimit", barConsumption)
+        UsageLimitConsumption usageLimitConsumption = UsageLimitConsumption.builder(service)
+            .addInt( "maxPets", petsRegistered)
+            .addLong( "fooLimit", fooConsumption)
+            .addDouble("maxSeconds", consumedSeconds)
+            .addFloat("barLimit", barConsumption)
             .build();
 
-        assertThatNoException().isThrownBy(() -> serializer.toJson(consumption));
+        assertThatNoException().isThrownBy(() -> serializer.toJson(usageLimitConsumption));
 
         String intUsageLimit = "petclinic-maxPets";
         String longUsageLimit = "petclinic-fooLimit";
         String floatUsageLimit = "petclinic-barLimit";
         String doubleUsageLimit =  "petclinic-maxSeconds";
-        JSONObject consumptionPayload = serializer.toJson(consumption);
+        JSONObject consumptionPayload = serializer.toJson(usageLimitConsumption);
 
         assertThat(consumptionPayload.keySet()).contains(intUsageLimit, longUsageLimit, floatUsageLimit, doubleUsageLimit);
         assertThat(consumptionPayload.getInt(intUsageLimit)).isEqualTo(petsRegistered);