Skip to content

Edge-Drop is a clipboard shelf on the edge of your screen. Hover to open it. Drag files and images into any app, click to copy text and links. Free and open-source for Windows.

6.6 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { tmpdir } from 'node:os'

const fsRoots = vi.hoisted(() => ({
  home: '',
  userData: ''
}))

vi.mock('electron', () => ({
  app: {
    isPackaged: false,
    getAppPath: () => join(fsRoots.userData, 'app'),
    getPath: (name: string) => (name === 'userData' ? fsRoots.userData : join(fsRoots.userData, name))
  },
  nativeImage: {
    createFromPath: () => ({ isEmpty: () => true })
  },
  safeStorage: {
    isEncryptionAvailable: () => false
  }
}))

vi.mock('node:os', async (importOriginal) => {
  const actual = await importOriginal<typeof import('node:os')>()
  return {
    ...actual,
    homedir: () => fsRoots.home
  }
})

import { ItemStore } from '../electron/store/ItemStore'
import type { ClipboardItem, ItemData } from '../shared/types'

function textData(t: string): ItemData {
  return { kind: 'text', text: t, isUrl: false }
}

describe('ItemStore removal hooks (staged-temp lifecycle wiring)', () => {
  beforeEach(() => {
    fsRoots.userData = join(tmpdir(), `ed-store-ud-${Date.now()}-${Math.random().toString(16).slice(2)}`)
    fsRoots.home = join(tmpdir(), `ed-store-home-${Date.now()}-${Math.random().toString(16).slice(2)}`)
    mkdirSync(fsRoots.userData, { recursive: true })
    mkdirSync(fsRoots.home, { recursive: true })
  })

  afterEach(() => {
    try { rmSync(fsRoots.userData, { recursive: true, force: true }) } catch { /* ignore */ }
    try { rmSync(fsRoots.home, { recursive: true, force: true }) } catch { /* ignore */ }
  })

  function makeStore(): { store: ItemStore; removed: ClipboardItem[][] } {
    const removed: ClipboardItem[][] = []
    const store = new ItemStore((batch) => removed.push([...batch]))
    return { store, removed }
  }

  it('notifies with the removed item on delete()', () => {
    const { store, removed } = makeStore()
    store.add(textData('alpha'), 10)
    const id = store.list()[0].id

    store.delete(id)

    expect(removed).toHaveLength(1)
    expect(removed[0]).toHaveLength(1)
    expect(removed[0][0].id).toBe(id)
  })

  it('notifies once per batch on deleteBatch()', () => {
    const { store, removed } = makeStore()
    store.add(textData('one'), 10)
    store.add(textData('two'), 10)
    const ids = store.list().map((i) => i.id)

    store.deleteBatch(ids)

    expect(removed).toHaveLength(1)
    expect(removed[0].map((r) => r.id).sort()).toEqual([...ids].sort())
  })

  it('clearUnpinned() notifies with every unpinned item and spares pinned ones', () => {
    const { store, removed } = makeStore()
    store.add(textData('pinned-keeper'), 10)
    store.setPinned(store.list()[0].id, true)
    store.add(textData('recent-a'), 10)
    store.add(textData('recent-b'), 10)

    store.clearUnpinned()

    const flat = removed.flat()
    expect(flat).toHaveLength(2)
    expect(flat.every((r) => r.data.kind === 'text' && r.data.text !== 'pinned-keeper')).toBe(true)
    expect(store.list()).toHaveLength(1)
  })

  it('pruneExpired() notifies only with expired items', () => {
    const { store, removed } = makeStore()
    store.add(textData('old-item'), 10)
    const oldId = store.list()[0].id
    // Backdate past the cutoff.
    ;(store.list()[0] as { capturedAt: number }).capturedAt = Date.now() - 2 * 3600 * 1000
    store.add(textData('fresh-item'), 10)

    const changed = store.pruneExpired(1)

    expect(changed).toBe(true)
    expect(removed).toHaveLength(1)
    expect(removed[0]).toHaveLength(1)
    expect(removed[0][0].id).toBe(oldId)
    expect(store.list()).toHaveLength(1)
  })

  it('silent capacity eviction (trim) notifies with the evicted oldest unpinned item', () => {
    const { store, removed } = makeStore()
    store.add(textData('first'), 2)
    const firstId = store.list()[store.list().length - 1].id
    store.add(textData('second'), 2)
    store.add(textData('third'), 2)

    expect(store.list()).toHaveLength(2)
    expect(removed).toHaveLength(1)
    expect(removed[0]).toHaveLength(1)
    expect(removed[0][0].id).toBe(firstId)
  })

  it('merge() transfers ownership without firing removal hooks', () => {
    const { store, removed } = makeStore()
    store.add(textData('src'), 10)
    store.add(textData('tgt'), 10)
    const ids = store.list().map((i) => i.id)

    const result = store.merge(ids[1], ids[0])

    expect(result.ok).toBe(false) // text items cannot merge — no ownership change
    expect(removed).toHaveLength(0)
  })
})

describe('ItemStore image recovery (no silent low-res fallback)', () => {
  beforeEach(() => {
    fsRoots.userData = join(tmpdir(), `ed-recov-ud-${Date.now()}-${Math.random().toString(16).slice(2)}`)
    fsRoots.home = join(tmpdir(), `ed-recov-home-${Date.now()}-${Math.random().toString(16).slice(2)}`)
    mkdirSync(join(fsRoots.userData, 'images'), { recursive: true })
    mkdirSync(fsRoots.home, { recursive: true })
  })

  afterEach(() => {
    try { rmSync(fsRoots.userData, { recursive: true, force: true }) } catch { /* ignore */ }
    try { rmSync(fsRoots.home, { recursive: true, force: true }) } catch { /* ignore */ }
  })

  function newStore(): ItemStore {
    return new ItemStore()
  }

  it('resolves the exact extension path when present', () => {
    const p = join(fsRoots.userData, 'images', 'img1.png')
    writeFileSync(p, 'png')
    expect(newStore().resolveStoredImagePath('img1', 'png')).toBe(p)
  })

  it('recovers via directory scan when the recorded extension no longer matches', () => {
    const jpgPath = join(fsRoots.userData, 'images', 'img2.jpg')
    writeFileSync(jpgPath, 'jpeg-bytes')
    expect(newStore().resolveStoredImagePath('img2', 'png')).toBe(jpgPath)
  })

  it('returns null when the image is genuinely unrecoverable', () => {
    expect(newStore().resolveStoredImagePath('missing', 'png')).toBe(null)
    expect(newStore().resolveStoredImagePath('', 'png')).toBe(null)
  })

  it('hasRecoverableCollectionImage() requires at least one surviving image', () => {
    const store = newStore()
    writeFileSync(join(fsRoots.userData, 'images', 'alive.png'), 'a')

    expect(store.hasRecoverableCollectionImage([{ imageId: 'alive', ext: 'png' }, { imageId: 'dead', ext: 'png' }])).toBe(true)
    expect(store.hasRecoverableCollectionImage([{ imageId: 'dead', ext: 'png' }])).toBe(false)
  })

  it('reports missing files as unrecoverable after they are deleted from disk', () => {
    const store = newStore()
    const p = join(fsRoots.userData, 'images', 'vanishing.png')
    writeFileSync(p, 'b')
    expect(store.resolveStoredImagePath('vanishing', 'png')).toBe(p)
    existsSync(p) && rmSync(p)
    expect(store.resolveStoredImagePath('vanishing', 'png')).toBe(null)
  })
})