@thorprovider/adapters 5.0.9 → 5.0.11

package/src/providers/medusa/available-filters.test.ts

@@ -0,0 +1,280 @@
+/**
+ * Adapter facet truthfulness — E2 `storefront-catalog-search-filters` task 2.3.
+ *
+ * `getAvailableFilters` must never fabricate a numeric range or a per-option
+ * facet count. Medusa's Store `/store/products` returns matching products and a
+ * total count, not filterable values or their ranges, so no price range is read
+ * here and the control is omitted rather than defaulted to `0..10000`. A custom
+ * attribute range/count is emitted only when the backend actually supplies the
+ * finite metadata; a missing bound or count is omitted, never replaced by a
+ * `0`/`100` default or a synthesized `0`.
+ *
+ * The HTTP boundary is intercepted with msw against a controlled fixture, so
+ * the exact emitted filter shapes are asserted.
+ */
+import { describe, expect, it } from 'vitest'
+import { http, HttpResponse } from 'msw'
+import { server } from '../stelorder/client.test-helpers'
+import { MedusaProvider } from './index'
+
+const BASE = 'https://medusa.example.com'
+const PUB_KEY = 'pk_test_abc123'
+const CURRENCY = 'usd'
+
+const CATEGORIES = [
+  {
+    id: 'pcat_x',
+    name: 'Category X',
+    handle: 'x',
+    description: null,
+    parent_category_id: null,
+    product_count: 3,
+    metadata: null,
+  },
+]
+
+const COLLECTIONS = [
+  { id: 'pcol_c1', handle: 'c1', title: 'Collection One', metadata: null },
+]
+
+/** A `multi-select` attribute whose values carry real backend counts. */
+const MULTI_WITH_COUNTS = {
+  attribute_id: 'attr_ram',
+  attribute: {
+    name: 'RAM',
+    handle: 'ram',
+    type: 'multi-select',
+    is_filterable: true,
+    is_active: true,
+    ranking: 40,
+    values: [
+      { id: 'val_8', value: '8GB', count: 15 },
+      { id: 'val_16', value: '16GB', count: 23 },
+    ],
+  },
+}
+
+/** A `multi-select` attribute whose values carry no counts. */
+const MULTI_WITHOUT_COUNTS = {
+  attribute_id: 'attr_ram',
+  attribute: {
+    ...MULTI_WITH_COUNTS.attribute,
+    values: [
+      { id: 'val_8', value: '8GB' },
+      { id: 'val_16', value: '16GB' },
+    ],
+  },
+}
+
+/** A `number` attribute with a real backend range. */
+const RANGE_WITH_BOUNDS = {
+  attribute_id: 'attr_price',
+  attribute: {
+    name: 'Price',
+    handle: 'price-attr',
+    type: 'number',
+    is_filterable: true,
+    is_active: true,
+    ranking: 30,
+    metadata: { min: 5, max: 250 },
+  },
+}
+
+/** A `number` attribute with metadata but no real bounds. */
+const RANGE_WITHOUT_BOUNDS = {
+  attribute_id: 'attr_price',
+  attribute: {
+    ...RANGE_WITH_BOUNDS.attribute,
+    metadata: {},
+  },
+}
+
+function makeProvider() {
+  return new MedusaProvider({
+    baseUrl: BASE,
+    publishableKey: PUB_KEY,
+    currencyCode: CURRENCY,
+    debug: false,
+  })
+}
+
+interface Fixture {
+  /** Every `/store/custom-attributes/category/:id` request URL. */
+  customAttributeUrls: string[]
+}
+
+function installFixture(
+  attributes: Array<Record<string, unknown>> = [],
+): Fixture {
+  const fixture: Fixture = { customAttributeUrls: [] }
+  server.use(
+    // Thor plugin endpoints are absent; the static capability fallback applies
+    // (advancedSearch/customAttributes true) and channel scoping stays unscoped.
+    http.get(`${BASE}/store/thor/capabilities`, () =>
+      HttpResponse.json({}, { status: 404 }),
+    ),
+    http.get(`${BASE}/store/thor/categories`, () =>
+      HttpResponse.json({}, { status: 404 }),
+    ),
+    http.get(`${BASE}/store/thor/collections`, () =>
+      HttpResponse.json({}, { status: 404 }),
+    ),
+    // The optional advanced endpoint is absent: the facet-support probe must
+    // treat this as "not demonstrated" rather than reading a capability flag.
+    http.get(`${BASE}/store/search`, () =>
+      HttpResponse.json(
+        { error: 'Failed to search products', message: 'search unavailable' },
+        { status: 500 },
+      ),
+    ),
+    http.get(`${BASE}/store/product-categories`, () =>
+      HttpResponse.json({
+        product_categories: CATEGORIES,
+        count: CATEGORIES.length,
+        offset: 0,
+        limit: 50,
+      }),
+    ),
+    http.get(`${BASE}/store/collections`, () =>
+      HttpResponse.json({
+        collections: COLLECTIONS,
+        count: COLLECTIONS.length,
+        offset: 0,
+        limit: 100,
+      }),
+    ),
+    http.get(
+      `${BASE}/store/custom-attributes/category/:categoryId`,
+      ({ request }) => {
+        fixture.customAttributeUrls.push(request.url)
+        return HttpResponse.json({ attributes })
+      },
+    ),
+  )
+  return fixture
+}
+
+describe('MedusaProvider.getAvailableFilters — facet truthfulness', () => {
+  it('emits no price range when the backend supplies no price metadata (never 0..10000)', async () => {
+    installFixture()
+    const filters = await makeProvider().getAvailableFilters({
+      useAdvancedSearch: true,
+    })
+
+    // The call succeeded against the real backend: basic filters are present.
+    expect(filters.map((f) => f.id)).toContain('categories')
+    // No hardcoded price filter and no synthetic range anywhere.
+    expect(filters.find((f) => f.id === 'price')).toBeUndefined()
+    expect(
+      filters.some((f) => f.type === 'range' && f.min === 0 && f.max === 10000),
+    ).toBe(false)
+  })
+
+  it('does not offer the stock toggle when the optional endpoint is absent (a capability boolean is not proof)', async () => {
+    installFixture()
+    const filters = await makeProvider().getAvailableFilters({
+      useAdvancedSearch: true,
+    })
+    // `advancedSearch: true` is advertised by the backend, but the real
+    // `/store/search` endpoint returns 500, so `inStock` is held and no toggle
+    // is offered (E2 task 2.4).
+    expect(filters.find((f) => f.id === 'isAvailable')).toBeUndefined()
+  })
+
+  it('offers the stock toggle only when the optional endpoint demonstrates inStock', async () => {
+    installFixture()
+    server.use(
+      http.get(`${BASE}/store/search`, () =>
+        HttpResponse.json({ hits: [], applied_filters: { isAvailable: true } }),
+      ),
+    )
+    const filters = await makeProvider().getAvailableFilters({
+      useAdvancedSearch: true,
+    })
+    expect(filters.find((f) => f.id === 'isAvailable')).toMatchObject({
+      type: 'boolean',
+    })
+  })
+
+  it('returns basic category/collection options with no synthesized counts', async () => {
+    installFixture()
+    const filters = await makeProvider().getAvailableFilters({})
+
+    const categories = filters.find((f) => f.id === 'categories')
+    expect(categories?.options).toEqual([
+      { value: 'x', label: 'Category X', id: 'pcat_x' },
+    ])
+    expect(categories?.options?.[0]).not.toHaveProperty('count')
+
+    const collections = filters.find((f) => f.id === 'collections')
+    expect(collections?.options?.[0]).not.toHaveProperty('count')
+  })
+
+  it('omits attribute counts when the backend supplies none', async () => {
+    installFixture([MULTI_WITHOUT_COUNTS])
+    const filters = await makeProvider().getAvailableFilters({
+      categoryId: 'pcat_x',
+      includeBasicFilters: false,
+      includeFacetCounts: true,
+    })
+
+    const ram = filters.find((f) => f.id === 'ram')
+    expect(ram?.options).toHaveLength(2)
+    expect(ram?.options?.[0]).not.toHaveProperty('count')
+  })
+
+  it('emits attribute counts only from real backend-supplied numbers', async () => {
+    installFixture([MULTI_WITH_COUNTS])
+    const filters = await makeProvider().getAvailableFilters({
+      categoryId: 'pcat_x',
+      includeBasicFilters: false,
+      includeFacetCounts: true,
+    })
+
+    const ram = filters.find((f) => f.id === 'ram')
+    expect(ram?.options).toEqual([
+      { value: '8gb', label: '8GB', id: 'val_8', count: 15 },
+      { value: '16gb', label: '16GB', id: 'val_16', count: 23 },
+    ])
+  })
+
+  it('omits attribute counts when the caller did not request them', async () => {
+    installFixture([MULTI_WITH_COUNTS])
+    const filters = await makeProvider().getAvailableFilters({
+      categoryId: 'pcat_x',
+      includeBasicFilters: false,
+      includeFacetCounts: false,
+    })
+
+    const ram = filters.find((f) => f.id === 'ram')
+    expect(ram?.options?.[0]).not.toHaveProperty('count')
+  })
+
+  it('emits an attribute range only from real backend bounds', async () => {
+    installFixture([RANGE_WITH_BOUNDS])
+    const filters = await makeProvider().getAvailableFilters({
+      categoryId: 'pcat_x',
+      includeBasicFilters: false,
+    })
+
+    expect(filters.find((f) => f.id === 'price-attr')).toMatchObject({
+      type: 'range',
+      min: 5,
+      max: 250,
+    })
+  })
+
+  it('does not fabricate a 0/100 range when metadata bounds are missing', async () => {
+    installFixture([RANGE_WITHOUT_BOUNDS])
+    const filters = await makeProvider().getAvailableFilters({
+      categoryId: 'pcat_x',
+      includeBasicFilters: false,
+    })
+
+    // No fabricated range control at all.
+    expect(filters.find((f) => f.id === 'price-attr')).toBeUndefined()
+    expect(
+      filters.some((f) => f.type === 'range' && f.min === 0 && f.max === 100),
+    ).toBe(false)
+  })
+})