Open History to see the last commit
1import { describe, expect, it, vi } from 'vitest'
2import { render, screen } from '@testing-library/react'
3import { ClientSlot } from '../src/ClientSlot'
4import { SlotProvider } from '../src/SlotContext'
5β
6describe('ClientSlot', () => {
7 describe('error handling', () => {
8 it('should throw when rendered outside SlotProvider', () => {
9 // Suppress React error boundary console output
10 const spy = vi.spyOn(console, 'error').mockImplementation(() => {})
11β
12 expect(() => {
13 render(<ClientSlot slot="test" args={[]} />)
14 }).toThrow('ClientSlot must be rendered within SlotProvider')
15β
16 spy.mockRestore()
17 })
18 })
19β
20 describe('missing implementations', () => {
21 it('should return null for missing slot in non-strict mode', () => {
22 render(
23 <SlotProvider implementations={{}} strict={false}>
24 <div data-testid="container">
25 <ClientSlot slot="missing" args={[]} />
26 </div>
27 </SlotProvider>,
28 )
29β
30 // Container should be empty (null rendered)
31 expect(screen.getByTestId('container').children).toHaveLength(0)
32 })
33β
34 it('should throw for missing slot in strict mode', () => {
35 const spy = vi.spyOn(console, 'error').mockImplementation(() => {})
36β
37 expect(() => {
38 render(
39 <SlotProvider implementations={{}} strict={true}>
40 <ClientSlot slot="missing" args={[]} />
41 </SlotProvider>,
42 )
43 }).toThrow('Missing slot implementation for "missing"')
44β
45 spy.mockRestore()
46 })
47 })
48β
49 describe('non-function implementations', () => {
50 it('should render string directly', () => {
51 render(
52 <SlotProvider implementations={{ greeting: 'Hello World' }}>
53 <div data-testid="slot">
54 <ClientSlot slot="greeting" args={[]} />
55 </div>
56 </SlotProvider>,
57 )
58β
59 expect(screen.getByTestId('slot').textContent).toBe('Hello World')
60 })
61β
62 it('should render number directly', () => {
63 render(
64 <SlotProvider implementations={{ count: 42 }}>
65 <div data-testid="slot">
66 <ClientSlot slot="count" args={[]} />
67 </div>
68 </SlotProvider>,
69 )
70β
71 expect(screen.getByTestId('slot').textContent).toBe('42')
72 })
73β
74 it('should render React element directly', () => {
75 render(
76 <SlotProvider implementations={{ element: <span>Element</span> }}>
77 <div data-testid="slot">
78 <ClientSlot slot="element" args={[]} />
79 </div>
80 </SlotProvider>,
81 )
82β
83 expect(screen.getByTestId('slot').textContent).toBe('Element')
84 })
85β
86 it('should render children slot', () => {
87 render(
88 <SlotProvider implementations={{ children: <div>Child content</div> }}>
89 <div data-testid="slot">
90 <ClientSlot slot="children" args={[]} />
91 </div>
92 </SlotProvider>,
93 )
94β
95 expect(screen.getByTestId('slot').textContent).toBe('Child content')
96 })
97 })
98β
99 describe('function implementations', () => {
100 it('should call function with no args', () => {
101 render(
102 <SlotProvider implementations={{ render: () => 'No args result' }}>
103 <div data-testid="slot">
104 <ClientSlot slot="render" args={[]} />
105 </div>
106 </SlotProvider>,
107 )
108β
109 expect(screen.getByTestId('slot').textContent).toBe('No args result')
110 })
111β
112 it('should call function with single arg', () => {
113 render(
114 <SlotProvider
115 implementations={{ render: (name: string) => `Hello ${name}` }}
116 >
117 <div data-testid="slot">
118 <ClientSlot slot="render" args={['World']} />
119 </div>
120 </SlotProvider>,
121 )
122β
123 expect(screen.getByTestId('slot').textContent).toBe('Hello World')
124 })
125β
126 it('should call function with multiple args', () => {
127 render(
128 <SlotProvider
129 implementations={{
130 render: (a: number, b: number, c: number) => `Sum: ${a + b + c}`,
131 }}
132 >
133 <div data-testid="slot">
134 <ClientSlot slot="render" args={[1, 2, 3]} />
135 </div>
136 </SlotProvider>,
137 )
138β
139 expect(screen.getByTestId('slot').textContent).toBe('Sum: 6')
140 })
141β
142 it('should call function returning React element', () => {
143 render(
144 <SlotProvider
145 implementations={{
146 render: (item: { id: number; name: string }) => (
147 <span key={item.id}>{item.name}</span>
148 ),
149 }}
150 >
151 <div data-testid="slot">
152 <ClientSlot slot="render" args={[{ id: 1, name: 'Item One' }]} />
153 </div>
154 </SlotProvider>,
155 )
156β
157 expect(screen.getByTestId('slot').textContent).toBe('Item One')
158 })
159β
160 it('should handle function returning null', () => {
161 render(
162 <SlotProvider implementations={{ render: () => null }}>
163 <div data-testid="slot">
164 <ClientSlot slot="render" args={[]} />
165 </div>
166 </SlotProvider>,
167 )
168β
169 expect(screen.getByTestId('slot').children).toHaveLength(0)
170 })
171 })
172β
173 describe('edge cases', () => {
174 it('should handle undefined args gracefully', () => {
175 render(
176 <SlotProvider
177 implementations={{
178 render: (...args: Array<unknown>) => `Args: ${args.length}`,
179 }}
180 >
181 <div data-testid="slot">
182 <ClientSlot slot="render" args={[undefined, undefined]} />
183 </div>
184 </SlotProvider>,
185 )
186β
187 expect(screen.getByTestId('slot').textContent).toBe('Args: 2')
188 })
189β
190 it('should handle complex object args', () => {
191 interface ComplexArg {
192 nested: { deep: { value: string } }
193 }
194β
195 render(
196 <SlotProvider
197 implementations={{
198 render: (obj: ComplexArg) => obj.nested.deep.value,
199 }}
200 >
201 <div data-testid="slot">
202 <ClientSlot
203 slot="render"
204 args={[{ nested: { deep: { value: 'Deep value' } } }]}
205 />
206 </div>
207 </SlotProvider>,
208 )
209β
210 expect(screen.getByTestId('slot').textContent).toBe('Deep value')
211 })
212 })
213})