@propriety/court-calendar 1.0.152 → 1.0.153

package/dist/__tests__/collectionsPipeline.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * End-to-end guard for collections dates reaching the calendar.
+ *
+ * Collections come back as the raw Court.Collections columns — CollectionID,
+ * HearingDate (date-only), HearingTime (HH:mm:ss) — not the CourtDateID/CourtDate
+ * shape every other surface reads. A missing mapping is invisible at the API layer
+ * and only shows up three stages later as "the date isn't on the calendar":
+ *
+ *   normalizeDateFromApi  →  CourtDateID undefined, CourtDate undefined
+ *   filterCourtDates      →  dropped by the leading `cd.CourtDateID != null`
+ *   buildCalEvents        →  dropped by the leading `if (!cd.CourtDate) continue`
+ *
+ * So this walks the real payload through all three stages rather than asserting on
+ * the normalizer alone.
+ */
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@propriety/court-calendar",
   "private": false,
-  "version": "1.0.152",
+  "version": "1.0.153",
   "type": "module",
   "main": "dist/index.js",
   "module": "./dist/index.mjs",

package/src/__tests__/collectionsPipeline.test.ts

@@ -0,0 +1,113 @@
+/**
+ * End-to-end guard for collections dates reaching the calendar.
+ *
+ * Collections come back as the raw Court.Collections columns — CollectionID,
+ * HearingDate (date-only), HearingTime (HH:mm:ss) — not the CourtDateID/CourtDate
+ * shape every other surface reads. A missing mapping is invisible at the API layer
+ * and only shows up three stages later as "the date isn't on the calendar":
+ *
+ *   normalizeDateFromApi  →  CourtDateID undefined, CourtDate undefined
+ *   filterCourtDates      →  dropped by the leading `cd.CourtDateID != null`
+ *   buildCalEvents        →  dropped by the leading `if (!cd.CourtDate) continue`
+ *
+ * So this walks the real payload through all three stages rather than asserting on
+ * the normalizer alone.
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { getAllDates } from '@/helpers/api/courtDates';
+import { buildCalEvents } from '@/helpers/CalEvent';
+import { filterCourtDates } from '@/helpers/filtering';
+import { caseKey } from '@/helpers/courtDates';
+import { DateType } from '@/types';
+import type { Case } from '@/types';
+import { DEFAULT_FILTER_CTX, MOCK_API_KEY } from './fixtures';
+
+// Verbatim from GET /court-dates/all?type=Collections on 2026-07-28.
+const RAW_COLLECTIONS = [
+    { CollectionID: 1, EntryDate: '2026-07-28T11:48:36-04:00', HearingDate: '2026-07-28', HearingTime: '09:30:00', MuniCode: '' },
+    { CollectionID: 2, EntryDate: '2026-07-28T11:48:56-04:00', HearingDate: '2026-07-28', HearingTime: '09:30:00', MuniCode: '' },
+    { CollectionID: 3, EntryDate: '2026-07-28T11:50:13-04:00', HearingDate: '2026-07-28', HearingTime: '09:30:00', MuniCode: 'W40' },
+];
+
+function mockFetch(body: unknown) {
+    return vi.fn(() => Promise.resolve({ ok: true, status: 200, json: () => Promise.resolve(body) }));
+}
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+
+describe('collections reach the calendar end-to-end', () => {
+    async function loadCollections() {
+        vi.stubGlobal('fetch', mockFetch({ dates: structuredClone(RAW_COLLECTIONS) }));
+        return await getAllDates(MOCK_API_KEY, DateType.COLLECTIONS);
+    }
+
+    it('normalizes every row to a usable id and date', async () => {
+        const dates = await loadCollections();
+        expect(dates).toHaveLength(3);
+        for (const d of dates) {
+            expect(d.CourtDateID).toEqual(expect.any(Number));
+            expect(d.CourtDate).toBeInstanceOf(Date);
+            expect(Number.isNaN(new Date(d.CourtDate).getTime())).toBe(false);
+            expect(d.DateType).toBe(DateType.COLLECTIONS);
+        }
+        expect(dates.map((d) => d.CourtDateID)).toEqual([1, 2, 3]);
+    });
+
+    it('keeps the local calendar day — no UTC shift off HearingDate', async () => {
+        const [first] = await loadCollections();
+        const d = new Date(first.CourtDate);
+        // new Date('2026-07-28') would be UTC midnight = Jul 27 20:00 in ET.
+        expect([d.getFullYear(), d.getMonth(), d.getDate()]).toEqual([2026, 6, 28]);
+        expect([d.getHours(), d.getMinutes()]).toEqual([9, 30]);
+    });
+
+    it('survives filterCourtDates under the default filter context', async () => {
+        const dates = await loadCollections();
+        const result = filterCourtDates(dates, { ...DEFAULT_FILTER_CTX }, {}, null);
+        expect(result).toHaveLength(3);
+    });
+
+    it('survives filterCourtDates on the collections tab', async () => {
+        const dates = await loadCollections();
+        const result = filterCourtDates(dates, { ...DEFAULT_FILTER_CTX, dateTypeFilter: 'collections' }, {}, null);
+        expect(result).toHaveLength(3);
+    });
+
+    it('is not hidden by the default-on unsettled filter despite having no cases', async () => {
+        const dates = await loadCollections();
+        const result = filterCourtDates(dates, { ...DEFAULT_FILTER_CTX, showOnlyUnsettled: true }, {}, null);
+        expect(result).toHaveLength(3);
+    });
+
+    it('produces one CalEvent per hearing once cases resolve to empty', async () => {
+        const dates = await loadCollections();
+        // UseCaseData's final reconciliation gives every requested key an entry, so an
+        // empty bucket reads as "loaded and genuinely empty" rather than "still pending".
+        const allCases: Record<string, Case[]> = {};
+        for (const d of dates) allCases[caseKey(d)] = [];
+
+        const events = buildCalEvents(filterCourtDates(dates, { ...DEFAULT_FILTER_CTX }, allCases, null), allCases);
+        expect(events).toHaveLength(3);
+        for (const e of events) {
+            expect(e.dateType).toBe(DateType.COLLECTIONS);
+            expect(e.casesLoaded).toBe(true);
+        }
+    });
+
+    it('gives each hearing a distinct case key so they do not collapse into one', async () => {
+        const dates = await loadCollections();
+        expect(new Set(dates.map(caseKey)).size).toBe(3);
+        expect(dates.map(caseKey)).toEqual(['col_1', 'col_2', 'col_3']);
+    });
+
+    it('handles a muni-less collections date without breaking village detection', async () => {
+        const dates = await loadCollections();
+        const noMuni = dates.filter((d) => !d.MuniCode);
+        expect(noMuni).toHaveLength(2);
+        const events = buildCalEvents(noMuni, {});
+        expect(events).toHaveLength(2);
+    });
+});