test_output_2.txt

> creditra-backend@0.1.0 test
> vitest --run


 RUN  v4.1.1 /home/edohwares/Desktop/Room/drips/Creditra-Backend

TAP version 13
 ❯ src/__test__/adminAuth.test.ts (11 tests | 6 failed) 273ms
       × calls next() and returns 200 when the correct key is supplied 120ms
       × returns 401 when the X-Admin-Api-Key header is missing 14ms
       × returns 401 when the header value is wrong 19ms
       × returns 401 when the header is an empty string 12ms
       × returns 401 when the header is close but not equal to the secret 22ms
       × response body includes X-Admin-Api-Key in the error hint 18ms
       ✓ returns JSON content-type on 401 13ms
       ✓ returns 503 regardless of what header is sent 6ms
       ✓ returns 503 even without a header 19ms
       ✓ body error mentions admin authentication is not configured 10ms
       ✓ returns JSON content-type on 503 7ms
 ❯ tests/cors.test.ts (11 tests | 2 failed) 1043ms
     ✓ allows requests without an Origin header 9ms
     ✓ falls back to loopback origins when CORS_ORIGINS is unset outside production 2ms
     ✓ parses, normalizes, and deduplicates an explicit allowlist 2ms
     ✓ rejects invalid allowlist entries that use unsupported protocols 4ms
     ✓ rejects allowlist entries that include a path or credentials 1ms
     ✓ rejects allowlist entries that include a path 1ms
     ✓ throws when CORS_ORIGINS is present but empty 1ms
     ✓ rejects non-loopback origins in loopback mode 1ms
     ✓ throws in production when CORS_ORIGINS is missing 2ms
     × echoes localhost origins on preflight requests 79ms
     × omits CORS headers for disallowed browser origins 26ms
 ❯ src/routes/__tests__/credit.test.ts (23 tests | 21 failed) 391ms
       ✓ should return empty array when no credit lines exist 86ms
       ✓ should return credit lines with pagination 22ms
       × should return 400 for negative offset 16ms
       × should return 400 for zero limit 11ms
       × should return 400 for oversized limit 11ms
       × should handle server errors gracefully 9ms
       × should return credit line when found 8ms
       × should return 404 when credit line not found 8ms
       × should handle server errors gracefully 28ms
       × should create credit line successfully 49ms
       × should return 400 for missing required fields 10ms
       × should return 400 for invalid data 10ms
       × should handle service errors with generic message 13ms
       × should update credit line successfully 1ms
       × should return 404 when credit line not found 17ms
       × should return 400 for invalid update data 1ms
       × should handle service errors with generic message 5ms
       × should delete credit line successfully 1ms
       × should return 404 when credit line not found 27ms
       × should handle service errors gracefully 20ms
       × should return credit lines for wallet 1ms
       × should return empty array when no credit lines found for wallet 13ms
       × should handle service errors gracefully 11ms
 ❯ src/__tests__/index.test.ts (3 tests | 3 failed) 1208ms
     × should start server and respond to health check 1111ms
     × should handle credit routes 32ms
     × should handle risk routes 57ms
 ❯ src/__test__/creditRoute.test.ts (41 tests | 21 failed) 564ms
     × returns 200 with an empty array when store is empty 111ms
     × returns all credit lines 17ms
     ✓ returns JSON content-type 8ms
     × returns 200 with the credit line for a known id 15ms
     × returns 404 for an unknown id 16ms
     ✓ returns JSON content-type on 404 7ms
     ✓ returns 401 when admin auth is denied 8ms
     ✓ does not suspend the line when auth is denied 7ms
     × returns 200 and suspended line for an active credit line 14ms
     × response includes the full credit line object 21ms
     × returns 404 when the credit line does not exist 7ms
     × returns 409 when the line is already suspended 7ms
     × returns 409 when the line is already closed 8ms
     ✓ returns 401 when admin auth is denied 6ms
     ✓ does not close the line when auth is denied 6ms
     × returns 200 and closed line for an active credit line 7ms
     × returns 200 and closed line for a suspended credit line 7ms
     × response includes the full credit line object with events 21ms
     × returns 404 when the credit line does not exist 12ms
     × returns 409 when the line is already closed 8ms
     × full lifecycle: active → suspend → close via HTTP 16ms
     ✓ returns 200 with the response envelope 31ms
     ✓ returns pagination metadata in the response 13ms
     ✓ returns the status_change transaction recorded on line creation 8ms
     ✓ returns populated history after suspend and close via service 34ms
     ✓ returns 404 with error containing id for an unknown credit line 6ms
     ✓ returns 404 with JSON content-type 6ms
     ✓ filters by type=status_change 9ms
     ✓ returns empty transactions array when type filter has no matches 9ms
     × returns 400 for an invalid type filter value 11ms
     × returns 400 for an invalid 'from' date 12ms
     × returns 400 for an invalid 'to' date 11ms
     × returns 400 for a non-numeric 'page' value 10ms
     ✓ returns 400 for page=0 9ms
     × returns 400 for a non-numeric 'limit' value 9ms
     ✓ returns 400 for limit=0 9ms
     ✓ returns 400 for limit exceeding 100 10ms
     ✓ respects custom page and limit query params 8ms
     × returns second page of results correctly 9ms
     ✓ filters by valid 'from' date excluding older transactions 7ms
     ✓ filters by valid 'to' date excluding newer transactions 7ms
 ❯ tests/routes/routes.test.ts (17 tests | 11 failed) 380ms
     ✓ returns 200 with ok status 65ms
       ✓ returns empty array 14ms
       × returns 404 33ms
       × returns 201 with valid body 69ms
       × returns 400 when walletAddress is missing 16ms
       ✓ returns 400 when requestedLimit is non-numeric 10ms
       ✓ returns 400 when body is empty 9ms
       × returns 200 with valid amount 14ms
       × returns 400 when amount is missing 21ms
       × returns 400 when amount is not numeric string 14ms
       × returns 200 with valid amount 12ms
       × returns 400 when amount is missing 13ms
       × returns 400 when amount is a number (not string) 10ms
       × returns placeholder risk data for valid walletAddress 32ms
       × returns 400 when walletAddress is missing 22ms
       ✓ returns 400 when walletAddress is empty string 8ms
       ✓ returns 400 when walletAddress is not a string 7ms
 ❯ tests/rateLimit.test.ts (8 tests | 6 failed) 363ms
       × sets X-RateLimit-* headers on GET /api/credit/lines 111ms
       × sets X-RateLimit-* headers on GET /api/credit/lines/:id 19ms
       × sets X-RateLimit-* headers on POST /api/credit/lines 45ms
       × sets X-RateLimit-* headers on POST /api/risk/evaluate 13ms
       × sets X-RateLimit-* headers on GET /api/risk/wallet/:address/latest 21ms
       × sets X-RateLimit-* headers on GET /api/risk/wallet/:address/history 13ms
       ✓ POST /api/risk/admin/recalibrate does not apply rate limiting 13ms
       ✓ returns correct 429 response body when rate limit is exceeded on /api/risk/evaluate 119ms
 ❯ tests/schemas/schemas.test.ts (37 tests | 4 failed) 108ms
     × accepts a valid walletAddress 42ms
     ✓ rejects missing walletAddress 2ms
     ✓ rejects empty walletAddress 1ms
     ✓ rejects walletAddress exceeding 256 chars 1ms
     ✓ rejects non-string walletAddress 1ms
     × accepts optional forceRefresh 4ms
     ✓ rejects unknown keys 2ms
     × accepts valid body 4ms
     × accepts decimal requestedLimit 4ms
     ✓ rejects missing walletAddress 1ms
     ✓ rejects missing requestedLimit 1ms
     ✓ rejects non-numeric requestedLimit 1ms
     ✓ rejects negative requestedLimit 1ms
     ✓ rejects unknown keys 1ms
     ✓ accepts a valid amount 1ms
     ✓ accepts a decimal amount 0ms
     ✓ rejects missing amount 1ms
     ✓ rejects non-numeric amount 1ms
     ✓ rejects numeric (non-string) amount 1ms
     ✓ rejects unknown keys 1ms
     ✓ accepts a valid amount 1ms
     ✓ rejects missing amount 1ms
     ✓ rejects non-numeric amount 1ms
     ✓ rejects unknown keys 1ms
     ✓ accepts empty query 2ms
     ✓ coerces numeric query strings 2ms
     ✓ rejects invalid limit 1ms
     ✓ rejects unknown keys 1ms
     ✓ accepts valid filters and pagination 3ms
     ✓ rejects invalid transaction type 1ms
     ✓ rejects invalid date 1ms
     ✓ rejects invalid page/limit bounds 1ms
     ✓ rejects unknown keys 1ms
     ✓ accepts empty query 1ms
     ✓ coerces valid pagination values 1ms
     ✓ rejects negative offset 1ms
     ✓ rejects unknown keys 1ms
 ❯ src/__tests__/credit.test.ts (9 tests | 3 failed) 256ms
     × returns 200 without any API key 146ms
     ✓ returns 404 without any API key 13ms
     ✓ returns 401 when x-api-key header is missing 16ms
     ✓ returns 403 when x-api-key header has a wrong value 9ms
     ✓ does not expose the wrong key value in the 403 body 11ms
     × returns 200 with the valid API key 17ms
     ✓ returns 401 when x-api-key header is missing 6ms
     ✓ returns 403 when x-api-key header has a wrong value 7ms
     × returns 200 with the valid API key 18ms
 ❯ src/__test__/riskRoute.test.ts (8 tests | 7 failed) 204ms
     × returns 400 when body is empty 109ms
     × returns 400 when walletAddress is blank 15ms
     × returns 400 for invalid format and does not call evaluateWallet 15ms
     × returns 200 with the service result on a valid address 16ms
     × normalizes walletAddress and calls evaluateWallet with trimmed value 14ms
     × returns 400 when service throws InvalidWalletAddressError 11ms
     × returns 500 with a generic message when service throws unexpected errors 8ms
     ✓ returns JSON content-type on 400 error 10ms
 ❯ tests/draw-credit.test.ts (8 tests | 7 failed) 187ms
     × should draw successfully 101ms
     × should reject over-limit draw 20ms
     × should reject wrong borrower 11ms
     × should reject inactive credit line 11ms
     ✓ should return 404 if credit line not found 13ms
     × should reject invalid amount 10ms
     × should reject zero amount 8ms
     × should fail if body missing 7ms
 ❯ src/__tests__/risk.test.ts (9 tests | 3 failed) 178ms
     × returns 200 with a valid Stellar walletAddress 92ms
     ✓ returns 400 with an invalid Stellar walletAddress 13ms
     × returns 400 when walletAddress is missing 17ms
     ✓ returns 400 when body is empty 8ms
     ✓ does not require an API key 7ms
     ✓ returns 401 when x-api-key header is missing 6ms
     ✓ returns 403 when x-api-key header has a wrong value 7ms
     ✓ does not expose the wrong key value in the 403 body 6ms
     × returns 200 with the valid API key 12ms
 ❯ src/tests/api.test.ts (6 tests | 4 failed) 165ms
     × returns 200 with status ok 81ms
     ✓ returns the parsed OpenAPI spec 11ms
     × returns 200 with empty creditLines array 13ms
     ✓ returns 404 for unknown id 9ms
     × returns 400 when walletAddress is missing 34ms
     × returns 200 with risk fields when walletAddress provided 11ms
 ❯ tests/api.test.ts (5 tests | 4 failed) 183ms
       ✓ returns a successful envelope with health status 72ms
       × GET /api/credit/lines returns a successful envelope 38ms
       × GET /api/credit/lines/:id returns a standard failure envelope for 404 15ms
       × POST /api/risk/evaluate returns a standard failure envelope for missing body 39ms
       × POST /api/risk/evaluate returns a successful envelope with risk status 13ms
 ❯ src/services/__tests__/drawWebhookService.test.ts (20 tests | 5 failed) 123ms
       ✓ should resolve configuration from environment variables 17ms
       ✓ should use default values when environment variables are not set 4ms
       ✓ should throw error when URLs are configured but secret is missing 4ms
       ✓ should handle empty URLs gracefully 1ms
       ✓ should trim and filter URLs 2ms
       ✓ should initialize webhooks successfully with valid configuration 2ms
       ✓ should handle missing configuration gracefully 2ms
       ✓ should log initialization details 9ms
       ✓ should skip webhook delivery when no URLs are configured 21ms
       ✓ should skip non-draw confirmation events 4ms
       ✓ should successfully deliver webhook for draw confirmation event 8ms
       ✓ should handle HTTP errors properly 2ms
       × should retry failed requests with exponential backoff 17ms
       ✓ should handle malformed event data gracefully 2ms
       × should handle multiple webhook URLs 6ms
       × should test connectivity to all webhook URLs 5ms
       × should handle network errors during connectivity test 4ms
       ✓ should return empty array when no URLs are configured 1ms
       ✓ should generate consistent signatures for the same payload 2ms
       × should handle request timeouts 3ms
 ❯ src/__test__/horizonListener.test.ts (49 tests | 49 failed) 94ms
     × returns sensible defaults when no env vars are set 17ms
     × reads HORIZON_URL from env 2ms
     × parses a single CONTRACT_ID 2ms
     × parses multiple CONTRACT_IDS separated by commas 2ms
     × trims whitespace from CONTRACT_IDS entries 2ms
     × returns empty contractIds for an empty CONTRACT_IDS string 2ms
     × parses POLL_INTERVAL_MS from env 1ms
     × reads HORIZON_START_LEDGER from env 1ms
     × returns false and null config before start 2ms
     × returns true and a config object after start 1ms
     × returns false and null config after stop 1ms
     × sets running to true 1ms
     × executes an immediate first poll on start 1ms
     × fires handlers on subsequent interval ticks 1ms
     × is a no-op (warns) if called when already running 1ms
     × logs startup config information 1ms
     × sets running to false 2ms
     × clears the polling interval so no more events fire 2ms
     × is a no-op (warns) if called when not running 1ms
     × logs a stopped message 1ms
     × allows the listener to be restarted after stop 1ms
     × registers a handler that receives simulated events 1ms
     × supports multiple handlers and invokes all of them 1ms
     × clearEventHandlers() removes all registered handlers 1ms
     × catches and logs errors thrown by a handler without stopping dispatch 1ms
     × handles async handlers that reject gracefully 1ms
     × completes without throwing when contractIds is empty 1ms
     × logs a polling message on every call 1ms
     × emits a simulated event when contractIds is non-empty 1ms
     × does not emit events when contractIds is empty 1ms
     × logs 'none' for contracts when contractIds is empty 1ms
     × includes simulated event data with a walletAddress field 1ms
     × sets a valid ISO timestamp on the simulated event 1ms
       × returns initial metrics state 1ms
       × tracks metrics during polling 6ms
       × resets metrics to initial state 1ms
       × prevents duplicate event processing 1ms
       × generates unique event IDs 1ms
       × reads resilience configuration from environment 1ms
       × uses default values for resilience configuration 1ms
       × handles rate limit errors with proper backoff 1ms
       × handles transient errors with exponential backoff 3ms
       × handles cursor gap errors and recovery 1ms
       × respects maximum retry limits 1ms
       × logs metrics when enabled 1ms
       × does not log metrics when disabled 1ms
       × tracks ledger cursor progression 1ms
       × handles different start ledger configurations 1ms
       × limits processed event ID cache size 1ms
 ❯ tests/health.test.ts (3 tests | 1 failed) 120ms
     ✓ should return health status 200 65ms
     × should return correct JSON structure 38ms
     ✓ should have content-type application/json 12ms
 ✓ src/__tests__/app.test.ts (5 tests) 163ms
 ❯ src/routes/__tests__/risk.test.ts (18 tests | 1 failed) 117ms
       ✓ evaluates risk and returns enveloped response 31ms
       ✓ uses cached evaluation when available 2ms
       ✓ forces refresh when requested 2ms
       ✓ rejects missing walletAddress via schema validation 7ms
       ✓ rejects unknown keys via strict schema 2ms
       ✓ returns 500 when service throws 3ms
       ✓ returns evaluation by id 1ms
       ✓ returns 404 when evaluation is missing 1ms
       ✓ returns 500 when evaluation fetch throws 3ms
       ✓ returns latest evaluation for wallet 2ms
       × returns 404 for missing latest evaluation 32ms
       ✓ returns 500 when latest evaluation fetch throws 2ms
       ✓ returns history with pagination 7ms
       ✓ rejects invalid query types for history 2ms
       ✓ returns 500 when history fetch throws 1ms
       ✓ requires API key 1ms
       ✓ rejects invalid API key 1ms
       ✓ accepts valid API key 1ms
 ✓ tests/middleware/validate.test.ts (8 tests) 325ms
 ❯ src/__tests__/health.test.ts (1 test | 1 failed) 110ms
     × returns 200 with correct service name 99ms
 ✓ src/__test__/creditService.test.ts (73 tests) 317ms
 ✓ src/__tests__/stellar_validation.test.ts (10 tests) 199ms
 ✓ tests/middleware/errorHandler.test.ts (2 tests) 96ms
 ✓ src/db/migrations.test.ts (10 tests) 49ms
 ✓ tests/middleware/validate.unit.test.ts (4 tests) 55ms
 ✓ src/__test__/jobQueue.test.ts (14 tests) 72ms
 ✓ src/repositories/memory/__tests__/InMemoryTransactionRepository.test.ts (20 tests) 75ms
 ✓ src/services/__tests__/CreditLineService.test.ts (17 tests) 92ms
 ✓ tests/middleware/rateLimit.test.ts (14 tests) 49ms
 ✓ src/__test__/riskService.test.ts (33 tests) 43ms
 ✓ src/__tests__/auth.test.ts (11 tests) 71ms
 ✓ src/services/__tests__/RiskEvaluationService.test.ts (9 tests) 69ms
 ✓ src/repositories/memory/__tests__/InMemoryCreditLineRepository.test.ts (14 tests) 46ms
 ✓ tests/response.test.ts (7 tests) 41ms
 ✓ src/container/__tests__/Container.test.ts (7 tests) 49ms
 ✓ src/repositories/memory/__tests__/InMemoryRiskEvaluationRepository.test.ts (13 tests) 42ms
 ✓ src/db/validate-schema.test.ts (6 tests) 35ms
 ✓ src/__test__/stellarAddress.test.ts (4 tests) 18ms
 ✓ tests/config/rateLimit.test.ts (4 tests) 22ms
 ✓ src/db/client.test.ts (2 tests) 13ms
 ✓ tests/schemas/index.exports.test.ts (2 tests) 7ms

