Skip to content
Source
Sign inSign up
TanStack/query
Open History to see the last commit

Explorer.test.tsx

611 lines20.3 KB

1import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
2import { fireEvent, render, within } from '@solidjs/testing-library'
3import { QueryClient, onlineManager } from '@tanstack/query-core'
4import Explorer from '../Explorer'
5import { QueryDevtoolsContext, ThemeContext } from '../contexts'
6​
7// `goober` compiles every `css\`...\`` template literal at mount time;
8// replace it with a no-op factory so label/role-based assertions stay fast.
9vi.mock(import('goober'), () => {
10 let counter = 0
11 const css = Object.assign(() => `tsqd-${++counter}`, {
12 bind: () => css,
13 })
14 return { css, glob: () => {}, setup: () => {} }
15})
16​
17describe('Explorer', () => {
18 let queryClient: QueryClient
19​
20 beforeEach(() => {
21 vi.useFakeTimers()
22 queryClient = new QueryClient()
23 })
24​
25 afterEach(() => {
26 queryClient.clear()
27 vi.useRealTimers()
28 })
29​
30 function renderExplorer(
31 props: Parameters<typeof Explorer>[0],
32 options: { theme?: 'dark' | 'light' } = {},
33 ) {
34 const theme = options.theme ?? 'dark'
35 return render(() => (
36 <QueryDevtoolsContext.Provider
37 value={{
38 client: queryClient,
39 queryFlavor: 'TanStack Query',
40 version: '5',
41 onlineManager,
42 }}
43 >
44 <ThemeContext.Provider value={() => theme}>
45 <Explorer {...props} />
46 </ThemeContext.Provider>
47 </QueryDevtoolsContext.Provider>
48 ))
49 }
50​
51 describe('primitive values', () => {
52 it('should render a "label: value" row for a string value', () => {
53 const rendered = renderExplorer({ label: 'name', value: 'Anna' })
54​
55 expect(rendered.getByText('name:')).toBeInTheDocument()
56 expect(rendered.getByText('"Anna"')).toBeInTheDocument()
57 })
58​
59 it('should render a "label: value" row for a number value', () => {
60 const rendered = renderExplorer({ label: 'count', value: 42 })
61​
62 expect(rendered.getByText('count:')).toBeInTheDocument()
63 expect(rendered.getByText('42')).toBeInTheDocument()
64 })
65​
66 it('should render a "label: value" row for a boolean value', () => {
67 const rendered = renderExplorer({ label: 'active', value: true })
68​
69 expect(rendered.getByText('active:')).toBeInTheDocument()
70 expect(rendered.getByText('true')).toBeInTheDocument()
71 })
72​
73 it('should render a "label: value" row for a "null" value', () => {
74 const rendered = renderExplorer({ label: 'missing', value: null })
75​
76 expect(rendered.getByText('missing:')).toBeInTheDocument()
77 expect(rendered.getByText('null')).toBeInTheDocument()
78 })
79 })
80​
81 describe('arrays and objects', () => {
82 it('should render an empty object as a primitive row (no expander)', () => {
83 const rendered = renderExplorer({ label: 'data', value: {} })
84​
85 expect(rendered.getByText('data:')).toBeInTheDocument()
86 expect(
87 rendered.queryByRole('button', { expanded: false }),
88 ).not.toBeInTheDocument()
89 })
90​
91 it('should render an array with an expander showing the item count', () => {
92 const rendered = renderExplorer({
93 label: 'list',
94 value: ['a', 'b', 'c'],
95 })
96​
97 const expander = rendered.getByRole('button', { expanded: false })
98 expect(expander).toBeInTheDocument()
99 expect(expander).toHaveTextContent('list')
100 expect(expander).toHaveTextContent('3 items')
101 })
102​
103 it('should render children under their index labels when the array expander is clicked', () => {
104 const rendered = renderExplorer({
105 label: 'list',
106 value: ['a', 'b'],
107 })
108​
109 fireEvent.click(rendered.getByRole('button', { expanded: false }))
110 expect(rendered.getByText('0:')).toBeInTheDocument()
111 expect(rendered.getByText('1:')).toBeInTheDocument()
112 expect(rendered.getByText('"a"')).toBeInTheDocument()
113 expect(rendered.getByText('"b"')).toBeInTheDocument()
114 })
115​
116 it('should render object entries under their keys when expanded', () => {
117 const rendered = renderExplorer({
118 label: 'user',
119 value: { name: 'Anna', age: 30 },
120 })
121​
122 fireEvent.click(rendered.getByRole('button', { expanded: false }))
123 expect(rendered.getByText('name:')).toBeInTheDocument()
124 expect(rendered.getByText('"Anna"')).toBeInTheDocument()
125 expect(rendered.getByText('age:')).toBeInTheDocument()
126 expect(rendered.getByText('30')).toBeInTheDocument()
127 })
128 })
129​
130 describe('Map and iterable values', () => {
131 it('should preserve "Map" keys as labels when expanded', () => {
132 const rendered = renderExplorer({
133 label: 'm',
134 value: new Map([
135 ['first', 1],
136 ['second', 2],
137 ]),
138 })
139​
140 fireEvent.click(rendered.getByRole('button', { expanded: false }))
141 expect(rendered.getByText('first:')).toBeInTheDocument()
142 expect(rendered.getByText('second:')).toBeInTheDocument()
143 })
144​
145 it('should mark an iterable value with an "(Iterable)" prefix on the expander', () => {
146 const rendered = renderExplorer({
147 label: 's',
148 value: new Set(['x', 'y']),
149 })
150​
151 expect(
152 rendered.getByRole('button', { expanded: false }),
153 ).toHaveTextContent('(Iterable)')
154 })
155​
156 it('should render iterable children under their numeric index when expanded', () => {
157 const rendered = renderExplorer({
158 label: 's',
159 value: new Set(['x', 'y']),
160 })
161​
162 fireEvent.click(rendered.getByRole('button', { expanded: false }))
163 expect(rendered.getByText('0:')).toBeInTheDocument()
164 expect(rendered.getByText('1:')).toBeInTheDocument()
165 })
166 })
167​
168 describe('"defaultExpanded"', () => {
169 it('should render children eagerly when the label is in "defaultExpanded"', () => {
170 const rendered = renderExplorer({
171 label: 'list',
172 value: ['a'],
173 defaultExpanded: ['list'],
174 })
175​
176 expect(
177 rendered.getByRole('button', { expanded: true }),
178 ).toBeInTheDocument()
179 expect(rendered.getByText('0:')).toBeInTheDocument()
180 })
181 })
182​
183 describe('action menu', () => {
184 it('should copy the serialized value to the clipboard when the copy button is clicked', () => {
185 const writeText = vi
186 .fn<Clipboard['writeText']>()
187 .mockResolvedValue(undefined)
188 vi.stubGlobal('navigator', { clipboard: { writeText } })
189 queryClient.setQueryData(['data'], { name: 'Anna' })
190​
191 const rendered = renderExplorer({
192 label: 'data',
193 value: { name: 'Anna' },
194 editable: true,
195 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
196 })
197​
198 fireEvent.click(rendered.getByLabelText('Copy object to clipboard'))
199 expect(writeText).toHaveBeenCalledTimes(1)
200 const [arg] = writeText.mock.calls[0]!
201 expect(JSON.parse(arg)).toMatchObject({
202 json: { name: 'Anna' },
203 })
204 })
205​
206 it('should switch the copy button to an error state when clipboard write fails', async () => {
207 const writeText = vi
208 .fn<Clipboard['writeText']>()
209 .mockRejectedValue(new Error('denied'))
210 vi.stubGlobal('navigator', { clipboard: { writeText } })
211 const consoleErrorMock = vi
212 .spyOn(console, 'error')
213 .mockImplementation(() => {})
214 queryClient.setQueryData(['data'], { name: 'Anna' })
215​
216 const rendered = renderExplorer({
217 label: 'data',
218 value: { name: 'Anna' },
219 editable: true,
220 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
221 })
222​
223 fireEvent.click(rendered.getByLabelText('Copy object to clipboard'))
224 await vi.advanceTimersByTimeAsync(0)
225 expect(
226 rendered.getByLabelText('Error copying object to clipboard'),
227 ).toBeInTheDocument()
228 expect(consoleErrorMock).toHaveBeenCalledWith(
229 'Failed to copy: ',
230 new Error('denied'),
231 )
232 })
233​
234 it('should reset the copy button to the idle state 1500ms after a successful copy', async () => {
235 const writeText = vi
236 .fn<Clipboard['writeText']>()
237 .mockResolvedValue(undefined)
238 vi.stubGlobal('navigator', { clipboard: { writeText } })
239 queryClient.setQueryData(['data'], { name: 'Anna' })
240​
241 const rendered = renderExplorer({
242 label: 'data',
243 value: { name: 'Anna' },
244 editable: true,
245 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
246 })
247​
248 fireEvent.click(rendered.getByLabelText('Copy object to clipboard'))
249 await vi.advanceTimersByTimeAsync(0)
250 expect(
251 rendered.getByLabelText('Object copied to clipboard'),
252 ).toBeInTheDocument()
253 await vi.advanceTimersByTimeAsync(1500)
254 expect(
255 rendered.getByLabelText('Copy object to clipboard'),
256 ).toBeInTheDocument()
257 })
258​
259 it('should reset the copy button to the idle state 1500ms after a failed copy', async () => {
260 const writeText = vi
261 .fn<Clipboard['writeText']>()
262 .mockRejectedValue(new Error('denied'))
263 vi.stubGlobal('navigator', { clipboard: { writeText } })
264 vi.spyOn(console, 'error').mockImplementation(() => {})
265 queryClient.setQueryData(['data'], { name: 'Anna' })
266​
267 const rendered = renderExplorer({
268 label: 'data',
269 value: { name: 'Anna' },
270 editable: true,
271 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
272 })
273​
274 fireEvent.click(rendered.getByLabelText('Copy object to clipboard'))
275 await vi.advanceTimersByTimeAsync(0)
276 expect(
277 rendered.getByLabelText('Error copying object to clipboard'),
278 ).toBeInTheDocument()
279 await vi.advanceTimersByTimeAsync(1500)
280 expect(
281 rendered.getByLabelText('Copy object to clipboard'),
282 ).toBeInTheDocument()
283 })
284​
285 it('should clear array items via "setQueryData" when the clear-array button is clicked', () => {
286 queryClient.setQueryData(['data'], ['a', 'b', 'c'])
287​
288 const rendered = renderExplorer({
289 label: 'list',
290 value: ['a', 'b', 'c'],
291 editable: true,
292 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
293 })
294​
295 fireEvent.click(rendered.getByLabelText('Remove all items'))
296 expect(queryClient.getQueryData(['data'])).toStrictEqual([])
297 })
298​
299 it('should delete the entry at the current "dataPath" when the delete button is clicked', () => {
300 queryClient.setQueryData(['data'], ['a', 'b', 'c'])
301​
302 const rendered = renderExplorer({
303 label: 'list',
304 value: ['a', 'b', 'c'],
305 editable: true,
306 itemsDeletable: true,
307 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
308 dataPath: ['1'],
309 })
310​
311 fireEvent.click(rendered.getByLabelText('Delete item'))
312 expect(queryClient.getQueryData(['data'])).toStrictEqual(['a', 'c'])
313 })
314​
315 it('should toggle a boolean value via "setQueryData" when the toggle button is clicked', () => {
316 queryClient.setQueryData(['data'], { flag: true })
317​
318 const rendered = renderExplorer({
319 label: 'flag',
320 value: true,
321 editable: true,
322 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
323 dataPath: ['flag'],
324 })
325​
326 fireEvent.click(rendered.getByLabelText('Toggle value'))
327 expect(queryClient.getQueryData(['data'])).toStrictEqual({ flag: false })
328 })
329​
330 it.each([true, false])(
331 'should expose "aria-pressed" on the toggle button when the value is %s',
332 (value) => {
333 queryClient.setQueryData(['data'], { flag: value })
334​
335 const rendered = renderExplorer({
336 label: 'flag',
337 value,
338 editable: true,
339 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
340 dataPath: ['flag'],
341 })
342​
343 expect(rendered.getByLabelText('Toggle value')).toHaveAttribute(
344 'aria-pressed',
345 String(value),
346 )
347 },
348 )
349​
350 it('should not render action buttons when "editable" is false', () => {
351 queryClient.setQueryData(['data'], ['a'])
352​
353 const rendered = renderExplorer({
354 label: 'list',
355 value: ['a'],
356 editable: false,
357 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
358 })
359​
360 expect(
361 rendered.queryByLabelText('Copy object to clipboard'),
362 ).not.toBeInTheDocument()
363 expect(
364 rendered.queryByLabelText('Remove all items'),
365 ).not.toBeInTheDocument()
366 })
367​
368 it('should not render "ClearArrayButton" when value is not an array', () => {
369 queryClient.setQueryData(['data'], { name: 'Anna' })
370​
371 const rendered = renderExplorer({
372 label: 'user',
373 value: { name: 'Anna' },
374 editable: true,
375 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
376 })
377​
378 expect(
379 rendered.queryByLabelText('Remove all items'),
380 ).not.toBeInTheDocument()
381 expect(
382 rendered.getByLabelText('Copy object to clipboard'),
383 ).toBeInTheDocument()
384 })
385 })
386​
387 describe('pagination', () => {
388 it('should group entries into 100-item pages when the array has more than 100 entries', () => {
389 const rendered = renderExplorer({
390 label: 'big',
391 value: Array.from({ length: 101 }, (_, i) => i),
392 })
393​
394 fireEvent.click(rendered.getByRole('button', { expanded: false }))
395 expect(rendered.getByText('[0...99]')).toBeInTheDocument()
396 expect(rendered.getByText('[100...199]')).toBeInTheDocument()
397 })
398​
399 it('should keep the items of a page hidden until the page header is clicked', () => {
400 const rendered = renderExplorer({
401 label: 'big',
402 value: Array.from({ length: 101 }, (_, i) => `item-${i}`),
403 })
404​
405 fireEvent.click(rendered.getByRole('button', { expanded: false }))
406 expect(rendered.queryByText('0:')).not.toBeInTheDocument()
407 })
408​
409 it('should reveal the items of a page when the page header is clicked', () => {
410 const rendered = renderExplorer({
411 label: 'big',
412 value: Array.from({ length: 101 }, (_, i) => `item-${i}`),
413 })
414​
415 fireEvent.click(rendered.getByRole('button', { expanded: false }))
416 fireEvent.click(rendered.getByText('[0...99]'))
417 expect(rendered.getByText('0:')).toBeInTheDocument()
418 expect(rendered.getByText('"item-0"')).toBeInTheDocument()
419 })
420​
421 it('should independently toggle two pages when their headers are clicked', () => {
422 const rendered = renderExplorer({
423 label: 'big',
424 value: Array.from({ length: 200 }, (_, i) => `item-${i}`),
425 })
426​
427 fireEvent.click(rendered.getByRole('button', { expanded: false }))
428 fireEvent.click(rendered.getByText('[0...99]'))
429 fireEvent.click(rendered.getByText('[100...199]'))
430 expect(rendered.getByText('"item-0"')).toBeInTheDocument()
431 expect(rendered.getByText('"item-100"')).toBeInTheDocument()
432​
433 fireEvent.click(rendered.getByText('[0...99]'))
434 expect(rendered.queryByText('"item-0"')).not.toBeInTheDocument()
435 expect(rendered.getByText('"item-100"')).toBeInTheDocument()
436 })
437​
438 it('should render action buttons for items inside a paginated page', () => {
439 const value: Array<Array<number>> = Array.from(
440 { length: 200 },
441 (_, i) => [i],
442 )
443 queryClient.setQueryData(['data'], value)
444​
445 const rendered = renderExplorer({
446 label: 'Data',
447 value,
448 defaultExpanded: ['Data'],
449 editable: true,
450 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
451 })
452​
453 fireEvent.click(rendered.getByText('[0...99]'))
454 expect(
455 rendered.getAllByLabelText('Remove all items').length,
456 ).toBeGreaterThan(1)
457 })
458 })
459​
460 describe('inline edit', () => {
461 it('should write the new string value via "setQueryData" when a text input is changed', () => {
462 queryClient.setQueryData(['data'], { name: 'Anna' })
463​
464 const rendered = renderExplorer({
465 label: 'name',
466 value: 'Anna',
467 editable: true,
468 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
469 dataPath: ['name'],
470 })
471​
472 const input = rendered.getByLabelText('name:')
473 expect(input).toHaveAttribute('type', 'text')
474​
475 fireEvent.change(input, { target: { value: 'Bob' } })
476 expect(queryClient.getQueryData(['data'])).toStrictEqual({ name: 'Bob' })
477 })
478​
479 it('should write the new number value via "setQueryData" when a number input is changed', () => {
480 queryClient.setQueryData(['data'], { count: 1 })
481​
482 const rendered = renderExplorer({
483 label: 'count',
484 value: 1,
485 editable: true,
486 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
487 dataPath: ['count'],
488 })
489​
490 const input = rendered.getByLabelText('count:')
491 expect(input).toHaveAttribute('type', 'number')
492​
493 fireEvent.change(input, {
494 target: { value: '42', valueAsNumber: 42 },
495 })
496 expect(queryClient.getQueryData(['data'])).toStrictEqual({ count: 42 })
497 })
498​
499 it('should render "ToggleValueButton" inline for a boolean primitive row', () => {
500 queryClient.setQueryData(['data'], { flag: false })
501​
502 const rendered = renderExplorer({
503 label: 'flag',
504 value: false,
505 editable: true,
506 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
507 dataPath: ['flag'],
508 })
509​
510 expect(rendered.getByLabelText('Toggle value')).toBeInTheDocument()
511 })
512​
513 it('should render "DeleteItemButton" inline when a primitive row has "itemsDeletable"', () => {
514 queryClient.setQueryData(['data'], { name: 'Anna' })
515​
516 const rendered = renderExplorer({
517 label: 'name',
518 value: 'Anna',
519 editable: true,
520 itemsDeletable: true,
521 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
522 dataPath: ['name'],
523 })
524​
525 expect(rendered.getByLabelText('Delete item')).toBeInTheDocument()
526 })
527​
528 it('should delete fields from the active query when their inline delete buttons are clicked', () => {
529 const value = { name: 'Anna', age: 30 }
530 queryClient.setQueryData(['data'], value)
531​
532 const rendered = renderExplorer({
533 label: 'Data',
534 value,
535 defaultExpanded: ['Data'],
536 editable: true,
537 activeQuery: queryClient.getQueryCache().find({ queryKey: ['data'] }),
538 })
539​
540 const ageRow = rendered.getByText('age:').parentElement!
541 fireEvent.click(within(ageRow).getByLabelText('Delete item'))
542 expect(queryClient.getQueryData(['data'])).toStrictEqual({ name: 'Anna' })
543​
544 const nameRow = rendered.getByText('name:').parentElement!
545 fireEvent.click(within(nameRow).getByLabelText('Delete item'))
546 expect(queryClient.getQueryData(['data'])).toStrictEqual({})
547 })
548 })
549​
550 describe('theme', () => {
551 it('should render without throwing under the "light" theme', () => {
552 const value = { items: ['a'], flag: true }
553 queryClient.setQueryData(['data'], value)
554​
555 expect(() =>
556 renderExplorer(
557 {
558 label: 'Data',
559 value,
560 defaultExpanded: ['Data'],
561 editable: true,
562 activeQuery: queryClient
563 .getQueryCache()
564 .find({ queryKey: ['data'] }),
565 },
566 { theme: 'light' },
567 ),
568 ).not.toThrow()
569 })
570 })
571​
572 describe('"shadowDOMTarget"', () => {
573 it('should render without throwing when a "shadowDOMTarget" is provided', () => {
574 const host = document.createElement('div')
575 document.body.appendChild(host)
576 const shadowRoot = host.attachShadow({ mode: 'open' })
577 const value = { items: ['a'], flag: true }
578 queryClient.setQueryData(['data'], value)
579​
580 try {
581 expect(() =>
582 render(() => (
583 <QueryDevtoolsContext.Provider
584 value={{
585 client: queryClient,
586 queryFlavor: 'TanStack Query',
587 version: '5',
588 onlineManager,
589 shadowDOMTarget: shadowRoot,
590 }}
591 >
592 <ThemeContext.Provider value={() => 'dark'}>
593 <Explorer
594 label="Data"
595 value={value}
596 defaultExpanded={['Data']}
597 editable={true}
598 activeQuery={queryClient
599 .getQueryCache()
600 .find({ queryKey: ['data'] })}
601 />
602 </ThemeContext.Provider>
603 </QueryDevtoolsContext.Provider>
604 )),
605 ).not.toThrow()
606 } finally {
607 host.remove()
608 }
609 })
610 })
611})