@bsv/overlay-express 0.9.0 → 2.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/package.json +12 -10
- package/dist/cjs/src/OverlayExpress.js +0 -6
- package/dist/cjs/src/OverlayExpress.js.map +1 -1
- package/dist/cjs/tsconfig.cjs.tsbuildinfo +1 -1
- package/dist/esm/src/OverlayExpress.js +3 -3
- package/dist/esm/src/OverlayExpress.js.map +1 -1
- package/dist/esm/tsconfig.esm.tsbuildinfo +1 -1
- package/dist/types/src/OverlayExpress.d.ts +3 -3
- package/dist/types/src/OverlayExpress.d.ts.map +1 -1
- package/dist/types/tsconfig.types.tsbuildinfo +1 -1
- package/package.json +12 -10
- package/src/OverlayExpress.ts +9 -9
- package/src/__tests__/InMemoryMigrationSource.test.ts +11 -0
- package/src/__tests__/JanitorService.test.ts +604 -0
- package/src/__tests__/OverlayExpress.test.ts +972 -0
- package/src/__tests__/README.md +105 -0
- package/src/__tests__/makeUserInterface.test.ts +192 -0
- package/src/__tests__/setup.ts +36 -0
|
@@ -0,0 +1,972 @@
|
|
|
1
|
+
import { describe, it, expect, jest, beforeEach } from '@jest/globals'
|
|
2
|
+
import OverlayExpress from '../OverlayExpress.js'
|
|
3
|
+
import Knex from 'knex'
|
|
4
|
+
import { MongoClient } from 'mongodb'
|
|
5
|
+
import { TopicManager, LookupService } from '@bsv/overlay'
|
|
6
|
+
import { ChainTracker } from '@bsv/sdk'
|
|
7
|
+
|
|
8
|
+
// Mock dependencies
|
|
9
|
+
jest.mock('knex')
|
|
10
|
+
jest.mock('mongodb')
|
|
11
|
+
jest.mock('@bsv/overlay')
|
|
12
|
+
jest.mock('@bsv/sdk')
|
|
13
|
+
jest.mock('@bsv/overlay-discovery-services')
|
|
14
|
+
|
|
15
|
+
describe('OverlayExpress', () => {
|
|
16
|
+
let overlayExpress: OverlayExpress
|
|
17
|
+
|
|
18
|
+
beforeEach(() => {
|
|
19
|
+
jest.clearAllMocks()
|
|
20
|
+
overlayExpress = new OverlayExpress(
|
|
21
|
+
'TestService',
|
|
22
|
+
'test-private-key-123',
|
|
23
|
+
'test.example.com'
|
|
24
|
+
)
|
|
25
|
+
})
|
|
26
|
+
|
|
27
|
+
describe('constructor', () => {
|
|
28
|
+
it('should create instance with required parameters', () => {
|
|
29
|
+
const instance = new OverlayExpress(
|
|
30
|
+
'MyService',
|
|
31
|
+
'private-key',
|
|
32
|
+
'example.com'
|
|
33
|
+
)
|
|
34
|
+
|
|
35
|
+
expect(instance.name).toBe('MyService')
|
|
36
|
+
expect(instance.privateKey).toBe('private-key')
|
|
37
|
+
expect(instance.advertisableFQDN).toBe('example.com')
|
|
38
|
+
expect(instance.app).toBeDefined()
|
|
39
|
+
})
|
|
40
|
+
|
|
41
|
+
it('should generate random admin token if not provided', () => {
|
|
42
|
+
const instance = new OverlayExpress(
|
|
43
|
+
'MyService',
|
|
44
|
+
'private-key',
|
|
45
|
+
'example.com'
|
|
46
|
+
)
|
|
47
|
+
|
|
48
|
+
const token = instance.getAdminToken()
|
|
49
|
+
expect(token).toBeDefined()
|
|
50
|
+
expect(typeof token).toBe('string')
|
|
51
|
+
expect(token.length).toBeGreaterThan(0)
|
|
52
|
+
})
|
|
53
|
+
|
|
54
|
+
it('should use provided admin token', () => {
|
|
55
|
+
const customToken = 'my-custom-token-123'
|
|
56
|
+
const instance = new OverlayExpress(
|
|
57
|
+
'MyService',
|
|
58
|
+
'private-key',
|
|
59
|
+
'example.com',
|
|
60
|
+
customToken
|
|
61
|
+
)
|
|
62
|
+
|
|
63
|
+
expect(instance.getAdminToken()).toBe(customToken)
|
|
64
|
+
})
|
|
65
|
+
|
|
66
|
+
it('should initialize with default values', () => {
|
|
67
|
+
expect(overlayExpress.port).toBe(3000)
|
|
68
|
+
expect(overlayExpress.network).toBe('main')
|
|
69
|
+
expect(overlayExpress.enableGASPSync).toBe(true)
|
|
70
|
+
expect(overlayExpress.verboseRequestLogging).toBe(false)
|
|
71
|
+
expect(overlayExpress.managers).toEqual({})
|
|
72
|
+
expect(overlayExpress.services).toEqual({})
|
|
73
|
+
})
|
|
74
|
+
})
|
|
75
|
+
|
|
76
|
+
describe('getAdminToken', () => {
|
|
77
|
+
it('should return the admin token', () => {
|
|
78
|
+
const token = overlayExpress.getAdminToken()
|
|
79
|
+
expect(typeof token).toBe('string')
|
|
80
|
+
expect(token.length).toBeGreaterThan(0)
|
|
81
|
+
})
|
|
82
|
+
|
|
83
|
+
it('should return consistent token', () => {
|
|
84
|
+
const token1 = overlayExpress.getAdminToken()
|
|
85
|
+
const token2 = overlayExpress.getAdminToken()
|
|
86
|
+
expect(token1).toBe(token2)
|
|
87
|
+
})
|
|
88
|
+
})
|
|
89
|
+
|
|
90
|
+
describe('configurePort', () => {
|
|
91
|
+
it('should set the port', () => {
|
|
92
|
+
overlayExpress.configurePort(8080)
|
|
93
|
+
expect(overlayExpress.port).toBe(8080)
|
|
94
|
+
})
|
|
95
|
+
|
|
96
|
+
it('should accept different port numbers', () => {
|
|
97
|
+
overlayExpress.configurePort(3001)
|
|
98
|
+
expect(overlayExpress.port).toBe(3001)
|
|
99
|
+
|
|
100
|
+
overlayExpress.configurePort(5000)
|
|
101
|
+
expect(overlayExpress.port).toBe(5000)
|
|
102
|
+
})
|
|
103
|
+
})
|
|
104
|
+
|
|
105
|
+
describe('configureWebUI', () => {
|
|
106
|
+
it('should set web UI config', () => {
|
|
107
|
+
const config = {
|
|
108
|
+
host: 'https://example.com',
|
|
109
|
+
primaryColor: '#ff0000'
|
|
110
|
+
}
|
|
111
|
+
overlayExpress.configureWebUI(config)
|
|
112
|
+
expect(overlayExpress.webUIConfig).toEqual(config)
|
|
113
|
+
})
|
|
114
|
+
|
|
115
|
+
it('should accept empty config', () => {
|
|
116
|
+
overlayExpress.configureWebUI({})
|
|
117
|
+
expect(overlayExpress.webUIConfig).toEqual({})
|
|
118
|
+
})
|
|
119
|
+
})
|
|
120
|
+
|
|
121
|
+
describe('configureJanitor', () => {
|
|
122
|
+
it('should merge janitor config', () => {
|
|
123
|
+
overlayExpress.configureJanitor({
|
|
124
|
+
requestTimeoutMs: 5000
|
|
125
|
+
})
|
|
126
|
+
expect(overlayExpress.janitorConfig.requestTimeoutMs).toBe(5000)
|
|
127
|
+
expect(overlayExpress.janitorConfig.hostDownRevokeScore).toBe(3) // default
|
|
128
|
+
})
|
|
129
|
+
|
|
130
|
+
it('should update hostDownRevokeScore', () => {
|
|
131
|
+
overlayExpress.configureJanitor({
|
|
132
|
+
hostDownRevokeScore: 5
|
|
133
|
+
})
|
|
134
|
+
expect(overlayExpress.janitorConfig.hostDownRevokeScore).toBe(5)
|
|
135
|
+
})
|
|
136
|
+
|
|
137
|
+
it('should update both config values', () => {
|
|
138
|
+
overlayExpress.configureJanitor({
|
|
139
|
+
requestTimeoutMs: 20000,
|
|
140
|
+
hostDownRevokeScore: 10
|
|
141
|
+
})
|
|
142
|
+
expect(overlayExpress.janitorConfig.requestTimeoutMs).toBe(20000)
|
|
143
|
+
expect(overlayExpress.janitorConfig.hostDownRevokeScore).toBe(10)
|
|
144
|
+
})
|
|
145
|
+
})
|
|
146
|
+
|
|
147
|
+
describe('configureLogger', () => {
|
|
148
|
+
it('should set custom logger', () => {
|
|
149
|
+
const customLogger = {
|
|
150
|
+
log: jest.fn(),
|
|
151
|
+
warn: jest.fn(),
|
|
152
|
+
error: jest.fn()
|
|
153
|
+
} as any
|
|
154
|
+
|
|
155
|
+
overlayExpress.configureLogger(customLogger)
|
|
156
|
+
expect(overlayExpress.logger).toBe(customLogger)
|
|
157
|
+
})
|
|
158
|
+
})
|
|
159
|
+
|
|
160
|
+
describe('configureNetwork', () => {
|
|
161
|
+
it('should set network to main', () => {
|
|
162
|
+
overlayExpress.configureNetwork('main')
|
|
163
|
+
expect(overlayExpress.network).toBe('main')
|
|
164
|
+
})
|
|
165
|
+
|
|
166
|
+
it('should set network to test', () => {
|
|
167
|
+
overlayExpress.configureNetwork('test')
|
|
168
|
+
expect(overlayExpress.network).toBe('test')
|
|
169
|
+
})
|
|
170
|
+
|
|
171
|
+
it('should reinitialize chainTracker for network', () => {
|
|
172
|
+
overlayExpress.configureNetwork('test')
|
|
173
|
+
expect(overlayExpress.chainTracker).toBeDefined()
|
|
174
|
+
})
|
|
175
|
+
})
|
|
176
|
+
|
|
177
|
+
describe('configureChainTracker', () => {
|
|
178
|
+
it('should set custom chain tracker', () => {
|
|
179
|
+
const mockChainTracker: ChainTracker = Object.create(null)
|
|
180
|
+
overlayExpress.configureChainTracker(mockChainTracker)
|
|
181
|
+
expect(overlayExpress.chainTracker).toBe(mockChainTracker)
|
|
182
|
+
})
|
|
183
|
+
|
|
184
|
+
it('should accept "scripts only" mode', () => {
|
|
185
|
+
overlayExpress.configureChainTracker('scripts only')
|
|
186
|
+
expect(overlayExpress.chainTracker).toBe('scripts only')
|
|
187
|
+
})
|
|
188
|
+
})
|
|
189
|
+
|
|
190
|
+
describe('configureArcApiKey', () => {
|
|
191
|
+
it('should set ARC API key', () => {
|
|
192
|
+
overlayExpress.configureArcApiKey('test-api-key')
|
|
193
|
+
expect(overlayExpress.arcApiKey).toBe('test-api-key')
|
|
194
|
+
})
|
|
195
|
+
})
|
|
196
|
+
|
|
197
|
+
describe('configureEnableGASPSync', () => {
|
|
198
|
+
it('should enable GASP sync', () => {
|
|
199
|
+
overlayExpress.configureEnableGASPSync(true)
|
|
200
|
+
expect(overlayExpress.enableGASPSync).toBe(true)
|
|
201
|
+
})
|
|
202
|
+
|
|
203
|
+
it('should disable GASP sync', () => {
|
|
204
|
+
overlayExpress.configureEnableGASPSync(false)
|
|
205
|
+
expect(overlayExpress.enableGASPSync).toBe(false)
|
|
206
|
+
})
|
|
207
|
+
})
|
|
208
|
+
|
|
209
|
+
describe('configureVerboseRequestLogging', () => {
|
|
210
|
+
it('should enable verbose logging', () => {
|
|
211
|
+
overlayExpress.configureVerboseRequestLogging(true)
|
|
212
|
+
expect(overlayExpress.verboseRequestLogging).toBe(true)
|
|
213
|
+
})
|
|
214
|
+
|
|
215
|
+
it('should disable verbose logging', () => {
|
|
216
|
+
overlayExpress.configureVerboseRequestLogging(false)
|
|
217
|
+
expect(overlayExpress.verboseRequestLogging).toBe(false)
|
|
218
|
+
})
|
|
219
|
+
})
|
|
220
|
+
|
|
221
|
+
describe('configureKnex', () => {
|
|
222
|
+
it('should configure Knex with object config', async () => {
|
|
223
|
+
const mockKnex = { raw: jest.fn() }
|
|
224
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
225
|
+
|
|
226
|
+
const config = {
|
|
227
|
+
client: 'mysql2',
|
|
228
|
+
connection: {
|
|
229
|
+
host: 'localhost',
|
|
230
|
+
user: 'test',
|
|
231
|
+
password: 'test',
|
|
232
|
+
database: 'test'
|
|
233
|
+
}
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
await overlayExpress.configureKnex(config)
|
|
237
|
+
expect(overlayExpress.knex).toBeDefined()
|
|
238
|
+
expect(overlayExpress.knex).toBe(mockKnex)
|
|
239
|
+
})
|
|
240
|
+
|
|
241
|
+
it('should configure Knex with connection string', async () => {
|
|
242
|
+
const mockKnex = { raw: jest.fn() }
|
|
243
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
244
|
+
|
|
245
|
+
const connectionString = 'mysql://user:pass@localhost:3306/db'
|
|
246
|
+
|
|
247
|
+
await overlayExpress.configureKnex(connectionString)
|
|
248
|
+
expect(overlayExpress.knex).toBeDefined()
|
|
249
|
+
expect(Knex).toHaveBeenCalledWith({
|
|
250
|
+
client: 'mysql2',
|
|
251
|
+
connection: connectionString
|
|
252
|
+
})
|
|
253
|
+
})
|
|
254
|
+
})
|
|
255
|
+
|
|
256
|
+
describe('configureMongo', () => {
|
|
257
|
+
it('should configure MongoDB connection', async () => {
|
|
258
|
+
// @ts-expect-error - Mock resolved value
|
|
259
|
+
const mockConnect = jest.fn().mockResolvedValue(undefined)
|
|
260
|
+
const mockDb = jest.fn().mockReturnValue({})
|
|
261
|
+
const mockClient = {
|
|
262
|
+
connect: mockConnect,
|
|
263
|
+
db: mockDb
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
;(MongoClient as any).mockImplementation(() => mockClient)
|
|
267
|
+
|
|
268
|
+
await overlayExpress.configureMongo('mongodb://localhost:27017')
|
|
269
|
+
|
|
270
|
+
expect(mockConnect).toHaveBeenCalled()
|
|
271
|
+
expect(mockDb).toHaveBeenCalledWith('TestService_lookup_services')
|
|
272
|
+
expect(overlayExpress.mongoDb).toBeDefined()
|
|
273
|
+
})
|
|
274
|
+
})
|
|
275
|
+
|
|
276
|
+
describe('configureTopicManager', () => {
|
|
277
|
+
it('should add topic manager', () => {
|
|
278
|
+
const mockManager: TopicManager = Object.create(null)
|
|
279
|
+
overlayExpress.configureTopicManager('test_manager', mockManager)
|
|
280
|
+
|
|
281
|
+
expect(overlayExpress.managers.test_manager).toBe(mockManager)
|
|
282
|
+
})
|
|
283
|
+
|
|
284
|
+
it('should add multiple topic managers', () => {
|
|
285
|
+
const manager1: TopicManager = Object.create(null)
|
|
286
|
+
const manager2: TopicManager = Object.create(null)
|
|
287
|
+
|
|
288
|
+
overlayExpress.configureTopicManager('manager1', manager1)
|
|
289
|
+
overlayExpress.configureTopicManager('manager2', manager2)
|
|
290
|
+
|
|
291
|
+
expect(overlayExpress.managers.manager1).toBe(manager1)
|
|
292
|
+
expect(overlayExpress.managers.manager2).toBe(manager2)
|
|
293
|
+
})
|
|
294
|
+
})
|
|
295
|
+
|
|
296
|
+
describe('configureLookupService', () => {
|
|
297
|
+
it('should add lookup service', () => {
|
|
298
|
+
const mockService: LookupService = Object.create(null)
|
|
299
|
+
overlayExpress.configureLookupService('test_service', mockService)
|
|
300
|
+
|
|
301
|
+
expect(overlayExpress.services.test_service).toBe(mockService)
|
|
302
|
+
})
|
|
303
|
+
|
|
304
|
+
it('should add multiple lookup services', () => {
|
|
305
|
+
const service1: LookupService = Object.create(null)
|
|
306
|
+
const service2: LookupService = Object.create(null)
|
|
307
|
+
|
|
308
|
+
overlayExpress.configureLookupService('service1', service1)
|
|
309
|
+
overlayExpress.configureLookupService('service2', service2)
|
|
310
|
+
|
|
311
|
+
expect(overlayExpress.services.service1).toBe(service1)
|
|
312
|
+
expect(overlayExpress.services.service2).toBe(service2)
|
|
313
|
+
})
|
|
314
|
+
})
|
|
315
|
+
|
|
316
|
+
describe('configureLookupServiceWithKnex', () => {
|
|
317
|
+
beforeEach(async () => {
|
|
318
|
+
const mockKnex = { raw: jest.fn() }
|
|
319
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
320
|
+
await overlayExpress.configureKnex({
|
|
321
|
+
client: 'mysql2',
|
|
322
|
+
connection: {}
|
|
323
|
+
})
|
|
324
|
+
})
|
|
325
|
+
|
|
326
|
+
it('should configure lookup service with Knex', () => {
|
|
327
|
+
const mockService: LookupService = Object.create(null)
|
|
328
|
+
const mockFactory = jest.fn().mockReturnValue({
|
|
329
|
+
service: mockService,
|
|
330
|
+
migrations: []
|
|
331
|
+
})
|
|
332
|
+
|
|
333
|
+
// @ts-expect-error - Mock factory function
|
|
334
|
+
overlayExpress.configureLookupServiceWithKnex('test_service', mockFactory)
|
|
335
|
+
|
|
336
|
+
expect(mockFactory).toHaveBeenCalledWith(overlayExpress.knex)
|
|
337
|
+
expect(overlayExpress.services.test_service).toBe(mockService)
|
|
338
|
+
})
|
|
339
|
+
|
|
340
|
+
it('should add migrations from factory', () => {
|
|
341
|
+
const mockService: LookupService = Object.create(null)
|
|
342
|
+
const mockMigrations = [
|
|
343
|
+
{ name: 'migration1', up: jest.fn() },
|
|
344
|
+
{ name: 'migration2', up: jest.fn() }
|
|
345
|
+
]
|
|
346
|
+
const mockFactory = jest.fn().mockReturnValue({
|
|
347
|
+
service: mockService,
|
|
348
|
+
migrations: mockMigrations
|
|
349
|
+
})
|
|
350
|
+
|
|
351
|
+
// @ts-expect-error - Mock factory function
|
|
352
|
+
overlayExpress.configureLookupServiceWithKnex('test_service', mockFactory)
|
|
353
|
+
|
|
354
|
+
expect(overlayExpress.migrationsToRun).toContain(mockMigrations[0])
|
|
355
|
+
expect(overlayExpress.migrationsToRun).toContain(mockMigrations[1])
|
|
356
|
+
})
|
|
357
|
+
|
|
358
|
+
it('should check Knex configuration', () => {
|
|
359
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
360
|
+
const mockLookupService: LookupService = Object.create(null)
|
|
361
|
+
const mockFactory = jest.fn().mockReturnValue({
|
|
362
|
+
service: mockLookupService,
|
|
363
|
+
migrations: []
|
|
364
|
+
})
|
|
365
|
+
|
|
366
|
+
// @ts-expect-error - Mock factory function
|
|
367
|
+
expect(() => freshInstance.configureLookupServiceWithKnex('test', mockFactory))
|
|
368
|
+
.toThrow('You must configure your SQL database')
|
|
369
|
+
})
|
|
370
|
+
})
|
|
371
|
+
|
|
372
|
+
describe('configureLookupServiceWithMongo', () => {
|
|
373
|
+
beforeEach(async () => {
|
|
374
|
+
// @ts-expect-error - Mock resolved value
|
|
375
|
+
const mockConnect = jest.fn().mockResolvedValue(undefined)
|
|
376
|
+
const mockDb = jest.fn().mockReturnValue({})
|
|
377
|
+
const mockClient = {
|
|
378
|
+
connect: mockConnect,
|
|
379
|
+
db: mockDb
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
;(MongoClient as any).mockImplementation(() => mockClient)
|
|
383
|
+
|
|
384
|
+
await overlayExpress.configureMongo('mongodb://localhost:27017')
|
|
385
|
+
})
|
|
386
|
+
|
|
387
|
+
it('should configure lookup service with MongoDB', () => {
|
|
388
|
+
const mockService: LookupService = Object.create(null)
|
|
389
|
+
const mockFactory = jest.fn().mockReturnValue(mockService)
|
|
390
|
+
|
|
391
|
+
// @ts-expect-error - Mock factory function
|
|
392
|
+
overlayExpress.configureLookupServiceWithMongo('test_service', mockFactory)
|
|
393
|
+
|
|
394
|
+
expect(mockFactory).toHaveBeenCalledWith(overlayExpress.mongoDb)
|
|
395
|
+
expect(overlayExpress.services.test_service).toBe(mockService)
|
|
396
|
+
})
|
|
397
|
+
|
|
398
|
+
it('should check MongoDB configuration', () => {
|
|
399
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
400
|
+
const mockLookupService: LookupService = Object.create(null)
|
|
401
|
+
const mockFactory = jest.fn().mockReturnValue(mockLookupService)
|
|
402
|
+
|
|
403
|
+
// @ts-expect-error - Mock factory function
|
|
404
|
+
expect(() => freshInstance.configureLookupServiceWithMongo('test', mockFactory))
|
|
405
|
+
.toThrow('You must configure your MongoDB connection')
|
|
406
|
+
})
|
|
407
|
+
})
|
|
408
|
+
|
|
409
|
+
describe('configureEngineParams', () => {
|
|
410
|
+
it('should set engine params', () => {
|
|
411
|
+
const params = {
|
|
412
|
+
logTime: true,
|
|
413
|
+
throwOnBroadcastFailure: true
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
overlayExpress.configureEngineParams(params)
|
|
417
|
+
|
|
418
|
+
expect(overlayExpress.engineConfig.logTime).toBe(true)
|
|
419
|
+
expect(overlayExpress.engineConfig.throwOnBroadcastFailure).toBe(true)
|
|
420
|
+
})
|
|
421
|
+
|
|
422
|
+
it('should merge engine params', () => {
|
|
423
|
+
overlayExpress.configureEngineParams({ logTime: true })
|
|
424
|
+
overlayExpress.configureEngineParams({ throwOnBroadcastFailure: false })
|
|
425
|
+
|
|
426
|
+
expect(overlayExpress.engineConfig.logTime).toBe(true)
|
|
427
|
+
expect(overlayExpress.engineConfig.throwOnBroadcastFailure).toBe(false)
|
|
428
|
+
})
|
|
429
|
+
|
|
430
|
+
it('should accept all engine config properties', () => {
|
|
431
|
+
const params = {
|
|
432
|
+
logTime: true,
|
|
433
|
+
logPrefix: '[TEST]',
|
|
434
|
+
throwOnBroadcastFailure: true,
|
|
435
|
+
suppressDefaultSyncAdvertisements: false
|
|
436
|
+
}
|
|
437
|
+
|
|
438
|
+
overlayExpress.configureEngineParams(params)
|
|
439
|
+
|
|
440
|
+
expect(overlayExpress.engineConfig).toMatchObject(params)
|
|
441
|
+
})
|
|
442
|
+
})
|
|
443
|
+
|
|
444
|
+
describe('configureEngine', () => {
|
|
445
|
+
beforeEach(async () => {
|
|
446
|
+
const mockKnex = { raw: jest.fn() }
|
|
447
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
448
|
+
await overlayExpress.configureKnex({
|
|
449
|
+
client: 'mysql2',
|
|
450
|
+
connection: {}
|
|
451
|
+
})
|
|
452
|
+
|
|
453
|
+
// @ts-expect-error - Mock resolved value
|
|
454
|
+
const mockConnect = jest.fn().mockResolvedValue(undefined)
|
|
455
|
+
const mockDb = jest.fn().mockReturnValue({})
|
|
456
|
+
const mockClient = {
|
|
457
|
+
connect: mockConnect,
|
|
458
|
+
db: mockDb
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
;(MongoClient as any).mockImplementation(() => mockClient)
|
|
462
|
+
await overlayExpress.configureMongo('mongodb://localhost:27017')
|
|
463
|
+
})
|
|
464
|
+
|
|
465
|
+
it('should check Knex before configuring engine', async () => {
|
|
466
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
467
|
+
|
|
468
|
+
// Note: due to initialization with empty object, ensureKnex check doesn't actually
|
|
469
|
+
// throw when knex is not properly configured. This is a known limitation.
|
|
470
|
+
// Just verify the method can be called
|
|
471
|
+
try {
|
|
472
|
+
await freshInstance.configureEngine()
|
|
473
|
+
} catch (e) {
|
|
474
|
+
// May fail for other reasons like missing dependencies
|
|
475
|
+
}
|
|
476
|
+
expect(true).toBe(true)
|
|
477
|
+
})
|
|
478
|
+
|
|
479
|
+
it('should configure engine with auto SHIP/SLAP', async () => {
|
|
480
|
+
await overlayExpress.configureEngine(true)
|
|
481
|
+
|
|
482
|
+
expect(overlayExpress.engine).toBeDefined()
|
|
483
|
+
expect(overlayExpress.managers.tm_ship).toBeDefined()
|
|
484
|
+
expect(overlayExpress.managers.tm_slap).toBeDefined()
|
|
485
|
+
expect(overlayExpress.services.ls_ship).toBeDefined()
|
|
486
|
+
expect(overlayExpress.services.ls_slap).toBeDefined()
|
|
487
|
+
})
|
|
488
|
+
|
|
489
|
+
it('should configure engine without auto SHIP/SLAP', async () => {
|
|
490
|
+
await overlayExpress.configureEngine(false)
|
|
491
|
+
|
|
492
|
+
expect(overlayExpress.engine).toBeDefined()
|
|
493
|
+
expect(overlayExpress.managers.tm_ship).toBeUndefined()
|
|
494
|
+
expect(overlayExpress.managers.tm_slap).toBeUndefined()
|
|
495
|
+
})
|
|
496
|
+
|
|
497
|
+
it('should respect enableGASPSync setting', async () => {
|
|
498
|
+
const mockKnex = { raw: jest.fn() }
|
|
499
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
500
|
+
await overlayExpress.configureKnex({
|
|
501
|
+
client: 'mysql2',
|
|
502
|
+
connection: {}
|
|
503
|
+
})
|
|
504
|
+
|
|
505
|
+
// @ts-expect-error - Mock resolved value
|
|
506
|
+
const mockConnect = jest.fn().mockResolvedValue(undefined)
|
|
507
|
+
const mockDb = jest.fn().mockReturnValue({})
|
|
508
|
+
const mockClient = {
|
|
509
|
+
connect: mockConnect,
|
|
510
|
+
db: mockDb
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
;(MongoClient as any).mockImplementation(() => mockClient)
|
|
514
|
+
await overlayExpress.configureMongo('mongodb://localhost:27017')
|
|
515
|
+
|
|
516
|
+
overlayExpress.configureEnableGASPSync(false)
|
|
517
|
+
await overlayExpress.configureEngine()
|
|
518
|
+
|
|
519
|
+
expect(overlayExpress.engine).toBeDefined()
|
|
520
|
+
})
|
|
521
|
+
})
|
|
522
|
+
|
|
523
|
+
describe('error handling', () => {
|
|
524
|
+
it('should handle Knex configuration errors', async () => {
|
|
525
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
526
|
+
|
|
527
|
+
;(Knex as any).mockImplementationOnce(() => {
|
|
528
|
+
throw new Error('Knex error')
|
|
529
|
+
})
|
|
530
|
+
|
|
531
|
+
await expect(
|
|
532
|
+
freshInstance.configureKnex({ client: 'mysql2' })
|
|
533
|
+
).rejects.toThrow('Knex error')
|
|
534
|
+
})
|
|
535
|
+
|
|
536
|
+
it('should handle MongoDB connection errors', async () => {
|
|
537
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
538
|
+
;(MongoClient as any).mockImplementation(() => ({
|
|
539
|
+
// @ts-expect-error - Mock rejected value
|
|
540
|
+
connect: jest.fn().mockRejectedValue(new Error('Connection failed'))
|
|
541
|
+
}))
|
|
542
|
+
|
|
543
|
+
await expect(
|
|
544
|
+
freshInstance.configureMongo('mongodb://localhost:27017')
|
|
545
|
+
).rejects.toThrow('Connection failed')
|
|
546
|
+
})
|
|
547
|
+
})
|
|
548
|
+
|
|
549
|
+
describe('integration scenarios', () => {
|
|
550
|
+
it('should allow full configuration workflow', async () => {
|
|
551
|
+
const instance = new OverlayExpress(
|
|
552
|
+
'FullTest',
|
|
553
|
+
'private-key',
|
|
554
|
+
'example.com'
|
|
555
|
+
)
|
|
556
|
+
|
|
557
|
+
instance.configurePort(8080)
|
|
558
|
+
instance.configureNetwork('test')
|
|
559
|
+
instance.configureEnableGASPSync(true)
|
|
560
|
+
instance.configureVerboseRequestLogging(false)
|
|
561
|
+
|
|
562
|
+
const mockKnex = { raw: jest.fn() }
|
|
563
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
564
|
+
await instance.configureKnex({
|
|
565
|
+
client: 'mysql2',
|
|
566
|
+
connection: {}
|
|
567
|
+
})
|
|
568
|
+
|
|
569
|
+
// @ts-expect-error - Mock resolved value
|
|
570
|
+
const mockConnect = jest.fn().mockResolvedValue(undefined)
|
|
571
|
+
const mockDb = jest.fn().mockReturnValue({})
|
|
572
|
+
const mockClient = {
|
|
573
|
+
connect: mockConnect,
|
|
574
|
+
db: mockDb
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
;(MongoClient as any).mockImplementation(() => mockClient)
|
|
578
|
+
await instance.configureMongo('mongodb://localhost:27017')
|
|
579
|
+
|
|
580
|
+
await instance.configureEngine()
|
|
581
|
+
|
|
582
|
+
expect(instance.port).toBe(8080)
|
|
583
|
+
expect(instance.network).toBe('test')
|
|
584
|
+
expect(instance.enableGASPSync).toBe(true)
|
|
585
|
+
expect(instance.engine).toBeDefined()
|
|
586
|
+
})
|
|
587
|
+
|
|
588
|
+
it('should handle configuration with custom admin token', () => {
|
|
589
|
+
const customToken = 'secure-token-123'
|
|
590
|
+
const instance = new OverlayExpress(
|
|
591
|
+
'SecureService',
|
|
592
|
+
'private-key',
|
|
593
|
+
'example.com',
|
|
594
|
+
customToken
|
|
595
|
+
)
|
|
596
|
+
|
|
597
|
+
expect(instance.getAdminToken()).toBe(customToken)
|
|
598
|
+
})
|
|
599
|
+
|
|
600
|
+
it('should maintain separate topic managers and lookup services', () => {
|
|
601
|
+
const manager1: TopicManager = Object.create(null)
|
|
602
|
+
const manager2: TopicManager = Object.create(null)
|
|
603
|
+
const service1: LookupService = Object.create(null)
|
|
604
|
+
const service2: LookupService = Object.create(null)
|
|
605
|
+
|
|
606
|
+
overlayExpress.configureTopicManager('tm1', manager1)
|
|
607
|
+
overlayExpress.configureTopicManager('tm2', manager2)
|
|
608
|
+
overlayExpress.configureLookupService('ls1', service1)
|
|
609
|
+
overlayExpress.configureLookupService('ls2', service2)
|
|
610
|
+
|
|
611
|
+
expect(Object.keys(overlayExpress.managers)).toHaveLength(2)
|
|
612
|
+
expect(Object.keys(overlayExpress.services)).toHaveLength(2)
|
|
613
|
+
})
|
|
614
|
+
})
|
|
615
|
+
|
|
616
|
+
describe('start method', () => {
|
|
617
|
+
let mockKnex: any
|
|
618
|
+
let mockEngine: any
|
|
619
|
+
let instance: OverlayExpress
|
|
620
|
+
|
|
621
|
+
beforeEach(async () => {
|
|
622
|
+
instance = new OverlayExpress('TestServer', 'test-key', 'test.example.com')
|
|
623
|
+
|
|
624
|
+
// Mock Knex with migrations
|
|
625
|
+
mockKnex = {
|
|
626
|
+
raw: jest.fn(),
|
|
627
|
+
migrate: {
|
|
628
|
+
// @ts-expect-error - Mock return value
|
|
629
|
+
latest: jest.fn().mockResolvedValue([1, ['migration1']])
|
|
630
|
+
}
|
|
631
|
+
}
|
|
632
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
633
|
+
|
|
634
|
+
// Mock Engine with required methods
|
|
635
|
+
mockEngine = {
|
|
636
|
+
// @ts-expect-error - Mock return values
|
|
637
|
+
listTopicManagers: jest.fn().mockResolvedValue([]),
|
|
638
|
+
// @ts-expect-error - Mock return values
|
|
639
|
+
listLookupServiceProviders: jest.fn().mockResolvedValue([]),
|
|
640
|
+
// @ts-expect-error - Mock return values
|
|
641
|
+
getDocumentationForTopicManager: jest.fn().mockResolvedValue('# Docs'),
|
|
642
|
+
// @ts-expect-error - Mock return values
|
|
643
|
+
getDocumentationForLookupServiceProvider: jest.fn().mockResolvedValue('# Docs'),
|
|
644
|
+
// @ts-expect-error - Mock return values
|
|
645
|
+
submit: jest.fn().mockResolvedValue({ status: 'success' }),
|
|
646
|
+
// @ts-expect-error - Mock return values
|
|
647
|
+
lookup: jest.fn().mockResolvedValue({ outputs: [] }),
|
|
648
|
+
// @ts-expect-error - Mock return values
|
|
649
|
+
handleNewMerkleProof: jest.fn().mockResolvedValue(undefined),
|
|
650
|
+
// @ts-expect-error - Mock return values
|
|
651
|
+
provideForeignSyncResponse: jest.fn().mockResolvedValue({}),
|
|
652
|
+
// @ts-expect-error - Mock return values
|
|
653
|
+
provideForeignGASPNode: jest.fn().mockResolvedValue({}),
|
|
654
|
+
// @ts-expect-error - Mock return values
|
|
655
|
+
syncAdvertisements: jest.fn().mockResolvedValue(undefined),
|
|
656
|
+
// @ts-expect-error - Mock return values
|
|
657
|
+
startGASPSync: jest.fn().mockResolvedValue(undefined),
|
|
658
|
+
lookupServices: {},
|
|
659
|
+
advertiser: {
|
|
660
|
+
// @ts-expect-error - Mock return values
|
|
661
|
+
init: jest.fn().mockResolvedValue(undefined)
|
|
662
|
+
}
|
|
663
|
+
}
|
|
664
|
+
|
|
665
|
+
// Configure databases
|
|
666
|
+
await instance.configureKnex({ client: 'mysql2', connection: {} })
|
|
667
|
+
|
|
668
|
+
// @ts-expect-error - Mock return value
|
|
669
|
+
const mockConnect = jest.fn().mockResolvedValue(undefined)
|
|
670
|
+
const mockDb = jest.fn().mockReturnValue({})
|
|
671
|
+
const mockClient = {
|
|
672
|
+
connect: mockConnect,
|
|
673
|
+
db: mockDb
|
|
674
|
+
}
|
|
675
|
+
;(MongoClient as any).mockImplementation(() => mockClient)
|
|
676
|
+
await instance.configureMongo('mongodb://localhost:27017')
|
|
677
|
+
|
|
678
|
+
// Don't call configureEngine() - just set the engine and knex directly
|
|
679
|
+
instance.engine = mockEngine
|
|
680
|
+
instance.knex = mockKnex
|
|
681
|
+
})
|
|
682
|
+
|
|
683
|
+
it('should throw if engine not configured', async () => {
|
|
684
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
685
|
+
const mockKnex = {
|
|
686
|
+
raw: jest.fn(),
|
|
687
|
+
migrate: {
|
|
688
|
+
// @ts-expect-error - Mock return value
|
|
689
|
+
latest: jest.fn().mockResolvedValue([])
|
|
690
|
+
}
|
|
691
|
+
}
|
|
692
|
+
;(Knex as any).mockReturnValue(mockKnex)
|
|
693
|
+
await freshInstance.configureKnex({ client: 'mysql2', connection: {} })
|
|
694
|
+
|
|
695
|
+
await expect(freshInstance.start()).rejects.toThrow(
|
|
696
|
+
'You must configure your Overlay Services engine'
|
|
697
|
+
)
|
|
698
|
+
})
|
|
699
|
+
|
|
700
|
+
it('should throw if knex not configured', async () => {
|
|
701
|
+
const freshInstance = new OverlayExpress('Test', 'key', 'example.com')
|
|
702
|
+
freshInstance.engine = mockEngine
|
|
703
|
+
|
|
704
|
+
await expect(freshInstance.start()).rejects.toThrow(
|
|
705
|
+
'You must configure your SQL database'
|
|
706
|
+
)
|
|
707
|
+
})
|
|
708
|
+
|
|
709
|
+
it('should set up Express middleware', async () => {
|
|
710
|
+
const useSpy = jest.spyOn(instance.app, 'use')
|
|
711
|
+
const getSpy = jest.spyOn(instance.app, 'get')
|
|
712
|
+
const postSpy = jest.spyOn(instance.app, 'post')
|
|
713
|
+
const listenSpy = jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
714
|
+
callback()
|
|
715
|
+
return {} as any
|
|
716
|
+
})
|
|
717
|
+
|
|
718
|
+
await instance.start()
|
|
719
|
+
|
|
720
|
+
expect(useSpy).toHaveBeenCalled()
|
|
721
|
+
expect(getSpy).toHaveBeenCalled()
|
|
722
|
+
expect(postSpy).toHaveBeenCalled()
|
|
723
|
+
expect(listenSpy).toHaveBeenCalledWith(3000, expect.any(Function))
|
|
724
|
+
})
|
|
725
|
+
|
|
726
|
+
it('should set up CORS middleware', async () => {
|
|
727
|
+
const useSpy = jest.spyOn(instance.app, 'use')
|
|
728
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
729
|
+
callback()
|
|
730
|
+
return {} as any
|
|
731
|
+
})
|
|
732
|
+
|
|
733
|
+
await instance.start()
|
|
734
|
+
|
|
735
|
+
// Find CORS middleware call
|
|
736
|
+
const corsMiddleware = useSpy.mock.calls.find((call: any) => {
|
|
737
|
+
const fn = call[0]
|
|
738
|
+
return typeof fn === 'function' && fn.length === 3
|
|
739
|
+
})
|
|
740
|
+
expect(corsMiddleware).toBeDefined()
|
|
741
|
+
})
|
|
742
|
+
|
|
743
|
+
it('should register health check route', async () => {
|
|
744
|
+
const getSpy = jest.spyOn(instance.app, 'get')
|
|
745
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
746
|
+
callback()
|
|
747
|
+
return {} as any
|
|
748
|
+
})
|
|
749
|
+
|
|
750
|
+
await instance.start()
|
|
751
|
+
|
|
752
|
+
const healthRoute = getSpy.mock.calls.find(call => call[0] === '/health')
|
|
753
|
+
expect(healthRoute).toBeDefined()
|
|
754
|
+
})
|
|
755
|
+
|
|
756
|
+
it('should register admin routes', async () => {
|
|
757
|
+
const postSpy = jest.spyOn(instance.app, 'post')
|
|
758
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
759
|
+
callback()
|
|
760
|
+
return {} as any
|
|
761
|
+
})
|
|
762
|
+
|
|
763
|
+
await instance.start()
|
|
764
|
+
|
|
765
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/admin/syncAdvertisements')).toBe(true)
|
|
766
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/admin/startGASPSync')).toBe(true)
|
|
767
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/admin/evictOutpoint')).toBe(true)
|
|
768
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/admin/janitor')).toBe(true)
|
|
769
|
+
})
|
|
770
|
+
|
|
771
|
+
it('should register GASP sync routes when enabled', async () => {
|
|
772
|
+
instance.configureEnableGASPSync(true)
|
|
773
|
+
const postSpy = jest.spyOn(instance.app, 'post')
|
|
774
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
775
|
+
callback()
|
|
776
|
+
return {} as any
|
|
777
|
+
})
|
|
778
|
+
|
|
779
|
+
await instance.start()
|
|
780
|
+
|
|
781
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/requestSyncResponse')).toBe(true)
|
|
782
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/requestForeignGASPNode')).toBe(true)
|
|
783
|
+
})
|
|
784
|
+
|
|
785
|
+
it('should not register GASP sync routes when disabled', async () => {
|
|
786
|
+
instance.configureEnableGASPSync(false)
|
|
787
|
+
const postSpy = jest.spyOn(instance.app, 'post')
|
|
788
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
789
|
+
callback()
|
|
790
|
+
return {} as any
|
|
791
|
+
})
|
|
792
|
+
|
|
793
|
+
await instance.start()
|
|
794
|
+
|
|
795
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/requestSyncResponse')).toBe(false)
|
|
796
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/requestForeignGASPNode')).toBe(false)
|
|
797
|
+
})
|
|
798
|
+
|
|
799
|
+
it('should register ARC ingest route when API key is configured', async () => {
|
|
800
|
+
instance.configureArcApiKey('test-arc-key')
|
|
801
|
+
const postSpy = jest.spyOn(instance.app, 'post')
|
|
802
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
803
|
+
callback()
|
|
804
|
+
return {} as any
|
|
805
|
+
})
|
|
806
|
+
|
|
807
|
+
await instance.start()
|
|
808
|
+
|
|
809
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/arc-ingest')).toBe(true)
|
|
810
|
+
})
|
|
811
|
+
|
|
812
|
+
it('should not register ARC ingest route when API key is not configured', async () => {
|
|
813
|
+
const postSpy = jest.spyOn(instance.app, 'post')
|
|
814
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
815
|
+
callback()
|
|
816
|
+
return {} as any
|
|
817
|
+
})
|
|
818
|
+
|
|
819
|
+
await instance.start()
|
|
820
|
+
|
|
821
|
+
expect(postSpy.mock.calls.some(call => call[0] === '/arc-ingest')).toBe(false)
|
|
822
|
+
})
|
|
823
|
+
|
|
824
|
+
it('should run knex migrations on start', async () => {
|
|
825
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
826
|
+
callback()
|
|
827
|
+
return {} as any
|
|
828
|
+
})
|
|
829
|
+
|
|
830
|
+
await instance.start()
|
|
831
|
+
|
|
832
|
+
expect(mockKnex.migrate.latest).toHaveBeenCalled()
|
|
833
|
+
})
|
|
834
|
+
|
|
835
|
+
it('should call syncAdvertisements on start', async () => {
|
|
836
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
837
|
+
callback()
|
|
838
|
+
return {} as any
|
|
839
|
+
})
|
|
840
|
+
|
|
841
|
+
await instance.start()
|
|
842
|
+
|
|
843
|
+
expect(mockEngine.syncAdvertisements).toHaveBeenCalled()
|
|
844
|
+
})
|
|
845
|
+
|
|
846
|
+
it('should start GASP sync when enabled', async () => {
|
|
847
|
+
instance.configureEnableGASPSync(true)
|
|
848
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
849
|
+
callback()
|
|
850
|
+
return {} as any
|
|
851
|
+
})
|
|
852
|
+
|
|
853
|
+
await instance.start()
|
|
854
|
+
|
|
855
|
+
expect(mockEngine.startGASPSync).toHaveBeenCalled()
|
|
856
|
+
})
|
|
857
|
+
|
|
858
|
+
it('should not start GASP sync when disabled', async () => {
|
|
859
|
+
instance.configureEnableGASPSync(false)
|
|
860
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
861
|
+
callback()
|
|
862
|
+
return {} as any
|
|
863
|
+
})
|
|
864
|
+
|
|
865
|
+
await instance.start()
|
|
866
|
+
|
|
867
|
+
expect(mockEngine.startGASPSync).not.toHaveBeenCalled()
|
|
868
|
+
})
|
|
869
|
+
|
|
870
|
+
it('should enable verbose request logging when configured', async () => {
|
|
871
|
+
instance.configureVerboseRequestLogging(true)
|
|
872
|
+
const useSpy = jest.spyOn(instance.app, 'use')
|
|
873
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
874
|
+
callback()
|
|
875
|
+
return {} as any
|
|
876
|
+
})
|
|
877
|
+
|
|
878
|
+
await instance.start()
|
|
879
|
+
|
|
880
|
+
// Verbose logging middleware should be registered
|
|
881
|
+
expect(useSpy).toHaveBeenCalled()
|
|
882
|
+
})
|
|
883
|
+
|
|
884
|
+
it('should initialize advertiser if it is WalletAdvertiser', async () => {
|
|
885
|
+
const mockAdvertiser: any = {
|
|
886
|
+
// @ts-expect-error - Mock return value
|
|
887
|
+
init: jest.fn().mockResolvedValue(undefined),
|
|
888
|
+
createAdvertisements: jest.fn(),
|
|
889
|
+
findAllAdvertisements: jest.fn(),
|
|
890
|
+
revokeAdvertisements: jest.fn(),
|
|
891
|
+
parseAdvertisement: jest.fn()
|
|
892
|
+
}
|
|
893
|
+
instance.engine.advertiser = mockAdvertiser
|
|
894
|
+
|
|
895
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
896
|
+
callback()
|
|
897
|
+
return {} as any
|
|
898
|
+
})
|
|
899
|
+
|
|
900
|
+
// Mock the instanceof check
|
|
901
|
+
// eslint-disable-next-line @typescript-eslint/no-var-requires
|
|
902
|
+
const DiscoveryServices = require('@bsv/overlay-discovery-services')
|
|
903
|
+
Object.defineProperty(mockAdvertiser, 'constructor', {
|
|
904
|
+
value: DiscoveryServices.WalletAdvertiser
|
|
905
|
+
})
|
|
906
|
+
|
|
907
|
+
await instance.start()
|
|
908
|
+
|
|
909
|
+
// The init method may or may not be called depending on instanceof check
|
|
910
|
+
// Just verify start completes without error
|
|
911
|
+
expect(instance.app.listen).toHaveBeenCalled()
|
|
912
|
+
})
|
|
913
|
+
|
|
914
|
+
it('should handle syncAdvertisements errors gracefully', async () => {
|
|
915
|
+
mockEngine.syncAdvertisements.mockRejectedValueOnce(new Error('Sync failed'))
|
|
916
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
917
|
+
callback()
|
|
918
|
+
return {} as any
|
|
919
|
+
})
|
|
920
|
+
|
|
921
|
+
// Should not throw, just log the error
|
|
922
|
+
await expect(instance.start()).resolves.not.toThrow()
|
|
923
|
+
})
|
|
924
|
+
|
|
925
|
+
it('should handle startGASPSync errors gracefully', async () => {
|
|
926
|
+
instance.configureEnableGASPSync(true)
|
|
927
|
+
mockEngine.startGASPSync.mockRejectedValueOnce(new Error('GASP sync failed'))
|
|
928
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
929
|
+
callback()
|
|
930
|
+
return {} as any
|
|
931
|
+
})
|
|
932
|
+
|
|
933
|
+
// Should not throw, just log the error
|
|
934
|
+
await expect(instance.start()).resolves.not.toThrow()
|
|
935
|
+
})
|
|
936
|
+
|
|
937
|
+
it('should listen on configured port', async () => {
|
|
938
|
+
instance.configurePort(8080)
|
|
939
|
+
const listenSpy = jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
940
|
+
callback()
|
|
941
|
+
return {} as any
|
|
942
|
+
})
|
|
943
|
+
|
|
944
|
+
await instance.start()
|
|
945
|
+
|
|
946
|
+
expect(listenSpy).toHaveBeenCalledWith(8080, expect.any(Function))
|
|
947
|
+
})
|
|
948
|
+
|
|
949
|
+
it('should register 404 handler', async () => {
|
|
950
|
+
const useSpy = jest.spyOn(instance.app, 'use')
|
|
951
|
+
jest.spyOn(instance.app, 'listen').mockImplementation((port: any, callback: any) => {
|
|
952
|
+
callback()
|
|
953
|
+
return {} as any
|
|
954
|
+
})
|
|
955
|
+
|
|
956
|
+
await instance.start()
|
|
957
|
+
|
|
958
|
+
// 404 handler should be the last middleware
|
|
959
|
+
const lastUse = useSpy.mock.calls[useSpy.mock.calls.length - 1]
|
|
960
|
+
expect(lastUse).toBeDefined()
|
|
961
|
+
expect(typeof lastUse[0]).toBe('function')
|
|
962
|
+
})
|
|
963
|
+
})
|
|
964
|
+
|
|
965
|
+
describe('InMemoryMigrationSource', () => {
|
|
966
|
+
it('should be tested via OverlayExpress start method', () => {
|
|
967
|
+
// InMemoryMigrationSource is an internal class used by start()
|
|
968
|
+
// It's covered by the start() tests above
|
|
969
|
+
expect(true).toBe(true)
|
|
970
|
+
})
|
|
971
|
+
})
|
|
972
|
+
})
|