Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

39.3 KB
Raw Blame
import { router } from 'kea-router'
import { expectLogic } from 'kea-test-utils'
import posthog from 'posthog-js'

import { ApiError } from 'lib/api-error'
import { lemonToast } from 'lib/lemon-ui/LemonToast'

import { initKeaTests } from '~/test/init'

import type {
    DatasetItemCreateApi,
    DatasetReadApi as Dataset,
    PaginatedDatasetReadListApi,
} from '../generated/api.schemas'
import { datasetsApi } from './datasetsApi'
import {
    DATASETS_PER_PAGE,
    RECENT_DATASETS_LIMIT,
    getStorageKey,
    saveToDatasetButtonLogic,
    truncateRecentDatasets,
} from './saveToDatasetButtonLogic'

jest.mock('./datasetsApi', () => ({
    datasetsApi: {
        listDatasets: jest.fn(),
        createItem: jest.fn(),
    },
}))
jest.mock('lib/lemon-ui/LemonToast')

describe('saveToDatasetButtonLogic', () => {
    const mockDataset1: Dataset = {
        tags: [],
        id: 'test-dataset-1',
        name: 'Test Dataset 1',
        description: 'First test dataset',
        metadata: { key1: 'value1' },
        team_id: 997,
        created_at: '2024-01-01T00:00:00Z',
        updated_at: '2024-01-01T00:00:00Z',
        created_by: null,
        archived: false,
        expires_at: null,
        expiring_soon: false,
        current_revision: null,
        current_revision_id: null,
        user_access_level: 'editor',
    }

    const mockDataset2: Dataset = {
        tags: [],
        id: 'test-dataset-2',
        name: 'Test Dataset 2',
        description: 'Second test dataset',
        metadata: { key2: 'value2' },
        team_id: 997,
        created_at: '2024-01-02T00:00:00Z',
        updated_at: '2024-01-02T00:00:00Z',
        created_by: null,
        archived: false,
        expires_at: null,
        expiring_soon: false,
        current_revision: null,
        current_revision_id: null,
        user_access_level: 'editor',
    }

    const mockPartialDatasetItem: Partial<DatasetItemCreateApi> = {
        client_item_id: 'event-1',
        input: { message: 'Hello' },
        source_output: { response: 'Hi there' },
        metadata: { source: 'test' },
        source_trace_id: 'trace-1',
        source_event_id: 'event-1',
        source_timestamp: '2024-01-01T00:00:00Z',
    }

    const mockDatasetsResponse: PaginatedDatasetReadListApi = {
        results: [mockDataset1, mockDataset2],
        count: 2,
        next: null,
        previous: null,
    }

    const mockDatasetsApi = jest.mocked(datasetsApi)

    beforeEach(() => {
        jest.resetAllMocks()

        // Clear localStorage to ensure persistent state doesn't leak between tests
        window.localStorage.clear()

        // Mock lemonToast methods
        ;(lemonToast.success as jest.Mock) = jest.fn()
        ;(lemonToast.error as jest.Mock) = jest.fn()

        mockDatasetsApi.listDatasets.mockResolvedValue(mockDatasetsResponse)
        mockDatasetsApi.createItem.mockResolvedValue({} as never)
    })

    describe('getStorageKey', () => {
        it('serializes a key with search term', () => {
            const key = getStorageKey('test search')
            expect(key).toBe('limit=100&offset=0&search=test%20search')
        })

        it('serializes a key with empty search', () => {
            const key = getStorageKey('')
            expect(key).toBe('limit=100&offset=0&search=')
        })

        it('serializes a key with special characters', () => {
            const key = getStorageKey('test & special')
            expect(key).toBe('limit=100&offset=0&search=test%20%26%20special')
        })
    })

    describe('truncateRecentDatasets', () => {
        it('returns array unchanged when under limit', () => {
            const input = [mockDataset1, mockDataset2]
            const result = truncateRecentDatasets(input)
            expect(result).toEqual(input)
            expect(result).toHaveLength(2)
        })

        it('truncates array to limit when over limit', () => {
            const mockDataset3: Dataset = { ...mockDataset1, id: 'test-dataset-3', name: 'Test Dataset 3' }
            const mockDataset4: Dataset = { ...mockDataset1, id: 'test-dataset-4', name: 'Test Dataset 4' }
            const input = [mockDataset1, mockDataset2, mockDataset3, mockDataset4]
            const result = truncateRecentDatasets(input)
            expect(result).toEqual([mockDataset1, mockDataset2, mockDataset3])
            expect(result).toHaveLength(RECENT_DATASETS_LIMIT)
        })

        it('returns empty array when input is empty', () => {
            const result = truncateRecentDatasets([])
            expect(result).toEqual([])
            expect(result).toHaveLength(0)
        })

        it('returns array unchanged when exactly at limit', () => {
            const mockDataset3: Dataset = { ...mockDataset1, id: 'test-dataset-3', name: 'Test Dataset 3' }
            const input = [mockDataset1, mockDataset2, mockDataset3]
            const result = truncateRecentDatasets(input)
            expect(result).toEqual(input)
            expect(result).toHaveLength(RECENT_DATASETS_LIMIT)
        })
    })

    describe('logic tests', () => {
        beforeEach(() => {
            initKeaTests()
            // Mock router actions after Kea is initialized
            jest.spyOn(router.actions, 'push').mockImplementation(jest.fn())
        })

        describe('datasets selector', () => {
            it('returns datasets for matching search key', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // Set search form value first
                logic.actions.setSearchFormValue('search', 'test')

                // Manually populate the datasetStore with the right key
                const storageKey = getStorageKey('test')
                logic.actions.loadDatasetsSuccess({
                    ...logic.values.datasetStore,
                    [storageKey]: mockDatasetsResponse.results,
                })

                expect(logic.values.datasets).toEqual([mockDataset1, mockDataset2])
            })

            it('returns null when no datasets match search key', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setSearchFormValue('search', 'nonexistent')

                expect(logic.values.datasets).toBeNull()
            })

            it('returns datasets for empty search', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // For empty search, the default search form value is ''
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    ...logic.values.datasetStore,
                    [storageKey]: mockDatasetsResponse.results,
                })

                expect(logic.values.datasets).toEqual([mockDataset1, mockDataset2])
            })
        })

        describe('isLoadingDatasets selector', () => {
            it('returns true when datasets is null and loading', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.loadDatasets()

                expect(logic.values.isLoadingDatasets).toBe(true)
            })

            it('returns false when datasets exist', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // Load datasets with the correct storage key structure
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })

                expect(logic.values.isLoadingDatasets).toBe(false)
            })

            it('returns false when not loading even if datasets is null', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // Wait for any initial loading to complete
                await expectLogic(logic).toFinishAllListeners()

                // Now make sure datasets is populated so the selector can work properly
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })

                // isLoadingDatasets should be false when datasets exist
                expect(logic.values.isLoadingDatasets).toBe(false)

                // Clear datasets to test null case but not loading
                logic.actions.loadDatasetsSuccess({})

                // datasets should be null and still not loading
                expect(logic.values.datasets).toBeNull()
                expect(logic.values.isLoadingDatasets).toBe(false)
            })
        })

        describe('form reset conditions', () => {
            it('resets search form when modal is opened', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setSearchFormValue('search', 'test search')
                logic.actions.setIsModalOpen(true)

                expect(logic.values.searchForm.search).toBe('')
            })

            it('resets search form when dropdown is closed', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setSearchFormValue('search', 'test search')
                // Manually reset the form to simulate what would happen in the UI
                logic.actions.resetSearchForm()

                expect(logic.values.searchForm.search).toBe('')
            })

            it('resets search form after successful dataset selection', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // First set the search form value, then load datasets with matching key
                logic.actions.setSearchFormValue('search', 'test')
                const storageKey = getStorageKey('test')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })

                // Set edit mode to create so the form submission creates an item
                logic.actions.setEditMode('create')

                // Verify the form has the expected value before submission
                expect(logic.values.searchForm.search).toBe('test')

                // Test direct form reset first
                logic.actions.resetSearchForm()
                expect(logic.values.searchForm.search).toBe('')

                // Set it back to test and try the full submission flow
                logic.actions.setSearchFormValue('search', 'test')
                expect(logic.values.searchForm.search).toBe('test')

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: 'test', datasetId: 'test-dataset-1' })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                // After successful submission, the form should be reset
                expect(logic.values.searchForm.search).toBe('')
                expect(logic.values.searchForm.datasetId).toBeNull()
            })
        })

        describe('dataset item creation', () => {
            it('successfully creates dataset item in create mode', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // First set the search form value to match what will be submitted
                logic.actions.setSearchFormValue('search', '')
                // Then load datasets with the correct storage key structure
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })
                logic.actions.setEditMode('create')

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: 'test', datasetId: 'test-dataset-1' })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                expect(mockDatasetsApi.createItem).toHaveBeenCalledWith({
                    dataset: 'test-dataset-1',
                    client_item_id: mockPartialDatasetItem.client_item_id,
                    input: mockPartialDatasetItem.input,
                    expected_output: undefined,
                    source_output: mockPartialDatasetItem.source_output,
                    metadata: mockPartialDatasetItem.metadata,
                    source_trace_id: mockPartialDatasetItem.source_trace_id,
                    source_event_id: mockPartialDatasetItem.source_event_id,
                    source_timestamp: mockPartialDatasetItem.source_timestamp,
                })
                expect(lemonToast.success).toHaveBeenCalledWith('Dataset item has been created successfully', {
                    button: {
                        label: 'View',
                        action: expect.any(Function),
                    },
                })
            })

            it('shows the API detail when dataset item creation conflicts', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // First set the search form value to match what will be submitted
                logic.actions.setSearchFormValue('search', '')
                // Then load datasets with the correct storage key structure
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })
                logic.actions.setEditMode('create')
                mockDatasetsApi.createItem.mockRejectedValue(
                    new ApiError(undefined, 409, undefined, {
                        detail: 'Restore this dataset before adding items.',
                        code: 'dataset_archived',
                    })
                )

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: '', datasetId: 'test-dataset-1' })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                expect(lemonToast.error).toHaveBeenCalledWith('Restore this dataset before adding items.')
            })

            it('opens modal in edit mode without creating item', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // First set the search form value to match what will be submitted
                logic.actions.setSearchFormValue('search', '')
                // Then load datasets with the correct storage key structure
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })
                logic.actions.setEditMode('edit')

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: '', datasetId: 'test-dataset-1' })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                expect(mockDatasetsApi.createItem).not.toHaveBeenCalled()
                expect(logic.values.selectedDataset).toEqual(mockDataset1)
                expect(logic.values.isModalOpen).toBe(true)
            })

            it('does nothing when dataset is not found', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // First set the search form value to match what will be submitted
                logic.actions.setSearchFormValue('search', '')
                // Then load datasets with the correct storage key structure
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: '', datasetId: 'nonexistent-dataset' })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                expect(mockDatasetsApi.createItem).not.toHaveBeenCalled()
                expect(logic.values.selectedDataset).toBeNull()
                expect(logic.values.isModalOpen).toBe(false)
            })

            it('loads datasets when no datasetId is provided', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: 'test', datasetId: null })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                    limit: DATASETS_PER_PAGE,
                    offset: 0,
                    search: 'test',
                })
            })

            it('navigates to dataset page after successful creation', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                // First set the search form value to match what will be submitted
                logic.actions.setSearchFormValue('search', '')
                // Then load datasets with the correct storage key structure
                const storageKey = getStorageKey('')
                logic.actions.loadDatasetsSuccess({
                    [storageKey]: mockDatasetsResponse.results,
                })
                logic.actions.setEditMode('create')

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValues({ search: '', datasetId: 'test-dataset-1' })
                    logic.actions.submitSearchForm()
                }).toFinishAllListeners()

                const successCall = (lemonToast.success as jest.Mock).mock.calls[0]
                const viewAction = successCall[1].button.action

                viewAction()

                expect(router.actions.push).toHaveBeenCalledWith(
                    '/ai-evals/evaluations/offline/datasets/test-dataset-1'
                )
            })
        })

        describe('data loading', () => {
            it('loads datasets on mount if none exist', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                await expectLogic(logic).toFinishAllListeners()

                expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                    limit: DATASETS_PER_PAGE,
                    offset: 0,
                })
            })

            it('does not load datasets on mount if they already exist', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.loadDatasetsSuccess({
                    [getStorageKey('')]: mockDatasetsResponse.results,
                })
                logic.unmount()
                mockDatasetsApi.listDatasets.mockClear()

                logic.mount()

                expect(mockDatasetsApi.listDatasets).toHaveBeenCalledTimes(1)
            })

            it('loads datasets when search form value changes', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                await expectLogic(logic, () => {
                    logic.actions.setSearchFormValue('search', 'new search')
                }).toFinishAllListeners()

                expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                    limit: DATASETS_PER_PAGE,
                    offset: 0,
                    search: 'new search',
                })
            })

            it('loads datasets when dropdown becomes visible', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()
                mockDatasetsApi.listDatasets.mockClear()

                await expectLogic(logic, () => {
                    logic.actions.setDropdownVisible(true)
                }).toFinishAllListeners()

                expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                    limit: DATASETS_PER_PAGE,
                    offset: 0,
                })
            })

            it('drops an in-flight load that resolves after unmount', async () => {
                const captureException = jest.spyOn(posthog, 'captureException').mockImplementation(() => undefined)
                let resolveListDatasets: (response: PaginatedDatasetReadListApi) => void = () => {}
                mockDatasetsApi.listDatasets.mockReturnValue(
                    new Promise((resolve) => {
                        resolveListDatasets = resolve
                    })
                )

                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()
                logic.unmount()

                resolveListDatasets(mockDatasetsResponse)
                await new Promise((resolve) => setTimeout(resolve, 0))

                expect(captureException).not.toHaveBeenCalled()
                captureException.mockRestore()
            })

            it('uses debounce when loading datasets', async () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                await expectLogic(logic, () => {
                    logic.actions.loadDatasets(true)
                }).toFinishAllListeners()

                expect(mockDatasetsApi.listDatasets).toHaveBeenCalled()
            })
        })

        describe('state management', () => {
            it('sets modal open state', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setIsModalOpen(true)
                expect(logic.values.isModalOpen).toBe(true)

                logic.actions.setIsModalOpen(false)
                expect(logic.values.isModalOpen).toBe(false)
            })

            it('sets edit mode', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setEditMode('edit')
                expect(logic.values.editMode).toBe('edit')

                logic.actions.setEditMode('create')
                expect(logic.values.editMode).toBe('create')
            })

            it('resets edit mode to create when modal is closed', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setEditMode('edit')
                logic.actions.setIsModalOpen(false)

                expect(logic.values.editMode).toBe('create')
            })

            it('sets dropdown visibility', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setDropdownVisible(true)
                expect(logic.values.dropdownVisible).toBe(true)

                logic.actions.setDropdownVisible(false)
                expect(logic.values.dropdownVisible).toBe(false)
            })

            it('sets selected dataset', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                logic.actions.setSelectedDataset(mockDataset1)
                expect(logic.values.selectedDataset).toEqual(mockDataset1)

                logic.actions.setSelectedDataset(null)
                expect(logic.values.selectedDataset).toBeNull()
            })

            it('computes isModalMounted based on edit mode', () => {
                const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                logic.mount()

                expect(logic.values.isModalMounted).toBe(false)

                logic.actions.setEditMode('edit')
                expect(logic.values.isModalMounted).toBe(true)

                logic.actions.setEditMode('create')
                expect(logic.values.isModalMounted).toBe(false)
            })
        })

        describe('recent datasets functionality', () => {
            describe('recent dataset IDs state management', () => {
                it('initializes with empty recent dataset IDs', () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    expect(logic.values.recentDatasetIds).toEqual([])
                })

                it('sets recent dataset IDs and truncates to limit', () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    const ids = ['id1', 'id2', 'id3', 'id4', 'id5']
                    logic.actions.setRecentDatasetIds(ids)

                    expect(logic.values.recentDatasetIds).toEqual(['id1', 'id2', 'id3'])
                    expect(logic.values.recentDatasetIds).toHaveLength(RECENT_DATASETS_LIMIT)
                })

                it('preserves order when setting recent dataset IDs', () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    const ids = ['newest', 'middle', 'oldest']
                    logic.actions.setRecentDatasetIds(ids)

                    expect(logic.values.recentDatasetIds).toEqual(['newest', 'middle', 'oldest'])
                })
            })

            describe('recent datasets state management', () => {
                it('initializes with empty recent datasets', () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    expect(logic.values.recentDatasets).toEqual([])
                })

                it('sets recent datasets and truncates to limit', () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    const mockDataset3: Dataset = { ...mockDataset1, id: 'test-dataset-3', name: 'Test Dataset 3' }
                    const mockDataset4: Dataset = { ...mockDataset1, id: 'test-dataset-4', name: 'Test Dataset 4' }
                    const datasets = [mockDataset1, mockDataset2, mockDataset3, mockDataset4]

                    logic.actions.setRecentDatasets(datasets)

                    expect(logic.values.recentDatasets).toEqual([mockDataset1, mockDataset2, mockDataset3])
                    expect(logic.values.recentDatasets).toHaveLength(RECENT_DATASETS_LIMIT)
                })

                it('preserves order when setting recent datasets', () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    const datasets = [mockDataset2, mockDataset1]
                    logic.actions.setRecentDatasets(datasets)

                    expect(logic.values.recentDatasets).toEqual([mockDataset2, mockDataset1])
                })
            })

            describe('recent datasets loading', () => {
                it('loads recent datasets by ID', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    logic.actions.setRecentDatasetIds(['test-dataset-1', 'test-dataset-2'])

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                        id__in: ['test-dataset-1', 'test-dataset-2'],
                        limit: RECENT_DATASETS_LIMIT,
                        offset: 0,
                    })
                })

                it('returns empty array when no recent dataset IDs exist', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Ensure recentDatasetIds is empty first
                    expect(logic.values.recentDatasetIds).toEqual([])

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasets).toEqual([])
                    expect(mockDatasetsApi.listDatasets).not.toHaveBeenCalledWith(
                        expect.objectContaining({ id__in: expect.anything() })
                    )
                })

                it('handles missing datasets by updating recent dataset IDs', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    logic.actions.setRecentDatasetIds(['test-dataset-1', 'missing-dataset', 'test-dataset-2'])

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual(['test-dataset-1', 'test-dataset-2'])
                    expect(logic.values.recentDatasets).toEqual([mockDataset1, mockDataset2])
                })

                it('preserves original order of recent dataset IDs when loading', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    logic.actions.setRecentDatasetIds(['test-dataset-2', 'test-dataset-1'])

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasets).toEqual([mockDataset2, mockDataset1])
                })

                it('excludes archived datasets and removes them from recents', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    logic.actions.setRecentDatasetIds(['test-dataset-1', 'test-dataset-2'])
                    mockDatasetsApi.listDatasets.mockResolvedValue({
                        ...mockDatasetsResponse,
                        results: [mockDataset1, { ...mockDataset2, archived: true }],
                    })

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual(['test-dataset-1'])
                    expect(logic.values.recentDatasets).toEqual([mockDataset1])
                })

                it('keeps recent dataset IDs when loading fails', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    logic.actions.setRecentDatasetIds(['test-dataset-1'])
                    mockDatasetsApi.listDatasets.mockRejectedValue(new Error('API Error'))

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual(['test-dataset-1'])
                    expect(logic.values.recentDatasets).toEqual([])
                })

                it('uses debounce when loading recent datasets', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    logic.actions.setRecentDatasetIds(['test-dataset-1'])

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets(true)
                    }).toFinishAllListeners()

                    expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                        id__in: ['test-dataset-1'],
                        limit: RECENT_DATASETS_LIMIT,
                        offset: 0,
                    })
                })

                it('loads recent datasets on mount when recent dataset IDs exist', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Set up recent dataset IDs and verify they're loaded when loadRecentDatasets is called
                    logic.actions.setRecentDatasetIds(['test-dataset-1'])

                    mockDatasetsApi.listDatasets.mockClear()

                    await expectLogic(logic, () => {
                        logic.actions.loadRecentDatasets()
                    }).toFinishAllListeners()

                    expect(mockDatasetsApi.listDatasets).toHaveBeenCalledWith({
                        id__in: ['test-dataset-1'],
                        limit: RECENT_DATASETS_LIMIT,
                        offset: 0,
                    })
                })
            })

            describe('adding to recent datasets', () => {
                it('adds dataset to recent when dataset ID is selected and not already recent', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Ensure clean state
                    expect(logic.values.recentDatasetIds).toEqual([])
                    expect(logic.values.recentDatasets).toEqual([])

                    // Load datasets first
                    const storageKey = getStorageKey('')
                    logic.actions.loadDatasetsSuccess({
                        [storageKey]: [mockDataset1, mockDataset2],
                    })

                    await expectLogic(logic, () => {
                        logic.actions.setSearchFormValue('datasetId', 'test-dataset-1')
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual(['test-dataset-1'])
                })

                it('does not add dataset to recent when dataset ID is already in recent', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Ensure clean state first
                    expect(logic.values.recentDatasetIds).toEqual([])
                    expect(logic.values.recentDatasets).toEqual([])

                    // Set up existing recent datasets
                    logic.actions.setRecentDatasetIds(['test-dataset-1'])
                    logic.actions.setRecentDatasets([mockDataset1])

                    // Load datasets
                    const storageKey = getStorageKey('')
                    logic.actions.loadDatasetsSuccess({
                        [storageKey]: [mockDataset1, mockDataset2],
                    })

                    await expectLogic(logic, () => {
                        logic.actions.setSearchFormValue('datasetId', 'test-dataset-1')
                    }).toFinishAllListeners()

                    // Should remain unchanged
                    expect(logic.values.recentDatasetIds).toEqual(['test-dataset-1'])
                })

                it('adds new dataset to front of recent lists', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Ensure clean state first
                    expect(logic.values.recentDatasetIds).toEqual([])
                    expect(logic.values.recentDatasets).toEqual([])

                    // Set up existing recent datasets
                    logic.actions.setRecentDatasetIds(['test-dataset-1'])
                    logic.actions.setRecentDatasets([mockDataset1])

                    // Load datasets
                    const storageKey = getStorageKey('')
                    logic.actions.loadDatasetsSuccess({
                        [storageKey]: [mockDataset1, mockDataset2],
                    })

                    await expectLogic(logic, () => {
                        logic.actions.setSearchFormValue('datasetId', 'test-dataset-2')
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual(['test-dataset-2', 'test-dataset-1'])
                })

                it('does not add to recent when dataset is not found in datasets', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Clear any existing recent datasets
                    logic.actions.setRecentDatasetIds([])
                    logic.actions.setRecentDatasets([])

                    // Load datasets without the target dataset
                    const storageKey = getStorageKey('')
                    logic.actions.loadDatasetsSuccess({
                        [storageKey]: [mockDataset1],
                    })

                    await expectLogic(logic, () => {
                        logic.actions.setSearchFormValue('datasetId', 'nonexistent-dataset')
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual([])
                    expect(logic.values.recentDatasets).toEqual([])
                })

                it('does not add to recent when datasets is null', async () => {
                    const logic = saveToDatasetButtonLogic({ partialDatasetItem: mockPartialDatasetItem })
                    logic.mount()

                    // Clear any existing recent datasets
                    logic.actions.setRecentDatasetIds([])
                    logic.actions.setRecentDatasets([])

                    // Ensure datasets is null (don't load any datasets)
                    expect(logic.values.datasets).toBeNull()

                    await expectLogic(logic, () => {
                        logic.actions.setSearchFormValue('datasetId', 'test-dataset-1')
                    }).toFinishAllListeners()

                    expect(logic.values.recentDatasetIds).toEqual([])
                    expect(logic.values.recentDatasets).toEqual([])
                })
            })
        })
    })
})