feat: ensure first and last tier range are valid

Author: adrianliz

exercises/tiered_pricing/solutions/adrianliz/java/src/main/java/tv/codely/checkout/SubscriptionTier.java

@@ -13,6 +13,14 @@ public SubscriptionTier(
         this.price = price;
     }
 
+    public boolean isFirst() {
+        return range.isFirst();
+    }
+
+    public boolean isLast() {
+        return range.isLast();
+    }
+
     public boolean isInRange(int numberOfSubscriptions) {
         return this.range.isSuitableFor(numberOfSubscriptions);
     }
@@ -24,8 +32,4 @@ public double unitPrice() {
     public double getTotalPrice(int numberOfSubscriptions) {
         return unitPrice() * numberOfSubscriptions;
     }
-
-    public boolean isLast() {
-        return range.isLast();
-    }
 }

exercises/tiered_pricing/solutions/adrianliz/java/src/main/java/tv/codely/checkout/SubscriptionTierRange.java

@@ -14,12 +14,16 @@ public static SubscriptionTierRange last(int numberOfSubscriptionsFrom) {
         return new SubscriptionTierRange(numberOfSubscriptionsFrom, Integer.MAX_VALUE);
     }
 
-    public boolean isSuitableFor(int numberOfSubscriptions) {
-        return numberOfSubscriptions >= numberOfSubscriptionsFrom
-            && numberOfSubscriptions <= numberOfSubscriptionsTo;
+    public boolean isFirst() {
+        return numberOfSubscriptionsFrom == 1;
     }
 
     public boolean isLast() {
         return numberOfSubscriptionsTo == Integer.MAX_VALUE;
     }
+
+    public boolean isSuitableFor(int numberOfSubscriptions) {
+        return numberOfSubscriptions >= numberOfSubscriptionsFrom
+            && numberOfSubscriptions <= numberOfSubscriptionsTo;
+    }
 }

exercises/tiered_pricing/solutions/adrianliz/java/src/main/java/tv/codely/checkout/SubscriptionTiers.java

@@ -16,12 +16,28 @@ private static void validate(final List<SubscriptionTier> tiers) {
             throw new InvalidSubscriptionTiers("There must be at least one subscription tier");
         }
 
+        if (tiers.stream().noneMatch(SubscriptionTier::isFirst)) {
+            throw new InvalidSubscriptionTiers("There must be a first subscription tier");
+        }
+
         if (tiers.stream().noneMatch(SubscriptionTier::isLast)) {
-            throw new IllegalArgumentException("There must be a last subscription tier");
+            throw new InvalidSubscriptionTiers("There must be a last subscription tier");
         }
     }
 
-    public List<SubscriptionTier> tiers() {
-        return tiers;
+    private SubscriptionTier findSuitableTier(int subscriptions) {
+        return tiers.stream()
+            .filter(tier -> tier.isInRange(subscriptions))
+            .findFirst()
+            .orElseThrow(() -> new InvalidSubscriptionTiers(
+                "There is no subscription tier for " + subscriptions + " subscriptions"));
+    }
+
+    public double getTotalPrice(int subscriptions) {
+        return findSuitableTier(subscriptions).getTotalPrice(subscriptions);
+    }
+
+    public double getBasePrice(int subscriptions) {
+        return findSuitableTier(subscriptions).unitPrice();
     }
 }

exercises/tiered_pricing/solutions/adrianliz/java/src/main/java/tv/codely/checkout/TieredPricing.java

