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
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()
|
|
})
|
|
})
|
|
|