Open History to see the last commit
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})