@open-mercato/ui 0.6.7-develop.6860.1.f796b22e80 → 0.6.7

package/src/backend/utils/__tests__/customFieldForms.optionsPaging.test.ts

@@ -1,95 +0,0 @@
-/** @jest-environment node */
-
-const apiCall = jest.fn()
-
-jest.mock('../apiCall', () => ({
-  apiCall: (...args: unknown[]) => apiCall(...args),
-}))
-
-jest.mock('../../fields/registry', () => ({
-  FieldRegistry: { getInput: () => null },
-  loadGeneratedFieldRegistrations: async () => {},
-}))
-
-import { buildFormFieldFromCustomFieldDef } from '../customFieldForms'
-
-const okPage = (payload: Record<string, unknown>) => ({ ok: true, result: payload })
-
-const requestedUrls = () => apiCall.mock.calls.map(([url]) => url as string)
-
-const loadOptionsFor = (def: Parameters<typeof buildFormFieldFromCustomFieldDef>[0]) => {
-  const field = buildFormFieldFromCustomFieldDef(def)
-  const loadOptions = (field as { loadOptions?: (query?: string) => Promise<Array<{ value: string; label: string }>> })
-    .loadOptions
-  if (!loadOptions) throw new Error('[internal] expected the field to expose loadOptions')
-  return loadOptions
-}
-
-/**
- * Guards the review finding on #4175: the entries route caps rows per response,
- * so the generic `optionsUrl` loader behind every select/currency/relation and
- * multi-dictionary custom field must page instead of dropping everything past
- * the first page.
- */
-describe('custom field remote options paging', () => {
-  beforeEach(() => {
-    apiCall.mockReset()
-  })
-
-  it('walks every page of a dictionary-backed multi-select', async () => {
-    apiCall
-      .mockResolvedValueOnce(
-        okPage({ items: [{ value: 'a', label: 'Alpha' }], total: 2, hasMore: true }),
-      )
-      .mockResolvedValueOnce(
-        okPage({ items: [{ value: 'b', label: 'Beta' }], total: 2, hasMore: false }),
-      )
-
-    const options = await loadOptionsFor({
-      key: 'tags',
-      kind: 'dictionary',
-      multi: true,
-      dictionaryId: 'dict-1',
-    })()
-
-    expect(requestedUrls()).toEqual([
-      '/api/dictionaries/dict-1/entries',
-      '/api/dictionaries/dict-1/entries?offset=1',
-    ])
-    expect(options).toEqual([
-      { value: 'a', label: 'Alpha' },
-      { value: 'b', label: 'Beta' },
-    ])
-  })
-
-  it('keeps the typeahead query on every page it requests', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a', label: 'Alpha' }], hasMore: true }))
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'ab', label: 'Able' }], hasMore: false }))
-
-    await loadOptionsFor({ key: 'ref', kind: 'select', optionsUrl: '/api/refs' })('al')
-
-    expect(requestedUrls()[0]).toContain('query=al')
-    expect(requestedUrls()[1]).toContain('query=al')
-    expect(requestedUrls()[1]).toContain('offset=1')
-  })
-
-  it('issues one request for a route that does not report hasMore', async () => {
-    apiCall.mockResolvedValueOnce(okPage({ items: [{ value: 'usd', label: 'USD' }] }))
-
-    const options = await loadOptionsFor({ key: 'ref', kind: 'select', optionsUrl: '/api/refs' })()
-
-    expect(apiCall).toHaveBeenCalledTimes(1)
-    expect(options).toEqual([{ value: 'usd', label: 'USD' }])
-  })
-
-  it('returns no options when a page fails rather than a partial list', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a', label: 'Alpha' }], hasMore: true }))
-      .mockResolvedValueOnce({ ok: false, result: { error: 'Forbidden' } })
-
-    const options = await loadOptionsFor({ key: 'ref', kind: 'select', optionsUrl: '/api/refs' })()
-
-    expect(options).toEqual([])
-  })
-})

package/src/backend/utils/__tests__/fetchAllPages.test.ts

