Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

29.3 KB
Raw Blame
import type { AppPartial } from '@dify/contracts/api/console/apps/types.gen'
import type { RecommendedAppResponse } from '@dify/contracts/api/console/explore/types.gen'
import type { ReactNode } from 'react'
import type { StepByStepTourSessionState } from '@/app/components/step-by-step-tour/types'
import type { consoleClient } from '@/service/console'
import type { ConsoleQueryTestOptions } from '@/test/console/query-data'
import { zAppPagination } from '@dify/contracts/api/console/apps/zod.gen'
import { zGetFeaturesResponse } from '@dify/contracts/api/console/features/zod.gen'
import { act, fireEvent, screen, waitFor, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { createStore, Provider as JotaiProvider } from 'jotai'
import { queryClientAtom } from 'jotai-tanstack-query'
import { NuqsTestingAdapter } from 'nuqs/adapters/testing'
import { AppDetailTop } from '@/app/components/app-sidebar/app-detail-top'
import { stepByStepTourSessionAtom } from '@/app/components/step-by-step-tour/state'
import { consoleQuery } from '@/service/console'
import { createConsoleQueryClient, renderWithConsoleQuery } from '@/test/console/query-data'
import { createDeferred } from '@/test/deferred'
import { createAppDetailFixture } from '@/test/fixtures/app'
import { mockIntersectionObserver } from '@/test/intersection-observer'
import { AppACLPermission } from '@/utils/permission'
import { List } from '../list'

const api = vi.hoisted(() => ({
  apps: vi.fn<typeof consoleClient.apps.get>(),
  delete: vi.fn<typeof consoleClient.apps.byAppId.delete>(),
  starred: vi.fn<typeof consoleClient.apps.starred.get>(),
  online: vi.fn<typeof consoleClient.apps.workflows.onlineUsers.post>(),
  learn: vi.fn<typeof consoleClient.explore.apps.learnDify.get>(),
  push: vi.fn(),
  replace: vi.fn(),
  searchParams: new URLSearchParams(),
}))
vi.mock('@/next/navigation', async (importOriginal) => ({
  ...(await importOriginal<typeof import('@/next/navigation')>()),
  useRouter: () => ({ push: api.push, replace: api.replace }),
  usePathname: () => '/apps',
  useSearchParams: () => api.searchParams,
}))
vi.mock('@/service/console', async (importOriginal) => {
  const actual = await importOriginal<typeof import('@/service/console')>()
  const { withConsoleResponses } = await import('@/test/console/service-responses')
  return {
    ...actual,
    consoleQuery: withConsoleResponses(actual.consoleQuery, {
      'features.get': async () => zGetFeaturesResponse.parse({}),
      'apps.get': api.apps,
      'apps.byAppId.delete': api.delete,
      'apps.starred.get': api.starred,
      'apps.workflows.onlineUsers.post': api.online,
      'explore.apps.learnDify.get': api.learn,
      'explore.apps.get': async () => ({ recommended_apps: [], categories: [] }),
      'tags.get': async () => [{ id: 'tag-1', name: 'Research', type: 'app' }],
    }),
  }
})

const app = (overrides: Partial<AppPartial> = {}) => ({
  ...createAppDetailFixture({ id: 'app-1', name: 'Chat app', maintainer: 'creator-1' }),
  permission_keys: [AppACLPermission.Edit],
  ...overrides,
})
const apps = [app(), app({ id: 'app-2', name: 'Workflow app', mode: 'workflow' })]
const page = (data = apps, pageNumber = 1, hasMore = false) =>
  zAppPagination.parse({
    data,
    page: pageNumber,
    limit: 30,
    has_more: hasMore,
    total: data.length,
  })
const search = () =>
  screen.getByRole('searchbox', { name: 'app.gotoAnything.actions.searchApplications' })
const catalog = () => screen.getByRole('region', { name: 'navigation.menus.apps' })
const emptyStatus = () => screen.getByRole('status', { name: '' })
const openTagFilter = async (user: ReturnType<typeof userEvent.setup>) => {
  await user.click(screen.getByRole('combobox', { name: 'common.tag.placeholder' }))
  await user.click(await screen.findByRole('option', { name: 'Research' }))
  await user.keyboard('{Escape}')
}

const learnApp = {
  app_id: 'learn-dify-template',
  app: {
    id: 'learn-dify-template-source',
    mode: 'chat',
    icon_type: 'emoji',
    icon: '🤖',
    icon_background: '#fff',
    icon_url: '',
    name: 'Learn Dify Template',
  },
  description: 'Learn how to build with Dify',
  copyright: '',
  privacy_policy: null,
  custom_disclaimer: null,
  categories: ['Assistant'],
  position: 1,
  is_listed: true,
  can_trial: true,
} satisfies RecommendedAppResponse

let intersect: ReturnType<typeof mockIntersectionObserver>

async function setup(
  searchParams = '',
  {
    waitForResults = true,
    ...options
  }: ConsoleQueryTestOptions & { waitForResults?: boolean } = {},
  tour?: StepByStepTourSessionState,
) {
  api.searchParams = new URLSearchParams(searchParams)
  const queryClient = createConsoleQueryClient()
  queryClient.setQueryData(consoleQuery.workspaces.current.members.get.queryKey({ input: {} }), {
    accounts: [
      {
        id: 'creator-1',
        name: 'Alice',
        avatar_url: null,
        status: 'active',
        email: '[email protected]',
        role: 'admin',
      },
    ],
  })
  const store = createStore()
  store.set(queryClientAtom, queryClient)
  if (tour) store.set(stepByStepTourSessionAtom, tour)
  const onUrlUpdate = vi.fn()
  const onCreateLearnDify = vi.fn()
  const onTryLearnDify = vi.fn()
  const list = <List onCreateLearnDify={onCreateLearnDify} onTryLearnDify={onTryLearnDify} />
  const route = (path: string, params: string, content: ReactNode) => (
    <JotaiProvider store={store}>
      <NuqsTestingAdapter key={path} hasMemory searchParams={params} onUrlUpdate={onUrlUpdate}>
        {content}
      </NuqsTestingAdapter>
    </JotaiProvider>
  )
  let rendered!: ReturnType<typeof renderWithConsoleQuery>
  await act(async () => {
    rendered = renderWithConsoleQuery(route('/apps', searchParams, list), {
      queryClient,
      accountProfile: { id: 'creator-1' },
      features: {},
      workspacePermissionKeys: ['app.create_and_management', 'app.tag.manage'],
      systemFeatures: {
        rbac_enabled: true,
        enable_learn_app: false,
      },
      ...options,
    })
  })
  if (waitForResults)
    await waitFor(() =>
      expect(screen.queryByRole('status', { name: 'common.loading' })).not.toBeInTheDocument(),
    )
  const navigate = async (href: string, content: ReactNode) => {
    const [path, params = ''] = href.split('?')
    api.searchParams = new URLSearchParams(params)
    await act(async () => rendered.rerender(route(path!, params, content)))
  }
  return {
    user: userEvent.setup(),
    onUrlUpdate,
    queryClient,
    onCreateLearnDify,
    onTryLearnDify,
    showDetail: () => navigate('/app/app-2/workflow', <AppDetailTop />),
    showList: (href: string) => navigate(href, list),
  }
}

beforeEach(() => {
  api.apps.mockReset().mockResolvedValue(page())
  api.delete.mockReset().mockResolvedValue(undefined)
  api.starred.mockReset().mockResolvedValue(page([]))
  api.online.mockReset().mockResolvedValue({ data: [] })
  api.learn.mockReset().mockResolvedValue({ recommended_apps: [learnApp] })
  api.push.mockReset()
  api.replace.mockReset()
  intersect = mockIntersectionObserver()
})
afterEach(() => vi.unstubAllGlobals())

it('renders real starred links before the workspace catalog', async () => {
  api.starred.mockResolvedValue(page([app({ id: 'starred', name: 'Starred app' })]))
  await setup()
  const lists = within(catalog()).getAllByRole('list')
  expect(lists[0]).toHaveAccessibleName('app.studio.starred')
  expect(lists[1]).toHaveAccessibleName('app.studio.allApps')
  expect(within(lists[0]!).getByRole('link', { name: 'Starred app' })).toHaveAttribute(
    'href',
    '/app/starred/configuration',
  )
  expect(within(lists[1]!).getByRole('link', { name: 'Workflow app' })).toHaveAttribute(
    'href',
    '/app/app-2/workflow',
  )
})

it('shows creation guidance only for an unfiltered empty workspace with creation access', async () => {
  api.apps.mockResolvedValue(page([]))
  const { user } = await setup()
  expect(screen.getByText('app.firstEmpty.title')).toBeInTheDocument()
  expect(screen.queryByText('app.firstEmpty.learnDifyTitle')).not.toBeInTheDocument()
  await user.type(search(), 'missing')
  expect(screen.queryByText('app.firstEmpty.title')).not.toBeInTheDocument()
  await waitFor(() => expect(emptyStatus()).toHaveTextContent('app.filterEmpty.noApps'))
})

it('does not offer creation to a user without workspace creation permission', async () => {
  api.apps.mockResolvedValue(page([]))
  await setup('', { workspacePermissionKeys: [] })
  expect(emptyStatus()).toHaveTextContent('app.filterEmpty.noApps')
  expect(screen.queryByText('app.firstEmpty.title')).not.toBeInTheDocument()
  expect(screen.queryByRole('button', { name: 'common.operation.create' })).not.toBeInTheDocument()
})

it.each(['CLOUD', 'COMMUNITY'] as const)(
  'uses the real Learn Dify card for the %s action',
  async (edition) => {
    api.apps.mockResolvedValue(page([]))
    const { user, onCreateLearnDify, onTryLearnDify } = await setup('', {
      systemFeatures: { deployment_edition: edition, enable_learn_app: true },
    })
    await user.click(await screen.findByRole('button', { name: 'Learn Dify Template' }))
    expect(edition === 'CLOUD' ? onTryLearnDify : onCreateLearnDify).toHaveBeenCalledWith(learnApp)
    expect(edition === 'CLOUD' ? onCreateLearnDify : onTryLearnDify).not.toHaveBeenCalled()
  },
)

it('waits for both initial requests before announcing results', async () => {
  const main = createDeferred<Awaited<ReturnType<typeof api.apps>>>()
  const starred = createDeferred<Awaited<ReturnType<typeof api.starred>>>()
  api.apps.mockReturnValue(main.promise)
  api.starred.mockReturnValue(starred.promise)
  await setup('', { waitForResults: false })
  expect(screen.getAllByRole('status', { name: 'common.loading' })).toHaveLength(1)
  expect(screen.queryByText('app.firstEmpty.title')).not.toBeInTheDocument()
  await act(async () => main.resolve(page()))
  expect(screen.getByRole('status', { name: 'common.loading' })).toBeInTheDocument()
  expect(screen.queryByRole('link', { name: 'Chat app' })).not.toBeInTheDocument()
  await act(async () => starred.resolve(page([])))
  expect(await screen.findByRole('link', { name: 'Chat app' })).toBeInTheDocument()
  expect(screen.queryByRole('status', { name: 'common.loading' })).not.toBeInTheDocument()
})

it('queries collaborators only for workflow apps when collaboration is enabled', async () => {
  await setup('', { features: { workflow_collaboration_enabled: true } })
  await waitFor(() => expect(api.online).toHaveBeenCalledWith({ body: { app_ids: ['app-2'] } }))
})

it('combines real creator and tag selections with URL filters for both catalogs', async () => {
  const { user } = await setup('?keywords=sales&category=workflow')
  const scrollTo = vi.fn()
  catalog().scrollTo = scrollTo
  await user.click(screen.getByRole('combobox', { name: 'app.studio.filters.creators' }))
  await user.click(await screen.findByRole('option', { name: /Alice/ }))
  await user.keyboard('{Escape}')
  await openTagFilter(user)
  const filters = {
    page: 1,
    name: 'sales',
    sort_by: 'last_modified',
    tag_ids: ['tag-1'],
    creator_ids: ['creator-1'],
    mode: 'workflow',
  }
  await waitFor(() =>
    expect(api.apps).toHaveBeenLastCalledWith({ query: { ...filters, limit: 30 } }),
  )
  expect(api.starred).toHaveBeenLastCalledWith({ query: { ...filters, limit: 100 } })
  expect(scrollTo).toHaveBeenCalledWith({ top: 0 })
})

it('restores creator and tag filters from the URL for both catalogs', async () => {
  await setup(
    '?creatorIDs=creator-1&tagIDs=tag-1&category=workflow&keywords=sales&sort_by=earliest_created',
  )
  const filters = {
    page: 1,
    name: 'sales',
    sort_by: 'earliest_created',
    creator_ids: ['creator-1'],
    tag_ids: ['tag-1'],
    mode: 'workflow',
  }
  expect(api.apps).toHaveBeenLastCalledWith({ query: { ...filters, limit: 30 } })
  expect(api.starred).toHaveBeenLastCalledWith({ query: { ...filters, limit: 100 } })
  expect(screen.getByRole('combobox', { name: 'Research' })).toHaveTextContent('Research')
})

it('retains selected creators and tags through the workflow return link', async () => {
  const { user, onUrlUpdate, showDetail, showList } = await setup('?category=workflow')
  await user.click(screen.getByRole('combobox', { name: 'app.studio.filters.creators' }))
  await user.click(await screen.findByRole('option', { name: /Alice/ }))
  await user.keyboard('{Escape}')
  await openTagFilter(user)
  await waitFor(() =>
    expect(onUrlUpdate.mock.lastCall?.[0].searchParams.get('tagIDs')).toBe('tag-1'),
  )

  await showDetail()
  const href = screen.getByRole('link', { name: 'navigation.menus.apps' }).getAttribute('href')!
  const params = new URLSearchParams(href.split('?')[1])
  expect(params.get('creatorIDs')).toBe('creator-1')
  expect(params.get('tagIDs')).toBe('tag-1')
  expect(params.get('category')).toBe('workflow')

  await showList(href)
  expect(screen.getByRole('combobox', { name: 'Research' })).toBeInTheDocument()
  await user.click(screen.getByRole('combobox', { name: 'app.studio.filters.creators' }))
  expect(await screen.findByRole('option', { name: /Alice/ })).toHaveAttribute(
    'aria-selected',
    'true',
  )
  expect(api.apps).toHaveBeenLastCalledWith({
    query: expect.objectContaining({
      creator_ids: ['creator-1'],
      tag_ids: ['tag-1'],
      mode: 'workflow',
    }),
  })
})

it('does not restore cleared creator and tag filters when returning from a workflow', async () => {
  const { user, onUrlUpdate, showDetail, showList } = await setup(
    '?creatorIDs=creator-1&tagIDs=tag-1',
  )
  await user.click(screen.getByRole('button', { name: 'app.studio.filters.reset' }))
  await user.click(screen.getByRole('button', { name: 'common.operation.clear' }))
  await waitFor(() => expect(onUrlUpdate.mock.lastCall?.[0].searchParams.toString()).toBe(''))
  await showDetail()
  expect(screen.getByRole('link', { name: 'navigation.menus.apps' })).toHaveAttribute(
    'href',
    '/apps',
  )
  await showList('/apps')
  expect(screen.queryByRole('button', { name: 'app.studio.filters.reset' })).not.toBeInTheDocument()
  expect(screen.getByRole('combobox', { name: 'common.tag.placeholder' })).toBeInTheDocument()
  expect(api.apps).toHaveBeenLastCalledWith({
    query: expect.not.objectContaining({
      creator_ids: expect.anything(),
      tag_ids: expect.anything(),
    }),
  })
})

it('keeps previous main and starred cards while search resolves and announces empty results afterwards', async () => {
  api.starred.mockResolvedValue(page([app({ id: 'starred', name: 'Starred app' })]))
  const { user } = await setup()
  const main = createDeferred<Awaited<ReturnType<typeof api.apps>>>()
  const starred = createDeferred<Awaited<ReturnType<typeof api.starred>>>()
  api.apps.mockReturnValue(main.promise)
  api.starred.mockReturnValue(starred.promise)
  await user.type(search(), 'missing')
  await waitFor(() =>
    expect(api.apps).toHaveBeenLastCalledWith({
      query: expect.objectContaining({ name: 'missing' }),
    }),
  )
  expect(screen.getByRole('link', { name: 'Chat app' })).toBeInTheDocument()
  expect(screen.getByRole('link', { name: 'Starred app' })).toBeInTheDocument()
  expect(emptyStatus()).toBeEmptyDOMElement()
  await act(async () => {
    main.resolve(page([]))
    starred.resolve(page([]))
  })
  await waitFor(() => expect(emptyStatus()).toHaveTextContent('app.filterEmpty.noApps'))
  expect(screen.queryByRole('link', { name: 'Chat app' })).not.toBeInTheDocument()
  expect(screen.queryByRole('link', { name: 'Starred app' })).not.toBeInTheDocument()
})

it('keeps a settled empty announcement during background refresh', async () => {
  api.apps.mockResolvedValue(page([]))
  const { queryClient } = await setup('?keywords=missing')
  api.apps.mockReturnValue(createDeferred<Awaited<ReturnType<typeof api.apps>>>().promise)
  act(() => {
    void queryClient.invalidateQueries({ queryKey: consoleQuery.apps.get.key() })
  })
  await waitFor(() => expect(api.apps).toHaveBeenCalledTimes(2))
  expect(emptyStatus()).toHaveTextContent('app.filterEmpty.noApps')
})

it('clears search in the URL and restores the unfiltered catalog', async () => {
  api.apps.mockImplementation(async ({ query }: Parameters<typeof api.apps>[0] = {}) =>
    page(query?.name ? [] : apps),
  )
  const { user, onUrlUpdate } = await setup('?keywords=missing')
  await user.click(screen.getByRole('button', { name: 'common.operation.clear' }))
  expect(search()).toHaveValue('')
  await waitFor(() =>
    expect(onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.has('keywords')).toBe(false),
  )
  expect(await screen.findByRole('link', { name: 'Chat app' })).toBeInTheDocument()
})

it.each([
  ['workflow', 'app.types.workflow'],
  ['advanced-chat', 'app.types.advanced'],
  ['chat', 'app.types.chatbot'],
  ['agent-chat', 'app.types.agent'],
  ['completion', 'app.newApp.completeApp'],
])('synchronizes the %s category with URL and service queries', async (mode, label) => {
  const { user, onUrlUpdate } = await setup()
  await user.click(screen.getByRole('combobox', { name: 'app.studio.filters.types' }))
  await user.click(await screen.findByRole('option', { name: label }))
  await waitFor(() =>
    expect(api.apps).toHaveBeenLastCalledWith({ query: expect.objectContaining({ mode }) }),
  )
  expect(onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.get('category')).toBe(mode)
})

it('clears category selection back to all apps', async () => {
  const { user, onUrlUpdate } = await setup('?category=workflow')
  await user.click(screen.getByRole('combobox', { name: 'app.studio.filters.types' }))
  expect(screen.getByRole('option', { name: 'app.types.workflow' })).toHaveAttribute(
    'aria-selected',
    'true',
  )
  await user.click(screen.getByRole('option', { name: 'app.types.all' }))
  await waitFor(() =>
    expect(onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.has('category')).toBe(false),
  )
  expect(api.apps).toHaveBeenLastCalledWith({
    query: expect.not.objectContaining({ mode: expect.anything() }),
  })
})

it('ignores unsupported categories from the URL', async () => {
  await setup('?category=channel')
  expect(api.apps).toHaveBeenCalledWith({
    query: expect.not.objectContaining({ mode: expect.anything() }),
  })
})

it.each([
  ['earliest_created', 'earliest_created', 'app.studio.sort.earliestCreated'],
  ['invalid', 'last_modified', 'app.studio.sort.lastModified'],
])('resolves URL sort %s for the control and query', async (value, expected, label) => {
  await setup(`?sort_by=${value}`)
  expect(screen.getByRole('combobox', { name: 'app.studio.sort.sortBy' })).toHaveTextContent(label)
  expect(api.apps).toHaveBeenCalledWith({ query: expect.objectContaining({ sort_by: expected }) })
})

it('changes sorting without losing filters and resets catalog scroll', async () => {
  const { user, onUrlUpdate } = await setup('?category=workflow&keywords=sales')
  const scrollTo = vi.fn()
  catalog().scrollTo = scrollTo
  await user.click(screen.getByRole('combobox', { name: 'app.studio.sort.sortBy' }))
  await user.click(screen.getByRole('option', { name: 'app.studio.sort.recentlyCreated' }))
  await waitFor(() =>
    expect(api.apps).toHaveBeenLastCalledWith({
      query: expect.objectContaining({
        sort_by: 'recently_created',
        mode: 'workflow',
        name: 'sales',
      }),
    }),
  )
  const params = onUrlUpdate.mock.calls.at(-1)?.[0].searchParams
  expect(params?.get('category')).toBe('workflow')
  expect(params?.get('keywords')).toBe('sales')
  expect(params?.get('sort_by')).toBe('recently_created')
  expect(scrollTo).toHaveBeenCalledWith({ top: 0 })
  await user.click(screen.getByRole('combobox', { name: 'app.studio.sort.sortBy' }))
  await user.click(screen.getByRole('option', { name: 'app.studio.sort.lastModified' }))
  await waitFor(() =>
    expect(onUrlUpdate.mock.calls.at(-1)?.[0].searchParams.has('sort_by')).toBe(false),
  )
})

it.each([
  ['app.newApp.startFromBlank', 'app.newApp.startFromBlank'],
  ['app.newApp.startFromTemplate', 'app.newApp.startFromTemplate'],
  ['app.importApp', 'app.importApp'],
])('opens the real %s creation dialog from the menu', async (label, title) => {
  const { user } = await setup()
  await user.click(screen.getByRole('button', { name: 'common.operation.create' }))
  await user.click(await screen.findByRole('menuitem', { name: new RegExp(label) }))
  const dialog = await screen.findByRole('dialog', { name: title })
  await user.click(within(dialog).getByRole('button', { name: /^(Close|common.operation.close)$/ }))
  await waitFor(() => expect(dialog).not.toBeInTheDocument())
})

it('opens a real blank-app form from the first empty state', async () => {
  api.apps.mockResolvedValue(page([]))
  const { user } = await setup()
  await user.click(screen.getByRole('button', { name: /app.newApp.startFromBlank/ }))
  const dialog = await screen.findByRole('dialog', { name: 'app.newApp.startFromBlank' })
  expect(within(dialog).getByRole('textbox', { name: 'app.newApp.name' })).toBeInTheDocument()
})

it('opens DSL import with the file dropped on the app list', async () => {
  await setup()
  const file = new File(
    ['version: 0.1.0\nkind: app\napp:\n  name: Imported app\n  mode: chat'],
    'example.yml',
    { type: 'application/yaml' },
  )
  fireEvent.drop(catalog(), { dataTransfer: { files: [file], types: ['Files'] } })
  const dialog = await screen.findByRole('dialog', { name: 'app.importApp' })
  expect(within(dialog).getByText('example.yml')).toBeInTheDocument()
})

it('opens real tag management from the list filter', async () => {
  const { user } = await setup()
  await user.click(screen.getByRole('combobox', { name: 'common.tag.placeholder' }))
  await user.click(screen.getByRole('button', { name: 'common.tag.manageTags' }))
  const dialog = await screen.findByRole('dialog', { name: 'common.tag.manageTags' })
  expect(within(dialog).getByRole('textbox', { name: 'common.tag.addNew' })).toBeInTheDocument()
})

it('does not paginate repeatedly while a page is pending or after the last page', async () => {
  const next = createDeferred<Awaited<ReturnType<typeof api.apps>>>()
  api.apps.mockResolvedValueOnce(page(apps, 1, true)).mockReturnValue(next.promise)
  await setup()
  intersect(false)
  expect(api.apps).toHaveBeenCalledTimes(1)
  intersect()
  await waitFor(() => expect(api.apps).toHaveBeenCalledTimes(2))
  intersect()
  expect(api.apps).toHaveBeenCalledTimes(2)
  await act(async () => next.resolve(page([app({ id: 'app-3', name: 'Third app' })], 2)))
  expect(await screen.findByRole('link', { name: 'Third app' })).toBeInTheDocument()
  expect(screen.getByRole('link', { name: 'Chat app' })).toBeInTheDocument()
  expect(api.apps).toHaveBeenLastCalledWith({ query: expect.objectContaining({ page: 2 }) })
  intersect()
  expect(api.apps).toHaveBeenCalledTimes(2)
})

it('does not paginate previous results while a changed filter is pending', async () => {
  api.apps
    .mockResolvedValueOnce(page(apps, 1, true))
    .mockReturnValue(createDeferred<Awaited<ReturnType<typeof api.apps>>>().promise)
  const { user } = await setup()
  await openTagFilter(user)
  await waitFor(() => expect(api.apps).toHaveBeenCalledTimes(2))
  intersect()
  expect(api.apps).toHaveBeenCalledTimes(2)
  expect(api.apps).toHaveBeenLastCalledWith({
    query: expect.objectContaining({ page: 1, tag_ids: ['tag-1'] }),
  })
})

it('keeps the main catalog available when starred apps fail to load', async () => {
  api.starred.mockRejectedValue(new Error('Starred request failed'))
  await setup()
  expect(await screen.findByRole('link', { name: 'Chat app' })).toBeInTheDocument()
  expect(screen.queryByRole('list', { name: 'app.studio.starred' })).not.toBeInTheDocument()
})

it('preserves loaded cards and retries a failed next page', async () => {
  api.apps
    .mockResolvedValueOnce(page(apps, 1, true))
    .mockRejectedValueOnce(new Error('Page failed'))
    .mockResolvedValue(page([app({ id: 'app-3', name: 'Third app' })], 2))
  const { user } = await setup()
  intersect()
  const retry = await screen.findByRole('button', { name: 'common.operation.retry' })
  expect(screen.getByRole('link', { name: 'Chat app' })).toBeInTheDocument()
  await user.click(retry)
  expect(await screen.findByRole('link', { name: 'Third app' })).toBeInTheDocument()
  expect(api.apps).toHaveBeenCalledTimes(3)
  expect(api.apps).toHaveBeenLastCalledWith({ query: expect.objectContaining({ page: 2 }) })
})

it('opens only the first real app action menu for the manage-app tour', async () => {
  await setup(
    '',
    {},
    { activeTaskId: 'studio', activeGuideGroup: 'studioWithApps', activeGuideIndex: 1 },
  )
  const menus = screen.getAllByRole('menu', { hidden: true })
  expect(menus).toHaveLength(1)
  expect(
    within(menus[0]!).getByRole('menuitem', { name: 'app.editApp', hidden: true }),
  ).toBeInTheDocument()
  expect(menus[0]).toHaveAttribute('aria-hidden', 'true')
})

it('opens the create walkthrough after resolving the guide group without activating its actions', async () => {
  await setup('', {}, { activeTaskId: 'studio', activeGuideIndex: 0 })
  const menu = await screen.findByRole('menu', { hidden: true })
  expect(menu).toHaveAttribute('aria-hidden', 'true')
  // This is a presentation-only tour surface; a direct event must not create an app either.
  fireEvent.click(
    within(menu).getByRole('menuitem', { name: /app.newApp.startFromBlank/, hidden: true }),
  )
  expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
})

async function openDeleteDialog(user: ReturnType<typeof userEvent.setup>, appName = 'Chat app') {
  const card = screen.getByRole('link', { name: appName }).closest('li')!
  await user.click(within(card).getByRole('button', { name: /common\.operation\.moreActionsFor/ }))
  await user.click(await screen.findByRole('menuitem', { name: 'common.operation.delete' }))
  return screen.findByRole('textbox')
}

it('clears the failed deletion and confirmation name when reopening the catalog dialog', async () => {
  api.apps.mockResolvedValue(page([app({ permission_keys: [AppACLPermission.Delete] })]))
  api.delete.mockRejectedValueOnce(new Error('Delete failed'))
  const { user } = await setup()
  await user.type(await openDeleteDialog(user), 'Chat app')
  await user.click(screen.getByRole('button', { name: 'common.operation.confirm' }))
  expect(await screen.findByRole('alert')).toHaveTextContent('Delete failed')
  await user.click(screen.getByRole('button', { name: 'common.operation.cancel' }))
  await waitFor(() => expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument())
  expect(await openDeleteDialog(user)).toHaveValue('')
  expect(screen.queryByRole('alert')).not.toBeInTheDocument()
  expect(screen.getByRole('button', { name: 'common.operation.confirm' })).toBeDisabled()
})

it('retains a failed catalog deletion for retry and closes after success', async () => {
  api.apps.mockResolvedValue(page([app({ permission_keys: [AppACLPermission.Delete] })]))
  api.delete.mockRejectedValueOnce(new Error('Delete failed'))
  const { user } = await setup()
  await user.type(await openDeleteDialog(user), 'Chat app')
  await user.click(screen.getByRole('button', { name: 'common.operation.confirm' }))
  expect(await screen.findByRole('alert')).toHaveTextContent('Delete failed')
  expect(screen.getByRole('textbox')).toHaveValue('Chat app')
  expect(api.delete).toHaveBeenCalledWith({ params: { app_id: 'app-1' } })
  api.apps.mockResolvedValue(page([]))
  await user.click(screen.getByRole('button', { name: 'common.operation.confirm' }))
  await waitFor(() => expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument())
  expect(api.delete).toHaveBeenCalledTimes(2)
})

it('keeps the confirmation name stable and blocks dismissal while catalog deletion is pending', async () => {
  const target = app({ permission_keys: [AppACLPermission.Delete] })
  api.apps.mockResolvedValue(page([target]))
  const pending = createDeferred<void>()
  api.delete.mockReturnValueOnce(pending.promise)
  const { user, queryClient } = await setup()
  await openDeleteDialog(user)
  await user.click(screen.getByRole('button', { name: 'common.operation.fill' }))
  api.apps.mockResolvedValue(page([{ ...target, name: 'Renamed elsewhere' }]))
  await act(async () => queryClient.invalidateQueries({ queryKey: consoleQuery.apps.get.key() }))
  expect(screen.getByRole('textbox')).toHaveValue('Chat app')
  await user.click(screen.getByRole('button', { name: 'common.operation.confirm' }))
  await waitFor(() => expect(api.delete).toHaveBeenCalledOnce())
  expect(screen.getByRole('textbox')).toHaveAttribute('readonly')
  expect(screen.getByRole('button', { name: 'common.operation.fill' })).toBeDisabled()
  await user.keyboard('{Escape}')
  expect(screen.getByRole('alertdialog')).toBeInTheDocument()
  api.apps.mockResolvedValue(page([]))
  await act(async () => pending.resolve())
  await waitFor(() => expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument())
})

it('requires the exact app name and supports autofill before deleting from the catalog', async () => {
  api.apps.mockResolvedValue(page([app({ permission_keys: [AppACLPermission.Delete] })]))
  const { user } = await setup()
  const input = await openDeleteDialog(user)
  await user.type(input, 'Chat')
  expect(screen.getByRole('button', { name: 'common.operation.confirm' })).toBeDisabled()
  await user.keyboard('{Enter}')
  expect(api.delete).not.toHaveBeenCalled()
  await user.click(screen.getByRole('button', { name: 'common.operation.fill' }))
  expect(input).toHaveValue('Chat app')
  api.apps.mockResolvedValue(page([]))
  await user.click(screen.getByRole('button', { name: 'common.operation.confirm' }))
  await waitFor(() => expect(screen.queryByRole('alertdialog')).not.toBeInTheDocument())
  expect(api.delete).toHaveBeenCalledExactlyOnceWith({ params: { app_id: 'app-1' } })
})