@bash-app/bash-common 30.224.0 → 30.226.0

package/src/utils/__tests__/badgeUtils.test.ts

@@ -0,0 +1,191 @@
+/**
+ * badgeUtils — host level / temp-badge helpers.
+ *
+ * The level-badge calculation is the public reputation signal on every host
+ * profile. A bug here either over- or under-credits a host (= unfair / loss
+ * of trust). We pin the actual ladder defined in DEFAULT_LEVEL_BADGES:
+ *
+ *   novice   → 1+ events
+ *   regular  → 5+ events,  rating ≥ 4.0
+ *   maverick → 15+ events, rating ≥ 4.5
+ *   legend   → 30+ events, rating ≥ 4.8
+ *
+ * We also pin temp-badge expiry semantics: missing expiresOn = never expires.
+ */
+import {
+  getLevelBadgeById,
+  getTemporaryBadgeById,
+  isTemporaryBadgeExpired,
+  filterExpiredTemporaryBadges,
+  determineLevelBadge,
+} from "../badgeUtils.js";
+import type { UserTemporaryBadge } from "../../definitions.js";
+
+// ============================================================================
+// getLevelBadgeById / getTemporaryBadgeById — registry lookups
+// ============================================================================
+
+describe("getLevelBadgeById", () => {
+  it("returns the canonical badge object for a known id", () => {
+    const b = getLevelBadgeById("legend");
+    expect(b).toBeDefined();
+    expect(b?.id).toBe("legend");
+    expect(b?.requiredEvents).toBe(30);
+    expect(b?.requiredRating).toBe(4.8);
+  });
+
+  it("returns undefined for an unknown id", () => {
+    expect(getLevelBadgeById("definitely-not-a-badge")).toBeUndefined();
+  });
+
+  it("returns undefined for empty string", () => {
+    expect(getLevelBadgeById("")).toBeUndefined();
+  });
+});
+
+describe("getTemporaryBadgeById", () => {
+  it("returns a known temp badge", () => {
+    expect(getTemporaryBadgeById("trendingStar")?.id).toBe("trendingStar");
+  });
+
+  it("returns undefined for an unknown id", () => {
+    expect(getTemporaryBadgeById("nope")).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// isTemporaryBadgeExpired
+// ============================================================================
+
+describe("isTemporaryBadgeExpired", () => {
+  it("returns false when expiresOn is missing (badge never expires)", () => {
+    const badge: UserTemporaryBadge = {
+      badgeId: "earlyAdopter",
+      earnedOn: "2020-01-01T00:00:00Z",
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(false);
+  });
+
+  it("returns true for a clearly past expiresOn", () => {
+    const badge: UserTemporaryBadge = {
+      badgeId: "trendingStar",
+      earnedOn: "2020-01-01T00:00:00Z",
+      expiresOn: "2020-02-01T00:00:00Z",
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(true);
+  });
+
+  it("returns false for a clearly future expiresOn", () => {
+    const future = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000)
+      .toISOString();
+    const badge: UserTemporaryBadge = {
+      badgeId: "topHost",
+      earnedOn: new Date().toISOString(),
+      expiresOn: future,
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(false);
+  });
+
+  it("returns true when expiresOn is RIGHT NOW (boundary: not strictly in the future)", () => {
+    // Source uses `expiryDate < currentDate`. A simultaneous tick = false (not expired),
+    // but Date.now() inside the function is sampled later than ours — which is enough
+    // to flip <. We pin the practical observable: "earlier than now → expired".
+    const past = new Date(Date.now() - 1).toISOString();
+    const badge: UserTemporaryBadge = {
+      badgeId: "topHost",
+      earnedOn: "2020-01-01T00:00:00Z",
+      expiresOn: past,
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(true);
+  });
+});
+
+// ============================================================================
+// filterExpiredTemporaryBadges
+// ============================================================================
+
+describe("filterExpiredTemporaryBadges", () => {
+  it("returns [] for [] (no surprise allocation)", () => {
+    expect(filterExpiredTemporaryBadges([])).toEqual([]);
+  });
+
+  it("keeps non-expiring badges", () => {
+    const badges: UserTemporaryBadge[] = [
+      { badgeId: "earlyAdopter", earnedOn: "2020-01-01T00:00:00Z" },
+    ];
+    expect(filterExpiredTemporaryBadges(badges)).toHaveLength(1);
+  });
+
+  it("drops expired badges and keeps the rest", () => {
+    const future = new Date(Date.now() + 86_400_000).toISOString();
+    const past = new Date(Date.now() - 86_400_000).toISOString();
+    const badges: UserTemporaryBadge[] = [
+      { badgeId: "topHost", earnedOn: "2020-01-01T00:00:00Z", expiresOn: past },
+      { badgeId: "trendingStar", earnedOn: "2020-01-01T00:00:00Z", expiresOn: future },
+      { badgeId: "earlyAdopter", earnedOn: "2020-01-01T00:00:00Z" },
+    ];
+    const result = filterExpiredTemporaryBadges(badges);
+    expect(result.map((b) => b.badgeId)).toEqual(["trendingStar", "earlyAdopter"]);
+  });
+});
+
+// ============================================================================
+// determineLevelBadge — the reputation ladder
+// ============================================================================
+
+describe("determineLevelBadge — host reputation ladder", () => {
+  it("returns null when the host has no events", () => {
+    expect(determineLevelBadge(0, 5)).toBeNull();
+  });
+
+  it("returns null when events are below the lowest threshold (1) even with high rating", () => {
+    expect(determineLevelBadge(0, 5)).toBeNull();
+  });
+
+  it("awards 'novice' at 1 event with no rating threshold", () => {
+    expect(determineLevelBadge(1, 0)).toBe("novice");
+  });
+
+  it("stays at 'novice' between 1 and 4 events", () => {
+    expect(determineLevelBadge(2, 4.9)).toBe("novice");
+    expect(determineLevelBadge(4, 4.9)).toBe("novice");
+  });
+
+  it("awards 'regular' at 5 events when rating ≥ 4.0", () => {
+    expect(determineLevelBadge(5, 4.0)).toBe("regular");
+    expect(determineLevelBadge(10, 4.49)).toBe("regular");
+  });
+
+  it("falls BACK to 'novice' when 5+ events but rating < 4.0 (rating gate failed)", () => {
+    // Rating gate failed for 'regular', so the next-best the host qualifies for is 'novice'.
+    expect(determineLevelBadge(5, 3.9)).toBe("novice");
+    expect(determineLevelBadge(20, 3.0)).toBe("novice");
+  });
+
+  it("awards 'maverick' at 15 events when rating ≥ 4.5", () => {
+    expect(determineLevelBadge(15, 4.5)).toBe("maverick");
+    expect(determineLevelBadge(29, 4.79)).toBe("maverick");
+  });
+
+  it("falls back to 'regular' at 15+ events when rating is between 4.0 and 4.5", () => {
+    expect(determineLevelBadge(15, 4.49)).toBe("regular");
+  });
+
+  it("awards 'legend' at 30 events when rating ≥ 4.8", () => {
+    expect(determineLevelBadge(30, 4.8)).toBe("legend");
+    expect(determineLevelBadge(1000, 5)).toBe("legend");
+  });
+
+  it("falls back to 'maverick' at 30+ events when rating drops below 4.8", () => {
+    expect(determineLevelBadge(30, 4.7)).toBe("maverick");
+  });
+
+  it("falls all the way back to 'novice' for a host with many events but a poor rating", () => {
+    // 1000 events but rating 1.0 → only the no-rating-gate 'novice' qualifies.
+    expect(determineLevelBadge(1000, 1.0)).toBe("novice");
+  });
+
+  it("treats fractional event counts the same as integer (>=)", () => {
+    expect(determineLevelBadge(5.5, 4.0)).toBe("regular");
+  });
+});

package/src/utils/__tests__/bashPointsPaymentUtils.test.ts

@@ -0,0 +1,153 @@
+/**
+ * bashPointsPaymentUtils — earning math + display + deprecated stubs.
+ *
+ * BashPoints are loyalty cashback. The active code paths are:
+ *   - calculateBashPointsCashback(amountCents, rate) → integer points
+ *   - formatBashPoints(n)                            → "1,000 points"
+ *
+ * The "service booking" overloads were intentionally deprecated because
+ * BashPoints have no fixed dollar value and cannot pay for services. We pin
+ * the deprecated stubs here so they stay benign (return safe defaults, log a
+ * warning) — accidentally re-enabling them would cause real money loss.
+ */
+import {
+  formatBashPoints,
+  calculateBashPointsCashback,
+  centsToBashPoints,
+  bashPointsToCents,
+  calculateMaxBashPointsForBooking,
+  calculateSplitPayment,
+  validateBashPointsPayment,
+} from "../bashPointsPaymentUtils.js";
+
+describe("formatBashPoints", () => {
+  it("uses singular 'point' for exactly 1", () => {
+    expect(formatBashPoints(1)).toBe("1 point");
+  });
+
+  it("uses plural 'points' for 0", () => {
+    expect(formatBashPoints(0)).toBe("0 points");
+  });
+
+  it("uses plural for >1", () => {
+    expect(formatBashPoints(2)).toBe("2 points");
+  });
+
+  it("inserts en-US thousands separators", () => {
+    expect(formatBashPoints(1000)).toBe("1,000 points");
+    expect(formatBashPoints(28750)).toBe("28,750 points");
+    expect(formatBashPoints(1_000_000)).toBe("1,000,000 points");
+  });
+
+  it("formats negative values (defensive — should never happen but no throw)", () => {
+    // -1 !== 1 so it gets the plural suffix
+    expect(formatBashPoints(-5)).toBe("-5 points");
+  });
+});
+
+describe("calculateBashPointsCashback", () => {
+  it("awards 5% on a $10.00 (1000¢) purchase → 50 points", () => {
+    expect(calculateBashPointsCashback(1000, 0.05)).toBe(50);
+  });
+
+  it("awards 0 points on a $0 purchase", () => {
+    expect(calculateBashPointsCashback(0, 0.05)).toBe(0);
+  });
+
+  it("awards 0 points when the rate is 0", () => {
+    expect(calculateBashPointsCashback(10_000, 0)).toBe(0);
+  });
+
+  it("FLOORS fractional results (never over-awards)", () => {
+    // 333 * 0.05 = 16.65 → floor → 16
+    expect(calculateBashPointsCashback(333, 0.05)).toBe(16);
+  });
+
+  it("handles a 100% rebate rate", () => {
+    expect(calculateBashPointsCashback(2500, 1)).toBe(2500);
+  });
+
+  it("rate > 1 still floors (host can configure bonuses; trust input)", () => {
+    expect(calculateBashPointsCashback(100, 1.5)).toBe(150);
+  });
+
+  it("returns 0 (not negative) for negative amounts after floor", () => {
+    // Math.floor(-1) = -1; we don't bound the result to >=0 in source,
+    // so this pins the actual contract: negative inputs flow through as-is.
+    expect(calculateBashPointsCashback(-100, 0.05)).toBe(-5);
+  });
+});
+
+describe("DEPRECATED stubs — must remain safe defaults", () => {
+  let warnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  describe("centsToBashPoints", () => {
+    it("returns the input as-is and warns", () => {
+      expect(centsToBashPoints(1234)).toBe(1234);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: centsToBashPoints")
+      );
+    });
+  });
+
+  describe("bashPointsToCents", () => {
+    it("returns the input as-is and warns", () => {
+      expect(bashPointsToCents(500)).toBe(500);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: bashPointsToCents")
+      );
+    });
+  });
+
+  describe("calculateMaxBashPointsForBooking", () => {
+    it("returns 0 (no BashPoints can be applied to a service booking) and warns", () => {
+      expect(calculateMaxBashPointsForBooking(10_000, 5_000)).toBe(0);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: calculateMaxBashPointsForBooking")
+      );
+    });
+  });
+
+  describe("calculateSplitPayment", () => {
+    it("forces the full amount onto Stripe (BashPoints contribution = 0) and warns", () => {
+      const result = calculateSplitPayment(10_000, 9_999);
+      expect(result).toEqual({
+        bashPointsCents: 0,
+        stripeCents: 10_000,
+        bashPointsCredits: 0,
+      });
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: calculateSplitPayment")
+      );
+    });
+
+    it("preserves the original total on stripeCents even when called with 0", () => {
+      const result = calculateSplitPayment(0, 100);
+      expect(result.stripeCents).toBe(0);
+    });
+  });
+
+  describe("validateBashPointsPayment", () => {
+    it("ALWAYS returns invalid with a clear redirect-to-Stripe message", () => {
+      const result = validateBashPointsPayment(100, 1_000, 500);
+      expect(result.valid).toBe(false);
+      expect(result.errorMessage).toMatch(/credit card/i);
+      expect(result.errorMessage).toMatch(/BashPoints-priced tickets/i);
+    });
+
+    it("rejects even when the user has enough balance (no special-case bypass)", () => {
+      // 1_000_000 balance, 100 needed → still rejected because services can't take BashPoints.
+      expect(
+        validateBashPointsPayment(100, 1_000_000, 100).valid
+      ).toBe(false);
+    });
+  });
+});