@@ -1,103 +0,0 @@
-/** @jest-environment node */
-
-const apiCall = jest.fn()
-
-jest.mock('../apiCall', () => ({
-  apiCall: (...args: unknown[]) => apiCall(...args),
-}))
-
-import { fetchAllOffsetPages, MAX_OFFSET_PAGES } from '../fetchAllPages'
-
-const okPage = (payload: Record<string, unknown>) => ({ ok: true, result: payload })
-
-const requestedUrls = () => apiCall.mock.calls.map(([url]) => url as string)
-
-describe('fetchAllOffsetPages', () => {
-  beforeEach(() => {
-    apiCall.mockReset()
-  })
-
-  it('issues a single untouched request when the route does not report hasMore', async () => {
-    apiCall.mockResolvedValueOnce(okPage({ items: [{ value: 'a' }, { value: 'b' }] }))
-
-    const result = await fetchAllOffsetPages('/api/options')
-
-    expect(requestedUrls()).toEqual(['/api/options'])
-    expect(result.ok).toBe(true)
-    expect(result.pageCount).toBe(1)
-    expect(result.items).toEqual([{ value: 'a' }, { value: 'b' }])
-  })
-
-  it('walks hasMore, advancing the offset by the rows already collected', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }, { value: 'b' }], hasMore: true }))
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'c' }], hasMore: false }))
-
-    const result = await fetchAllOffsetPages('/api/options')
-
-    expect(requestedUrls()).toEqual(['/api/options', '/api/options?offset=2'])
-    expect(result.items).toHaveLength(3)
-    expect(result.pageCount).toBe(2)
-  })
-
-  it('preserves the caller query string when it appends the offset', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'b' }], hasMore: false }))
-
-    await fetchAllOffsetPages('/api/options?query=ab&q=ab')
-
-    expect(requestedUrls()[1]).toBe('/api/options?query=ab&q=ab&offset=1')
-  })
-
-  it('continues from an offset the caller already put on the url', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'b' }], hasMore: false }))
-
-    await fetchAllOffsetPages('/api/options?offset=10')
-
-    expect(requestedUrls()).toEqual(['/api/options?offset=10', '/api/options?offset=11'])
-  })
-
-  it('exposes the first payload so callers can read page-invariant metadata', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true, sortMode: 'value_desc' }))
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'b' }], hasMore: false, sortMode: 'value_desc' }))
-
-    const result = await fetchAllOffsetPages('/api/options')
-
-    expect(result.firstPayload.sortMode).toBe('value_desc')
-  })
-
-  it('stops on an empty page so a route reporting hasMore forever cannot spin', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
-      .mockResolvedValueOnce(okPage({ items: [], hasMore: true }))
-
-    const result = await fetchAllOffsetPages('/api/options')
-
-    expect(apiCall).toHaveBeenCalledTimes(2)
-    expect(result.items).toHaveLength(1)
-  })
-
-  it('caps the walk at the page ceiling', async () => {
-    apiCall.mockResolvedValue(okPage({ items: [{ value: 'a' }], hasMore: true }))
-
-    const result = await fetchAllOffsetPages('/api/options')
-
-    expect(apiCall).toHaveBeenCalledTimes(MAX_OFFSET_PAGES)
-    expect(result.pageCount).toBe(MAX_OFFSET_PAGES)
-  })
-
-  it('reports a failed page instead of returning a silently truncated list', async () => {
-    apiCall
-      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
-      .mockResolvedValueOnce({ ok: false, result: { error: 'Forbidden' } })
-
-    const result = await fetchAllOffsetPages('/api/options')
-
-    expect(result.ok).toBe(false)
-    expect(result.errorPayload).toEqual({ error: 'Forbidden' })
-  })
-})

package/src/backend/utils/fetchAllPages.ts

