See the best posts from any Bluesky account
add functional tests for backfill dispatch and dedup
8 tests covering Task 8:
- D1: first-time visit dispatches BackfillJob and renders loading page
- D2: concurrent first visits dispatch only once (dedup gate)
- D3: in-progress job visit shows loading page without re-dispatching
- D4: HandleNotFoundError renders 404 with no rows created
- D5: BlueskyRateLimitedError renders 503 with no rows created
- D6: dispatch is awaited before render (throwing dispatch → 500, not 200)
- D7: InvalidHandleError from normalize still renders 400 (Task 6 unchanged)
- D8: already-backfilled user doesn't trigger dispatch
Uses queue.fake()/queue.restore() from @adonisjs/queue/services/main for
job assertion, and container swap() for HandleResolver mocking.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
+310
+310
apps/web/tests/functional/profile_controller_dispatch.spec.ts
+310
apps/web/tests/functional/profile_controller_dispatch.spec.ts
···
1
+
/**
2
+
* Functional tests for ProfileController backfill dispatch logic (Task 8).
3
+
*
4
+
* These tests verify:
5
+
* - First-time visit triggers BackfillJob dispatch
6
+
* - Concurrent visits dispatch only once (dedup gate via BackfillJobRow PK)
7
+
* - Subsequent visits while job is in progress don't re-dispatch
8
+
* - HandleNotFoundError renders 404
9
+
* - BlueskyRateLimitedError renders 503
10
+
* - Dispatch happens before loading page renders (order of operations)
11
+
* - InvalidHandleError (Task 6 path) still renders 404
12
+
* - Already-backfilled user skips dispatch
13
+
*/
14
+
import { test } from '@japa/runner'
15
+
import testUtils from '@adonisjs/core/services/test_utils'
16
+
import queue from '@adonisjs/queue/services/main'
17
+
import User from '#models/user'
18
+
import BackfillJobRow from '#models/backfill_job'
19
+
import BackfillJob from '#jobs/backfill_job'
20
+
import { HandleResolver, HandleNotFoundError } from '#services/handle_resolver'
21
+
import { BlueskyRateLimitedError } from '@skystar/atproto'
22
+
23
+
// ---------------------------------------------------------------------------
24
+
// Helpers
25
+
// ---------------------------------------------------------------------------
26
+
27
+
const TEST_HANDLE = 'newuser.bsky.social'
28
+
const TEST_DID = 'did:plc:dispatchtest001'
29
+
30
+
/**
31
+
* Build a fake HandleResolver whose resolveToDid either returns the given DID
32
+
* or throws the given error. normalize() delegates to the real implementation.
33
+
*/
34
+
function makeFakeHandleResolver(opts: { did?: string; throws?: Error }): HandleResolver {
35
+
return {
36
+
normalize(input: string): string {
37
+
// Minimal real normalize: trim, strip @, lowercase, append .bsky.social if no dot
38
+
let h = input.trim()
39
+
if (h.startsWith('@')) h = h.slice(1)
40
+
h = h.toLowerCase()
41
+
if (!h.includes('.')) h = `${h}.bsky.social`
42
+
return h
43
+
},
44
+
async resolveToDid(_handle: string): Promise<string> {
45
+
if (opts.throws) throw opts.throws
46
+
return opts.did!
47
+
},
48
+
async resolve(input: string): Promise<{ canonicalHandle: string; did: string }> {
49
+
const canonicalHandle = this.normalize(input)
50
+
const did = await this.resolveToDid(canonicalHandle)
51
+
return { canonicalHandle, did }
52
+
},
53
+
} as HandleResolver
54
+
}
55
+
56
+
// ---------------------------------------------------------------------------
57
+
// Tests
58
+
// ---------------------------------------------------------------------------
59
+
60
+
test.group('BackfillJob dispatch — first-time visit', (group) => {
61
+
group.each.setup(() => testUtils.db().withGlobalTransaction())
62
+
63
+
group.each.setup(() => {
64
+
// Put the queue in fake mode so jobs are captured, not executed
65
+
queue.fake()
66
+
})
67
+
68
+
group.each.teardown(() => {
69
+
queue.restore()
70
+
})
71
+
72
+
// Test D1: First-time visit dispatches BackfillJob
73
+
test('first-time visit dispatches BackfillJob and renders loading page', async ({
74
+
client,
75
+
assert,
76
+
swap,
77
+
}) => {
78
+
swap(HandleResolver, makeFakeHandleResolver({ did: TEST_DID }))
79
+
80
+
const response = await client.get(`/profile/${TEST_HANDLE}/likes`)
81
+
82
+
// Loading page returned
83
+
response.assertStatus(200)
84
+
assert.include(response.text(), 'meta http-equiv="refresh"')
85
+
86
+
// User row created
87
+
const user = await User.findBy('handle', TEST_HANDLE)
88
+
assert.isNotNull(user)
89
+
assert.equal(user!.did, TEST_DID)
90
+
assert.isNull(user!.backfilledAt)
91
+
92
+
// BackfillJobRow created with state=running
93
+
const jobRow = await BackfillJobRow.find(TEST_DID)
94
+
assert.isNotNull(jobRow)
95
+
assert.equal(jobRow!.state, 'running')
96
+
assert.isNotNull(jobRow!.startedAt)
97
+
98
+
// BackfillJob was dispatched exactly once
99
+
const fakeAdapter = queue.fake()
100
+
fakeAdapter.assertPushed('BackfillJob')
101
+
fakeAdapter.assertPushedCount(1)
102
+
})
103
+
104
+
// Test D2: Concurrent first visits dispatch only once (dedup gate)
105
+
test('concurrent first visits dispatch BackfillJob only once', async ({
106
+
client,
107
+
assert,
108
+
swap,
109
+
}) => {
110
+
swap(HandleResolver, makeFakeHandleResolver({ did: TEST_DID }))
111
+
112
+
// Fire both requests in parallel
113
+
const [r1, r2] = await Promise.all([
114
+
client.get(`/profile/${TEST_HANDLE}/likes`),
115
+
client.get(`/profile/${TEST_HANDLE}/likes`),
116
+
])
117
+
118
+
// Both show the loading page
119
+
r1.assertStatus(200)
120
+
r2.assertStatus(200)
121
+
122
+
// Only ONE User row
123
+
const users = await User.query().where('handle', TEST_HANDLE)
124
+
assert.equal(users.length, 1)
125
+
126
+
// Only ONE BackfillJobRow
127
+
const jobs = await BackfillJobRow.query().where('did', TEST_DID)
128
+
assert.equal(jobs.length, 1)
129
+
130
+
// BackfillJob dispatched exactly once (dedup gate worked)
131
+
const fakeAdapter = queue.fake()
132
+
fakeAdapter.assertPushedCount(1)
133
+
fakeAdapter.assertPushed('BackfillJob')
134
+
})
135
+
136
+
// Test D3: Subsequent visit while job is in progress doesn't re-dispatch
137
+
test('subsequent visit with in-progress job shows loading page without re-dispatching', async ({
138
+
client,
139
+
assert,
140
+
swap,
141
+
}) => {
142
+
// Pre-seed the user (no backfilledAt) and an in-progress BackfillJobRow
143
+
await User.create({
144
+
did: TEST_DID,
145
+
handle: TEST_HANDLE,
146
+
firstSeenAt: Date.now(),
147
+
})
148
+
await BackfillJobRow.create({
149
+
did: TEST_DID,
150
+
startedAt: Date.now(),
151
+
state: 'running',
152
+
fetchedPosts: 0,
153
+
})
154
+
155
+
// HandleResolver should NOT be called (rows already exist), but swap it
156
+
// defensively — if called it returns the same DID so no harm done
157
+
swap(HandleResolver, makeFakeHandleResolver({ did: TEST_DID }))
158
+
159
+
const response = await client.get(`/profile/${TEST_HANDLE}/likes`)
160
+
161
+
response.assertStatus(200)
162
+
assert.include(response.text(), 'meta http-equiv="refresh"')
163
+
164
+
// BackfillJob was NOT dispatched (job row already existed)
165
+
const fakeAdapter = queue.fake()
166
+
fakeAdapter.assertNothingPushed()
167
+
})
168
+
})
169
+
170
+
test.group('BackfillJob dispatch — error handling', (group) => {
171
+
group.each.setup(() => testUtils.db().withGlobalTransaction())
172
+
173
+
group.each.setup(() => {
174
+
queue.fake()
175
+
})
176
+
177
+
group.each.teardown(() => {
178
+
queue.restore()
179
+
})
180
+
181
+
// Test D4: HandleNotFoundError renders 404
182
+
test('HandleNotFoundError from resolveToDid renders 404', async ({ client, assert, swap }) => {
183
+
swap(
184
+
HandleResolver,
185
+
makeFakeHandleResolver({ throws: new HandleNotFoundError('nope.bsky.social', undefined) })
186
+
)
187
+
188
+
const response = await client.get('/profile/nope.bsky.social/likes')
189
+
190
+
response.assertStatus(404)
191
+
assert.include(response.text(), "can't find")
192
+
193
+
// No rows created
194
+
const user = await User.findBy('handle', 'nope.bsky.social')
195
+
assert.isNull(user)
196
+
const jobs = await BackfillJobRow.all()
197
+
assert.equal(jobs.length, 0)
198
+
199
+
// Nothing dispatched
200
+
queue.fake().assertNothingPushed()
201
+
})
202
+
203
+
// Test D5: BlueskyRateLimitedError renders 503
204
+
test('BlueskyRateLimitedError from resolveToDid renders 503', async ({
205
+
client,
206
+
assert,
207
+
swap,
208
+
}) => {
209
+
swap(
210
+
HandleResolver,
211
+
makeFakeHandleResolver({ throws: new BlueskyRateLimitedError('Rate limited', 3) })
212
+
)
213
+
214
+
const response = await client.get('/profile/throttled.bsky.social/likes')
215
+
216
+
response.assertStatus(503)
217
+
assert.include(response.text(), 'rate-limited')
218
+
219
+
// No rows created
220
+
const user = await User.findBy('handle', 'throttled.bsky.social')
221
+
assert.isNull(user)
222
+
223
+
queue.fake().assertNothingPushed()
224
+
})
225
+
226
+
// Test D6: Dispatch happens BEFORE loading page renders (order of operations)
227
+
//
228
+
// Verify by making dispatch throw and asserting the response is 500 (not 200).
229
+
// If dispatch happened after the render, the response would be 200 and the throw
230
+
// would be an unhandled background error. Seeing 500 proves the await is before render.
231
+
test('dispatch throws → request returns 500 (not 200), proving dispatch is awaited before render', async ({
232
+
client,
233
+
swap,
234
+
}) => {
235
+
// Restore real queue so dispatch actually runs (not fake)
236
+
queue.restore()
237
+
238
+
// Override BackfillJob.dispatch to throw
239
+
const originalDispatch = BackfillJob.dispatch
240
+
;(BackfillJob as unknown as { dispatch: unknown }).dispatch = async (_payload: {
241
+
did: string
242
+
}) => {
243
+
throw new Error('Synthetic dispatch failure for test D6')
244
+
}
245
+
246
+
try {
247
+
swap(HandleResolver, makeFakeHandleResolver({ did: TEST_DID }))
248
+
249
+
const response = await client.get(`/profile/${TEST_HANDLE}/likes`)
250
+
251
+
// Must be 500 — proves dispatch is awaited before render
252
+
response.assertStatus(500)
253
+
} finally {
254
+
;(BackfillJob as unknown as { dispatch: unknown }).dispatch = originalDispatch
255
+
}
256
+
})
257
+
258
+
// Test D7: InvalidHandleError (normalize path, Task 6) still renders 400
259
+
test('InvalidHandleError from normalize still renders 400 (Task 6 behavior unchanged)', async ({
260
+
client,
261
+
}) => {
262
+
// !!! is not a valid handle — normalize() throws InvalidHandleError
263
+
const response = await client.get('/profile/!!!/likes')
264
+
response.assertStatus(400)
265
+
})
266
+
})
267
+
268
+
test.group('BackfillJob dispatch — already backfilled user', (group) => {
269
+
group.each.setup(() => testUtils.db().withGlobalTransaction())
270
+
271
+
group.each.setup(() => {
272
+
queue.fake()
273
+
})
274
+
275
+
group.each.teardown(() => {
276
+
queue.restore()
277
+
})
278
+
279
+
// Test D8: Already-backfilled user skips dispatch
280
+
test('already-backfilled user does not trigger dispatch', async ({ client, assert, swap }) => {
281
+
// Pre-seed a fully backfilled user
282
+
await User.create({
283
+
did: TEST_DID,
284
+
handle: TEST_HANDLE,
285
+
firstSeenAt: Date.now(),
286
+
backfilledAt: Date.now(),
287
+
})
288
+
289
+
// HandleResolver should NOT be called — but swap it defensively
290
+
swap(HandleResolver, makeFakeHandleResolver({ did: TEST_DID }))
291
+
292
+
// The controller will try to call ClickHouseStore.getTopPosts — provide a stub
293
+
// that returns empty array so the profile page renders without ClickHouse
294
+
const { ClickHouseStore } = await import('@skystar/clickhouse')
295
+
swap(ClickHouseStore, {
296
+
async getTopPosts() {
297
+
return []
298
+
},
299
+
} as unknown as InstanceType<typeof ClickHouseStore>)
300
+
301
+
const response = await client.get(`/profile/${TEST_HANDLE}/likes`)
302
+
303
+
// Profile rendered (200), not loading page
304
+
response.assertStatus(200)
305
+
assert.notInclude(response.text(), 'meta http-equiv="refresh"')
306
+
307
+
// No dispatch
308
+
queue.fake().assertNothingPushed()
309
+
})
310
+
})