import { expect } from '@open-wc/testing' import { DataProvider } from '../src/data-provider.js' import type { DataConsumer } from '../src/data-consumer.js' import type { FetchOption, FetchResult } from '../src/types.js' function pending() { let resolve!: (result: FetchResult) => void let reject!: (error: Error) => void const promise = new Promise((yes, no) => { resolve = yes reject = no }) return { promise, resolve, reject } } function setup() { const calls: { options: FetchOption; result: ReturnType }[] = [] const events: any[] = [] let data: any = { records: [] } let spinning = false const consumer = Object.assign(new EventTarget(), { shownMode: 'GRID' as const, get data() { return data }, set data(next) { data = next }, _data: data, checkDirties() {}, showSpinner() { spinning = true }, hideSpinner() { spinning = false }, fetchHandler(options: FetchOption) { const result = pending() calls.push({ options, result }) return result.promise } }) as DataConsumer // The grid's dirty copy follows adoption; an append must preserve its edited values. consumer.addEventListener('list-adopted', event => { const detail = (event as CustomEvent).detail events.push(detail) consumer._data = { ...detail } }) return { provider: new DataProvider(consumer), consumer, calls, events, spinning: () => spinning } } const answer = (...ids: string[]): FetchResult => ({ total: 100, records: ids.map(id => ({ id })) }) describe('query generations', () => { it('hands each read a signal that a replacement or an invalidation aborts, an append sharing its generation', async () => { const { provider, calls } = setup() void provider.fetch() const first = calls[0].options.signal! expect(first.aborted).to.equal(false) void provider.fetch() expect(first.aborted).to.equal(true) calls[1].result.resolve(answer('one')) await Promise.resolve() await Promise.resolve() void provider.attach() expect(calls[2].options.signal).to.equal(calls[1].options.signal) provider.invalidate() expect(calls[2].options.signal!.aborted).to.equal(true) }) it('never appends an old query page to a replacement', async () => { const { provider, calls, events } = setup() const initial = provider.fetch() calls[0].result.resolve(answer('old-1')) await initial const oldPage = provider.attach() const replacement = provider.fetch() calls[2].result.resolve(answer('new-1')) await replacement calls[1].result.resolve(answer('old-2')) await oldPage expect(provider.records.map(row => row.id)).to.deep.equal(['new-1']) expect(events.map(event => event.kind)).to.deep.equal(['replace', 'replace']) }) it('coalesces next-page triggers and preserves edits and legitimate repeated ids', async () => { const { provider, consumer, calls, events } = setup() const initial = provider.attach(true) calls[0].result.resolve(answer('one')) await initial consumer._data.records[0].edited = true const a = provider.attach() const b = provider.attach() expect(a).to.equal(b) expect(calls.length).to.equal(2) calls[1].result.resolve(answer('one', 'two', 'two')) await a expect(provider.records).to.deep.equal([{ id: 'one', edited: true }, { id: 'one' }, { id: 'two' }, { id: 'two' }]) expect(events[1].page).to.equal(2) expect(events[1].records.length).to.equal(4) expect(events[1].pageRecords.length).to.equal(3) }) it('keeps rows and retries the same page after a failed append', async () => { const { provider, calls } = setup() const initial = provider.fetch() calls[0].result.resolve(answer('one')) await initial const append = provider.attach() calls[1].result.reject(new Error('offline')) try { await append } catch {} expect(provider.records.map(row => row.id)).to.deep.equal(['one']) const retry = provider.attach() expect(calls[2].options.page).to.equal(2) calls[2].result.resolve(answer('two')) await retry expect(provider.records.map(row => row.id)).to.deep.equal(['one', 'two']) }) it('a stale response cannot stop the current spinner or announce adoption', async () => { const { provider, calls, events, spinning } = setup() const old = provider.fetch() const next = provider.fetch() calls[0].result.resolve(answer('old')) await old expect(spinning()).to.equal(true) expect(events.length).to.equal(0) calls[1].result.resolve(answer('new')) await next expect(spinning()).to.equal(false) expect(events.length).to.equal(1) }) it('disposal invalidates replacement and append responses', async () => { const { provider, calls, events, spinning } = setup() const request = provider.fetch() provider.dispose() expect(spinning()).to.equal(false) calls[0].result.resolve(answer('late')) await request expect(events.length).to.equal(0) }) it('deactivation ends an append spinner and a late result cannot disturb a new read', async () => { const { provider, calls, spinning } = setup() const initial = provider.fetch() calls[0].result.resolve(answer('one')) await initial const append = provider.attach() provider.invalidate() expect(spinning()).to.equal(false) const replacement = provider.fetch() calls[1].result.resolve(answer('old')) await append expect(spinning()).to.equal(true) calls[2].result.resolve(answer('new')) await replacement expect(spinning()).to.equal(false) expect(provider.records.map(row => row.id)).to.deep.equal(['new']) }) })