Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

26.6 KB
Raw Blame
import fs from 'fs/promises'
import path from 'path'
import { afterEach, describe, expect, it, vi } from 'vitest'

import { generateDeterministicUuid } from './snippets.browser'
import {
  createFolder,
  deleteFolder,
  deleteSnippet,
  getFilesystemEntries,
  getFolders,
  getSnippet,
  getSnippets,
  saveSnippet,
  updateSnippet,
  type Snippet,
} from './snippets.utils'

// Mock fs/promises — explicit factory required since Vitest 4 automocking
// doesn't create mock functions for getter-based exports on Node built-ins.
vi.mock('fs/promises', () => ({
  default: {
    access: vi.fn(),
    mkdir: vi.fn(),
    readdir: vi.fn(),
    readFile: vi.fn(),
    writeFile: vi.fn(),
    unlink: vi.fn(),
    rm: vi.fn(),
    stat: vi.fn(),
  },
}))
const mockedFS = vi.mocked(fs)

vi.mock('./snippets.constants', () => ({
  SNIPPETS_DIR: '/mock/snippets/dir',
}))

const MOCK_SNIPPETS_DIR = '/mock/snippets/dir'
const DEFAULT_BIRTHTIME = new Date('2023-01-01')

const file = (name: string) => ({ name, isDirectory: () => false, isFile: () => true })
const dir = (name: string) => ({ name, isDirectory: () => true, isFile: () => false })
type Dirent = ReturnType<typeof file>

/**
 * Mocks an existing snippets directory. `root` lists entries at the top level, `folders` maps
 * folder names to their entries. File contents default to `content` unless `contents` has an
 * entry for the file name.
 */
function mockTree({
  root,
  folders = {},
  content = 'SELECT 1;',
  contents = {},
}: {
  root: Dirent[]
  folders?: Record<string, Dirent[]>
  content?: string
  contents?: Record<string, string>
}) {
  mockedFS.access.mockResolvedValue(undefined)
  mockedFS.readdir.mockImplementation(((dirPath: string) => {
    if (dirPath === MOCK_SNIPPETS_DIR) return Promise.resolve(root)
    const folderName = path.relative(MOCK_SNIPPETS_DIR, dirPath)
    return Promise.resolve(folders[folderName] ?? [])
  }) as never)
  mockedFS.readFile.mockImplementation(((filePath: string) =>
    Promise.resolve(contents[path.basename(filePath)] ?? content)) as never)
  mockedFS.stat.mockResolvedValue({ birthtime: DEFAULT_BIRTHTIME } as never)
}

const makeSnippet = (overrides: Partial<Snippet>): Snippet => ({
  id: 'test-id',
  inserted_at: '2023-01-01T00:00:00.000Z',
  updated_at: '2023-01-01T00:00:00.000Z',
  type: 'sql',
  name: 'test-snippet',
  description: '',
  favorite: false,
  content: { sql: 'SELECT * FROM test;', content_id: 'content-id', schema_version: '1.0' },
  visibility: 'user',
  project_id: 1,
  folder_id: null,
  owner_id: 1,
  owner: { id: 1, username: 'testuser' },
  updated_by: { id: 1, username: 'testuser' },
  ...overrides,
})

const errnoError = (message: string, code: string) =>
  Object.assign(new Error(message), { code }) satisfies NodeJS.ErrnoException

const UNSAFE_NAMES = [
  ['../ traversal', '../malicious'],
  ['nested directories', 'foo/bar/malicious'],
  ['null bytes', 'malicious\0name'],
  ['absolute path', '/etc/passwd'],
]

