feat: ensure tier range is created only with named constructor

Author: adrianliz

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

@@ -8,34 +8,51 @@ public final class SubscriptionTierRange {
     private final int numberOfSubscriptionsFrom;
     private final int numberOfSubscriptionsTo;
 
-    public SubscriptionTierRange(int numberOfSubscriptionsFrom, int numberOfSubscriptionsTo) {
+    private SubscriptionTierRange(int numberOfSubscriptionsFrom, int numberOfSubscriptionsTo) {
         this.numberOfSubscriptionsFrom = numberOfSubscriptionsFrom;
         this.numberOfSubscriptionsTo = numberOfSubscriptionsTo;
     }
 
     public static SubscriptionTierRange first(int numberOfSubscriptions) {
-        if (numberOfSubscriptions < 1) {
-            throw new InvalidSubscriptionTierRange(
-                "Number of subscriptions must be greater than 0");
-        }
+        validate(numberOfSubscriptions);
         return new SubscriptionTierRange(1, numberOfSubscriptions);
     }
 
+    public static SubscriptionTierRange last(final SubscriptionTierRange range) {
+        validate(range);
+        return new SubscriptionTierRange(range.numberOfSubscriptionsTo + 1, Integer.MAX_VALUE);
+    }
+
     public static SubscriptionTierRange from(
         final SubscriptionTierRange range,
         final int numberOfSubscriptions) {
 
+        validate(range);
+        validate(numberOfSubscriptions);
+
         final int numberOfSubscriptionsFrom = range.numberOfSubscriptionsTo + 1;
         final int numberOfSubscriptionsTo = numberOfSubscriptionsFrom + numberOfSubscriptions;
         return new SubscriptionTierRange(numberOfSubscriptionsFrom, numberOfSubscriptionsTo);
     }
 
-    public static SubscriptionTierRange last(int numberOfSubscriptionsFrom) {
-        return new SubscriptionTierRange(numberOfSubscriptionsFrom, Integer.MAX_VALUE);
+
+    private static void validate(final int numberOfSubscriptions) {
+        if (numberOfSubscriptions < 1) {
+            throw new InvalidSubscriptionTierRange(
+                "Number of subscriptions must be greater than 0");
+        }
     }
 
-    public static SubscriptionTierRange last(final SubscriptionTierRange range) {
-        return new SubscriptionTierRange(range.numberOfSubscriptionsTo + 1, Integer.MAX_VALUE);
+    private static void validate(final SubscriptionTierRange range) {
+        if (range == null) {
+            throw new InvalidSubscriptionTierRange(
+                "Cannot create a new subscription tier range from a null one");
+        }
+
+        if (range.isLast()) {
+            throw new InvalidSubscriptionTierRange(
+                "Cannot create a new subscription tier range after the last one");
+        }
     }
 
     public boolean isFirst() {

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

@@ -1,6 +1,5 @@
 package tv.codely.checkout;
 
-import java.util.HashSet;
 import java.util.List;
 
 public final class SubscriptionTiers {
@@ -24,20 +23,6 @@ private static void validate(final List<SubscriptionTier> tiers) {
         if (tiers.stream().noneMatch(SubscriptionTier::isLast)) {
             throw new InvalidSubscriptionTiers("There must be a last subscription tier");
         }
-
-        if (tiers.size() == 1) {
-            return;
-        }
-
-        final var validTiers = new HashSet<SubscriptionTier>();
-        for (final SubscriptionTier tier : tiers) {
-            if (tiers.stream()
-                .anyMatch(
-                    t -> !validTiers.contains(t) && !t.equals(tier) && !t.isAfter(tier))) {
-                throw new InvalidSubscriptionTiers("All tiers must be after the previous one");
-            }
-            validTiers.add(tier);
-        }
     }
 
     private SubscriptionTier findSuitableTier(int subscriptions) {

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

@@ -118,33 +118,11 @@ 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));
-    }
-
-    @Test
-    void throw_invalid_subscription_tiers_if_tiers_are_not_in_order() {
         final var subscriptionTiers =
             List.of(SubscriptionTierMother.create(SubscriptionTierRangeMother.first(10),
-                    SubscriptionTierPriceMother.random()),
-                SubscriptionTierMother.create(SubscriptionTierRangeMother.create(9, 20),
-                    SubscriptionTierPriceMother.random()),
-                SubscriptionTierMother.create(SubscriptionTierRangeMother.last(2),
-                    SubscriptionTierPriceMother.random()));
+                SubscriptionTierPriceMother.random()));
 
         assertThrows(InvalidSubscriptionTiers.class, () -> new TieredPricing(subscriptionTiers));
     }

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

@@ -6,47 +6,39 @@
 
 public final class SubscriptionTierRangeMother {
 
-    public static SubscriptionTierRange create(
-        final int numberOfSubscriptionsFrom,
-        final int numberOfSubscriptionsTo) {
-
-        return new SubscriptionTierRange(numberOfSubscriptionsFrom, numberOfSubscriptionsTo);
-    }
-
     public static SubscriptionTierRange first(final int numberOfSubscriptions) {
         return SubscriptionTierRange.first(numberOfSubscriptions);
     }
 
-    public static SubscriptionTierRange last(final int numberOfSubscriptionsFrom) {
-        return SubscriptionTierRange.last(numberOfSubscriptionsFrom);
+    public static SubscriptionTierRange last(final SubscriptionTierRange range) {
+        return SubscriptionTierRange.last(range);
     }
 
     public static List<SubscriptionTierRange> randoms() {
-        final var subscriptionTiers = new ArrayList<SubscriptionTierRange>();
+        final var tierRanges = new ArrayList<SubscriptionTierRange>();
         final var numberOfTiers = IntegerMother.randomBetween(1, 6);
         final var minSubscriptionsInTier = 3;
         final var maxSubscriptionsInTier =
             IntegerMother.randomBetween(minSubscriptionsInTier + 1, 20);
-
-        var lastNumberOfSubscriptionsTo = 0;
+        var currentTierRange = first(
+            IntegerMother.randomBetween(minSubscriptionsInTier, maxSubscriptionsInTier));
+        tierRanges.add(currentTierRange);
 
         for (int i = 0; i < numberOfTiers; i++) {
             if (i == numberOfTiers - 1) {
-                subscriptionTiers.add(last(lastNumberOfSubscriptionsTo + 1));
+                tierRanges.add(last(currentTierRange));
                 break;
             }
 
-            final var numberOfSubscriptionsFrom = lastNumberOfSubscriptionsTo + 1;
-            final var numberOfSubscriptionsTo =
-                IntegerMother.randomBetween(
-                    numberOfSubscriptionsFrom + 1,
-                    maxSubscriptionsInTier * (i + 1));
-
-            lastNumberOfSubscriptionsTo = numberOfSubscriptionsTo;
+            final var numberOfSubscriptions =
+                IntegerMother.randomBetween(minSubscriptionsInTier, maxSubscriptionsInTier);
+            final var tierRange = SubscriptionTierRange.from(currentTierRange,
+                numberOfSubscriptions);
 
-            subscriptionTiers.add(create(numberOfSubscriptionsFrom, numberOfSubscriptionsTo));
+            currentTierRange = tierRange;
+            tierRanges.add(tierRange);
         }
 
-        return subscriptionTiers;
+        return tierRanges;
     }
 }