@@ -3,30 +3,22 @@
 import java.util.List;
 
 public class TieredPricing {
-
-    private final List<SubscriptionTier> subscriptionTiers;
+    
+    private final SubscriptionTiers tiers;
 
     public TieredPricing(final SubscriptionTiers subscriptionTiers) {
-        this.subscriptionTiers = subscriptionTiers.tiers();
+        this.tiers = subscriptionTiers;
     }
 
     public TieredPricing(final List<SubscriptionTier> subscriptionTiers) {
         this(new SubscriptionTiers(subscriptionTiers));
     }
 
     public double getTotalPrice(int subscriptions) {
-        return subscriptionTiers.stream()
-            .filter(subscriptionTier -> subscriptionTier.isInRange(subscriptions))
-            .findFirst()
-            .map(subscriptionTier -> subscriptionTier.getTotalPrice(subscriptions))
-            .orElse(0D);
+        return tiers.getTotalPrice(subscriptions);
     }
 
     public double getBasePrice(int subscriptions) {
-        return subscriptionTiers.stream()
-            .filter(subscriptionTier -> subscriptionTier.isInRange(subscriptions))
-            .findFirst()
-            .map(SubscriptionTier::unitPrice)
-            .orElse(0D);
+        return tiers.getBasePrice(subscriptions);
     }
 }

exercises/tiered_pricing/solutions/adrianliz/java/src/test/java/tv/codely/checkout/TieredPricingShould.java

@@ -9,6 +9,8 @@
 import org.junit.jupiter.api.Test;
 import tv.codely.checkout.mother.IntegerMother;
 import tv.codely.checkout.mother.SubscriptionTierMother;
+import tv.codely.checkout.mother.SubscriptionTierPriceMother;
+import tv.codely.checkout.mother.SubscriptionTierRangeMother;
 
 public class TieredPricingShould {
 
@@ -49,23 +51,6 @@ void return_total_price_based_on_number_of_subscriptions() {
         assertEquals(expectedPrice, totalPrice);
     }
 
-    @Test
-    void should_throw_invalid_tiers_if_there_is_no_last_tier() {
-        final var subscriptionTiers = SubscriptionTierMother.randoms();
-        final var lastSubscriptionTier =
-            subscriptionTiers.stream()
-                .filter(SubscriptionTier::isLast)
-                .findFirst()
-                .orElse(null);
-
-        assertNotNull(lastSubscriptionTier);
-    }
-
-    @Test
-    void should_throw_invalid_tiers_if_there_is_no_tiers() {
-        assertThrows(InvalidSubscriptionTiers.class, () -> new TieredPricing(List.of()));
-    }
-
     @Test
     void should_have_a_subscription_tier_range_with_no_upper_limit() {
         final var subscriptionTiers = SubscriptionTierMother.randoms();
@@ -122,4 +107,27 @@ void return_total_price_for_51_subscriptions() {
         final var totalPrice = tieredPricing.getTotalPrice(51);
         assertEquals(expectedPrice, totalPrice);
     }
+
+    @Test
+    void throw_invalid_subscription_tiers_if_there_is_no_tiers() {
+        assertThrows(InvalidSubscriptionTiers.class, () -> new TieredPricing(List.of()));
+    }
+
+    @Test
+    void throw_invalid_subscription_tiers_if_first_tier_range_does_not_start_at_1() {
+        final var subscriptionTiers =
+            List.of(SubscriptionTierMother.create(SubscriptionTierRangeMother.create(2, 10),
+                SubscriptionTierPriceMother.random()));
+
+        assertThrows(InvalidSubscriptionTiers.class, () -> new TieredPricing(subscriptionTiers));
+    }
+
+    @Test
+    void throw_invalid_subscription_tiers_if_there_is_no_last_tier() {
+        final var subscriptionTiers =
+            List.of(SubscriptionTierMother.create(SubscriptionTierRangeMother.create(1, 10),
+                SubscriptionTierPriceMother.random()));
+
+        assertThrows(InvalidSubscriptionTiers.class, () -> new TieredPricing(subscriptionTiers));
+    }
 }

exercises/tiered_pricing/solutions/adrianliz/java/src/test/java/tv/codely/checkout/mother/SubscriptionTierPriceMother.java

@@ -7,4 +7,8 @@ public final class SubscriptionTierPriceMother {
     public static SubscriptionTierPrice create(final double value) {
         return new SubscriptionTierPrice(value);
     }
+
+    public static SubscriptionTierPrice random() {
+        return create(DoubleMother.randomBetween(100, 300));
+    }
 }