describe('snippets.utils', () => {
  afterEach(() => {
    vi.resetAllMocks()
  })

  describe('getFilesystemEntries', () => {
    it('should create the snippets directory if it does not exist', async () => {
      mockedFS.access.mockRejectedValue(new Error('Directory not found'))
      mockedFS.mkdir.mockResolvedValue(undefined)
      mockedFS.readdir.mockResolvedValue([])

      await getFilesystemEntries()

      expect(mockedFS.mkdir).toHaveBeenCalledWith(MOCK_SNIPPETS_DIR, { recursive: true })
    })

    it('should read SQL files from the root and from folders, ignoring non-SQL files', async () => {
      mockTree({
        root: [file('root-snippet.sql'), dir('folder1'), file('not-sql.txt')],
        folders: { folder1: [file('folder1-snippet.sql')] },
        contents: {
          'root-snippet.sql': 'SELECT * FROM root;',
          'folder1-snippet.sql': 'SELECT * FROM folder1_table;',
        },
      })

      const entries = await getFilesystemEntries()

      expect(entries).toHaveLength(3)
      expect(entries).toContainEqual(
        expect.objectContaining({ type: 'folder', name: 'folder1', folderId: null })
      )
      expect(entries).toContainEqual(
        expect.objectContaining({
          type: 'file',
          name: 'root-snippet',
          content: 'SELECT * FROM root;',
          folderId: null,
        })
      )
      expect(entries).toContainEqual(
        expect.objectContaining({
          type: 'file',
          name: 'folder1-snippet',
          content: 'SELECT * FROM folder1_table;',
          folderId: generateDeterministicUuid(['folder1']),
        })
      )
    })

    it('should skip subdirectories inside folders (not supported)', async () => {
      mockTree({
        root: [dir('folder1')],
        folders: { folder1: [file('snippet.sql'), dir('subfolder')] },
      })

      const entries = await getFilesystemEntries()

      expect(entries.map((e) => e.type).sort()).toEqual(['file', 'folder'])
    })

    it('should handle empty SQL files', async () => {
      mockTree({ root: [file('empty.sql')], content: '' })

      const entries = await getFilesystemEntries()

      expect(entries).toHaveLength(1)
      expect(entries[0].content).toBe('')
    })

    it('should propagate file read errors', async () => {
      mockTree({ root: [file('error.sql')] })
      mockedFS.readFile.mockRejectedValue(new Error('Permission denied'))

      await expect(getFilesystemEntries()).rejects.toThrow('Permission denied')
    })

    it('should propagate mkdir failure', async () => {
      mockedFS.access.mockRejectedValue(new Error('Directory not found'))
      mockedFS.mkdir.mockRejectedValue(new Error('Permission denied'))

      await expect(getFilesystemEntries()).rejects.toThrow('Permission denied')
    })

    it('should skip reading file content when includeContent is false', async () => {
      mockTree({ root: [file('snippet1.sql'), file('snippet2.sql')] })

      const entries = await getFilesystemEntries({ includeContent: false })

      expect(entries).toHaveLength(2)
      expect(entries.every((f) => f.content === undefined)).toBe(true)
      // Listings should never touch file contents off disk.
      expect(mockedFS.readFile).not.toHaveBeenCalled()
    })
  })

  describe('getSnippet', () => {
    it('should get a specific snippet by id', async () => {
      mockTree({ root: [file('test-snippet.sql')], content: 'SELECT * FROM test;' })

      const snippet = await getSnippet(generateDeterministicUuid(['test-snippet.sql']))

      expect(snippet).toMatchObject({
        name: 'test-snippet',
        content: { sql: 'SELECT * FROM test;' },
        folder_id: null,
      })
    })

    it('should get a snippet from a folder', async () => {
      const folderId = generateDeterministicUuid(['my-folder'])
      mockTree({
        root: [dir('my-folder')],
        folders: { 'my-folder': [file('folder-snippet.sql')] },
        content: 'SELECT * FROM folder_table;',
      })

      const snippet = await getSnippet(generateDeterministicUuid([folderId, 'folder-snippet.sql']))

      expect(snippet).toMatchObject({
        name: 'folder-snippet',
        content: { sql: 'SELECT * FROM folder_table;' },
        folder_id: folderId,
      })
    })

    it('should throw error when snippet not found', async () => {
      mockTree({ root: [] })

      await expect(getSnippet('non-existent-id')).rejects.toThrow(
        'Snippet with id non-existent-id not found'
      )
    })
  })

  describe('getSnippets', () => {
    it('should get only root snippets when folderId is null', async () => {
      mockTree({
        root: [file('snippet1.sql'), file('snippet2.sql'), dir('folder1')],
        folders: { folder1: [file('nested.sql')] },
      })

      const result = await getSnippets({ folderId: null, sort: 'name', sortOrder: 'asc' })

      expect(result.snippets.map((s) => s.name)).toEqual(['snippet1', 'snippet2'])
      expect(result.snippets.every((s) => s.folder_id === null)).toBe(true)
      expect(result.cursor).toBeUndefined()
    })

    it('should get snippets from a specific folder', async () => {
      const folderId = generateDeterministicUuid(['my-folder'])
      mockTree({
        root: [file('root-snippet.sql'), dir('my-folder')],
        folders: { 'my-folder': [file('folder-snippet.sql')] },
      })

      const result = await getSnippets({ folderId })

      expect(result.snippets).toHaveLength(1)
      expect(result.snippets[0]).toMatchObject({ name: 'folder-snippet', folder_id: folderId })
    })

    it('should return empty result when no snippets in folder', async () => {
      mockTree({ root: [] })

      const result = await getSnippets({ folderId: generateDeterministicUuid(['empty-folder']) })

      expect(result.snippets).toEqual([])
      expect(result.cursor).toBeUndefined()
    })

    it('should filter by search term case-insensitively across all folders', async () => {
      mockTree({
        root: [
          file('USER-query.sql'),
          file('admin-report.sql'),
          file('Test-User-Data.sql'),
          dir('my-folder'),
        ],
        folders: { 'my-folder': [file('user-permissions.sql')] },
      })

      const result = await getSnippets({ searchTerm: 'user', sort: 'name', sortOrder: 'asc' })

      expect(result.snippets.map((s) => s.name)).toEqual([
        'Test-User-Data',
        'user-permissions',
        'USER-query',
      ])
    })

    it('should ignore a whitespace-only search term and filter by folderId', async () => {
      const folderId = generateDeterministicUuid(['my-folder'])
      mockTree({
        root: [file('root-snippet.sql'), dir('my-folder')],
        folders: { 'my-folder': [file('folder-snippet.sql')] },
      })

      const result = await getSnippets({ searchTerm: '   ', folderId })

      expect(result.snippets.map((s) => s.name)).toEqual(['folder-snippet'])
    })

    it.each([
      ['asc', ['Apple', 'banana', 'zebra']],
      ['desc', ['zebra', 'banana', 'Apple']],
    ] as const)('should sort by name case-insensitively (%s)', async (sortOrder, expected) => {
      mockTree({ root: [file('zebra.sql'), file('Apple.sql'), file('banana.sql')] })

      const result = await getSnippets({ sort: 'name', sortOrder })

      expect(result.snippets.map((s) => s.name)).toEqual(expected)
    })

    it('should sort snippets by creation date', async () => {
      mockTree({ root: [file('newest.sql'), file('oldest.sql'), file('middle.sql')] })
      const birthtimes: Record<string, string> = {
        'newest.sql': '2023-03-01',
        'oldest.sql': '2023-01-01',
        'middle.sql': '2023-02-01',
      }
      mockedFS.stat.mockImplementation(((filePath: string) =>
        Promise.resolve({ birthtime: new Date(birthtimes[path.basename(filePath)]) })) as never)

      const resultDesc = await getSnippets({ sort: 'inserted_at', sortOrder: 'desc' })
      expect(resultDesc.snippets.map((s) => s.name)).toEqual(['newest', 'middle', 'oldest'])

      const resultAsc = await getSnippets({ sort: 'inserted_at', sortOrder: 'asc' })
      expect(resultAsc.snippets.map((s) => s.name)).toEqual(['oldest', 'middle', 'newest'])
    })

    it('should paginate with limit and cursor', async () => {
      mockTree({ root: [file('snippet1.sql'), file('snippet2.sql'), file('snippet3.sql')] })

      const firstPage = await getSnippets({ limit: 2, sort: 'name', sortOrder: 'asc' })
      expect(firstPage.snippets.map((s) => s.name)).toEqual(['snippet1', 'snippet2'])
      expect(firstPage.cursor).toBeDefined()

      const secondPage = await getSnippets({
        cursor: firstPage.cursor,
        limit: 2,
        sort: 'name',
        sortOrder: 'asc',
      })
      expect(secondPage.snippets.map((s) => s.name)).toEqual(['snippet3'])
    })

    it('should ignore an invalid cursor', async () => {
      mockTree({ root: [file('snippet1.sql')] })

      const result = await getSnippets({ cursor: 'invalid-cursor-id' })

      expect(result.snippets.map((s) => s.name)).toEqual(['snippet1'])
    })

    it('should propagate filesystem errors', async () => {
      mockedFS.access.mockRejectedValue(new Error('Directory not accessible'))
      mockedFS.mkdir.mockRejectedValue(new Error('Directory not accessible'))

      await expect(getSnippets({})).rejects.toThrow('Directory not accessible')
    })

    it('should return correct snippet structure', async () => {
      mockTree({ root: [file('test-snippet.sql')], content: 'SELECT * FROM users;' })
      mockedFS.stat.mockResolvedValue({ birthtime: new Date('2023-01-01T10:00:00Z') } as never)

      const result = await getSnippets({})

      expect(result.snippets).toHaveLength(1)
      expect(result.snippets[0]).toMatchObject({
        id: expect.any(String),
        name: 'test-snippet',
        type: 'sql',
        content: { sql: 'SELECT * FROM users;', schema_version: '1.0' },
        visibility: 'user',
        folder_id: null,
        inserted_at: '2023-01-01T10:00:00.000Z',
        updated_at: '2023-01-01T10:00:00.000Z',
      })
    })

    it('should validate the limit parameter', async () => {
      await expect(getSnippets({ limit: 0 })).rejects.toThrow('Limit must be a positive number')
      await expect(getSnippets({ limit: -5 })).rejects.toThrow('Limit must be a positive number')
      await expect(getSnippets({ limit: 1001 })).rejects.toThrow('Limit cannot exceed 1000')

      mockTree({ root: [file('snippet1.sql')] })
      await expect(getSnippets({ limit: 1000 })).resolves.toMatchObject({
        snippets: [expect.objectContaining({ name: 'snippet1' })],
      })
    })

    it('should omit content but keep metadata when includeContent is false', async () => {
      mockTree({ root: [file('test-snippet.sql')] })

      const result = await getSnippets({ includeContent: false })

      expect(result.snippets).toHaveLength(1)
      const snippet = result.snippets[0]
      // Matches the Management API folder-listing contract: metadata, no SQL body.
      expect(snippet).not.toHaveProperty('content')
      expect(snippet).toMatchObject({ name: 'test-snippet', type: 'sql', folder_id: null })
      // Listing must not read file contents off disk.
      expect(mockedFS.readFile).not.toHaveBeenCalled()
    })

    it('searches by name without reading content when includeContent is false', async () => {
      mockTree({ root: [file('user-query.sql'), file('admin-report.sql')] })

      const result = await getSnippets({ searchTerm: 'user', includeContent: false })

      expect(result.snippets.map((s) => s.name)).toEqual(['user-query'])
      expect(mockedFS.readFile).not.toHaveBeenCalled()
    })
  })

  describe('saveSnippet', () => {
    it.each([
      ['regular content', 'test-snippet', 'SELECT * FROM test;'],
      ['empty content', 'empty-snippet', ''],
      ['special characters in the name', 'my-snippet_v2 (copy)', 'SELECT 1;'],
    ])('should save a snippet with %s', async (_, name, sql) => {
      mockTree({ root: [] })

      const result = await saveSnippet(
        makeSnippet({ name, content: { sql, content_id: 'c', schema_version: '1.0' } })
      )

      expect(mockedFS.writeFile).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, `${name}.sql`),
        sql,
        'utf-8'
      )
      expect(result.name).toBe(name)
      expect(result.content.sql).toBe(sql)
    })

    it('should throw error when snippet already exists', async () => {
      const snippet = makeSnippet({
        id: generateDeterministicUuid(['existing-snippet.sql']),
        name: 'existing-snippet',
      })
      mockTree({ root: [file('existing-snippet.sql')] })

      await expect(saveSnippet(snippet)).rejects.toThrow(
        `Snippet with id ${snippet.id} already exists`
      )
    })

    it('should save snippet to a folder when folder_id is provided', async () => {
      const folderId = generateDeterministicUuid(['test-folder'])
      mockTree({ root: [dir('test-folder')] })

      const result = await saveSnippet(makeSnippet({ name: 'folder-snippet', folder_id: folderId }))

      expect(mockedFS.writeFile).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'test-folder', 'folder-snippet.sql'),
        'SELECT * FROM test;',
        'utf-8'
      )
      expect(result.folder_id).toBe(folderId)
    })

    it('should throw error when folder_id is provided but folder does not exist', async () => {
      mockTree({ root: [] })

      await expect(
        saveSnippet(makeSnippet({ folder_id: 'non-existent-folder-id' }))
      ).rejects.toThrow('Folder with id non-existent-folder-id not found')
    })

    it.each(UNSAFE_NAMES)('should reject unsafe names (%s)', async (_, name) => {
      mockTree({ root: [] })

      await expect(saveSnippet(makeSnippet({ name }))).rejects.toThrow(
        'Invalid name: path traversal or null bytes detected'
      )
      expect(mockedFS.writeFile).not.toHaveBeenCalled()
    })
  })

  describe('deleteSnippet', () => {
    it('should delete a snippet file', async () => {
      mockTree({ root: [file('test-snippet.sql')] })

      await deleteSnippet(generateDeterministicUuid(['test-snippet.sql']))

      expect(mockedFS.unlink).toHaveBeenCalledWith(path.join(MOCK_SNIPPETS_DIR, 'test-snippet.sql'))
    })

    it('should delete a snippet file from a folder', async () => {
      const folderId = generateDeterministicUuid(['my-folder'])
      mockTree({
        root: [dir('my-folder')],
        folders: { 'my-folder': [file('folder-snippet.sql')] },
      })

      await deleteSnippet(generateDeterministicUuid([folderId, 'folder-snippet.sql']))

      expect(mockedFS.unlink).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'my-folder', 'folder-snippet.sql')
      )
    })

    it('should not throw when the file is already gone (ENOENT)', async () => {
      mockTree({ root: [file('test-snippet.sql')] })
      mockedFS.unlink.mockRejectedValue(errnoError('File not found', 'ENOENT'))

      await expect(
        deleteSnippet(generateDeterministicUuid(['test-snippet.sql']))
      ).resolves.toBeUndefined()
    })

    it('should throw for other filesystem errors', async () => {
      mockTree({ root: [file('test-snippet.sql')] })
      mockedFS.unlink.mockRejectedValue(errnoError('Permission denied', 'EACCES'))

      await expect(deleteSnippet(generateDeterministicUuid(['test-snippet.sql']))).rejects.toThrow(
        'Permission denied'
      )
    })

    it('should throw error when snippet not found', async () => {
      mockTree({ root: [] })

      await expect(deleteSnippet('non-existent-id')).rejects.toThrow(
        'Snippet with id non-existent-id not found'
      )
    })
  })

  describe('updateSnippet', () => {
    const id = generateDeterministicUuid(['existing-snippet.sql'])
    const targetFolderId = generateDeterministicUuid(['target-folder'])

    it('should rename and update content, removing the old file', async () => {
      mockTree({ root: [file('existing-snippet.sql')], content: 'SELECT * FROM old;' })

      const result = await updateSnippet(id, {
        name: 'updated-snippet',
        content: { sql: 'SELECT * FROM new;' },
      })

      expect(mockedFS.unlink).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'existing-snippet.sql')
      )
      expect(mockedFS.writeFile).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'updated-snippet.sql'),
        'SELECT * FROM new;',
        'utf-8'
      )
      expect(result.name).toBe('updated-snippet')
      expect(result.content.sql).toBe('SELECT * FROM new;')
    })

    it('should update only provided fields', async () => {
      mockTree({ root: [file('existing-snippet.sql')], content: 'SELECT * FROM old;' })

      const result = await updateSnippet(id, { name: 'new-name' })

      expect(result.name).toBe('new-name')
      expect(result.content.sql).toBe('SELECT * FROM old;')
    })

    it('should update content to empty string', async () => {
      mockTree({ root: [file('existing-snippet.sql')], content: 'SELECT * FROM old;' })

      const result = await updateSnippet(id, { content: { sql: '' } })

      expect(result.content.sql).toBe('')
      expect(mockedFS.writeFile).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'existing-snippet.sql'),
        '',
        'utf-8'
      )
    })

    it('should throw error when snippet not found', async () => {
      mockTree({ root: [] })

      await expect(updateSnippet('non-existent-id', {})).rejects.toThrow(
        'Snippet with id non-existent-id not found'
      )
    })

    it('should move snippet to a folder, renaming it at the same time', async () => {
      mockTree({
        root: [file('existing-snippet.sql'), dir('target-folder')],
        content: 'SELECT * FROM old;',
      })

      const result = await updateSnippet(id, {
        name: 'renamed-snippet',
        folder_id: targetFolderId,
        content: { sql: 'SELECT * FROM new;' },
      })

      expect(mockedFS.writeFile).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'target-folder', 'renamed-snippet.sql'),
        'SELECT * FROM new;',
        'utf-8'
      )
      expect(mockedFS.unlink).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'existing-snippet.sql')
      )
      expect(result).toMatchObject({ name: 'renamed-snippet', folder_id: targetFolderId })
    })

    it('should move snippet from folder to root when folder_id is set to null', async () => {
      const folderId = generateDeterministicUuid(['source-folder'])
      mockTree({
        root: [dir('source-folder')],
        folders: { 'source-folder': [file('existing-snippet.sql')] },
        content: 'SELECT * FROM folder;',
      })

      const result = await updateSnippet(
        generateDeterministicUuid([folderId, 'existing-snippet.sql']),
        { folder_id: null }
      )

      expect(mockedFS.writeFile).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'existing-snippet.sql'),
        'SELECT * FROM folder;',
        'utf-8'
      )
      expect(mockedFS.unlink).toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'source-folder', 'existing-snippet.sql')
      )
      expect(result.folder_id).toBe(null)
    })

    it('should throw error when trying to move to non-existent folder', async () => {
      mockTree({ root: [file('existing-snippet.sql')] })

      await expect(updateSnippet(id, { folder_id: 'non-existent-folder-id' })).rejects.toThrow(
        'Folder with id non-existent-folder-id not found'
      )
    })

    it('should throw when the target folder already contains a snippet with the same name', async () => {
      mockTree({
        root: [file('existing-snippet.sql'), dir('target-folder')],
        folders: { 'target-folder': [file('existing-snippet.sql')] },
      })

      await expect(updateSnippet(id, { folder_id: targetFolderId })).rejects.toThrow(
        'Snippet named "existing-snippet" already exists in the specified folder'
      )
    })

    it('should throw when old file deletion fails with an error other than ENOENT', async () => {
      mockTree({ root: [file('existing-snippet.sql')] })
      mockedFS.unlink.mockRejectedValue(errnoError('Permission denied', 'EACCES'))

      await expect(updateSnippet(id, { name: 'new-name' })).rejects.toThrow('Permission denied')
    })

    it('should continue when old file deletion fails with ENOENT', async () => {
      mockTree({ root: [file('existing-snippet.sql')], content: 'SELECT * FROM old;' })
      mockedFS.unlink.mockRejectedValue(errnoError('File not found', 'ENOENT'))

      const result = await updateSnippet(id, { name: 'new-name' })

      expect(result.name).toBe('new-name')
      expect(result.content.sql).toBe('SELECT * FROM old;')
    })
  })

  describe('getFolders', () => {
    it('should return only directories, with deterministic ids', async () => {
      mockTree({ root: [dir('folder1'), dir('folder2'), file('snippet.sql')] })

      const folders = await getFolders()

      expect(folders.map((f) => ({ id: f.id, name: f.name }))).toEqual([
        { id: generateDeterministicUuid(['folder1']), name: 'folder1' },
        { id: generateDeterministicUuid(['folder2']), name: 'folder2' },
      ])
    })

    it('should return empty array when no directories exist', async () => {
      mockTree({ root: [file('snippet.sql')] })

      expect(await getFolders()).toEqual([])
    })
  })

  describe('createFolder', () => {
    it('should create a new folder as an actual directory', async () => {
      const name = 'Folder with spaces & symbols!'
      mockTree({ root: [] })

      const result = await createFolder(name)

      expect(result.id).toBe(generateDeterministicUuid([name]))
      expect(result.name).toBe(name)
      expect(mockedFS.mkdir).toHaveBeenCalledWith(path.join(MOCK_SNIPPETS_DIR, name), {
        recursive: true,
      })
    })

    it('should throw error when folder already exists', async () => {
      mockTree({ root: [dir('Existing Folder')] })

      await expect(createFolder('Existing Folder')).rejects.toThrow(
        'Folder with name Existing Folder already exists'
      )
    })

    it('should propagate mkdir errors', async () => {
      mockTree({ root: [] })
      mockedFS.mkdir.mockRejectedValue(new Error('Permission denied'))

      await expect(createFolder('New Folder')).rejects.toThrow('Permission denied')
    })

    it.each(UNSAFE_NAMES)('should reject unsafe names (%s)', async (_, name) => {
      mockTree({ root: [] })

      await expect(createFolder(name)).rejects.toThrow(
        'Invalid name: path traversal or null bytes detected'
      )
      expect(mockedFS.mkdir).not.toHaveBeenCalled()
    })
  })

  describe('deleteFolder', () => {
    it('should delete only the targeted folder directory', async () => {
      mockTree({ root: [dir('Delete Me'), dir('Keep Me')] })

      await deleteFolder(generateDeterministicUuid(['Delete Me']))

      expect(mockedFS.rm).toHaveBeenCalledWith(path.join(MOCK_SNIPPETS_DIR, 'Delete Me'), {
        recursive: true,
        force: true,
      })
      expect(mockedFS.rm).not.toHaveBeenCalledWith(
        path.join(MOCK_SNIPPETS_DIR, 'Keep Me'),
        expect.anything()
      )
    })

    it('should throw error when folder not found', async () => {
      mockTree({ root: [] })

      await expect(deleteFolder('non-existent-folder-id')).rejects.toThrow(
        'Folder with id non-existent-folder-id not found'
      )
    })

    it('should propagate directory deletion errors', async () => {
      mockTree({ root: [dir('Test Folder')] })
      mockedFS.rm.mockRejectedValue(errnoError('Permission denied', 'EACCES'))

      await expect(deleteFolder(generateDeterministicUuid(['Test Folder']))).rejects.toThrow(
        'Permission denied'
      )
    })

    it('should report not found when the directory disappears during deletion (ENOENT)', async () => {
      const folderId = generateDeterministicUuid(['Test Folder'])
      mockTree({ root: [dir('Test Folder')] })
      mockedFS.rm.mockRejectedValue(errnoError('Directory not found', 'ENOENT'))

      await expect(deleteFolder(folderId)).rejects.toThrow(`Folder with id ${folderId} not found`)
    })
  })
})