@opensaas/stack-ui 0.22.0 → 0.23.0

package/tests/components/AdminUISingleton.test.tsx

@@ -0,0 +1,296 @@
+import { describe, it, expect, vi } from 'vitest'
+import * as React from 'react'
+import { render, screen } from '@testing-library/react'
+import type { AccessContext, OpenSaasConfig } from '@opensaas/stack-core'
+import { list } from '@opensaas/stack-core'
+import { text } from '@opensaas/stack-core/fields'
+import { AdminUI } from '../../src/components/AdminUI.js'
+import { SingletonView } from '../../src/components/SingletonView.js'
+import { ListView } from '../../src/components/ListView.js'
+
+// Mock Next.js navigation — the form/table client components call useRouter().
+const mockPush = vi.fn()
+const mockRefresh = vi.fn()
+vi.mock('next/navigation.js', () => ({
+  useRouter: () => ({ push: mockPush, refresh: mockRefresh }),
+}))
+
+// next/link renders an anchor; happy-dom can render it directly.
+vi.mock('next/link.js', () => ({
+  default: ({ children, href }: { children: React.ReactNode; href: string }) => (
+    <a href={href}>{children}</a>
+  ),
+}))
+
+/**
+ * A config with one singleton list (Settings) and one ordinary list (Post).
+ * Built with the real `list()` + field builders so the components see the
+ * same field shapes they would in a real app.
+ */
+const config: OpenSaasConfig = {
+  db: { provider: 'sqlite', url: 'file:./test.db' },
+  lists: {
+    Settings: list({
+      isSingleton: true,
+      fields: {
+        siteName: text(),
+      },
+    }),
+    Post: list({
+      fields: {
+        title: text(),
+      },
+    }),
+  },
+}
+
+interface DelegateStub {
+  get?: () => Promise<Record<string, unknown> | null>
+  findUnique?: (args: unknown) => Promise<Record<string, unknown> | null>
+  findMany?: (args: unknown) => Promise<Array<Record<string, unknown>>>
+  count?: (args: unknown) => Promise<number>
+}
+
+/**
+ * Build a minimal AccessContext whose db delegates return canned data.
+ * Only the methods the views call are implemented.
+ */
+function makeContext(delegates: Record<string, DelegateStub>): AccessContext<unknown> {
+  const context = {
+    db: delegates,
+    session: null,
+    storage: {},
+    plugins: {},
+    _isSudo: false,
+    _resolveOutputCounter: { depth: 0 },
+  }
+  // Cast: this is a stub for rendering tests, not a full Prisma-backed context.
+  return context as unknown as AccessContext<unknown>
+}
+
+const noopServerAction = vi.fn(async () => ({ success: true }))
+
+// React represents `<Component />` as an element whose `.type` is the component
+// function. The router picks the component but does not await it (nested server
+// components resolve during streaming, not in this unit), so we assert the
+// branch by inspecting which component AdminUI chose for the bare [list] route.
+function routedContent(tree: React.ReactNode): React.ReactElement {
+  // AdminUI returns <> {style?} <div><Navigation/><main>{content}</main></div> </>
+  const fragment = tree as React.ReactElement<{ children: React.ReactNode }>
+  const children = React.Children.toArray(fragment.props.children)
+  const wrapper = children.find(
+    (child): child is React.ReactElement<{ children: React.ReactNode }> =>
+      React.isValidElement(child) && child.type === 'div',
+  )
+  if (!wrapper) throw new Error('AdminUI layout wrapper not found')
+  const main = React.Children.toArray(wrapper.props.children).find(
+    (child): child is React.ReactElement<{ children: React.ReactNode }> =>
+      React.isValidElement(child) && child.type === 'main',
+  )
+  if (!main) throw new Error('AdminUI <main> not found')
+  return main.props.children as React.ReactElement
+}
+
+describe('AdminUI singleton routing', () => {
+  it('routes a singleton bare [list] to SingletonView, a non-singleton to ListView', async () => {
+    const context = makeContext({
+      settings: { get: vi.fn(async () => ({ id: '1', siteName: 'My Site' })) },
+      post: { findMany: vi.fn(async () => []), count: vi.fn(async () => 0) },
+    })
+
+    const singletonTree = await AdminUI({
+      context,
+      config,
+      params: ['settings'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    expect(routedContent(singletonTree).type).toBe(SingletonView)
+
+    const listTree = await AdminUI({
+      context,
+      config,
+      params: ['post'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    expect(routedContent(listTree).type).toBe(ListView)
+  })
+
+  it('renders a single-record editor for a singleton list (SingletonView)', async () => {
+    const singletonGet = vi.fn(async () => ({ id: '1', siteName: 'My Site' }))
+    const context = makeContext({ settings: { get: singletonGet } })
+
+    const element = await SingletonView({
+      context,
+      config,
+      listKey: 'Settings',
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    render(element)
+
+    // Resolved via the singleton get() (auto-create path), not findMany.
+    expect(singletonGet).toHaveBeenCalledTimes(1)
+
+    // Editor header + the record's value rendered in a field input.
+    expect(screen.getByText('Edit Settings')).toBeInTheDocument()
+    expect(screen.getByDisplayValue('My Site')).toBeInTheDocument()
+
+    // Save button (edit form), not a list-table "Create" affordance.
+    expect(screen.getByRole('button', { name: 'Save' })).toBeInTheDocument()
+    expect(screen.queryByText('Create Settings')).not.toBeInTheDocument()
+  })
+
+  it('renders a create-on-save form for an autoCreate:false singleton with no row', async () => {
+    // autoCreate:false + no row → get() returns null. query+create are allowed,
+    // so the editor must offer a create-on-first-save form (mode="create").
+    const autoCreateFalseConfig: OpenSaasConfig = {
+      db: { provider: 'sqlite', url: 'file:./test.db' },
+      lists: {
+        Settings: list({
+          isSingleton: { autoCreate: false },
+          access: {
+            operation: {
+              query: () => true,
+              create: () => true,
+              update: () => true,
+              delete: () => true,
+            },
+          },
+          fields: { siteName: text() },
+        }),
+      },
+    }
+
+    const singletonGet = vi.fn(async () => null)
+    const context = makeContext({ settings: { get: singletonGet } })
+
+    const element = await SingletonView({
+      context,
+      config: autoCreateFalseConfig,
+      listKey: 'Settings',
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    render(element)
+
+    expect(singletonGet).toHaveBeenCalledTimes(1)
+
+    // Create header + the create affordance ("Create" submit button), not an edit form.
+    expect(screen.getByText('Create Settings')).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Create' })).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Save' })).not.toBeInTheDocument()
+    // An empty field input is rendered (no display value yet).
+    expect(screen.getByText('Site Name')).toBeInTheDocument()
+  })
+
+  it('renders a friendly message (not an editable form) for a read-denied singleton', async () => {
+    // query denied → get() returns null. A null is indistinguishable from an
+    // empty autoCreate:false singleton, so the editor disambiguates via access
+    // and must NOT show an editable/create form.
+    const readDeniedConfig: OpenSaasConfig = {
+      db: { provider: 'sqlite', url: 'file:./test.db' },
+      lists: {
+        Settings: list({
+          isSingleton: true,
+          access: {
+            operation: {
+              query: () => false,
+              create: () => true,
+              update: () => true,
+              delete: () => false,
+            },
+          },
+          fields: { siteName: text() },
+        }),
+      },
+    }
+
+    const singletonGet = vi.fn(async () => null)
+    const context = makeContext({ settings: { get: singletonGet } })
+
+    const element = await SingletonView({
+      context,
+      config: readDeniedConfig,
+      listKey: 'Settings',
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    render(element)
+
+    // Friendly no-access message, no form affordances at all.
+    expect(screen.getByText("You don't have access to Settings.")).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Create' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Save' })).not.toBeInTheDocument()
+    expect(screen.queryByText('Create Settings')).not.toBeInTheDocument()
+    expect(screen.queryByText('Edit Settings')).not.toBeInTheDocument()
+  })
+
+  it('renders a "no record yet" message when create is denied (no editable form)', async () => {
+    // autoCreate:false + no row, query allowed but create denied → cannot offer
+    // a create form; show a friendly "no record yet" message instead.
+    const createDeniedConfig: OpenSaasConfig = {
+      db: { provider: 'sqlite', url: 'file:./test.db' },
+      lists: {
+        Settings: list({
+          isSingleton: { autoCreate: false },
+          access: {
+            operation: {
+              query: () => true,
+              create: () => false,
+              update: () => true,
+              delete: () => false,
+            },
+          },
+          fields: { siteName: text() },
+        }),
+      },
+    }
+
+    const singletonGet = vi.fn(async () => null)
+    const context = makeContext({ settings: { get: singletonGet } })
+
+    const element = await SingletonView({
+      context,
+      config: createDeniedConfig,
+      listKey: 'Settings',
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    render(element)
+
+    expect(screen.getByText('There is no Settings record yet.')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Create' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Save' })).not.toBeInTheDocument()
+  })
+
+  it('renders the list table for a non-singleton list (ListView)', async () => {
+    const findMany = vi.fn(async () => [
+      { id: '1', title: 'First Post' },
+      { id: '2', title: 'Second Post' },
+    ])
+    const count = vi.fn(async () => 2)
+    const context = makeContext({ post: { findMany, count } })
+
+    const element = await ListView({
+      context,
+      config,
+      listKey: 'Post',
+      basePath: '/admin',
+    })
+    render(element)
+
+    // List view fetches via findMany/count (the singleton get() is never called).
+    expect(findMany).toHaveBeenCalledTimes(1)
+    expect(count).toHaveBeenCalledTimes(1)
+
+    // The list table renders rows + the "Create" affordance.
+    expect(screen.getByText('First Post')).toBeInTheDocument()
+    expect(screen.getByText('Second Post')).toBeInTheDocument()
+    expect(screen.getByText('Create Post')).toBeInTheDocument()
+
+    // It is NOT the singleton editor.
+    expect(screen.queryByText('Edit Post')).not.toBeInTheDocument()
+  })
+})

package/tests/components/AdminUISingletonSuppress.test.tsx

@@ -0,0 +1,259 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import * as React from 'react'
+import { render, screen } from '@testing-library/react'
+import type { AccessContext, OpenSaasConfig } from '@opensaas/stack-core'
+import { list } from '@opensaas/stack-core'
+import { text } from '@opensaas/stack-core/fields'
+import { AdminUI } from '../../src/components/AdminUI.js'
+import { ItemForm } from '../../src/components/ItemForm.js'
+import { SingletonView } from '../../src/components/SingletonView.js'
+import { Dashboard } from '../../src/components/Dashboard.js'
+
+// Mock Next.js navigation — AdminUI calls redirect() (server-side) for singleton
+// sub-routes, and the form/table client components call useRouter().
+const mockPush = vi.fn()
+const mockRefresh = vi.fn()
+const mockRedirect = vi.fn()
+vi.mock('next/navigation.js', () => ({
+  useRouter: () => ({ push: mockPush, refresh: mockRefresh }),
+  redirect: (url: string) => mockRedirect(url),
+}))
+
+// next/link renders an anchor; happy-dom can render it directly.
+vi.mock('next/link.js', () => ({
+  default: ({ children, href }: { children: React.ReactNode; href: string }) => (
+    <a href={href}>{children}</a>
+  ),
+}))
+
+/**
+ * A config with one singleton list (Settings) and one ordinary list (Post).
+ * Built with the real `list()` + field builders so the components see the same
+ * field shapes they would in a real app.
+ */
+const config: OpenSaasConfig = {
+  db: { provider: 'sqlite', url: 'file:./test.db' },
+  lists: {
+    Settings: list({
+      isSingleton: true,
+      fields: {
+        siteName: text(),
+      },
+    }),
+    Post: list({
+      fields: {
+        title: text(),
+      },
+    }),
+  },
+}
+
+interface DelegateStub {
+  get?: () => Promise<Record<string, unknown> | null>
+  findUnique?: (args: unknown) => Promise<Record<string, unknown> | null>
+  findMany?: (args: unknown) => Promise<Array<Record<string, unknown>>>
+  count?: (args?: unknown) => Promise<number>
+}
+
+/**
+ * Build a minimal AccessContext whose db delegates return canned data. Only the
+ * methods the views call are implemented.
+ */
+function makeContext(delegates: Record<string, DelegateStub>): AccessContext<unknown> {
+  const context = {
+    db: delegates,
+    session: null,
+    storage: {},
+    plugins: {},
+    _isSudo: false,
+    _resolveOutputCounter: { depth: 0 },
+  }
+  // Cast: this is a stub for rendering tests, not a full Prisma-backed context.
+  return context as unknown as AccessContext<unknown>
+}
+
+const noopServerAction = vi.fn(async () => ({ success: true }))
+
+beforeEach(() => {
+  mockRedirect.mockClear()
+  mockPush.mockClear()
+  mockRefresh.mockClear()
+})
+
+describe('AdminUI singleton sub-route redirects', () => {
+  it('redirects a singleton [list, "create"] to the bare editor route', async () => {
+    const context = makeContext({
+      settings: { get: vi.fn(async () => ({ id: '1', siteName: 'My Site' })) },
+    })
+
+    await AdminUI({
+      context,
+      config,
+      params: ['settings', 'create'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+
+    expect(mockRedirect).toHaveBeenCalledTimes(1)
+    expect(mockRedirect).toHaveBeenCalledWith('/admin/settings')
+  })
+
+  it('redirects a singleton [list, id] to the bare editor route', async () => {
+    const context = makeContext({
+      settings: { get: vi.fn(async () => ({ id: '1', siteName: 'My Site' })) },
+    })
+
+    await AdminUI({
+      context,
+      config,
+      params: ['settings', '1'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+
+    expect(mockRedirect).toHaveBeenCalledTimes(1)
+    expect(mockRedirect).toHaveBeenCalledWith('/admin/settings')
+  })
+
+  it('honours a custom basePath in the redirect target', async () => {
+    const context = makeContext({
+      settings: { get: vi.fn(async () => ({ id: '1', siteName: 'My Site' })) },
+    })
+
+    await AdminUI({
+      context,
+      config,
+      params: ['settings', 'create'],
+      basePath: '/dashboard',
+      serverAction: noopServerAction,
+    })
+
+    expect(mockRedirect).toHaveBeenCalledWith('/dashboard/settings')
+  })
+
+  it('does NOT redirect a singleton bare [list] route (renders the editor)', async () => {
+    const context = makeContext({
+      settings: { get: vi.fn(async () => ({ id: '1', siteName: 'My Site' })) },
+    })
+
+    await AdminUI({
+      context,
+      config,
+      params: ['settings'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+
+    expect(mockRedirect).not.toHaveBeenCalled()
+  })
+
+  it('does NOT redirect non-singleton create/edit routes (routing unchanged)', async () => {
+    const context = makeContext({
+      post: {
+        findMany: vi.fn(async () => []),
+        count: vi.fn(async () => 0),
+        findUnique: vi.fn(async () => ({ id: '1', title: 'First Post' })),
+      },
+    })
+
+    // Non-singleton create
+    await AdminUI({
+      context,
+      config,
+      params: ['post', 'create'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    expect(mockRedirect).not.toHaveBeenCalled()
+
+    // Non-singleton edit
+    await AdminUI({
+      context,
+      config,
+      params: ['post', '1'],
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    expect(mockRedirect).not.toHaveBeenCalled()
+  })
+})
+
+describe('Dashboard create suppression for singletons', () => {
+  it('does not render a "Create {singleton}" quick-action but does for a non-singleton', async () => {
+    const context = makeContext({
+      settings: { count: vi.fn(async () => 1) },
+      post: { count: vi.fn(async () => 2) },
+    })
+
+    const element = await Dashboard({ context, config, basePath: '/admin' })
+    render(element)
+
+    // The Quick Actions block offers "Create" only for the standard list.
+    expect(screen.getByText('Create Post')).toBeInTheDocument()
+    expect(screen.queryByText('Create Settings')).not.toBeInTheDocument()
+
+    // There is no create link pointing at the singleton anywhere on the dashboard.
+    const createLinks = screen.getAllByRole('link', { name: /Create/ })
+    for (const link of createLinks) {
+      expect(link).not.toHaveAttribute('href', '/admin/settings/create')
+    }
+  })
+
+  it('hides the Quick Actions card entirely in a singleton-only admin', async () => {
+    const singletonOnly: OpenSaasConfig = {
+      db: { provider: 'sqlite', url: 'file:./test.db' },
+      lists: {
+        Settings: list({ isSingleton: true, fields: { siteName: text() } }),
+      },
+    }
+    const context = makeContext({ settings: { count: vi.fn(async () => 1) } })
+
+    const element = await Dashboard({ context, config: singletonOnly, basePath: '/admin' })
+    render(element)
+
+    expect(screen.queryByText('Quick Actions')).not.toBeInTheDocument()
+    expect(screen.queryByText('Create Settings')).not.toBeInTheDocument()
+  })
+})
+
+describe('Delete suppression in the singleton editor', () => {
+  it('renders no delete control in the singleton editor (SingletonView)', async () => {
+    const context = makeContext({
+      settings: { get: vi.fn(async () => ({ id: '1', siteName: 'My Site' })) },
+    })
+
+    const element = await SingletonView({
+      context,
+      config,
+      listKey: 'Settings',
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    render(element)
+
+    // The edit form renders (Save present) but the Delete affordance is gone.
+    expect(screen.getByRole('button', { name: 'Save' })).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Delete' })).not.toBeInTheDocument()
+  })
+
+  it('still renders the delete control for a non-singleton edit form (ItemForm)', async () => {
+    const context = makeContext({
+      post: { findUnique: vi.fn(async () => ({ id: '1', title: 'First Post' })) },
+    })
+
+    const element = await ItemForm({
+      context,
+      config,
+      listKey: 'Post',
+      mode: 'edit',
+      itemId: '1',
+      basePath: '/admin',
+      serverAction: noopServerAction,
+    })
+    render(element)
+
+    // Non-singleton edit forms keep the delete affordance.
+    expect(screen.getByRole('button', { name: 'Save' })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Delete' })).toBeInTheDocument()
+  })
+})

package/tests/components/SingletonNavDashboard.test.tsx

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi } from 'vitest'
+import * as React from 'react'
+import { render, screen, within } from '@testing-library/react'
+import type { AccessContext, OpenSaasConfig } from '@opensaas/stack-core'
+import { list } from '@opensaas/stack-core'
+import { text } from '@opensaas/stack-core/fields'
+import { Navigation } from '../../src/components/Navigation.js'
+import { Dashboard } from '../../src/components/Dashboard.js'
+
+// next/link renders an anchor; happy-dom can render it directly.
+vi.mock('next/link.js', () => ({
+  default: ({ children, href }: { children: React.ReactNode; href: string }) => (
+    <a href={href}>{children}</a>
+  ),
+}))
+
+/**
+ * A config with one singleton list (SiteConfig) and one ordinary list (Post).
+ * Built with the real `list()` + field builders so the components see the same
+ * field shapes they would in a real app. The singleton is deliberately NOT
+ * named "Settings" so its link label can't be confused with the "Settings"
+ * group heading.
+ */
+const config: OpenSaasConfig = {
+  db: { provider: 'sqlite', url: 'file:./test.db' },
+  lists: {
+    SiteConfig: list({
+      isSingleton: true,
+      fields: {
+        siteName: text(),
+      },
+    }),
+    Post: list({
+      fields: {
+        title: text(),
+      },
+    }),
+  },
+}
+
+interface DelegateStub {
+  count?: (args?: unknown) => Promise<number>
+}
+
+/**
+ * Build a minimal AccessContext whose db delegates return canned data. Only the
+ * methods the views call are implemented.
+ */
+function makeContext(delegates: Record<string, DelegateStub>): AccessContext<unknown> {
+  const context = {
+    db: delegates,
+    session: null,
+    storage: {},
+    plugins: {},
+    _isSudo: false,
+    _resolveOutputCounter: { depth: 0 },
+  }
+  // Cast: this is a stub for rendering tests, not a full Prisma-backed context.
+  return context as unknown as AccessContext<unknown>
+}
+
+describe('Navigation singleton grouping', () => {
+  it('renders singletons under a "Settings" group and non-singletons under "Lists"', () => {
+    const context = makeContext({})
+
+    render(<Navigation context={context} config={config} basePath="/admin" />)
+
+    // Both group headings are present.
+    expect(screen.getByText('Lists')).toBeInTheDocument()
+    expect(screen.getByText('Settings')).toBeInTheDocument()
+
+    // The non-singleton Post links to its editor under the "Lists" group, and the
+    // singleton SiteConfig links to its editor under the "Settings" group. Both
+    // point at the bare [list] route (the editor).
+    const postLink = screen.getByRole('link', { name: /Post/ })
+    expect(postLink).toHaveAttribute('href', '/admin/post')
+
+    const siteConfigLink = screen.getByRole('link', { name: /Site Config/ })
+    expect(siteConfigLink).toHaveAttribute('href', '/admin/site-config')
+  })
+
+  it('does not render a "Settings" group when there are no singletons', () => {
+    const noSingletons: OpenSaasConfig = {
+      db: { provider: 'sqlite', url: 'file:./test.db' },
+      lists: {
+        Post: list({ fields: { title: text() } }),
+      },
+    }
+    const context = makeContext({})
+
+    render(<Navigation context={context} config={noSingletons} basePath="/admin" />)
+
+    expect(screen.getByText('Lists')).toBeInTheDocument()
+    expect(screen.queryByText('Settings')).not.toBeInTheDocument()
+  })
+
+  it('does not render a "Lists" group when there are only singletons', () => {
+    const onlySingletons: OpenSaasConfig = {
+      db: { provider: 'sqlite', url: 'file:./test.db' },
+      lists: {
+        SiteConfig: list({ isSingleton: true, fields: { siteName: text() } }),
+      },
+    }
+    const context = makeContext({})
+
+    render(<Navigation context={context} config={onlySingletons} basePath="/admin" />)
+
+    expect(screen.getByText('Settings')).toBeInTheDocument()
+    expect(screen.queryByText('Lists')).not.toBeInTheDocument()
+  })
+})
+
+describe('Dashboard singleton affordance', () => {
+  it('shows "Configure" for a singleton (no count) and a count for a non-singleton', async () => {
+    const siteConfigCount = vi.fn(async () => 1)
+    const postCount = vi.fn(async () => 2)
+    const context = makeContext({
+      siteConfig: { count: siteConfigCount },
+      post: { count: postCount },
+    })
+
+    const element = await Dashboard({ context, config, basePath: '/admin' })
+    render(element)
+
+    // Non-singleton Post card shows the normal "N items" count.
+    expect(screen.getByText('2 items')).toBeInTheDocument()
+
+    // The singleton card shows a "Configure" affordance and links to the editor.
+    const configureLink = screen.getByRole('link', { name: /Configure/ })
+    expect(configureLink).toHaveAttribute('href', '/admin/site-config')
+    expect(within(configureLink).getByText('Site Config')).toBeInTheDocument()
+
+    // The singleton's count() is never called — its count is misleading, so the
+    // dashboard does not query or render it.
+    expect(siteConfigCount).not.toHaveBeenCalled()
+    expect(postCount).toHaveBeenCalledTimes(1)
+
+    // No "N items" label appears for the singleton.
+    expect(screen.queryByText('1 item')).not.toBeInTheDocument()
+  })
+})