observability-toolkit 1.8.5 → 2.1.0

package/dist/server.test.js

@@ -1,20 +1,21 @@
 /**
  * Tests for server.ts - MCP server functionality
  */
-import { describe, it } from 'node:test';
+import { describe, it, beforeEach } from 'vitest';
 import * as assert from 'node:assert';
 import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { DEFAULT_LIMIT_10, SAMPLE_SIZE_100, COUNT_EIGHT, COUNT_FIFTY, COUNT_FIVE, COUNT_FOUR, COUNT_NINE, COUNT_SIXTY, COUNT_THOUSAND, COUNT_THREE, COUNT_TWENTY_FIVE, COUNT_TWO, COUNT_TWO_HUNDRED, SHORT_TIMEOUT_MS_100, } from './test-helpers/test-constants.js';
+import { TIME_MS, SECONDS, ONE_MILLION, } from './lib/core/units.js';
+const TEST_INVALID_QUERY_ARGUMENT_NUMBER = 123;
+const TEST_SERVER_INIT_ERROR_CODE = 123;
 /**
- * Convert Zod schema to JSON Schema for MCP using zod-to-json-schema library.
+ * Convert Zod schema to JSON Schema for MCP using native Zod v4 API.
  * This mirrors the implementation in server.ts
  */
 function convertZodToJsonSchema(zodSchema) {
-    const schema = zodToJsonSchema(zodSchema, {
-        $refStrategy: 'none', // Inline all refs for MCP compatibility
-    });
+    const schema = zodSchema.toJSONSchema?.() ?? {};
     // Remove $schema field as MCP doesn't need it
-    const { $schema, ...rest } = schema;
+    const { $schema: _schema, ...rest } = schema;
     return rest;
 }
 describe('convertZodToJsonSchema', () => {
@@ -54,7 +55,7 @@ describe('convertZodToJsonSchema', () => {
         });
         it('should convert ZodRecord to JSON Schema object', () => {
             const schema = z.object({
-                metadata: z.record(z.string()),
+                metadata: z.record(z.string(), z.string()),
             });
             const result = convertZodToJsonSchema(schema);
             const props = result.properties;
@@ -94,13 +95,13 @@ describe('convertZodToJsonSchema', () => {
     describe('default values', () => {
         it('should include default value in JSON Schema', () => {
             const schema = z.object({
-                limit: z.number().default(50),
+                limit: z.number().default(COUNT_FIFTY),
             });
             const result = convertZodToJsonSchema(schema);
             const props = result.properties;
-            assert.strictEqual(props.limit.default, 50);
+            assert.strictEqual(props.limit.default, COUNT_FIFTY);
         });
-        it('should not include fields with defaults in required array', () => {
+        it('should include fields with defaults in required array', () => {
             const schema = z.object({
                 required: z.string(),
                 withDefault: z.string().default('default-value'),
@@ -108,7 +109,7 @@ describe('convertZodToJsonSchema', () => {
             const result = convertZodToJsonSchema(schema);
             const required = result.required;
             assert.ok(required.includes('required'));
-            assert.ok(!required.includes('withDefault'));
+            assert.ok(required.includes('withDefault'));
         });
         it('should handle enum with default', () => {
             const schema = z.object({
@@ -144,7 +145,7 @@ describe('convertZodToJsonSchema', () => {
             assert.ok(required.includes('required1'));
             assert.ok(required.includes('required2'));
             assert.ok(!required.includes('optional1'));
-            assert.ok(!required.includes('withDefault'));
+            assert.ok(required.includes('withDefault')); // Fields with defaults are still required
             assert.ok(!required.includes('optional2'));
         });
         it('should handle real-world query schema', () => {
@@ -152,18 +153,20 @@ describe('convertZodToJsonSchema', () => {
                 backend: z.enum(['local', 'signoz', 'auto']).default('auto').describe('Backend to query'),
                 traceId: z.string().optional().describe('Filter by trace ID'),
                 serviceName: z.string().optional().describe('Filter by service'),
-                attributeFilter: z.record(z.union([z.string(), z.number(), z.boolean()])).optional().describe('Filter by attributes'),
-                limit: z.number().default(50).describe('Max results'),
+                attributeFilter: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional().describe('Filter by attributes'),
+                limit: z.number().default(COUNT_FIFTY).describe('Max results'),
             });
             const result = convertZodToJsonSchema(schema);
             const props = result.properties;
+            const required = result.required;
             // Verify structure
             assert.strictEqual(result.type, 'object');
-            assert.strictEqual(result.required, undefined); // All fields have defaults or are optional
+            // Fields with defaults are included in required array
+            assert.deepStrictEqual(required, ['backend', 'limit']);
             // Verify individual fields
             assert.deepStrictEqual(props.backend.enum, ['local', 'signoz', 'auto']);
             assert.strictEqual(props.backend.default, 'auto');
-            assert.strictEqual(props.limit.default, 50);
+            assert.strictEqual(props.limit.default, COUNT_FIFTY);
         });
         it('should handle union types (ZodUnion)', () => {
             const schema = z.object({
@@ -207,7 +210,7 @@ function createMockTools() {
             description: 'A test tool for unit testing',
             inputSchema: z.object({
                 query: z.string().describe('Search query'),
-                limit: z.number().default(10).describe('Result limit'),
+                limit: z.number().default(DEFAULT_LIMIT_10).describe('Result limit'),
             }),
             handler: async (input) => {
                 const { query, limit } = input;
@@ -274,7 +277,7 @@ async function handleCallTool(tools, request) {
         // Execute handler
         const result = await tool.handler(input);
         return {
-            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            content: [{ type: 'text', text: JSON.stringify(result, null, COUNT_TWO) }],
         };
     }
     catch (error) {
@@ -290,7 +293,7 @@ describe('ListToolsRequestSchema handler', () => {
     describe('tool listing', () => {
         it('should return all registered tools', () => {
             const result = handleListTools(tools);
-            assert.strictEqual(result.tools.length, 3);
+            assert.strictEqual(result.tools.length, COUNT_THREE);
         });
         it('should include tool name for each tool', () => {
             const result = handleListTools(tools);
@@ -322,7 +325,7 @@ describe('ListToolsRequestSchema handler', () => {
             const result = handleListTools(tools);
             const testTool = result.tools.find(t => t.name === 'test_tool');
             const props = (testTool?.inputSchema).properties;
-            assert.strictEqual(props.limit.default, 10);
+            assert.strictEqual(props.limit.default, DEFAULT_LIMIT_10);
         });
         it('should include descriptions in inputSchema', () => {
             const result = handleListTools(tools);
@@ -335,9 +338,9 @@ describe('ListToolsRequestSchema handler', () => {
             const testTool = result.tools.find(t => t.name === 'test_tool');
             const schema = testTool?.inputSchema;
             const required = schema.required;
-            // 'query' is required, 'limit' has default so not required
+            // 'query' is required, 'limit' has default but is still included in required
             assert.ok(required.includes('query'));
-            assert.ok(!required.includes('limit'));
+            assert.ok(required.includes('limit'));
         });
         it('should handle empty tools array', () => {
             const result = handleListTools([]);
@@ -361,14 +364,14 @@ describe('CallToolRequestSchema handler', () => {
                 params: { name: 'test_tool', arguments: { query: 'test' } },
             });
             const content = JSON.parse(result.content[0].text);
-            assert.strictEqual(content.count, 10); // default limit
+            assert.strictEqual(content.count, DEFAULT_LIMIT_10); // default limit
         });
         it('should use provided values over defaults', async () => {
             const result = await handleCallTool(tools, {
-                params: { name: 'test_tool', arguments: { query: 'test', limit: 25 } },
+                params: { name: 'test_tool', arguments: { query: 'test', limit: COUNT_TWENTY_FIVE } },
             });
             const content = JSON.parse(result.content[0].text);
-            assert.strictEqual(content.count, 25);
+            assert.strictEqual(content.count, COUNT_TWENTY_FIVE);
         });
         it('should handle empty arguments object', async () => {
             const result = await handleCallTool(tools, {
@@ -443,7 +446,7 @@ describe('CallToolRequestSchema handler', () => {
         });
         it('should return error for wrong argument type', async () => {
             const result = await handleCallTool(tools, {
-                params: { name: 'test_tool', arguments: { query: 123 } }, // query should be string
+                params: { name: 'test_tool', arguments: { query: TEST_INVALID_QUERY_ARGUMENT_NUMBER } }, // query should be string
             });
             assert.strictEqual(result.isError, true);
         });
@@ -499,11 +502,11 @@ describe('CallToolRequestSchema handler', () => {
         it('should wait for async handler to complete', async () => {
             const startTime = Date.now();
             const result = await handleCallTool(tools, {
-                params: { name: 'async_tool', arguments: { delay: 50 } },
+                params: { name: 'async_tool', arguments: { delay: COUNT_FIFTY } },
             });
             const elapsed = Date.now() - startTime;
             assert.strictEqual(result.isError, undefined);
-            assert.ok(elapsed >= 50, `Expected at least 50ms delay, got ${elapsed}ms`);
+            assert.ok(elapsed >= COUNT_FIFTY, `Expected at least 50ms delay, got ${elapsed}ms`);
         });
         it('should return result from async handler', async () => {
             const result = await handleCallTool(tools, {
@@ -548,37 +551,41 @@ describe('CallToolRequestSchema handler', () => {
  * Import the RateLimiter and ServerInitError for testing
  * Imported from server-utils to avoid starting the MCP server
  */
-import { RateLimiter, ServerInitError } from './lib/server-utils.js';
+import { RateLimiter, RATE_LIMIT, ServerInitError, resetMonotonicMs } from './lib/core/server-utils.js';
+import { MAX_DURATION_MS, MAX_RESULTS_IN_MEMORY, } from './lib/core/constants.js';
 describe('RateLimiter', () => {
+    beforeEach(() => {
+        resetMonotonicMs();
+    });
     describe('basic functionality', () => {
         it('should allow requests under the limit', () => {
-            const limiter = new RateLimiter(1000, 10, 10);
-            for (let i = 0; i < 10; i++) {
+            const limiter = new RateLimiter(COUNT_THOUSAND, DEFAULT_LIMIT_10, DEFAULT_LIMIT_10);
+            for (let i = 0; i < DEFAULT_LIMIT_10; i++) {
                 assert.strictEqual(limiter.isAllowed(), true, `Request ${i + 1} should be allowed`);
             }
         });
         it('should block requests over the limit', () => {
-            const limiter = new RateLimiter(1000, 5, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, COUNT_FIVE, DEFAULT_LIMIT_10);
             // Use up all allowed requests
-            for (let i = 0; i < 5; i++) {
+            for (let i = 0; i < COUNT_FIVE; i++) {
                 limiter.isAllowed();
             }
             // This should be blocked
             assert.strictEqual(limiter.isAllowed(), false);
         });
         it('should return correct remaining requests', () => {
-            const limiter = new RateLimiter(1000, 10, 10);
-            assert.strictEqual(limiter.getRemainingRequests(), 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, DEFAULT_LIMIT_10, DEFAULT_LIMIT_10);
+            assert.strictEqual(limiter.getRemainingRequests(), DEFAULT_LIMIT_10);
             limiter.isAllowed();
-            assert.strictEqual(limiter.getRemainingRequests(), 9);
-            for (let i = 0; i < 9; i++) {
+            assert.strictEqual(limiter.getRemainingRequests(), COUNT_NINE);
+            for (let i = 0; i < COUNT_NINE; i++) {
                 limiter.isAllowed();
             }
             assert.strictEqual(limiter.getRemainingRequests(), 0);
         });
         it('should return 0 remaining when limit exceeded', () => {
-            const limiter = new RateLimiter(1000, 3, 10);
-            for (let i = 0; i < 5; i++) {
+            const limiter = new RateLimiter(COUNT_THOUSAND, COUNT_THREE, DEFAULT_LIMIT_10);
+            for (let i = 0; i < COUNT_FIVE; i++) {
                 limiter.isAllowed();
             }
             assert.strictEqual(limiter.getRemainingRequests(), 0);
@@ -586,10 +593,10 @@ describe('RateLimiter', () => {
     });
     describe('bounded memory', () => {
         it('should have fixed memory footprint', () => {
-            const limiter = new RateLimiter(1000, 100, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, SAMPLE_SIZE_100, DEFAULT_LIMIT_10);
             const initialFootprint = limiter.getMemoryFootprint();
             // Simulate many requests
-            for (let i = 0; i < 1000; i++) {
+            for (let i = 0; i < COUNT_THOUSAND; i++) {
                 limiter.isAllowed();
             }
             const finalFootprint = limiter.getMemoryFootprint();
@@ -598,18 +605,18 @@ describe('RateLimiter', () => {
             assert.strictEqual(initialFootprint.arraySize, finalFootprint.arraySize);
         });
         it('should pre-allocate fixed bucket count', () => {
-            const bucketCount = 60;
-            const limiter = new RateLimiter(60000, 100, bucketCount);
+            const bucketCount = RATE_LIMIT.bucketCount;
+            const limiter = new RateLimiter(RATE_LIMIT.windowMs, RATE_LIMIT.maxRequests, bucketCount);
             const footprint = limiter.getMemoryFootprint();
             assert.strictEqual(footprint.bucketCount, bucketCount);
             // Two arrays: buckets and bucketTimestamps
-            assert.strictEqual(footprint.arraySize, bucketCount * 2);
+            assert.strictEqual(footprint.arraySize, bucketCount * COUNT_TWO);
         });
         it('should not grow memory during attack simulation', () => {
-            const limiter = new RateLimiter(1000, 100, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, SAMPLE_SIZE_100, DEFAULT_LIMIT_10);
             const initialFootprint = limiter.getMemoryFootprint();
             // Simulate attack: many requests in short time
-            for (let i = 0; i < 10000; i++) {
+            for (let i = 0; i < MAX_RESULTS_IN_MEMORY; i++) {
                 limiter.isAllowed();
             }
             const finalFootprint = limiter.getMemoryFootprint();
@@ -618,13 +625,13 @@ describe('RateLimiter', () => {
     });
     describe('O(1) operations', () => {
         it('should have consistent operation time regardless of request count', () => {
-            const limiter = new RateLimiter(60000, 1000000, 60);
+            const limiter = new RateLimiter(RATE_LIMIT.windowMs, ONE_MILLION, RATE_LIMIT.bucketCount);
             // Measure time for first request
             const start1 = process.hrtime.bigint();
             limiter.isAllowed();
             const time1 = process.hrtime.bigint() - start1;
             // Simulate many requests
-            for (let i = 0; i < 10000; i++) {
+            for (let i = 0; i < MAX_RESULTS_IN_MEMORY; i++) {
                 limiter.isAllowed();
             }
             // Measure time after many requests
@@ -634,68 +641,68 @@ describe('RateLimiter', () => {
             // Time should be roughly the same (within 10x, accounting for JIT and variance)
             // This is a sanity check, not a strict benchmark
             const ratio = Number(time2) / Number(time1);
-            assert.ok(ratio < 100, `Operation time ratio ${ratio} is too high, suggesting O(n) behavior`);
+            assert.ok(ratio < SAMPLE_SIZE_100, `Operation time ratio ${ratio} is too high, suggesting O(n) behavior`);
         });
     });
     describe('sliding window behavior', () => {
         it('should reset after time delay', async () => {
-            const windowMs = 100; // Short window for testing
-            const limiter = new RateLimiter(windowMs, 5, 10);
+            const windowMs = SHORT_TIMEOUT_MS_100; // Short window for testing
+            const limiter = new RateLimiter(windowMs, COUNT_FIVE, DEFAULT_LIMIT_10);
             // Use up all requests
-            for (let i = 0; i < 5; i++) {
+            for (let i = 0; i < COUNT_FIVE; i++) {
                 limiter.isAllowed();
             }
             assert.strictEqual(limiter.isAllowed(), false);
             // Wait for window to expire
-            await new Promise(resolve => setTimeout(resolve, windowMs + 50));
+            await new Promise(resolve => setTimeout(resolve, windowMs + COUNT_FIFTY));
             // Should allow requests again
             assert.strictEqual(limiter.isAllowed(), true);
         });
         it('should partially recover as time passes', async () => {
-            const windowMs = 200;
+            const windowMs = COUNT_TWO_HUNDRED;
             const bucketCount = 4; // 50ms per bucket
-            const limiter = new RateLimiter(windowMs, 4, bucketCount);
+            const limiter = new RateLimiter(windowMs, COUNT_FOUR, bucketCount);
             // Use all requests
-            for (let i = 0; i < 4; i++) {
+            for (let i = 0; i < COUNT_FOUR; i++) {
                 limiter.isAllowed();
             }
             assert.strictEqual(limiter.getRemainingRequests(), 0);
             // Wait for part of window to expire (one bucket)
-            await new Promise(resolve => setTimeout(resolve, 60));
+            await new Promise(resolve => setTimeout(resolve, COUNT_SIXTY));
             // Should have some capacity back as older buckets expire
             const remaining = limiter.getRemainingRequests();
-            assert.ok(remaining >= 0 && remaining <= 4);
+            assert.ok(remaining >= 0 && remaining <= COUNT_FOUR);
         });
         it('should handle requests across multiple buckets', async () => {
-            const windowMs = 200;
+            const windowMs = COUNT_TWO_HUNDRED;
             const bucketCount = 4; // 50ms per bucket
-            const limiter = new RateLimiter(windowMs, 10, bucketCount);
+            const limiter = new RateLimiter(windowMs, DEFAULT_LIMIT_10, bucketCount);
             // Make request
             limiter.isAllowed();
             // Wait and make another
-            await new Promise(resolve => setTimeout(resolve, 60));
+            await new Promise(resolve => setTimeout(resolve, COUNT_SIXTY));
             limiter.isAllowed();
             // Should count both
-            assert.strictEqual(limiter.getRemainingRequests(), 8);
+            assert.strictEqual(limiter.getRemainingRequests(), COUNT_EIGHT);
         });
     });
     describe('reset functionality', () => {
         it('should clear all state on reset', () => {
-            const limiter = new RateLimiter(1000, 10, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, DEFAULT_LIMIT_10, DEFAULT_LIMIT_10);
             // Use some requests
-            for (let i = 0; i < 5; i++) {
+            for (let i = 0; i < COUNT_FIVE; i++) {
                 limiter.isAllowed();
             }
-            assert.strictEqual(limiter.getRemainingRequests(), 5);
+            assert.strictEqual(limiter.getRemainingRequests(), COUNT_FIVE);
             // Reset
             limiter.reset();
             // All capacity should be restored
-            assert.strictEqual(limiter.getRemainingRequests(), 10);
+            assert.strictEqual(limiter.getRemainingRequests(), DEFAULT_LIMIT_10);
         });
         it('should allow requests after reset even if previously blocked', () => {
-            const limiter = new RateLimiter(1000, 3, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, COUNT_THREE, DEFAULT_LIMIT_10);
             // Exhaust limit
-            for (let i = 0; i < 3; i++) {
+            for (let i = 0; i < COUNT_THREE; i++) {
                 limiter.isAllowed();
             }
             assert.strictEqual(limiter.isAllowed(), false);
@@ -706,56 +713,56 @@ describe('RateLimiter', () => {
     });
     describe('edge cases', () => {
         it('should handle single bucket', () => {
-            const limiter = new RateLimiter(1000, 5, 1);
-            for (let i = 0; i < 5; i++) {
+            const limiter = new RateLimiter(COUNT_THOUSAND, COUNT_FIVE, 1);
+            for (let i = 0; i < COUNT_FIVE; i++) {
                 assert.strictEqual(limiter.isAllowed(), true);
             }
             assert.strictEqual(limiter.isAllowed(), false);
         });
         it('should handle very short window', () => {
-            const limiter = new RateLimiter(10, 5, 2);
+            const limiter = new RateLimiter(DEFAULT_LIMIT_10, COUNT_FIVE, COUNT_TWO);
             assert.strictEqual(limiter.isAllowed(), true);
         });
         it('should handle concurrent access pattern', () => {
-            const limiter = new RateLimiter(1000, 100, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, SAMPLE_SIZE_100, DEFAULT_LIMIT_10);
             // Simulate rapid concurrent-like requests
             const results = [];
-            for (let i = 0; i < 150; i++) {
+            for (let i = 0; i < SAMPLE_SIZE_100 + COUNT_FIFTY; i++) {
                 results.push(limiter.isAllowed());
             }
             // First 100 should be allowed
             const allowed = results.filter(r => r).length;
-            assert.strictEqual(allowed, 100);
+            assert.strictEqual(allowed, SAMPLE_SIZE_100);
             // Last 50 should be blocked
             const blocked = results.filter(r => !r).length;
-            assert.strictEqual(blocked, 50);
+            assert.strictEqual(blocked, COUNT_FIFTY);
         });
     });
     describe('bounds validation', () => {
         it('should throw error for bucketCount < 1', () => {
-            assert.throws(() => new RateLimiter(1000, 10, 0), /bucketCount must be between 1 and/);
+            assert.throws(() => new RateLimiter(COUNT_THOUSAND, DEFAULT_LIMIT_10, 0), /bucketCount must be between 1 and/);
         });
         it('should throw error for bucketCount > maxBucketCount', () => {
-            assert.throws(() => new RateLimiter(1000, 10, 3601), /bucketCount must be between 1 and/);
+            assert.throws(() => new RateLimiter(COUNT_THOUSAND, DEFAULT_LIMIT_10, RATE_LIMIT.maxBucketCount + 1), /bucketCount must be between 1 and/);
         });
         it('should throw error for maxRequests < 1', () => {
-            assert.throws(() => new RateLimiter(1000, 0, 10), /maxRequests must be >= 1/);
+            assert.throws(() => new RateLimiter(COUNT_THOUSAND, 0, DEFAULT_LIMIT_10), /maxRequests must be >= 1/);
         });
         it('should throw error for negative maxRequests', () => {
-            assert.throws(() => new RateLimiter(1000, -1, 10), /maxRequests must be >= 1/);
+            assert.throws(() => new RateLimiter(COUNT_THOUSAND, -1, DEFAULT_LIMIT_10), /maxRequests must be >= 1/);
         });
         it('should throw error for windowMs < 1', () => {
-            assert.throws(() => new RateLimiter(0, 10, 10), /windowMs must be between 1ms and 86400000ms/);
+            assert.throws(() => new RateLimiter(0, DEFAULT_LIMIT_10, DEFAULT_LIMIT_10), new RegExp(`windowMs must be between 1ms and ${MAX_DURATION_MS}ms`));
         });
-        it('should throw error for windowMs > 86400000 (1 day)', () => {
-            assert.throws(() => new RateLimiter(86400001, 10, 10), /windowMs must be between 1ms and 86400000ms/);
+        it('should throw error for windowMs > MAX_DURATION_MS', () => {
+            assert.throws(() => new RateLimiter(MAX_DURATION_MS + 1, DEFAULT_LIMIT_10, DEFAULT_LIMIT_10), new RegExp(`windowMs must be between 1ms and ${MAX_DURATION_MS}ms`));
         });
         it('should accept valid maximum bucketCount (3600)', () => {
-            const limiter = new RateLimiter(3600000, 100, 3600);
-            assert.strictEqual(limiter.getMemoryFootprint().bucketCount, 3600);
+            const limiter = new RateLimiter(TIME_MS.HOUR, SAMPLE_SIZE_100, SECONDS.HOUR);
+            assert.strictEqual(limiter.getMemoryFootprint().bucketCount, SECONDS.HOUR);
         });
         it('should accept valid minimum bucketCount (1)', () => {
-            const limiter = new RateLimiter(1000, 10, 1);
+            const limiter = new RateLimiter(COUNT_THOUSAND, DEFAULT_LIMIT_10, 1);
             assert.strictEqual(limiter.getMemoryFootprint().bucketCount, 1);
         });
     });
@@ -764,18 +771,18 @@ describe('RateLimiter', () => {
             const limiter = new RateLimiter();
             const footprint = limiter.getMemoryFootprint();
             // Default bucket count is 60
-            assert.strictEqual(footprint.bucketCount, 60);
+            assert.strictEqual(footprint.bucketCount, COUNT_SIXTY);
             // Default max requests is 100
-            assert.strictEqual(limiter.getRemainingRequests(), 100);
+            assert.strictEqual(limiter.getRemainingRequests(), SAMPLE_SIZE_100);
         });
     });
     describe('observability', () => {
         it('should track rate-limited requests count', () => {
-            const limiter = new RateLimiter(1000, 3, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, COUNT_THREE, DEFAULT_LIMIT_10);
             // Initially zero
             assert.strictEqual(limiter.getRateLimitedCount(), 0);
             // Use up all requests
-            for (let i = 0; i < 3; i++) {
+            for (let i = 0; i < COUNT_THREE; i++) {
                 limiter.isAllowed();
             }
             // Still zero - no rejections yet
@@ -784,16 +791,16 @@ describe('RateLimiter', () => {
             limiter.isAllowed();
             assert.strictEqual(limiter.getRateLimitedCount(), 1);
             limiter.isAllowed();
-            assert.strictEqual(limiter.getRateLimitedCount(), 2);
+            assert.strictEqual(limiter.getRateLimitedCount(), COUNT_TWO);
         });
         it('should reset rate-limited count on reset', () => {
-            const limiter = new RateLimiter(1000, 2, 10);
+            const limiter = new RateLimiter(COUNT_THOUSAND, COUNT_TWO, DEFAULT_LIMIT_10);
             // Exhaust limit and trigger rejections
             limiter.isAllowed();
             limiter.isAllowed();
             limiter.isAllowed(); // rejected
             limiter.isAllowed(); // rejected
-            assert.strictEqual(limiter.getRateLimitedCount(), 2);
+            assert.strictEqual(limiter.getRateLimitedCount(), COUNT_TWO);
             // Reset should clear counter
             limiter.reset();
             assert.strictEqual(limiter.getRateLimitedCount(), 0);
@@ -923,7 +930,7 @@ describe('ServerInitError', () => {
             }
         });
         it('should serialize to JSON with step and cause', () => {
-            const error = new ServerInitError('transport-connection', { code: 123 }, 'Test message');
+            const error = new ServerInitError('transport-connection', { code: TEST_SERVER_INIT_ERROR_CODE }, 'Test message');
             const json = JSON.stringify({
                 name: error.name,
                 message: error.message,
@@ -933,7 +940,7 @@ describe('ServerInitError', () => {
             const parsed = JSON.parse(json);
             assert.strictEqual(parsed.name, 'ServerInitError');
             assert.strictEqual(parsed.step, 'transport-connection');
-            assert.deepStrictEqual(parsed.cause, { code: 123 });
+            assert.deepStrictEqual(parsed.cause, { code: TEST_SERVER_INIT_ERROR_CODE });
         });
     });
 });