@@ -1,93 +0,0 @@
-"use client"
-
-import { apiCall } from './apiCall'
-
-// Offset-paged list routes cap how many rows one response may carry, so a
-// caller that needs the whole collection has to walk the pages. Bound the walk
-// so a route reporting hasMore forever cannot hang the caller; at the 500-row
-// dictionary ceiling this still covers 25k rows.
-export const MAX_OFFSET_PAGES = 50
-
-export type OffsetPagedPayload = Record<string, unknown>
-
-export type OffsetPagedResult = {
-  ok: boolean
-  items: unknown[]
-  pageCount: number
-  firstPayload: OffsetPagedPayload
-  errorPayload: OffsetPagedPayload | null
-}
-
-const ABSOLUTE_URL_PATTERN = /^([a-z][a-z\d+\-.]*:)?\/\//i
-
-type ParsedUrl = { url: URL; absolute: boolean }
-
-function parseUrl(value: string): ParsedUrl | null {
-  try {
-    const absolute = ABSOLUTE_URL_PATTERN.test(value)
-    const origin = typeof window !== 'undefined' ? window.location.origin : 'http://localhost'
-    return { url: absolute ? new URL(value) : new URL(value, origin), absolute }
-  } catch {
-    return null
-  }
-}
-
-function formatUrl(parsed: ParsedUrl): string {
-  return parsed.absolute ? parsed.url.toString() : `${parsed.url.pathname}${parsed.url.search}`
-}
-
-function readOffset(value: string): number {
-  const parsed = parseUrl(value)
-  if (!parsed) return 0
-  const offset = Number.parseInt(parsed.url.searchParams.get('offset') ?? '', 10)
-  return Number.isFinite(offset) && offset > 0 ? offset : 0
-}
-
-function withOffset(value: string, offset: number): string {
-  const parsed = parseUrl(value)
-  if (!parsed) {
-    const separator = value.includes('?') ? '&' : '?'
-    return `${value}${separator}offset=${offset}`
-  }
-  parsed.url.searchParams.set('offset', String(offset))
-  return formatUrl(parsed)
-}
-
-/**
- * Walk every page of an offset-paged list route and return the assembled items.
- *
- * A route that does not report `hasMore` resolves after a single request, so
- * this is a drop-in replacement for a one-shot `apiCall` against any list
- * endpoint. Ordering is preserved as the route returned it, page after page —
- * callers that need a global order across page boundaries must re-sort.
- */
-export async function fetchAllOffsetPages(
-  url: string,
-  options: { maxPages?: number } = {},
-): Promise<OffsetPagedResult> {
-  const maxPages = options.maxPages ?? MAX_OFFSET_PAGES
-  const baseOffset = readOffset(url)
-  const items: unknown[] = []
-  let firstPayload: OffsetPagedPayload = {}
-  let pageCount = 0
-
-  while (pageCount < maxPages) {
-    // The first request goes out untouched so a route that caches only its
-    // default page still serves that page from cache.
-    const pageUrl = pageCount === 0 ? url : withOffset(url, baseOffset + items.length)
-    const call = await apiCall<OffsetPagedPayload>(pageUrl, undefined, { fallback: {} })
-    const payload = call.result ?? {}
-    if (!call.ok) {
-      return { ok: false, items, pageCount, firstPayload, errorPayload: payload }
-    }
-    pageCount += 1
-    if (pageCount === 1) firstPayload = payload
-    const pageItems = Array.isArray(payload.items) ? payload.items : []
-    items.push(...pageItems)
-    // An empty page also stops the walk: without it a route that keeps
-    // reporting hasMore while returning nothing would spin to the page cap.
-    if (payload.hasMore !== true || pageItems.length === 0) break
-  }
-
-  return { ok: true, items, pageCount, firstPayload, errorPayload: null }
-}

package/src/portal/hooks/__tests__/usePortalEventBridge.test.tsx

@@ -1,66 +0,0 @@
-/** @jest-environment jsdom */
-import { act, renderHook } from '@testing-library/react'
-import { usePortalEventBridge } from '../usePortalEventBridge'
-import {
-  clearPortalBridgeHealth,
-  PORTAL_BRIDGE_STATUS_DOM_NAME,
-  readPortalBridgeHealth,
-  type PortalBridgeStatusDetail,
-} from '../portalBridgeStatus'
-
-class EventSourceMock {
-  static instances: EventSourceMock[] = []
-
-  onopen: ((event: Event) => void) | null = null
-  onmessage: ((event: MessageEvent) => void) | null = null
-  onerror: ((event: Event) => void) | null = null
-  close = jest.fn()
-
-  constructor() {
-    EventSourceMock.instances.push(this)
-  }
-}
-
-describe('usePortalEventBridge health lifecycle', () => {
-  const originalEventSource = globalThis.window?.EventSource
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    EventSourceMock.instances = []
-    clearPortalBridgeHealth()
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = EventSourceMock as unknown as typeof EventSource
-  })
-
-  afterEach(() => {
-    clearPortalBridgeHealth()
-    if (typeof originalEventSource === 'undefined') {
-      delete (window as unknown as { EventSource?: typeof EventSource }).EventSource
-    } else {
-      ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = originalEventSource
-    }
-  })
-
-  it('publishes healthy on open and unhealthy when the bridge unmounts', () => {
-    const statuses: boolean[] = []
-    const handleStatus = (event: Event) => {
-      statuses.push((event as CustomEvent<PortalBridgeStatusDetail>).detail.healthy)
-    }
-    window.addEventListener(PORTAL_BRIDGE_STATUS_DOM_NAME, handleStatus)
-
-    const { unmount } = renderHook(() => usePortalEventBridge())
-    const source = EventSourceMock.instances[0]
-    expect(source).toBeDefined()
-
-    act(() => {
-      source.onopen?.(new Event('open'))
-    })
-    expect(readPortalBridgeHealth()).toBe(true)
-
-    unmount()
-
-    expect(source.close).toHaveBeenCalledTimes(1)
-    expect(readPortalBridgeHealth()).toBe(false)
-    expect(statuses).toEqual([true, false])
-    window.removeEventListener(PORTAL_BRIDGE_STATUS_DOM_NAME, handleStatus)
-  })
-})

