feat(tiered_pricing): 🟢 add GraduatedTier named constructors

Author: adrianliz

exercises/graduated_tiered_prices/solutions/adrianliz/src/GraduatedTier.ts

@@ -7,9 +7,7 @@ export default class GraduatedTier {
     private readonly to: number,
     private readonly singleSubscriptionPrice: number
   ) {
-    if (to > Number.MAX_SAFE_INTEGER) {
-      throw new InvalidTier();
-    }
+    GraduatedTier.validate(from, to, singleSubscriptionPrice);
   }
 
   static firstTier(
@@ -44,6 +42,28 @@ export default class GraduatedTier {
     );
   }
 
+  private static validate(
+    from: number,
+    to: number,
+    singleSubscriptionPrice: number
+  ): void {
+    if (singleSubscriptionPrice <= 0) {
+      throw new InvalidTier();
+    }
+
+    if (from < 1) {
+      throw new InvalidTier();
+    }
+
+    if (from > to) {
+      throw new InvalidTier();
+    }
+
+    if (to > Number.MAX_SAFE_INTEGER) {
+      throw new InvalidTier();
+    }
+  }
+
   private total(): number {
     return this.size() * this.singleSubscriptionPrice;
   }

exercises/graduated_tiered_prices/solutions/adrianliz/tests/GraduatedTiered.test.ts

@@ -2,7 +2,23 @@ import GraduatedTier from "../src/GraduatedTier";
 import InvalidTier from "../src/InvalidTier";
 
 describe("Graduated tiered should", () => {
-  it("throw number of subscriptions not allowed for 0 subscriptions", () => {
+  it("throw invalid tier for 0 subscriptions in tier", () => {
     expect(() => GraduatedTier.firstTier(0, 199)).toThrow(InvalidTier);
   });
+
+  it("throw invalid tier for -100 subscriptions in tier", () => {
+    const firstTier = GraduatedTier.firstTier(2, 199);
+    expect(() => GraduatedTier.fromTier(firstTier, -100, 150)).toThrow(
+      InvalidTier
+    );
+  });
+
+  it("throw invalid tier for single subscription price of 0 in tier", () => {
+    expect(() => GraduatedTier.firstTier(2, 0)).toThrow(InvalidTier);
+  });
+
+  it("work for 1 subscription in tier", () => {
+    const firstTier = GraduatedTier.firstTier(1, 199);
+    GraduatedTier.fromTier(firstTier, 1, 150);
+  });
 });

exercises/graduated_tiered_prices/solutions/adrianliz/tests/GraduatedTieredPricing.test.ts

@@ -15,6 +15,15 @@ describe("Graduated tiered pricing should", () => {
     return [firstTier, secondTier, thirdTier, fourthTier, lastTier];
   };
 
+  const tiersWithOneSubscription = (): GraduatedTier[] => {
+    const firstTier = GraduatedTier.firstTier(1, 299);
+    const secondTier = GraduatedTier.fromTier(firstTier, 1, 239);
+    const thirdTier = GraduatedTier.fromTier(secondTier, 1, 219);
+    const fourthTier = GraduatedTier.fromTier(thirdTier, 1, 199);
+    const lastTier = GraduatedTier.lastTier(fourthTier, 149);
+    return [firstTier, secondTier, thirdTier, fourthTier, lastTier];
+  };
+
   it("throw number of subscriptions not allowed for 0 subscriptions", () => {
     const tiers = defaultTiers();
     const pricing = new GraduatedTieredPricing(tiers);
@@ -41,4 +50,22 @@ describe("Graduated tiered pricing should", () => {
       );
     }
   );
+
+  each([
+    [1, 299],
+    [2, 538],
+    [3, 757],
+    [4, 956],
+    [5, 1105],
+    [100, 15260],
+  ]).it(
+    "calculate the price for %i subscriptions with tiers with only one subscription",
+    (subscriptions: number, expectedPrice: number) => {
+      const tiers = tiersWithOneSubscription();
+      const pricing = new GraduatedTieredPricing(tiers);
+      expect(pricing.priceFor(new Subscriptions(subscriptions))).toBe(
+        expectedPrice
+      );
+    }
+  );
 });