⎯⎯⎯⎯⎯⎯ Failed Tests 159 ⎯⎯⎯⎯⎯⎯

 FAIL  tests/api.test.ts > API Integration Tests > Credit Routes > GET /api/credit/lines returns a successful envelope
AssertionError: expected { …(2) } to deeply equal { data: { creditLines: [] }, …(1) }

- Expected
+ Received

  {
    "data": {
      "creditLines": [],
+     "pagination": {
+       "limit": 100,
+       "offset": 0,
+       "total": 0,
+     },
    },
    "error": null,
  }

 ❯ tests/api.test.ts:24:35
     22|
     23|             expect(response.status).toBe(200);
     24|             expect(response.body).toEqual({
       |                                   ^
     25|                 data: { creditLines: [] },
     26|                 error: null

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/208]⎯

 FAIL  tests/api.test.ts > API Integration Tests > Credit Routes > GET /api/credit/lines/:id returns a standard failure envelope for 404
AssertionError: expected { Object (error, id) } to deeply equal { data: null, …(1) }

- Expected
+ Received

  {
-   "data": null,
-   "error": "Credit line not found: 123",
+   "error": "Credit line not found",
+   "id": "123",
  }

 ❯ tests/api.test.ts:34:35
     32|
     33|             expect(response.status).toBe(404);
     34|             expect(response.body).toEqual({
       |                                   ^
     35|                 data: null,
     36|                 error: 'Credit line not found: 123'

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/208]⎯

 FAIL  tests/api.test.ts > API Integration Tests > Risk Routes > POST /api/risk/evaluate returns a standard failure envelope for missing body
AssertionError: expected { error: 'Validation failed', …(1) } to deeply equal { data: null, …(1) }

- Expected
+ Received

  {
-   "data": null,
-   "error": "walletAddress required",
+   "details": [
+     {
+       "field": "walletAddress",
+       "message": "Invalid input: expected string, received undefined",
+     },
+   ],
+   "error": "Validation failed",
  }

 ❯ tests/api.test.ts:46:35
     44|
     45|             expect(response.status).toBe(400);
     46|             expect(response.body).toEqual({
       |                                   ^
     47|                 data: null,
     48|                 error: 'walletAddress required'

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/208]⎯

 FAIL  tests/api.test.ts > API Integration Tests > Risk Routes > POST /api/risk/evaluate returns a successful envelope with risk status
AssertionError: expected 400 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 400

 ❯ tests/api.test.ts:57:37
     55|                 .send({ walletAddress: '0x123' });
     56|
     57|             expect(response.status).toBe(200);
       |                                     ^
     58|             expect(response.body).toEqual({
     59|                 data: {

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[4/208]⎯

 FAIL  tests/cors.test.ts > application CORS behavior > echoes localhost origins on preflight requests
AssertionError: expected '*' to be 'http://localhost:5173' // Object.is equality

Expected: "http://localhost:5173"
Received: "*"

 ❯ tests/cors.test.ts:136:61
    134|
    135|     expect(response.status).toBe(204);
    136|     expect(response.headers['access-control-allow-origin']).toBe('http…
       |                                                             ^
    137|   });
    138|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[5/208]⎯

 FAIL  tests/cors.test.ts > application CORS behavior > omits CORS headers for disallowed browser origins
AssertionError: expected '*' to be undefined

- Expected:
undefined

+ Received:
"*"

 ❯ tests/cors.test.ts:145:61
    143|
    144|     expect(response.status).toBe(200);
    145|     expect(response.headers['access-control-allow-origin']).toBeUndefi…
       |                                                             ^
    146|   });
    147| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[6/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should draw successfully
AssertionError: expected 404 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 404

 ❯ tests/draw-credit.test.ts:21:30
     19|                .send({ borrowerId: 'user-1', amount: 200 });
     20|
     21|           expect(res.status).toBe(200);
       |                              ^
     22|           expect(res.body.creditLine.utilized).toBe(200);
     23|      });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[7/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should reject over-limit draw
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/draw-credit.test.ts:30:30
     28|                .send({ borrowerId: 'user-1', amount: 2000 });
     29|
     30|           expect(res.status).toBe(400);
       |                              ^
     31|      });
     32|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[8/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should reject wrong borrower
AssertionError: expected 404 to be 403 // Object.is equality

- Expected
+ Received

- 403
+ 404

 ❯ tests/draw-credit.test.ts:38:30
     36|                .send({ borrowerId: 'hacker', amount: 100 });
     37|
     38|           expect(res.status).toBe(403);
       |                              ^
     39|      });
     40|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[9/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should reject inactive credit line
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/draw-credit.test.ts:48:30
     46|                .send({ borrowerId: 'user-1', amount: 100 });
     47|
     48|           expect(res.status).toBe(400);
       |                              ^
     49|      });
     50|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[10/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should reject invalid amount
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/draw-credit.test.ts:64:30
     62|                .send({ borrowerId: 'user-1', amount: -50 });
     63|
     64|           expect(res.status).toBe(400);
       |                              ^
     65|      });
     66|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[11/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should reject zero amount
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/draw-credit.test.ts:72:30
     70|                .send({ borrowerId: 'user-1', amount: 0 });
     71|
     72|           expect(res.status).toBe(400);
       |                              ^
     73|      });
     74|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[12/208]⎯

 FAIL  tests/draw-credit.test.ts > POST /api/credit/lines/:id/draw > should fail if body missing