package/src/portal/hooks/__tests__/usePortalNotifications.test.tsx

@@ -1,155 +0,0 @@
-/** @jest-environment jsdom */
-import * as React from 'react'
-import { renderHook, act, waitFor } from '@testing-library/react'
-import { usePortalNotifications } from '../usePortalNotifications'
-import {
-  clearPortalBridgeHealth,
-  publishPortalBridgeHealth,
-} from '../portalBridgeStatus'
-
-const apiCallMock = jest.fn()
-
-jest.mock('../../../backend/utils/apiCall', () => ({
-  apiCall: (...args: unknown[]) => apiCallMock(...args),
-}))
-
-describe('usePortalNotifications strategy', () => {
-  const originalEventSource = globalThis.window?.EventSource
-  let setIntervalSpy: jest.SpyInstance
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    apiCallMock.mockResolvedValue({
-      ok: true,
-      result: { ok: true, items: [], unreadCount: 0 },
-    })
-    setIntervalSpy = jest.spyOn(global, 'setInterval')
-    clearPortalBridgeHealth()
-  })
-
-  afterEach(() => {
-    setIntervalSpy.mockRestore()
-    if (typeof originalEventSource === 'undefined') {
-      delete (window as unknown as { EventSource?: typeof EventSource }).EventSource
-    } else {
-      ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = originalEventSource
-    }
-  })
-
-  it('keeps polling until an available EventSource bridge reports healthy', async () => {
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = function EventSourceMock() {
-      return {} as EventSource
-    } as unknown as typeof EventSource
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-
-    expect(apiCallMock).toHaveBeenCalled()
-    expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 8000)
-  })
-
-  it('uses SSE strategy without polling when the bridge is explicitly healthy', async () => {
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = function EventSourceMock() {
-      return {} as EventSource
-    } as unknown as typeof EventSource
-    publishPortalBridgeHealth(true)
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-
-    expect(apiCallMock).toHaveBeenCalled()
-    expect(setIntervalSpy).not.toHaveBeenCalledWith(expect.any(Function), 8000)
-  })
-
-  it('falls back to polling strategy when EventSource is unavailable', async () => {
-    delete (window as unknown as { EventSource?: typeof EventSource }).EventSource
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-
-    expect(apiCallMock).toHaveBeenCalled()
-    expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 8000)
-  })
-
-  it('activates polling when SSE is explicitly marked unhealthy', async () => {
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = function EventSourceMock() {
-      return {} as EventSource
-    } as unknown as typeof EventSource
-
-    publishPortalBridgeHealth(false)
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-
-    expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 8000)
-  })
-
-  it('switches to polling fallback dynamically when status becomes unhealthy', async () => {
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = function EventSourceMock() {
-      return {} as EventSource
-    } as unknown as typeof EventSource
-    publishPortalBridgeHealth(true)
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-    expect(apiCallMock).toHaveBeenCalledTimes(2)
-
-    expect(setIntervalSpy).not.toHaveBeenCalledWith(expect.any(Function), 8000)
-
-    act(() => {
-      publishPortalBridgeHealth(false)
-    })
-
-    expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 8000)
-    await waitFor(() => expect(apiCallMock).toHaveBeenCalledTimes(4))
-  })
-
-  it('performs one reconciliation for an unhealthy-to-reconnected sequence', async () => {
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = function EventSourceMock() {
-      return {} as EventSource
-    } as unknown as typeof EventSource
-    publishPortalBridgeHealth(true)
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-    expect(apiCallMock).toHaveBeenCalledTimes(2)
-
-    act(() => {
-      publishPortalBridgeHealth(false)
-    })
-    await waitFor(() => expect(apiCallMock).toHaveBeenCalledTimes(4))
-
-    act(() => {
-      publishPortalBridgeHealth(true)
-      window.dispatchEvent(
-        new CustomEvent('om:portal-event', {
-          detail: {
-            id: 'om:portal-bridge:reconnected',
-            payload: {},
-          },
-        })
-      )
-    })
-
-    await waitFor(() => expect(apiCallMock).toHaveBeenCalledTimes(6))
-  })
-
-  it('reconciles notifications when the portal window regains focus', async () => {
-    ;(window as unknown as { EventSource?: typeof EventSource }).EventSource = function EventSourceMock() {
-      return {} as EventSource
-    } as unknown as typeof EventSource
-
-    const { result } = renderHook(() => usePortalNotifications())
-    await waitFor(() => expect(result.current.isLoading).toBe(false))
-    expect(apiCallMock).toHaveBeenCalledTimes(2)
-
-    await act(async () => {
-      window.dispatchEvent(new Event('focus'))
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, 0)
-      })
-    })
-
-    await waitFor(() => expect(apiCallMock).toHaveBeenCalledTimes(4))
-  })
-})

