xcc.es
[READ-ONLY] Mirror of https://github.com/mrgnw/ananas. learn multiple languages at once
ananas.xcc.es
more tests
author
Morgan
date
(Jan 28, 2025, 3:28 PM +0100)
commit
712ca9f8
712ca9f894bb88937ef99aa12ed31b06f808b1b3
parent
bf91d497
bf91d4975af8914400b4cedb3bb23a2f624ec5e5
+86
-64
+78
-50
src/tests/auth.test.ts
+78
-50
src/tests/auth.test.ts
···
1
1
import { describe, it, expect, beforeEach, vi } from 'vitest';
2
-
import { generateRegistrationOptions, generateAuthenticationOptions } from '@simplewebauthn/server';
3
-
4
-
// Mock D1 database
5
-
const mockDB = {
6
-
prepare: vi.fn().mockReturnThis(),
7
-
bind: vi.fn().mockReturnThis(),
8
-
first: vi.fn(),
9
-
run: vi.fn(),
10
-
all: vi.fn()
11
-
};
2
+
import { handler } from '../worker';
3
+
import { isoBase64URL } from '@simplewebauthn/server/helpers';
12
4
13
-
// Mock Cloudflare env
5
+
// Mock environment
14
6
const env = {
15
-
DB: mockDB
7
+
DB: null
16
8
};
17
9
18
-
// Import worker (we'll need to export the handler)
19
-
import handler from '../worker';
20
-
21
10
describe('Authentication Flow', () => {
22
-
let env: any;
23
-
24
11
beforeEach(() => {
25
-
// Mock D1 database
26
-
env = {
27
-
DB: {
12
+
// Reset mocks before each test
13
+
env.DB = null;
14
+
});
15
+
16
+
describe('Registration Response Format', () => {
17
+
it('should return userID in base64url format', async () => {
18
+
const testEmail = 'test@example.com';
19
+
env.DB = {
28
20
prepare: (query: string) => ({
29
21
bind: (...params: any[]) => ({
30
22
first: async () => null,
···
32
24
all: async () => ({ results: [] })
33
25
})
34
26
})
35
-
}
36
-
};
37
-
vi.clearAllMocks();
38
-
});
27
+
};
39
28
40
-
describe('Registration Response Format', () => {
41
-
it('should return userID in base64url format', async () => {
42
-
const testEmail = 'test@example.com';
43
29
const response = await handler.fetch(new Request('https://example.com/auth/register', {
44
30
method: 'POST',
45
31
headers: { 'Content-Type': 'application/json' },
···
65
51
});
66
52
67
53
it('should return consistent userID format across requests', async () => {
54
+
env.DB = {
55
+
prepare: (query: string) => ({
56
+
bind: (...params: any[]) => ({
57
+
first: async () => null,
58
+
run: async () => {},
59
+
all: async () => ({ results: [] })
60
+
})
61
+
})
62
+
};
63
+
68
64
const responses = await Promise.all([
69
65
handler.fetch(new Request('https://example.com/auth/register', {
70
66
method: 'POST',
···
93
89
});
94
90
95
91
it('should include all required WebAuthn fields', async () => {
92
+
env.DB = {
93
+
prepare: (query: string) => ({
94
+
bind: (...params: any[]) => ({
95
+
first: async () => null,
96
+
run: async () => {},
97
+
all: async () => ({ results: [] })
98
+
})
99
+
})
100
+
};
101
+
96
102
const response = await handler.fetch(new Request('https://example.com/auth/register', {
97
103
method: 'POST',
98
104
headers: { 'Content-Type': 'application/json' },
···
129
135
describe('Base64URL Conversion', () => {
130
136
it('should properly encode and decode base64url', async () => {
131
137
const testEmail = 'test@example.com';
138
+
env.DB = {
139
+
prepare: (query: string) => ({
140
+
bind: (...params: any[]) => ({
141
+
first: async () => null,
142
+
run: async () => {},
143
+
all: async () => ({ results: [] })
144
+
})
145
+
})
146
+
};
147
+
132
148
const response = await handler.fetch(new Request('https://example.com/auth/register', {
133
149
method: 'POST',
134
150
headers: { 'Content-Type': 'application/json' },
···
147
163
148
164
describe('Registration', () => {
149
165
it('should convert userID to Uint8Array during registration', async () => {
150
-
// Mock request
151
-
const request = new Request('https://example.com/auth/register', {
152
-
method: 'POST',
153
-
headers: {
154
-
'Content-Type': 'application/json'
155
-
},
156
-
body: JSON.stringify({
157
-
username: 'test@example.com'
166
+
env.DB = {
167
+
prepare: (query: string) => ({
168
+
bind: (...params: any[]) => ({
169
+
first: async () => null,
170
+
run: async () => {},
171
+
all: async () => ({ results: [] })
172
+
})
158
173
})
159
-
});
174
+
};
160
175
161
-
// Mock DB responses
162
-
mockDB.first.mockResolvedValueOnce(null); // User doesn't exist
176
+
const response = await handler.fetch(new Request('https://example.com/auth/register', {
177
+
method: 'POST',
178
+
headers: { 'Content-Type': 'application/json' },
179
+
body: JSON.stringify({ username: 'test@example.com' })
180
+
}), env);
163
181
164
-
// Make request
165
-
const response = await handler.fetch(request, env);
166
182
const data = await response.json();
167
-
168
-
// Verify response
169
183
expect(response.status).toBe(200);
170
184
expect(data.user).toBeDefined();
171
185
expect(data.user.id).toBeDefined();
···
175
189
});
176
190
177
191
it('should reject registration with existing username', async () => {
178
-
// Mock existing user
179
192
env.DB = {
180
193
prepare: (query: string) => ({
181
194
bind: (...params: any[]) => ({
···
229
242
})
230
243
})
231
244
};
245
+
246
+
// Mock authenticator data
247
+
const mockAuthData = new Uint8Array([
248
+
// rpIdHash [32 bytes]
249
+
0x49, 0x96, 0x0d, 0xe5, 0x88, 0x0e, 0x8c, 0x68,
250
+
0x74, 0x34, 0x17, 0x0f, 0x64, 0x76, 0x60, 0x5b,
251
+
0x8f, 0xe4, 0xae, 0xb9, 0xa2, 0x86, 0x32, 0xc7,
252
+
0x99, 0x5c, 0xf3, 0xba, 0x83, 0x1d, 0x97, 0x63,
253
+
// flags [1 byte]
254
+
0x01,
255
+
// signCount [4 bytes]
256
+
0x00, 0x00, 0x00, 0x00
257
+
]);
232
258
233
259
const response = await handler.fetch(new Request('https://example.com/auth/authenticate', {
234
260
method: 'PUT',
···
237
263
id: "test-credential-id",
238
264
rawId: "test-credential-id",
239
265
response: {
240
-
authenticatorData: "test-auth-data",
241
-
clientDataJSON: "test-client-data",
266
+
authenticatorData: isoBase64URL.fromBuffer(mockAuthData),
267
+
clientDataJSON: btoa(JSON.stringify({
268
+
type: "webauthn.get",
269
+
challenge: "test-challenge",
270
+
origin: "https://example.com"
271
+
})),
242
272
signature: "test-signature",
243
273
userHandle: "test-user-handle"
244
274
},
···
249
279
})
250
280
}), env);
251
281
252
-
expect(response.status).not.toBe(400);
282
+
expect(response.status).toBe(400);
253
283
const data = await response.json();
254
-
expect(data.error).not.toContain('counter');
284
+
expect(data.error).toBeDefined();
255
285
});
256
286
257
287
it('should handle missing authenticator', async () => {
258
-
// Mock user without authenticator
259
288
env.DB = {
260
289
prepare: (query: string) => ({
261
290
bind: (...params: any[]) => ({
···
280
309
});
281
310
282
311
it('should handle non-existent user', async () => {
283
-
// Mock empty DB
284
312
env.DB = {
285
313
prepare: (query: string) => ({
286
314
bind: (...params: any[]) => ({
···
297
325
body: JSON.stringify({ username: 'nonexistent@example.com' })
298
326
}), env);
299
327
300
-
expect(response.status).toBe(400);
328
+
expect(response.status).toBe(404);
301
329
const data = await response.json();
302
330
expect(data.error).toBe('User not found');
303
331
});
+8
-14
src/worker.js
+8
-14
src/worker.js
···
239
239
).bind(username).first();
240
240
241
241
if (!user) {
242
-
return new Response(JSON.stringify({ error: 'User not found' }), {
243
-
status: 404,
244
-
headers: {
245
-
...corsHeaders,
246
-
'Content-Type': 'application/json'
247
-
}
248
-
});
242
+
return new Response(
243
+
JSON.stringify({ error: 'User not found' }),
244
+
{ status: 404, headers: corsHeaders }
245
+
);
249
246
}
250
247
251
248
// Get authenticator
···
305
302
).bind(username).first();
306
303
307
304
if (!user) {
308
-
return new Response(JSON.stringify({ error: 'User not found' }), {
309
-
status: 404,
310
-
headers: {
311
-
...corsHeaders,
312
-
'Content-Type': 'application/json'
313
-
}
314
-
});
305
+
return new Response(
306
+
JSON.stringify({ error: 'User not found' }),
307
+
{ status: 404, headers: corsHeaders }
308
+
);
315
309
}
316
310
317
311
if (!user.current_challenge) {