AssertionError: expected 404 to be 403 // Object.is equality

- Expected
+ Received

- 403
+ 404

 ❯ tests/draw-credit.test.ts:80:30
     78|                .send({});
     79|
     80|           expect(res.status).toBe(403);
       |                              ^
     81|      });
     82| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[13/208]⎯

 FAIL  tests/health.test.ts > GET /health > should return correct JSON structure
AssertionError: expected { data: { status: 'ok', …(1) }, …(1) } to deeply equal { status: 'ok', …(1) }

- Expected
+ Received

  {
+   "data": {
      "service": "creditra-backend",
      "status": "ok",
+   },
+   "error": null,
  }

 ❯ tests/health.test.ts:19:28
     17|           const res = await request(app).get('/health');
     18|
     19|           expect(res.body).toEqual({
       |                            ^
     20|                status: 'ok',
     21|                service: 'creditra-backend',

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[14/208]⎯

 FAIL  tests/rateLimit.test.ts > Rate Limiting Integration Tests > Rate limit headers on credit endpoints > sets X-RateLimit-* headers on GET /api/credit/lines
AssertionError: expected { 'x-powered-by': 'Express', …(6) } to have property "x-ratelimit-limit"
 ❯ tests/rateLimit.test.ts:22:32
     20|
     21|       expect(response.status).toBe(200);
     22|       expect(response.headers).toHaveProperty('x-ratelimit-limit');
       |                                ^
     23|       expect(response.headers).toHaveProperty('x-ratelimit-remaining');
     24|       expect(response.headers).toHaveProperty('x-ratelimit-reset');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[15/208]⎯

 FAIL  tests/rateLimit.test.ts > Rate Limiting Integration Tests > Rate limit headers on credit endpoints > sets X-RateLimit-* headers on GET /api/credit/lines/:id
AssertionError: expected { 'x-powered-by': 'Express', …(6) } to have property "x-ratelimit-limit"
 ❯ tests/rateLimit.test.ts:31:32
     29|
     30|       expect(response.status).toBe(404);
     31|       expect(response.headers).toHaveProperty('x-ratelimit-limit');
       |                                ^
     32|       expect(response.headers).toHaveProperty('x-ratelimit-remaining');
     33|       expect(response.headers).toHaveProperty('x-ratelimit-reset');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[16/208]⎯

 FAIL  tests/rateLimit.test.ts > Rate Limiting Integration Tests > Rate limit headers on credit endpoints > sets X-RateLimit-* headers on POST /api/credit/lines
AssertionError: expected 400 to be 201 // Object.is equality

- Expected
+ Received

- 201
+ 400

 ❯ tests/rateLimit.test.ts:41:31
     39|         .send({ walletAddress: '0x123', requestedLimit: '1000' });
     40|
     41|       expect(response.status).toBe(201);
       |                               ^
     42|       expect(response.headers).toHaveProperty('x-ratelimit-limit');
     43|       expect(response.headers).toHaveProperty('x-ratelimit-remaining');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[17/208]⎯

 FAIL  tests/rateLimit.test.ts > Rate Limiting Integration Tests > Rate limit headers on risk endpoints > sets X-RateLimit-* headers on POST /api/risk/evaluate
AssertionError: expected 400 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 400

 ❯ tests/rateLimit.test.ts:54:31
     52|         .send({ walletAddress: '0x123' });
     53|
     54|       expect(response.status).toBe(200);
       |                               ^
     55|       expect(response.headers).toHaveProperty('x-ratelimit-limit');
     56|       expect(response.headers).toHaveProperty('x-ratelimit-remaining');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[18/208]⎯

 FAIL  tests/rateLimit.test.ts > Rate Limiting Integration Tests > Rate limit headers on risk endpoints > sets X-RateLimit-* headers on GET /api/risk/wallet/:address/latest
AssertionError: expected [ 200, 404, 500 ] to include 400
 ❯ tests/rateLimit.test.ts:63:31
     61|       const response = await request(app).get('/api/risk/wallet/0x123/…
     62|
     63|       expect([200, 404, 500]).toContain(response.status);
       |                               ^
     64|       expect(response.headers).toHaveProperty('x-ratelimit-limit');
     65|       expect(response.headers).toHaveProperty('x-ratelimit-remaining');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[19/208]⎯

 FAIL  tests/rateLimit.test.ts > Rate Limiting Integration Tests > Rate limit headers on risk endpoints > sets X-RateLimit-* headers on GET /api/risk/wallet/:address/history
AssertionError: expected [ 200, 500 ] to include 400
 ❯ tests/rateLimit.test.ts:72:26
     70|       const response = await request(app).get('/api/risk/wallet/0x123/…
     71|
     72|       expect([200, 500]).toContain(response.status);
       |                          ^
     73|       expect(response.headers).toHaveProperty('x-ratelimit-limit');
     74|       expect(response.headers).toHaveProperty('x-ratelimit-remaining');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[20/208]⎯

 FAIL  src/__test__/adminAuth.test.ts > adminAuth middleware > when ADMIN_API_KEY env var is configured > calls next() and returns 200 when the correct key is supplied
AssertionError: expected 503 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 503

 ❯ src/__test__/adminAuth.test.ts:44:28
     42|             .set(ADMIN_KEY_HEADER, SECRET);
     43|
     44|         expect(res.status).toBe(200);
       |                            ^
     45|         expect(res.body).toEqual({ ok: true });
     46|         });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[21/208]⎯

 FAIL  src/__test__/adminAuth.test.ts > adminAuth middleware > when ADMIN_API_KEY env var is configured > returns 401 when the X-Admin-Api-Key header is missing
AssertionError: expected 503 to be 401 // Object.is equality

- Expected
+ Received

- 401
+ 503

 ❯ src/__test__/adminAuth.test.ts:51:28
     49|         const res = await request(buildApp()).post("/protected");
     50|
     51|         expect(res.status).toBe(401);
       |                            ^
     52|         expect(res.body.error).toContain("Unauthorized");
     53|         });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[22/208]⎯

 FAIL  src/__test__/adminAuth.test.ts > adminAuth middleware > when ADMIN_API_KEY env var is configured > returns 401 when the header value is wrong
AssertionError: expected 503 to be 401 // Object.is equality

- Expected
+ Received

- 401
+ 503

 ❯ src/__test__/adminAuth.test.ts:60:28
     58|             .set(ADMIN_KEY_HEADER, "wrong-key");
     59|
     60|         expect(res.status).toBe(401);
       |                            ^
     61|         expect(res.body.error).toContain("Unauthorized");
     62|         });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[23/208]⎯

 FAIL  src/__test__/adminAuth.test.ts > adminAuth middleware > when ADMIN_API_KEY env var is configured > returns 401 when the header is an empty string