package/src/portal/hooks/portalBridgeStatus.ts

@@ -1,29 +0,0 @@
-export const PORTAL_BRIDGE_STATUS_DOM_NAME = 'om:portal-bridge:status'
-
-export type PortalBridgeStatusDetail = {
-  healthy: boolean
-}
-
-type PortalBridgeWindow = Window & {
-  __portalBridgeHealthy?: boolean
-}
-
-export function readPortalBridgeHealth(): boolean | undefined {
-  if (typeof window === 'undefined') return undefined
-  return (window as PortalBridgeWindow).__portalBridgeHealthy
-}
-
-export function publishPortalBridgeHealth(healthy: boolean): void {
-  if (typeof window === 'undefined') return
-  ;(window as PortalBridgeWindow).__portalBridgeHealthy = healthy
-  window.dispatchEvent(
-    new CustomEvent<PortalBridgeStatusDetail>(PORTAL_BRIDGE_STATUS_DOM_NAME, {
-      detail: { healthy },
-    }),
-  )
-}
-
-export function clearPortalBridgeHealth(): void {
-  if (typeof window === 'undefined') return
-  delete (window as PortalBridgeWindow).__portalBridgeHealthy
-}

package/src/primitives/__tests__/button.test.tsx

@@ -1,70 +0,0 @@
-/** @jest-environment jsdom */
-
-import * as React from 'react'
-import { render } from '@testing-library/react'
-import { Button, buttonVariants } from '../button'
-
-type ButtonVariant = NonNullable<Parameters<typeof buttonVariants>[0]>['variant']
-
-function classesOf(variant: ButtonVariant) {
-  return buttonVariants({ variant }).split(/\s+/).filter(Boolean)
-}
-
-describe('Button destructive variants', () => {
-  // The DS policy: `destructive` is the quiet trigger (red text on a calm
-  // surface) so a page full of delete buttons does not train users to ignore
-  // red; `destructive-solid` is the filled form, reserved for the single
-  // point-of-no-return confirmation inside a dialog. These tests pin both
-  // halves of that contract — swapping them back is a visual regression that
-  // no other test would catch.
-
-  it('destructive is quiet: destructive border and text on the page surface', () => {
-    const classes = classesOf('destructive')
-    expect(classes).toContain('border')
-    expect(classes).toContain('border-destructive')
-    expect(classes).toContain('bg-background')
-    expect(classes).toContain('text-destructive')
-  })
-
-  it('destructive does not fill with the destructive surface', () => {
-    const classes = classesOf('destructive')
-    expect(classes).not.toContain('bg-destructive')
-    expect(classes).not.toContain('text-white')
-  })
-
-  it('destructive-solid fills with the destructive surface and white glyph', () => {
-    const classes = classesOf('destructive-solid')
-    expect(classes).toContain('bg-destructive')
-    expect(classes).toContain('text-white')
-    expect(classes).not.toContain('border-destructive')
-  })
-
-  it('destructive-solid ships no dark background override', () => {
-    // `--destructive` is a semantic token that already resolves per theme; a
-    // `dark:bg-*` override on top of it is what broke IconButton in #3507.
-    const classes = classesOf('destructive-solid')
-    expect(classes.some((cls) => cls.startsWith('dark:bg-'))).toBe(false)
-  })
-
-  it('renders the quiet treatment on the element for variant="destructive"', () => {
-    const { getByRole } = render(<Button variant="destructive">Delete</Button>)
-    const className = getByRole('button').className
-    expect(className).toContain('text-destructive')
-    expect(className).toContain('border-destructive')
-    expect(className.split(/\s+/)).not.toContain('bg-destructive')
-  })
-
-  it('renders the filled treatment on the element for variant="destructive-solid"', () => {
-    const { getByRole } = render(<Button variant="destructive-solid">Delete permanently</Button>)
-    const classNames = getByRole('button').className.split(/\s+/)
-    expect(classNames).toContain('bg-destructive')
-    expect(classNames).toContain('text-white')
-  })
-
-  it('defaults to the primary variant when none is given', () => {
-    const { getByRole } = render(<Button>Save</Button>)
-    const classNames = getByRole('button').className.split(/\s+/)
-    expect(classNames).toContain('bg-primary')
-    expect(classNames).not.toContain('text-destructive')
-  })
-})