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

start.spec.ts

222 lines5.4 KB

1import { beforeEach, describe, expect, it, vi } from 'vitest'
2import { parse } from 'devalue'
3import { formOptions, initialServerFormState } from '@tanstack/form-core'
4import { getFormData, start } from '../src'
5​
6const startMocks = vi.hoisted(() => ({
7 calls: [] as Array<string>,
8 cookies: new Map<string, string>(),
9}))
10​
11vi.mock('@tanstack/react-start/server', () => ({
12 deleteCookie: (name: string) => {
13 startMocks.calls.push(`delete:${name}`)
14 startMocks.cookies.delete(name)
15 },
16 getCookie: (name: string) => startMocks.cookies.get(name),
17 setCookie: (name: string, value: string) => {
18 startMocks.calls.push(`set:${name}`)
19 startMocks.cookies.set(name, value)
20 },
21}))
22​
23vi.mock('@tanstack/react-start', () => ({
24 createServerFn: () => ({
25 handler: <THandler extends (...args: Array<any>) => any>(
26 handler: THandler,
27 ) => handler,
28 }),
29}))
30​
31const internalsCookieName = '_tanstack_form_internals'
32​
33function createFormData(values: Record<string, string>): FormData {
34 const formData = new FormData()
35 for (const [key, value] of Object.entries(values)) {
36 formData.set(key, value)
37 }
38 return formData
40​
41const formOpts = formOptions({
42 defaultValues: { name: '' },
43 validators: [
44 {
45 triggers: ['server'],
46 run: ({ value, createErrorMap }) => {
47 const errors = createErrorMap()
48​
49 if (!value.name.trim()) {
50 errors.fields.name = 'Name is required'
51 }
52​
53 return errors
54 },
55 },
56 ],
57})
58​
59describe('start server validation persistence', () => {
60 beforeEach(() => {
61 startMocks.calls.length = 0
62 startMocks.cookies.clear()
63 })
64​
65 it('writes invalid server state to the internal cookie', async () => {
66 const validate = start().createServerValidate(formOpts)
67​
68 const result = await validate({
69 formData: createFormData({ name: '' }),
70 })
71​
72 expect(result.success).toBe(false)
73 const cookie = startMocks.cookies.get(internalsCookieName)
74 expect(cookie).toBeDefined()
75 expect(parse(cookie!)).toMatchObject({
76 values: { name: '' },
77 submissionAttempts: 1,
78 validationResults: [
79 {
80 validatorIndex: 0,
81 result: {
82 fields: {
83 name: 'Name is required',
84 },
85 },
86 },
87 ],
88 })
89 })
90​
91 it('reads and deletes the internal cookie from getFormData', async () => {
92 const validate = start().createServerValidate(formOpts)
93 await validate({
94 formData: createFormData({ name: '' }),
95 })
96​
97 const serverState = await getFormData()
98​
99 expect(serverState).toMatchObject({
100 values: { name: '' },
101 submissionAttempts: 1,
102 })
103 expect(startMocks.cookies.has(internalsCookieName)).toBe(false)
104 expect(startMocks.calls).toContain(`delete:${internalsCookieName}`)
105 })
106​
107 it('returns initial server state when no internal cookie exists', async () => {
108 await expect(getFormData()).resolves.toEqual(initialServerFormState)
109 })
110​
111 it('infers number form data info from default values', async () => {
112 const validate = start().createServerValidate(
113 formOptions({
114 defaultValues: { age: 0 },
115 }),
116 )
117​
118 const result = await validate({
119 formData: createFormData({ age: '42' }),
120 })
121​
122 expect(result).toMatchObject({
123 success: true,
124 values: { age: 42 },
125 })
126 })
127​
128 it('uses explicit form-level info when inference is disabled', async () => {
129 const validate = start().createServerValidate(
130 formOptions({
131 defaultValues: { age: 0 },
132 }),
133 {
134 inferFormDataInfo: false,
135 info: {
136 numbers: ['age'],
137 },
138 },
139 )
140​
141 const result = await validate({
142 formData: createFormData({ age: '42' }),
143 })
144​
145 expect(result).toMatchObject({
146 success: true,
147 values: { age: 42 },
148 })
149 })
150​
151 it('merges invocation info after form-level info', async () => {
152 const validate = start().createServerValidate(
153 formOptions({
154 defaultValues: { age: 0, score: 0 },
155 }),
156 {
157 inferFormDataInfo: false,
158 info: {
159 numbers: ['age'],
160 },
161 },
162 )
163​
164 const result = await validate({
165 formData: createFormData({ age: '42', score: '7' }),
166 info: {
167 numbers: ['score'],
168 },
169 })
170​
171 expect(result).toMatchObject({
172 success: true,
173 values: { age: 42, score: 7 },
174 })
175 })
176​
177 it('can opt out of default value form data inference', async () => {
178 const validate = start().createServerValidate(
179 formOptions({
180 defaultValues: { age: 0 },
181 }),
182 {
183 inferFormDataInfo: false,
184 },
185 )
186​
187 const result = await validate({
188 formData: createFormData({ age: '42' }),
189 })
190​
191 expect(result).toMatchObject({
192 success: true,
193 values: { age: '42' },
194 })
195 })
196​
197 it('runs onInvalid after persisting invalid server state', async () => {
198 const validate = start({
199 onInvalid: ({ serverState }) => {
200 expect(startMocks.cookies.has(internalsCookieName)).toBe(true)
201 startMocks.calls.push('onInvalid')
202 return {
203 handled: true,
204 values: serverState.values,
205 } as const
206 },
207 }).createServerValidate(formOpts)
208​
209 const result = await validate({
210 formData: createFormData({ name: '' }),
211 })
212​
213 expect(result).toEqual({
214 handled: true,
215 values: { name: '' },
216 })
217 expect(startMocks.calls).toEqual([
218 `set:${internalsCookieName}`,
219 'onInvalid',
220 ])
221 })
222})