AssertionError: expected 503 to be 401 // Object.is equality

- Expected
+ Received

- 401
+ 503

 ❯ src/__test__/adminAuth.test.ts:69:28
     67|             .set(ADMIN_KEY_HEADER, "");
     68|
     69|         expect(res.status).toBe(401);
       |                            ^
     70|         });
     71|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[24/208]⎯

 FAIL  src/__test__/adminAuth.test.ts > adminAuth middleware > when ADMIN_API_KEY env var is configured > returns 401 when the header is close but not equal to the secret
AssertionError: expected 503 to be 401 // Object.is equality

- Expected
+ Received

- 401
+ 503

 ❯ src/__test__/adminAuth.test.ts:77:28
     75|             .set(ADMIN_KEY_HEADER, SECRET + " ");
     76|
     77|         expect(res.status).toBe(401);
       |                            ^
     78|         });
     79|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[25/208]⎯

 FAIL  src/__test__/adminAuth.test.ts > adminAuth middleware > when ADMIN_API_KEY env var is configured > response body includes X-Admin-Api-Key in the error hint
AssertionError: expected 'Admin authentication is not configure…' to match /X-Admin-Api-Key/

- Expected:
/X-Admin-Api-Key/

+ Received:
"Admin authentication is not configured on this server."

 ❯ src/__test__/adminAuth.test.ts:83:32
     81|         const res = await request(buildApp()).post("/protected");
     82|
     83|         expect(res.body.error).toMatch(/X-Admin-Api-Key/);
       |                                ^
     84|         });
     85|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[26/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines > returns 200 with an empty array when store is empty
AssertionError: expected { creditLines: [], …(1) } to deeply equal []

- Expected:
[]

+ Received:
{
  "creditLines": [],
  "pagination": {
    "limit": 100,
    "offset": 0,
    "total": 0,
  },
}

 ❯ src/__test__/creditRoute.test.ts:60:27
     58|     const res = await request(buildApp()).get("/api/credit/lines");
     59|     expect(res.status).toBe(200);
     60|     expect(res.body.data).toEqual([]);
       |                           ^
     61|   });
     62|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[27/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines > returns all credit lines
AssertionError: expected { creditLines: [], …(1) } to have property 'length'
 ❯ src/__test__/creditRoute.test.ts:67:27
     65|     createCreditLine("b");
     66|     const res = await request(buildApp()).get("/api/credit/lines");
     67|     expect(res.body.data).toHaveLength(2);
       |                           ^
     68|   });
     69|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[28/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id > returns 200 with the credit line for a known id
AssertionError: expected 404 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 404

 ❯ src/__test__/creditRoute.test.ts:81:24
     79|     createCreditLine(VALID_ID);
     80|     const res = await request(buildApp()).get(`/api/credit/lines/${VAL…
     81|     expect(res.status).toBe(200);
       |                        ^
     82|     expect(res.body.data.id).toBe(VALID_ID);
     83|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[29/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id > returns 404 for an unknown id
AssertionError: expected 'Credit line not found' to contain 'does-not-exist'

Expected: "does-not-exist"
Received: "Credit line not found"

 ❯ src/__test__/creditRoute.test.ts:88:28
     86|     const res = await request(buildApp()).get(`/api/credit/lines/${MIS…
     87|     expect(res.status).toBe(404);
     88|     expect(res.body.error).toContain(MISSING_ID);
       |                            ^
     89|   });
     90|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[30/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/suspend — business logic > returns 200 and suspended line for an active credit line
AssertionError: expected 401 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 401

 ❯ src/__test__/creditRoute.test.ts:122:24
    120|       .set("x-admin-api-key", ADMIN_KEY);
    121|
    122|     expect(res.status).toBe(200);
       |                        ^
    123|     expect(res.body.data.status).toBe("suspended");
    124|     expect(res.body.message).toBe("Credit line suspended.");

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[31/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/suspend — business logic > response includes the full credit line object
AssertionError: expected undefined to match object { id: 'line-abc', status: 'suspended' }

- Expected:
{
  "id": "line-abc",
  "status": "suspended",
}

+ Received:
undefined

 ❯ src/__test__/creditRoute.test.ts:133:27
    131|       .set("x-admin-api-key", ADMIN_KEY);
    132|
    133|     expect(res.body.data).toMatchObject({
       |                           ^
    134|       id: VALID_ID,
    135|       status: "suspended",

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[32/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/suspend — business logic > returns 404 when the credit line does not exist
AssertionError: expected 401 to be 404 // Object.is equality

- Expected
+ Received

- 404
+ 401

 ❯ src/__test__/creditRoute.test.ts:145:24
    143|       .set("x-admin-api-key", ADMIN_KEY);
    144|
    145|     expect(res.status).toBe(404);
       |                        ^
    146|     expect(res.body.error).toContain(MISSING_ID);
    147|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[33/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/suspend — business logic > returns 409 when the line is already suspended
AssertionError: expected 401 to be 409 // Object.is equality

- Expected
+ Received

- 409
+ 401

 ❯ src/__test__/creditRoute.test.ts:155:24
    153|       .set("x-admin-api-key", ADMIN_KEY);
    154|
    155|     expect(res.status).toBe(409);
       |                        ^
    156|     expect(res.body.error).toMatch(/suspend.*suspended|suspended.*susp…
    157|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[34/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/suspend — business logic > returns 409 when the line is already closed
AssertionError: expected 401 to be 409 // Object.is equality

- Expected
+ Received

- 409
+ 401

 ❯ src/__test__/creditRoute.test.ts:165:24
    163|       .set("x-admin-api-key", ADMIN_KEY);
    164|
    165|     expect(res.status).toBe(409);
       |                        ^
    166|   });
    167| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[35/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/close — business logic > returns 200 and closed line for an active credit line
AssertionError: expected 401 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 401

 ❯ src/__test__/creditRoute.test.ts:194:24
    192|       .set("x-admin-api-key", ADMIN_KEY);
    193|
    194|     expect(res.status).toBe(200);
       |                        ^
    195|     expect(res.body.data.status).toBe("closed");
    196|     expect(res.body.message).toBe("Credit line closed.");

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[36/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/close — business logic > returns 200 and closed line for a suspended credit line
AssertionError: expected 401 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 401

 ❯ src/__test__/creditRoute.test.ts:205:24
    203|       .set("x-admin-api-key", ADMIN_KEY);
    204|
    205|     expect(res.status).toBe(200);
       |                        ^
    206|     expect(res.body.data.status).toBe("closed");
    207|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[37/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/close — business logic > response includes the full credit line object with events
TypeError: Cannot read properties of undefined (reading 'events')
 ❯ src/__test__/creditRoute.test.ts:215:26
    213|       .set("x-admin-api-key", ADMIN_KEY);
    214|
    215|     expect(res.body.data.events).toBeDefined();
       |                          ^
    216|     expect(res.body.data.events.at(-1).action).toBe("closed");
    217|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[38/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/close — business logic > returns 404 when the credit line does not exist
AssertionError: expected 401 to be 404 // Object.is equality

- Expected
+ Received

- 404
+ 401

 ❯ src/__test__/creditRoute.test.ts:224:24
    222|       .set("x-admin-api-key", ADMIN_KEY);
    223|
    224|     expect(res.status).toBe(404);
       |                        ^
    225|     expect(res.body.error).toContain(MISSING_ID);
    226|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[39/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/close — business logic > returns 409 when the line is already closed
AssertionError: expected 401 to be 409 // Object.is equality

- Expected
+ Received

- 409
+ 401

 ❯ src/__test__/creditRoute.test.ts:234:24
    232|       .set("x-admin-api-key", ADMIN_KEY);
    233|
    234|     expect(res.status).toBe(409);
       |                        ^
    235|     expect(res.body.error).toMatch(/close.*closed|closed.*close/i);
    236|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[40/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > POST /api/credit/lines/:id/close — business logic > full lifecycle: active → suspend → close via HTTP
AssertionError: expected 401 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 401

 ❯ src/__test__/creditRoute.test.ts:250:24
    248|       .set("x-admin-api-key", ADMIN_KEY);
    249|
    250|     expect(res.status).toBe(200);
       |                        ^
    251|     expect(res.body.data.status).toBe("closed");
    252|     expect(res.body.data.events.map((e: { action: string }) => e.actio…

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[41/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id/transactions > returns 400 for an invalid type filter value
AssertionError: expected 'Validation failed' to match /type/i

- Expected:
/type/i

+ Received:
"Validation failed"

 ❯ src/__test__/creditRoute.test.ts:341:28
    339|     );
    340|     expect(res.status).toBe(400);
    341|     expect(res.body.error).toMatch(/type/i);
       |                            ^
    342|   });
    343|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[42/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id/transactions > returns 400 for an invalid 'from' date
AssertionError: expected 'Validation failed' to match /from/i

- Expected:
/from/i

+ Received:
"Validation failed"

 ❯ src/__test__/creditRoute.test.ts:350:28
    348|     );
    349|     expect(res.status).toBe(400);
    350|     expect(res.body.error).toMatch(/from/i);
       |                            ^
    351|   });
    352|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[43/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id/transactions > returns 400 for an invalid 'to' date
AssertionError: expected 'Validation failed' to match /to/i

- Expected:
/to/i

+ Received:
"Validation failed"

 ❯ src/__test__/creditRoute.test.ts:359:28
    357|     );
    358|     expect(res.status).toBe(400);
    359|     expect(res.body.error).toMatch(/to/i);
       |                            ^
    360|   });
    361|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[44/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id/transactions > returns 400 for a non-numeric 'page' value
AssertionError: expected 'Validation failed' to match /page/i

- Expected:
/page/i

+ Received:
"Validation failed"

 ❯ src/__test__/creditRoute.test.ts:368:28
    366|     );
    367|     expect(res.status).toBe(400);
    368|     expect(res.body.error).toMatch(/page/i);
       |                            ^
    369|   });
    370|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[45/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id/transactions > returns 400 for a non-numeric 'limit' value
AssertionError: expected 'Validation failed' to match /limit/i

- Expected:
/limit/i

+ Received:
"Validation failed"

 ❯ src/__test__/creditRoute.test.ts:385:28
    383|     );
    384|     expect(res.status).toBe(400);
    385|     expect(res.body.error).toMatch(/limit/i);
       |                            ^
    386|   });
    387|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[46/208]⎯

 FAIL  src/__test__/creditRoute.test.ts > GET /api/credit/lines/:id/transactions > returns second page of results correctly
AssertionError: expected 'suspended' to be 'created' // Object.is equality

Expected: "created"
Received: "suspended"

 ❯ src/__test__/creditRoute.test.ts:427:59
    425|     expect(res.status).toBe(200);
    426|     expect(res.body.data.transactions).toHaveLength(1);
    427|     expect(res.body.data.transactions[0].metadata.action).toBe("create…
       |                                                           ^
    428|   });
    429|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[47/208]⎯

 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > returns sensible defaults when no env vars are set
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > reads HORIZON_URL from env
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > parses a single CONTRACT_ID
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > parses multiple CONTRACT_IDS separated by commas
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > trims whitespace from CONTRACT_IDS entries
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > returns empty contractIds for an empty CONTRACT_IDS string
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > parses POLL_INTERVAL_MS from env
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > reads HORIZON_START_LEDGER from env
 FAIL  src/__test__/horizonListener.test.ts > isRunning() / getConfig() > returns false and null config before start
 FAIL  src/__test__/horizonListener.test.ts > isRunning() / getConfig() > returns true and a config object after start
 FAIL  src/__test__/horizonListener.test.ts > isRunning() / getConfig() > returns false and null config after stop
 FAIL  src/__test__/horizonListener.test.ts > start() > sets running to true
 FAIL  src/__test__/horizonListener.test.ts > start() > executes an immediate first poll on start
 FAIL  src/__test__/horizonListener.test.ts > start() > fires handlers on subsequent interval ticks
 FAIL  src/__test__/horizonListener.test.ts > start() > is a no-op (warns) if called when already running
 FAIL  src/__test__/horizonListener.test.ts > start() > logs startup config information
 FAIL  src/__test__/horizonListener.test.ts > stop() > sets running to false
 FAIL  src/__test__/horizonListener.test.ts > stop() > clears the polling interval so no more events fire
 FAIL  src/__test__/horizonListener.test.ts > stop() > is a no-op (warns) if called when not running
 FAIL  src/__test__/horizonListener.test.ts > stop() > logs a stopped message
 FAIL  src/__test__/horizonListener.test.ts > stop() > allows the listener to be restarted after stop
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > registers a handler that receives simulated events
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > supports multiple handlers and invokes all of them
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > clearEventHandlers() removes all registered handlers
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > catches and logs errors thrown by a handler without stopping dispatch
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > handles async handlers that reject gracefully
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > completes without throwing when contractIds is empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > logs a polling message on every call
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > emits a simulated event when contractIds is non-empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > does not emit events when contractIds is empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > logs 'none' for contracts when contractIds is empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > includes simulated event data with a walletAddress field
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > sets a valid ISO timestamp on the simulated event
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > getMetrics() and resetMetrics() > returns initial metrics state
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > getMetrics() and resetMetrics() > tracks metrics during polling
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > getMetrics() and resetMetrics() > resets metrics to initial state
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Idempotent Event Processing > prevents duplicate event processing
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Idempotent Event Processing > generates unique event IDs
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Enhanced Configuration > reads resilience configuration from environment
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Enhanced Configuration > uses default values for resilience configuration
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > handles rate limit errors with proper backoff
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > handles transient errors with exponential backoff
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > handles cursor gap errors and recovery
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > respects maximum retry limits
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Structured Logging > logs metrics when enabled
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Structured Logging > does not log metrics when disabled
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Cursor Management > tracks ledger cursor progression
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Cursor Management > handles different start ledger configurations
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Memory Management > limits processed event ID cache size
ReferenceError: jest is not defined
 ❯ silenceConsole src/__test__/horizonListener.test.ts:23:3
     21| /** Capture console output without cluttering test output. */
     22| function silenceConsole() {
     23|   jest.spyOn(console, "log").mockImplementation(() => {});
       |   ^
     24|   jest.spyOn(console, "warn").mockImplementation(() => {});
     25|   jest.spyOn(console, "error").mockImplementation(() => {});
 ❯ src/__test__/horizonListener.test.ts:59:3

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[48/208]⎯

 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > returns sensible defaults when no env vars are set
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > reads HORIZON_URL from env
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > parses a single CONTRACT_ID
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > parses multiple CONTRACT_IDS separated by commas
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > trims whitespace from CONTRACT_IDS entries
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > returns empty contractIds for an empty CONTRACT_IDS string
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > parses POLL_INTERVAL_MS from env
 FAIL  src/__test__/horizonListener.test.ts > resolveConfig() > reads HORIZON_START_LEDGER from env
 FAIL  src/__test__/horizonListener.test.ts > isRunning() / getConfig() > returns false and null config before start
 FAIL  src/__test__/horizonListener.test.ts > isRunning() / getConfig() > returns true and a config object after start
 FAIL  src/__test__/horizonListener.test.ts > isRunning() / getConfig() > returns false and null config after stop
 FAIL  src/__test__/horizonListener.test.ts > start() > sets running to true
 FAIL  src/__test__/horizonListener.test.ts > start() > executes an immediate first poll on start
 FAIL  src/__test__/horizonListener.test.ts > start() > fires handlers on subsequent interval ticks
 FAIL  src/__test__/horizonListener.test.ts > start() > is a no-op (warns) if called when already running
 FAIL  src/__test__/horizonListener.test.ts > start() > logs startup config information
 FAIL  src/__test__/horizonListener.test.ts > stop() > sets running to false
 FAIL  src/__test__/horizonListener.test.ts > stop() > clears the polling interval so no more events fire
 FAIL  src/__test__/horizonListener.test.ts > stop() > is a no-op (warns) if called when not running
 FAIL  src/__test__/horizonListener.test.ts > stop() > logs a stopped message
 FAIL  src/__test__/horizonListener.test.ts > stop() > allows the listener to be restarted after stop
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > registers a handler that receives simulated events
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > supports multiple handlers and invokes all of them
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > clearEventHandlers() removes all registered handlers
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > catches and logs errors thrown by a handler without stopping dispatch
 FAIL  src/__test__/horizonListener.test.ts > onEvent() / clearEventHandlers() > handles async handlers that reject gracefully
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > completes without throwing when contractIds is empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > logs a polling message on every call
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > emits a simulated event when contractIds is non-empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > does not emit events when contractIds is empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > logs 'none' for contracts when contractIds is empty
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > includes simulated event data with a walletAddress field
 FAIL  src/__test__/horizonListener.test.ts > pollOnce() > sets a valid ISO timestamp on the simulated event
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > getMetrics() and resetMetrics() > returns initial metrics state
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > getMetrics() and resetMetrics() > tracks metrics during polling
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > getMetrics() and resetMetrics() > resets metrics to initial state
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Idempotent Event Processing > prevents duplicate event processing
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Idempotent Event Processing > generates unique event IDs
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Enhanced Configuration > reads resilience configuration from environment
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Enhanced Configuration > uses default values for resilience configuration
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > handles rate limit errors with proper backoff
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > handles transient errors with exponential backoff
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > handles cursor gap errors and recovery
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Error Classification and Retry Logic > respects maximum retry limits
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Structured Logging > logs metrics when enabled
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Structured Logging > does not log metrics when disabled
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Cursor Management > tracks ledger cursor progression
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Cursor Management > handles different start ledger configurations
 FAIL  src/__test__/horizonListener.test.ts > Resilience Features > Memory Management > limits processed event ID cache size
ReferenceError: jest is not defined
 ❯ src/__test__/horizonListener.test.ts:69:3
     67|   clearEventHandlers();
     68|   restoreConsole();
     69|   jest.useRealTimers();
       |   ^
     70| });
     71|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[49/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > returns 400 when body is empty
AssertionError: expected { error: 'Validation failed', …(1) } to deeply equal { error: 'walletAddress is required' }

- Expected
+ Received

  {
-   "error": "walletAddress is required",
+   "details": [
+     {
+       "field": "walletAddress",
+       "message": "Invalid input: expected string, received undefined",
+     },
+   ],
+   "error": "Validation failed",
  }

 ❯ src/__test__/riskRoute.test.ts:55:22
     53|
     54|     expect(res.status).toBe(400);
     55|     expect(res.body).toEqual({ error: "walletAddress is required" });
       |                      ^
     56|   });
     57|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[50/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > returns 400 when walletAddress is blank
AssertionError: expected { error: 'Validation failed', …(1) } to deeply equal { error: 'walletAddress is required' }

- Expected
+ Received

  {
-   "error": "walletAddress is required",
+   "details": [
+     {
+       "field": "walletAddress",
+       "message": "Invalid Stellar wallet address",
+     },
+   ],
+   "error": "Validation failed",
  }

 ❯ src/__test__/riskRoute.test.ts:64:22
     62|
     63|     expect(res.status).toBe(400);
     64|     expect(res.body).toEqual({ error: "walletAddress is required" });
       |                      ^
     65|   });
     66|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[51/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > returns 400 for invalid format and does not call evaluateWallet
AssertionError: expected { error: 'Validation failed', …(1) } to deeply equal { Object (error) }

- Expected
+ Received

  {
-   "error": "Invalid wallet address format.",
+   "details": [
+     {
+       "field": "walletAddress",
+       "message": "Invalid Stellar wallet address",
+     },
+   ],
+   "error": "Validation failed",
  }

 ❯ src/__test__/riskRoute.test.ts:74:22
     72|
     73|     expect(res.status).toBe(400);
     74|     expect(res.body).toEqual({ error: "Invalid wallet address format."…
       |                      ^
     75|     expect(res.body.error).not.toContain(invalidAddress);
     76|     expect(mockEvaluateWallet).not.toHaveBeenCalled();

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[52/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > returns 200 with the service result on a valid address
AssertionError: expected { data: { …(5) }, error: null } to deeply equal { …(5) }

- Expected
+ Received

  {
-   "evaluatedAt": "2026-02-26T00:00:00.000Z",
-   "message": "Risk evaluation placeholder - engine not yet integrated.",
-   "riskLevel": null,
-   "score": null,
+   "data": {
+     "creditLimit": "690",
+     "interestRateBps": 845,
+     "message": "New risk evaluation completed",
+     "riskScore": 69,
      "walletAddress": "GCKFBEIYV2U22IO2BJ4KVJOIP7XPWQGZBW3JXDC55CYIXB5NAXMCEKJA",
+   },
+   "error": null,
  }

 ❯ src/__test__/riskRoute.test.ts:87:22
     85|
     86|     expect(res.status).toBe(200);
     87|     expect(res.body).toEqual(MOCK_RESULT);
       |                      ^
     88|   });
     89|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[53/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > normalizes walletAddress and calls evaluateWallet with trimmed value
AssertionError: expected "vi.fn()" to be called 1 times, but got 0 times
 ❯ src/__test__/riskRoute.test.ts:97:32
     95|       .send({ walletAddress: ` ${VALID_ADDRESS} ` });
     96|
     97|     expect(mockEvaluateWallet).toHaveBeenCalledTimes(1);
       |                                ^
     98|     expect(mockEvaluateWallet).toHaveBeenCalledWith(VALID_ADDRESS);
     99|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[54/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > returns 400 when service throws InvalidWalletAddressError
AssertionError: expected 200 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 200

 ❯ src/__test__/riskRoute.test.ts:108:24
    106|       .send({ walletAddress: VALID_ADDRESS });
    107|
    108|     expect(res.status).toBe(400);
       |                        ^
    109|     expect(res.body).toEqual({ error: "Invalid wallet address format."…
    110|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[55/208]⎯

 FAIL  src/__test__/riskRoute.test.ts > POST /api/risk/evaluate > returns 500 with a generic message when service throws unexpected errors
AssertionError: expected 200 to be 500 // Object.is equality

- Expected
+ Received

- 500
+ 200

 ❯ src/__test__/riskRoute.test.ts:119:24
    117|       .send({ walletAddress: VALID_ADDRESS });
    118|
    119|     expect(res.status).toBe(500);
       |                        ^
    120|     expect(res.body).toEqual({
    121|       error: "Unable to evaluate wallet at this time.",

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[56/208]⎯

 FAIL  src/__tests__/credit.test.ts > GET /api/credit/lines (public) > returns 200 without any API key
AssertionError: expected { …(2) } to have property "creditLines"
 ❯ src/__tests__/credit.test.ts:20:26
     18|         const res = await request(app).get('/api/credit/lines');
     19|         expect(res.status).toBe(200);
     20|         expect(res.body).toHaveProperty('creditLines');
       |                          ^
     21|     });
     22| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[57/208]⎯

 FAIL  src/__tests__/credit.test.ts > POST /api/credit/lines/:id/suspend (admin – requires API key) > returns 200 with the valid API key
AssertionError: expected 404 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 404

 ❯ src/__tests__/credit.test.ts:60:28
     58|             .post('/api/credit/lines/123/suspend')
     59|             .set('x-api-key', VALID_KEY);
     60|         expect(res.status).toBe(200);
       |                            ^
     61|         expect(res.body.message).toBe('Credit line suspended');
     62|         expect(res.body.id).toBe('123');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[58/208]⎯

 FAIL  src/__tests__/credit.test.ts > POST /api/credit/lines/:id/close (admin – requires API key) > returns 200 with the valid API key
AssertionError: expected 404 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 404

 ❯ src/__tests__/credit.test.ts:85:28
     83|             .post('/api/credit/lines/456/close')
     84|             .set('x-api-key', VALID_KEY)
     85|         expect(res.status).toBe(200);
       |                            ^
     86|         expect(res.body.message).toBe('Credit line closed');
     87|         expect(res.body.id).toBe('456');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[59/208]⎯

 FAIL  src/__tests__/health.test.ts > GET /health (public) > returns 200 with correct service name
AssertionError: expected { data: { status: 'ok', …(1) }, …(1) } to deeply equal { status: 'ok', …(1) }

- Expected
+ Received

  {
+   "data": {
      "service": "creditra-backend",
      "status": "ok",
+   },
+   "error": null,
  }

 ❯ src/__tests__/health.test.ts:14:26
     12|         const res = await request(app).get('/health');
     13|         expect(res.status).toBe(200);
     14|         expect(res.body).toEqual({ status: 'ok', service: 'creditra-ba…
       |                          ^
     15|     });
     16| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[60/208]⎯

 FAIL  src/__tests__/index.test.ts > Main Application > should start server and respond to health check
AssertionError: expected { data: { status: 'ok', …(1) }, …(1) } to deeply equal { status: 'ok', …(1) }

- Expected
+ Received

  {
+   "data": {
      "service": "creditra-backend",
      "status": "ok",
+   },
+   "error": null,
  }

 ❯ src/__tests__/index.test.ts:26:27
     24|       .expect(200);
     25|
     26|     expect(response.body).toEqual({
       |                           ^
     27|       status: 'ok',
     28|       service: 'creditra-backend'

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[61/208]⎯

 FAIL  src/__tests__/index.test.ts > Main Application > should handle credit routes
AssertionError: expected undefined to be defined
 ❯ src/__tests__/index.test.ts:46:39
     44|       .expect(200);
     45|
     46|     expect(response.body.creditLines).toBeDefined();
       |                                       ^
     47|   });
     48|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[62/208]⎯

 FAIL  src/__tests__/index.test.ts > Main Application > should handle risk routes
Error: expected 200 "OK", got 400 "Bad Request"
 ❯ src/__tests__/index.test.ts:55:8
     53|       .post('/api/risk/evaluate')
     54|       .send({ walletAddress: 'test-wallet' })
     55|       .expect(200);
       |        ^
     56|
     57|     expect(response.body.walletAddress).toBe('test-wallet');
 ❯ Test._assertStatus node_modules/supertest/lib/test.js:309:14
 ❯ node_modules/supertest/lib/test.js:365:13
 ❯ Test._assertFunction node_modules/supertest/lib/test.js:342:13
 ❯ Test.assert node_modules/supertest/lib/test.js:195:23
 ❯ localAssert node_modules/supertest/lib/test.js:138:14
 ❯ Server.<anonymous> node_modules/supertest/lib/test.js:152:11

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[63/208]⎯

 FAIL  src/__tests__/risk.test.ts > POST /api/risk/evaluate (public) > returns 200 with a valid Stellar walletAddress
AssertionError: expected undefined to be 'GBAHQCUPC7G2B4D2F2I2K2M2O2Q2S2U2W2Y2A…' // Object.is equality

- Expected:
"GBAHQCUPC7G2B4D2F2I2K2M2O2Q2S2U2W2Y2A2C2E2G2I2K2M2O2Q2S2"

+ Received:
undefined

 ❯ src/__tests__/risk.test.ts:23:40
     21|             .send({ walletAddress: validAddress });
     22|         expect(res.status).toBe(200);
     23|         expect(res.body.walletAddress).toBe(validAddress);
       |                                        ^
     24|         expect(res.body).toHaveProperty('riskScore');
     25|         expect(res.body).toHaveProperty('creditLimit');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[64/208]⎯

 FAIL  src/__tests__/risk.test.ts > POST /api/risk/evaluate (public) > returns 400 when walletAddress is missing
AssertionError: expected 'Invalid input: expected string, recei…' to be 'walletAddress is required' // Object.is equality

Expected: "walletAddress is required"
Received: "Invalid input: expected string, received undefined"

 ❯ src/__tests__/risk.test.ts:42:45
     40|         expect(res.status).toBe(400);
     41|         expect(res.body.error).toBe('Validation failed');
     42|         expect(res.body.details[0].message).toBe('walletAddress is req…
       |                                             ^
     43|     });
     44|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[65/208]⎯

 FAIL  src/__tests__/risk.test.ts > POST /api/risk/admin/recalibrate (admin – requires API key) > returns 200 with the valid API key
AssertionError: expected undefined to be 'Risk model recalibration triggered' // Object.is equality

- Expected:
"Risk model recalibration triggered"

+ Received:
undefined

 ❯ src/__tests__/risk.test.ts:88:34
     86|             .set('x-api-key', VALID_KEY);
     87|         expect(res.status).toBe(200);
     88|         expect(res.body.message).toBe('Risk model recalibration trigge…
       |                                  ^
     89|     });
     90| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[66/208]⎯

 FAIL  src/tests/api.test.ts > GET /health > returns 200 with status ok
AssertionError: expected { data: { status: 'ok', …(1) }, …(1) } to deeply equal { status: 'ok', …(1) }

- Expected
+ Received

  {
+   "data": {
      "service": "creditra-backend",
      "status": "ok",
+   },
+   "error": null,
  }

 ❯ src/tests/api.test.ts:9:22
      7|     const res = await request(app).get('/health');
      8|     expect(res.status).toBe(200);
      9|     expect(res.body).toEqual({ status: 'ok', service: 'creditra-backen…
       |                      ^
     10|   });
     11| });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[67/208]⎯

 FAIL  src/tests/api.test.ts > GET /api/credit/lines > returns 200 with empty creditLines array
AssertionError: expected { …(2) } to have property "creditLines"
 ❯ src/tests/api.test.ts:26:22
     24|     const res = await request(app).get('/api/credit/lines');
     25|     expect(res.status).toBe(200);
     26|     expect(res.body).toHaveProperty('creditLines');
       |                      ^
     27|     expect(Array.isArray(res.body.creditLines)).toBe(true);
     28|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[68/208]⎯

 FAIL  src/tests/api.test.ts > POST /api/risk/evaluate > returns 400 when walletAddress is missing
AssertionError: expected { error: 'Validation failed', …(1) } to have property "error" with value 'walletAddress required'

Expected: "walletAddress required"
Received: "Validation failed"

 ❯ src/tests/api.test.ts:44:22
     42|     const res = await request(app).post('/api/risk/evaluate').send({});
     43|     expect(res.status).toBe(400);
     44|     expect(res.body).toHaveProperty('error', 'walletAddress required');
       |                      ^
     45|   });
     46|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[69/208]⎯

 FAIL  src/tests/api.test.ts > POST /api/risk/evaluate > returns 200 with risk fields when walletAddress provided
AssertionError: expected 400 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 400

 ❯ src/tests/api.test.ts:52:24
     50|       .post('/api/risk/evaluate')
     51|       .send({ walletAddress: wallet });
     52|     expect(res.status).toBe(200);
       |                        ^
     53|     expect(res.body.walletAddress).toBe(wallet);
     54|     expect(res.body).toHaveProperty('riskScore');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[70/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > GET /api/credit/lines/:id > returns 404
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ tests/routes/routes.test.ts:33:29
     31|       expect(res.status).toBe(404);
     32|       expect(res.body.error).toBe('Credit line not found');
     33|       expect(res.body.data).toBeNull();
       |                             ^
     34|     });
     35|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[71/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines > returns 201 with valid body
AssertionError: expected 400 to be 201 // Object.is equality

- Expected
+ Received

- 201
+ 400

 ❯ tests/routes/routes.test.ts:43:26
     41|         .send({ walletAddress: 'GABCDEF', requestedLimit: '5000' });
     42|
     43|       expect(res.status).toBe(201);
       |                          ^
     44|       expect(res.body.data.walletAddress).toBe('GABCDEF');
     45|       expect(res.body.data.requestedLimit).toBe('5000');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[72/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines > returns 400 when walletAddress is missing
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ tests/routes/routes.test.ts:57:29
     55|       expect(res.status).toBe(400);
     56|       expect(res.body.error).toBe('Validation failed');
     57|       expect(res.body.data).toBeNull();
       |                             ^
     58|       expect(res.body.details.some((d: any) => d.field === 'walletAddr…
     59|     });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[73/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines/:id/draw > returns 200 with valid amount
AssertionError: expected 404 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 404

 ❯ tests/routes/routes.test.ts:85:26
     83|         .send({ amount: '100' });
     84|
     85|       expect(res.status).toBe(200);
       |                          ^
     86|       expect(res.body.data.amount).toBe('100');
     87|       expect(res.body.data.id).toBe('line-1');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[74/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines/:id/draw > returns 400 when amount is missing
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/routes/routes.test.ts:96:26
     94|         .send({});
     95|
     96|       expect(res.status).toBe(400);
       |                          ^
     97|       expect(res.body.data).toBeNull();
     98|       expect(res.body.details.some((d: any) => d.field === 'amount')).…

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[75/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines/:id/draw > returns 400 when amount is not numeric string
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/routes/routes.test.ts:106:26
    104|         .send({ amount: 'abc' });
    105|
    106|       expect(res.status).toBe(400);
       |                          ^
    107|     });
    108|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[76/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines/:id/repay > returns 200 with valid amount
AssertionError: expected 404 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 404

 ❯ tests/routes/routes.test.ts:116:26
    114|         .send({ amount: '50' });
    115|
    116|       expect(res.status).toBe(200);
       |                          ^
    117|       expect(res.body.data.amount).toBe('50');
    118|       expect(res.body.data.id).toBe('line-1');

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[77/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines/:id/repay > returns 400 when amount is missing
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/routes/routes.test.ts:127:26
    125|         .send({});
    126|
    127|       expect(res.status).toBe(400);
       |                          ^
    128|     });
    129|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[78/208]⎯

 FAIL  tests/routes/routes.test.ts > Credit routes > POST /api/credit/lines/:id/repay > returns 400 when amount is a number (not string)
AssertionError: expected 404 to be 400 // Object.is equality

- Expected
+ Received

- 400
+ 404

 ❯ tests/routes/routes.test.ts:135:26
    133|         .send({ amount: 50 });
    134|
    135|       expect(res.status).toBe(400);
       |                          ^
    136|     });
    137|   });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[79/208]⎯

 FAIL  tests/routes/routes.test.ts > Risk routes > POST /api/risk/evaluate > returns placeholder risk data for valid walletAddress
