You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

172 lines
6.3 KiB

import { beforeEach, describe, expect, it, vi } from 'vitest'
import { effectScope } from 'vue'
import { createPinia, setActivePinia } from 'pinia'
import { useTask } from '../../src/renderer/src/lib/useTask'
import { useFiles } from '../../src/renderer/src/features/files/useFiles'
import { useUpdates } from '../../src/renderer/src/features/updates/useUpdates'
import { usePreferences } from '../../src/renderer/src/features/preferences/store'
import type { trpc } from '../../src/renderer/src/lib/trpc'
import type { UpdateState } from '@template/contracts/update'
import { settingsSchema } from '@template/contracts/settings'
const shared = vi.hoisted(() => ({
settings: {
changed: { subscribe: vi.fn() },
get: { query: vi.fn() },
patch: { mutate: vi.fn() }
},
theme: { changed: { subscribe: vi.fn() } }
}))
vi.mock('../../src/renderer/src/lib/trpc', () => ({ trpc: shared }))
vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
function deferred<T>() {
let resolve!: (value: T) => void
let reject!: (error: Error) => void
const promise = new Promise<T>((yes, no) => {
resolve = yes
reject = no
})
return { promise, resolve, reject }
}
const flush = async () => {
for (let i = 0; i < 8; i++) await Promise.resolve()
}
const grant = (token: string) => ({ token, name: token, kind: 'directory' as const })
describe('renderer resource ownership', () => {
beforeEach(() => {
vi.clearAllMocks()
setActivePinia(createPinia())
})
it('ignores feedback from work completing after scope disposal', async () => {
const scope = effectScope()
const task = scope.run(() => useTask())!
const action = deferred<void>()
const pending = task.run(() => action.promise, 'saved')
scope.stop()
action.reject(new Error('late failure'))
await pending
expect(task.error.value).toBe('')
expect(task.success.value).toBe('')
expect(task.isActive()).toBe(false)
})
it('releases grants returned by dialogs after the page exits', async () => {
const dialog = deferred<ReturnType<typeof grant> | null>()
const release = vi.fn().mockResolvedValue(undefined)
const unsubscribe = vi.fn()
const client = {
files: {
changed: { subscribe: () => ({ unsubscribe }) },
choose: { mutate: () => dialog.promise },
release: { mutate: release }
}
} as unknown as typeof trpc
const scope = effectScope()
const files = scope.run(() => useFiles(client))!
const pending = files.choose('directory')
scope.stop()
dialog.resolve(grant('late'))
await pending
expect(release).toHaveBeenCalledWith('late')
expect(unsubscribe).toHaveBeenCalledOnce()
expect(files.folder.value).toBeNull()
})
it('keeps newer directory results when earlier refreshes finish later', async () => {
type Callbacks = Parameters<typeof trpc.files.changed.subscribe>[1]
let callbacks!: Callbacks
const old = deferred<{ name: string; directory: boolean }[]>()
const latest = deferred<{ name: string; directory: boolean }[]>()
const list = vi
.fn()
.mockResolvedValueOnce([])
.mockReturnValueOnce(old.promise)
.mockReturnValueOnce(latest.promise)
const client = {
files: {
changed: {
subscribe: (_: unknown, value: Callbacks) => {
callbacks = value
return { unsubscribe: vi.fn() }
}
},
choose: { mutate: async () => grant('folder') },
list: { query: list },
watch: { mutate: vi.fn().mockResolvedValue(undefined) },
release: { mutate: vi.fn().mockResolvedValue(undefined) }
}
} as unknown as typeof trpc
const scope = effectScope()
const files = scope.run(() => useFiles(client))!
await files.choose('directory')
callbacks.onData?.({ token: 'folder', event: 'change', name: 'first' })
callbacks.onData?.({ token: 'folder', event: 'change', name: 'second' })
latest.resolve([{ name: 'new', directory: false }])
await flush()
old.resolve([{ name: 'old', directory: false }])
await flush()
expect(files.entries.value[0]?.name).toBe('new')
scope.stop()
})
it('waits for the update stream and does not overwrite streamed status with an old snapshot', async () => {
type Callbacks = Parameters<typeof trpc.update.changed.subscribe>[1]
let callbacks!: Callbacks
const initial = deferred<UpdateState>()
const query = vi.fn(() => initial.promise)
const unsubscribe = vi.fn()
const client = {
update: {
changed: {
subscribe: (_: unknown, value: Callbacks) => {
callbacks = value
return { unsubscribe }
}
},
status: { query }
}
} as unknown as typeof trpc
const scope = effectScope()
const updates = scope.run(() => useUpdates(client))!
expect(query).not.toHaveBeenCalled()
callbacks.onStarted?.({ context: undefined })
await flush()
callbacks.onData?.({ status: 'available', version: '2.0.0' })
initial.resolve({ status: 'idle' })
await flush()
expect(updates.update.value.status).toBe('available')
scope.stop()
expect(unsubscribe).toHaveBeenCalledOnce()
})
it('does not let a mutation response overwrite a newer preference event', async () => {
type Callbacks = Parameters<typeof trpc.settings.changed.subscribe>[1]
let callbacks!: Callbacks
shared.settings.changed.subscribe.mockImplementation((_: unknown, value: Callbacks) => {
callbacks = value
value.onStarted?.({ context: undefined })
return { unsubscribe: vi.fn() }
})
shared.theme.changed.subscribe.mockImplementation(
(_: unknown, value: { onStarted: () => void }) => {
value.onStarted()
return { unsubscribe: vi.fn() }
}
)
const original = settingsSchema.parse({})
shared.settings.get.query.mockResolvedValue(original)
const response = deferred<typeof original>()
shared.settings.patch.mutate.mockReturnValue(response.promise)
const preferences = usePreferences()
await preferences.init()
const patch = preferences.patch({ theme: 'dark' })
callbacks.onData?.({ ...original, theme: 'dark', language: 'en' })
response.resolve({ ...original, theme: 'dark' })
await patch
expect(preferences.settings?.language).toBe('en')
preferences.dispose()
})
})