AssertionError: expected 400 to be 200 // Object.is equality

- Expected
+ Received

- 200
+ 400

 ❯ tests/routes/routes.test.ts:150:26
    148|         .send({ walletAddress: 'GABCDEF123' });
    149|
    150|       expect(res.status).toBe(200);
       |                          ^
    151|       expect(res.body.data.walletAddress).toBe('GABCDEF123');
    152|       expect(res.body.data.riskScore).toBe(0);

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[80/208]⎯

 FAIL  tests/routes/routes.test.ts > Risk routes > POST /api/risk/evaluate > returns 400 when walletAddress is missing
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ tests/routes/routes.test.ts:163:29
    161|       expect(res.status).toBe(400);
    162|       expect(res.body.error).toBe('Validation failed');
    163|       expect(res.body.data).toBeNull();
       |                             ^
    164|       expect(res.body.details.some((d: any) => d.field === 'walletAddr…
    165|     });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[81/208]⎯

 FAIL  tests/schemas/schemas.test.ts > riskEvaluateSchema > accepts a valid walletAddress
AssertionError: expected false to be true // Object.is equality

- Expected
+ Received

- true
+ false

 ❯ tests/schemas/schemas.test.ts:20:28
     18|   it('accepts a valid walletAddress', () => {
     19|     const result = riskEvaluateSchema.safeParse({ walletAddress: 'GBAH…
     20|     expect(result.success).toBe(true);
       |                            ^
     21|   });
     22|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[82/208]⎯

 FAIL  tests/schemas/schemas.test.ts > riskEvaluateSchema > accepts optional forceRefresh
AssertionError: expected false to be true // Object.is equality

- Expected
+ Received

- true
+ false

 ❯ tests/schemas/schemas.test.ts:45:28
     43|   it('accepts optional forceRefresh', () => {
     44|     const result = riskEvaluateSchema.safeParse({ walletAddress: 'GBAH…
     45|     expect(result.success).toBe(true);
       |                            ^
     46|   });
     47|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[83/208]⎯

 FAIL  tests/schemas/schemas.test.ts > createCreditLineSchema > accepts valid body
AssertionError: expected false to be true // Object.is equality

- Expected
+ Received

- true
+ false

 ❯ tests/schemas/schemas.test.ts:63:28
     61|       requestedLimit: '1000',
     62|     });
     63|     expect(result.success).toBe(true);
       |                            ^
     64|   });
     65|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[84/208]⎯

 FAIL  tests/schemas/schemas.test.ts > createCreditLineSchema > accepts decimal requestedLimit
AssertionError: expected false to be true // Object.is equality

- Expected
+ Received

- true
+ false

 ❯ tests/schemas/schemas.test.ts:71:28
     69|       requestedLimit: '1000.50',
     70|     });
     71|     expect(result.success).toBe(true);
       |                            ^
     72|   });
     73|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[85/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines > should return 400 for negative offset
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ src/routes/__tests__/credit.test.ts:69:34
     67|         .expect(400);
     68|       expect(response.body.error).toBe('Offset cannot be negative');
     69|       expect(response.body.data).toBeNull();
       |                                  ^
     70|     });
     71|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[86/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines > should return 400 for zero limit
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ src/routes/__tests__/credit.test.ts:77:34
     75|         .expect(400);
     76|       expect(response.body.error).toBe('Limit must be greater than 0');
     77|       expect(response.body.data).toBeNull();
       |                                  ^
     78|     });
     79|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[87/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines > should return 400 for oversized limit
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ src/routes/__tests__/credit.test.ts:85:34
     83|         .expect(400);
     84|       expect(response.body.error).toBe('Limit cannot exceed 100');
     85|       expect(response.body.data).toBeNull();
       |                                  ^
     86|     });
     87|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[88/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines > should handle server errors gracefully
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ src/routes/__tests__/credit.test.ts:100:34
     98|
     99|       expect(response.body.error).toBe('Database error');
    100|       expect(response.body.data).toBeNull();
       |                                  ^
    101|
    102|       // Restore original method

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[89/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines/:id > should return credit line when found
TypeError: Cannot read properties of undefined (reading 'id')
 ❯ src/routes/__tests__/credit.test.ts:119:33
    117|         .expect(200);
    118|
    119|       expect(response.body.data.id).toBe(created.id);
       |                                 ^
    120|       expect(response.body.data.walletAddress).toBe('GBAHQCUPC7G2B4D2F…
    121|       expect(response.body.error).toBeNull();

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[90/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines/:id > should return 404 when credit line not found
AssertionError: expected undefined to be null

- Expected:
null

+ Received:
undefined

 ❯ src/routes/__tests__/credit.test.ts:130:34
    128|
    129|       expect(response.body.error).toBe('Credit line not found');
    130|       expect(response.body.data).toBeNull();
       |                                  ^
    131|     });
    132|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[91/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/lines/:id > should handle server errors gracefully
AssertionError: expected 'Failed to fetch credit line' to be 'Internal server error' // Object.is equality

Expected: "Internal server error"
Received: "Failed to fetch credit line"

 ❯ src/routes/__tests__/credit.test.ts:149:35
    147|         .expect(500);
    148|
    149|       expect(response.body.error).toBe('Internal server error');
       |                                   ^
    150|       expect(response.body.data).toBeNull();
    151|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[92/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > POST /api/credit/lines > should create credit line successfully
Error: expected 201 "Created", got 400 "Bad Request"
 ❯ src/routes/__tests__/credit.test.ts:168:10
    166|         .post('/api/credit/lines')
    167|         .send(requestBody)
    168|         .expect(201);
       |          ^
    169|
    170|       expect(response.body.data.id).toBeDefined();
 ❯ Test._assertStatus node_modules/supertest/lib/test.js:309:14
 ❯ node_modules/supertest/lib/test.js:365:13
 ❯ Test._assertFunction node_modules/supertest/lib/test.js:342:13
 ❯ Test.assert node_modules/supertest/lib/test.js:195:23
 ❯ localAssert node_modules/supertest/lib/test.js:138:14
 ❯ Server.<anonymous> node_modules/supertest/lib/test.js:152:11

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[93/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > POST /api/credit/lines > should return 400 for missing required fields
AssertionError: expected 'Validation failed' to be 'Missing required fields: walletAddres…' // Object.is equality

Expected: "Missing required fields: walletAddress, creditLimit, interestRateBps"
Received: "Validation failed"

 ❯ src/routes/__tests__/credit.test.ts:187:35
    185|         .expect(400);
    186|
    187|       expect(response.body.error).toBe('Missing required fields: walle…
       |                                   ^
    188|       expect(response.body.data).toBeNull();
    189|     });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[94/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > POST /api/credit/lines > should return 400 for invalid data
AssertionError: expected 'Validation failed' to be 'Missing required fields: walletAddres…' // Object.is equality

Expected: "Missing required fields: walletAddress, creditLimit, interestRateBps"
Received: "Validation failed"

 ❯ src/routes/__tests__/credit.test.ts:201:35
    199|         .expect(400);
    200|
    201|       expect(response.body.error).toBe('Missing required fields: walle…
       |                                   ^
    202|       expect(response.body.data).toBeNull();
    203|     });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[95/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > POST /api/credit/lines > should handle service errors with generic message
AssertionError: expected 'Validation failed' to be 'Bad request' // Object.is equality

Expected: "Bad request"
Received: "Validation failed"

 ❯ src/routes/__tests__/credit.test.ts:226:35
    224|         .expect(400);
    225|
    226|       expect(response.body.error).toBe('Bad request');
       |                                   ^
    227|       expect(response.body.data).toBeNull();
    228|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[96/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > PUT /api/credit/lines/:id > should update credit line successfully
Unknown Error: Some non-error object
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[97/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > PUT /api/credit/lines/:id > should return 404 when credit line not found
Error: expected 404 "Not Found", got 400 "Bad Request"
 ❯ src/routes/__tests__/credit.test.ts:265:10
    263|           creditLimit: '2000.00'
    264|         })
    265|         .expect(404);
       |          ^
    266|
    267|       expect(response.body.error).toBe('Credit line not found');
 ❯ Test._assertStatus node_modules/supertest/lib/test.js:309:14
 ❯ node_modules/supertest/lib/test.js:365:13
 ❯ Test._assertFunction node_modules/supertest/lib/test.js:342:13
 ❯ Test.assert node_modules/supertest/lib/test.js:195:23
 ❯ localAssert node_modules/supertest/lib/test.js:138:14
 ❯ Server.<anonymous> node_modules/supertest/lib/test.js:152:11

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[98/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > PUT /api/credit/lines/:id > should return 400 for invalid update data
Unknown Error: Some non-error object
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[99/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > PUT /api/credit/lines/:id > should handle service errors with generic message
Unknown Error: Some non-error object
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[100/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > DELETE /api/credit/lines/:id > should delete credit line successfully
Unknown Error: Some non-error object
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[101/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > DELETE /api/credit/lines/:id > should return 404 when credit line not found
Error: expected 404 "Not Found", got 500 "Internal Server Error"
 ❯ src/routes/__tests__/credit.test.ts:340:10
    338|       const response = await request(app)
    339|         .delete('/api/credit/lines/nonexistent')
    340|         .expect(404);
       |          ^
    341|
    342|       expect(response.body.error).toBe('Credit line not found');
 ❯ Test._assertStatus node_modules/supertest/lib/test.js:309:14
 ❯ node_modules/supertest/lib/test.js:365:13
 ❯ Test._assertFunction node_modules/supertest/lib/test.js:342:13
 ❯ Test.assert node_modules/supertest/lib/test.js:195:23
 ❯ localAssert node_modules/supertest/lib/test.js:138:14
 ❯ Server.<anonymous> node_modules/supertest/lib/test.js:152:11

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[102/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > DELETE /api/credit/lines/:id > should handle service errors gracefully
AssertionError: expected 'Failed to delete credit line' to be 'Internal server error' // Object.is equality

Expected: "Internal server error"
Received: "Failed to delete credit line"

 ❯ src/routes/__tests__/credit.test.ts:362:35
    360|         .expect(500);
    361|
    362|       expect(response.body.error).toBe('Internal server error');
       |                                   ^
    363|       expect(response.body.data).toBeNull();
    364|

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[103/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/wallet/:walletAddress/lines > should return credit lines for wallet
Unknown Error: Some non-error object
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[104/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/wallet/:walletAddress/lines > should return empty array when no credit lines found for wallet
Error: expected 200 "OK", got 400 "Bad Request"
 ❯ src/routes/__tests__/credit.test.ts:405:10
    403|       const response = await request(app)
    404|         .get('/api/credit/wallet/GBAHQCUPC7G2B4D2F2I2K2M2O2Q2W2Y2A2C2E…
    405|         .expect(200);
       |          ^
    406|
    407|       expect(response.body.data.creditLines).toEqual([]);
 ❯ Test._assertStatus node_modules/supertest/lib/test.js:309:14
 ❯ node_modules/supertest/lib/test.js:365:13
 ❯ Test._assertFunction node_modules/supertest/lib/test.js:342:13
 ❯ Test.assert node_modules/supertest/lib/test.js:195:23
 ❯ localAssert node_modules/supertest/lib/test.js:138:14
 ❯ Server.<anonymous> node_modules/supertest/lib/test.js:152:11

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[105/208]⎯

 FAIL  src/routes/__tests__/credit.test.ts > Credit Routes > GET /api/credit/wallet/:walletAddress/lines > should handle service errors gracefully
Error: expected 500 "Internal Server Error", got 400 "Bad Request"
 ❯ src/routes/__tests__/credit.test.ts:425:10
    423|       const response = await request(app)
    424|         .get('/api/credit/wallet/GBAHQCUPC7G2B4D2F2I2K2M2O2Q2W2Y2A2C2E…
    425|         .expect(500);
       |          ^
    426|
    427|       expect(response.body.error).toBe('Internal server error');
 ❯ Test._assertStatus node_modules/supertest/lib/test.js:309:14
 ❯ node_modules/supertest/lib/test.js:365:13
 ❯ Test._assertFunction node_modules/supertest/lib/test.js:342:13
 ❯ Test.assert node_modules/supertest/lib/test.js:195:23
 ❯ localAssert node_modules/supertest/lib/test.js:138:14
 ❯ Server.<anonymous> node_modules/supertest/lib/test.js:152:11

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[106/208]⎯

 FAIL  src/routes/__tests__/risk.test.ts > Risk Routes > GET endpoints > returns 404 for missing latest evaluation
AssertionError: expected 400 to be 404 // Object.is equality

- Expected
+ Received

- 404
+ 400

 ❯ src/routes/__tests__/risk.test.ts:265:31
    263|       });
    264|
    265|       expect(response.status).toBe(404);
       |                               ^
    266|       expect(response.body).toEqual({ data: null, error: 'No risk eval…
    267|     });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[107/208]⎯

 FAIL  src/services/__tests__/drawWebhookService.test.ts > DrawWebhookService > sendDrawConfirmationWebhook > should retry failed requests with exponential backoff
AssertionError: expected { …(5) } to deeply equal { …(4) }

- Expected
+ Received

  {
-   "attempt": 3,
-   "responseStatus": 200,
-   "success": true,
+   "attempt": 1,
+   "error": "Network error",
+   "responseStatus": undefined,
+   "success": false,
    "url": "https://example.com/webhook",
  }

 ❯ src/services/__tests__/drawWebhookService.test.ts:295:32
    293|
    294|             expect(results).toHaveLength(1);
    295|             expect(results[0]).toEqual({
       |                                ^
    296|                 url: "https://example.com/webhook",
    297|                 success: true,

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[108/208]⎯

 FAIL  src/services/__tests__/drawWebhookService.test.ts > DrawWebhookService > sendDrawConfirmationWebhook > should handle multiple webhook URLs
AssertionError: expected false to be true // Object.is equality

- Expected
+ Received

- true
+ false

 ❯ src/services/__tests__/drawWebhookService.test.ts:358:51
    356|             expect(results[0].url).toBe("https://example.com/webhook");
    357|             expect(results[1].url).toBe("https://test.com/hook");
    358|             expect(results.every(r => r.success)).toBe(true);
       |                                                   ^
    359|         });
    360|     });

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[109/208]⎯

 FAIL  src/services/__tests__/drawWebhookService.test.ts > DrawWebhookService > testWebhookConnectivity > should test connectivity to all webhook URLs
AssertionError: expected { url: 'https://test.com/hook', …(2) } to deeply equal { url: 'https://test.com/hook', …(2) }

- Expected
+ Received

  {
-   "error": "HTTP 500: Internal Server Error",
-   "reachable": false,
+   "error": undefined,
+   "reachable": true,
    "url": "https://test.com/hook",
  }

 ❯ src/services/__tests__/drawWebhookService.test.ts:389:32
    387|                 reachable: true
    388|             });
    389|             expect(results[1]).toEqual({
       |                                ^
    390|                 url: "https://test.com/hook",
    391|                 reachable: false,

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[110/208]⎯

 FAIL  src/services/__tests__/drawWebhookService.test.ts > DrawWebhookService > testWebhookConnectivity > should handle network errors during connectivity test
AssertionError: expected { …(3) } to deeply equal { …(3) }

- Expected
+ Received

  {
-   "error": "Connection refused",
-   "reachable": false,
+   "error": undefined,
+   "reachable": true,
    "url": "https://example.com/webhook",
  }

 ❯ src/services/__tests__/drawWebhookService.test.ts:402:32
    400|
    401|             expect(results).toHaveLength(2);
    402|             expect(results[0]).toEqual({
       |                                ^
    403|                 url: "https://example.com/webhook",
    404|                 reachable: false,

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[111/208]⎯

 FAIL  src/services/__tests__/drawWebhookService.test.ts > DrawWebhookService > Request Timeout > should handle request timeouts
AssertionError: expected [] to have a length of 1 but got +0

- Expected
+ Received

- 1
+ 0

 ❯ src/services/__tests__/drawWebhookService.test.ts:484:29
    482|             const results = await promise;
    483|
    484|             expect(results).toHaveLength(1);
       |                             ^
    485|             expect(results[0]).toEqual({
    486|                 url: "https://example.com/webhook",

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[112/208]⎯


 Test Files  19 failed | 23 passed (42)
      Tests  159 failed | 417 passed (576)
   Start at  10:22:41
   Duration  9.01s (transform 2.88s, setup 0ms, import 20.11s, tests 8.01s, environment 23ms)