observability-toolkit 1.8.5 → 2.1.0

package/dist/tools/query-logs.test.js

@@ -1,81 +1,70 @@
 /**
  * Unit tests for query-logs tool
  */
-import { describe, it, beforeEach, afterEach } from 'node:test';
+import { describe, it, beforeEach } from 'vitest';
 import assert from 'node:assert';
 import { queryLogs, queryLogsSchema, queryLogsTool } from './query-logs.js';
-import { getMockOptions as getMockBackendOptions, createMockBackend } from '../test-helpers/mock-backends.js';
-import { validateBackendSchema, validateLimitSchema, validateDateRangeSchema } from '../test-helpers/schema-validators.js';
+import { getMockOptions as getMockBackendOptions } from '../test-helpers/mock-backends.js';
+import { validateLimitSchema, validateDateRangeSchema } from '../test-helpers/schema-validators.js';
 import { validateToolDefinition } from '../test-helpers/tool-validators.js';
-import { captureEnv, restoreEnv, clearSigNozEnv } from '../test-helpers/env-utils.js';
+import { TEXT_PREVIEW_LIMIT } from '../lib/core/constants.js';
+import { COUNT_TWO, COUNT_THREE } from '../test-helpers/test-constants.js';
+import { testTraceId } from '../test-helpers/test-data-builders.js';
+// ---------- test constants ----------
+const LOGS_DEFAULT_LIMIT = 50;
+const CUSTOM_LIMIT = 25;
+const LONG_BODY_LENGTH = 600;
+const TRUNCATION_SUFFIX_LENGTH = 3; // '...'
 // Mock data storage
-const mockStore = { local: [], signoz: [] };
-// Create mock local backend (for tests that need only local backend)
-function createMockLocalBackend() {
-    return createMockBackend(mockStore, 'logs', 'local');
-}
+const mockStore = { local: [] };
 // Options with mock backends
 function getMockOptions() {
     return getMockBackendOptions(mockStore, 'logs');
 }
-// Capture original env values
-const originalEnv = captureEnv();
-describe('query-logs tool', () => {
+void describe('query-logs tool', () => {
     // Use shared schema validators
-    validateBackendSchema(queryLogsSchema, 'queryLogsSchema');
-    validateLimitSchema(queryLogsSchema, 'queryLogsSchema', 50);
+    validateLimitSchema(queryLogsSchema, 'queryLogsSchema', LOGS_DEFAULT_LIMIT);
     validateDateRangeSchema(queryLogsSchema, 'queryLogsSchema');
     // Use shared tool definition validator
     validateToolDefinition(queryLogsTool, 'obs_query_logs', queryLogsSchema, queryLogs);
     // Tool-specific schema validation
-    describe('queryLogsSchema field validation', () => {
-        it('should validate optional severity field', () => {
+    void describe('queryLogsSchema field validation', () => {
+        void it('should validate optional severity field', () => {
             const result = queryLogsSchema.parse({ severity: 'ERROR' });
             assert.deepStrictEqual(result.severity, 'ERROR');
         });
-        it('should validate optional search field', () => {
+        void it('should validate optional search field', () => {
             const result = queryLogsSchema.parse({ search: 'error message' });
             assert.deepStrictEqual(result.search, 'error message');
         });
-        it('should validate optional traceId field', () => {
-            const result = queryLogsSchema.parse({ traceId: 'abc123' });
-            assert.deepStrictEqual(result.traceId, 'abc123');
+        void it('should validate optional traceId field', () => {
+            const result = queryLogsSchema.parse({ traceId: testTraceId(1) });
+            assert.deepStrictEqual(result.traceId, testTraceId(1));
         });
-        it('should validate multiple fields together', () => {
+        void it('should validate multiple fields together', () => {
             const result = queryLogsSchema.parse({
-                backend: 'local',
                 severity: 'WARN',
                 search: 'test',
-                traceId: 'trace-123',
+                traceId: testTraceId(2),
                 startDate: '2026-01-01',
                 endDate: '2026-01-31',
                 limit: 25,
             });
-            assert.deepStrictEqual(result.backend, 'local');
             assert.deepStrictEqual(result.severity, 'WARN');
             assert.deepStrictEqual(result.search, 'test');
-            assert.deepStrictEqual(result.traceId, 'trace-123');
+            assert.deepStrictEqual(result.traceId, testTraceId(2));
             assert.deepStrictEqual(result.startDate, '2026-01-01');
             assert.deepStrictEqual(result.endDate, '2026-01-31');
-            assert.deepStrictEqual(result.limit, 25);
+            assert.deepStrictEqual(result.limit, CUSTOM_LIMIT);
         });
     });
     // Test query logs handler function
-    describe('queryLogs handler', () => {
+    void describe('queryLogs handler', () => {
         // Reset state before each test
         beforeEach(() => {
             mockStore.local = [];
-            mockStore.signoz = [];
-            // Clear environment variables
-            process.env.SIGNOZ_URL = '';
-            process.env.SIGNOZ_API_KEY = '';
-        });
-        afterEach(() => {
-            // Restore original environment
-            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
-            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
         });
-        it('should query local backend when backend=local', async () => {
+        void it('should query local backend', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -83,12 +72,12 @@ describe('query-logs tool', () => {
                     body: 'Test error message',
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
-            assert.strictEqual(result.backend, 'local');
+            const result = await queryLogs({}, getMockOptions());
+            assert.strictEqual(result.backend, 'mock-local');
             assert.strictEqual(result.count, 1);
             assert.ok(Array.isArray(result.logs));
         });
-        it('should include severity filtering in options', async () => {
+        void it('should include severity filtering in options', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -102,13 +91,12 @@ describe('query-logs tool', () => {
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 severity: 'ERROR',
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should include search text filtering in options', async () => {
+        void it('should include search text filtering in options', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -117,29 +105,27 @@ describe('query-logs tool', () => {
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 search: 'connection',
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should include traceId filtering in options', async () => {
+        void it('should include traceId filtering in options', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
                     severity: 'ERROR',
                     body: 'Error in span',
-                    traceId: 'trace-123',
+                    traceId: testTraceId(3),
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
-                traceId: 'trace-123',
+                traceId: testTraceId(3),
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should include date range filtering in options', async () => {
+        void it('should include date range filtering in options', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-15T12:00:00Z',
@@ -148,14 +134,13 @@ describe('query-logs tool', () => {
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 startDate: '2026-01-01',
                 endDate: '2026-01-31',
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should respect limit parameter', async () => {
+        void it('should respect limit parameter', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -169,13 +154,12 @@ describe('query-logs tool', () => {
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 limit: 1,
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should return result with backend, count, and logs', async () => {
+        void it('should return result with backend, count, and logs', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -183,12 +167,12 @@ describe('query-logs tool', () => {
                     body: 'Test log',
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.backend);
             assert.ok(typeof result.count === 'number');
             assert.ok(Array.isArray(result.logs));
         });
-        it('should group logs by severity', async () => {
+        void it('should group logs by severity', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -206,12 +190,12 @@ describe('query-logs tool', () => {
                     body: 'Info message',
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.bySeverity);
             assert.strictEqual(typeof result.bySeverity, 'object');
             assert.ok(Object.keys(result.bySeverity).length > 0);
         });
-        it('should correctly count logs per severity', async () => {
+        void it('should correctly count logs per severity', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -229,13 +213,13 @@ describe('query-logs tool', () => {
                     body: 'Warning',
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.bySeverity);
-            assert.strictEqual(result.bySeverity.ERROR, 2);
+            assert.strictEqual(result.bySeverity.ERROR, COUNT_TWO);
             assert.strictEqual(result.bySeverity.WARN, 1);
         });
-        it('should truncate long log body to 500 chars', async () => {
-            const longBody = 'x'.repeat(600);
+        void it('should truncate long log body to 500 chars', async () => {
+            const longBody = 'x'.repeat(LONG_BODY_LENGTH);
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -243,12 +227,12 @@ describe('query-logs tool', () => {
                     body: longBody,
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.logs.length > 0);
-            assert.ok(result.logs[0].body.length <= 503); // 500 + '...'
+            assert.ok(result.logs[0].body.length <= TEXT_PREVIEW_LIMIT + TRUNCATION_SUFFIX_LENGTH);
             assert.ok(result.logs[0].body.endsWith('...'));
         });
-        it('should not truncate short log body', async () => {
+        void it('should not truncate short log body', async () => {
             const shortBody = 'Short message';
             mockStore.local = [
                 {
@@ -257,11 +241,11 @@ describe('query-logs tool', () => {
                     body: shortBody,
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.logs.length > 0);
             assert.strictEqual(result.logs[0].body, shortBody);
         });
-        it('should preserve log metadata in response', async () => {
+        void it('should preserve log metadata in response', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -272,7 +256,7 @@ describe('query-logs tool', () => {
                     attributes: { key: 'value' },
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.logs.length > 0);
             const log = result.logs[0];
             assert.strictEqual(log.timestamp, '2026-01-28T12:00:00Z');
@@ -280,124 +264,55 @@ describe('query-logs tool', () => {
             assert.strictEqual(log.traceId, 'trace-123');
             assert.deepStrictEqual(log.attributes, { key: 'value' });
         });
-        it('should return empty result when no logs match', async () => {
+        void it('should return empty result when no logs match', async () => {
             mockStore.local = [];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
-            assert.strictEqual(result.backend, 'local');
+            const result = await queryLogs({}, getMockOptions());
+            assert.strictEqual(result.backend, 'mock-local');
             assert.strictEqual(result.count, 0);
             assert.strictEqual(result.logs.length, 0);
         });
     });
-    // Test auto backend selection
-    describe('auto backend selection', () => {
-        beforeEach(() => {
-            mockStore.local = [];
-            mockStore.signoz = [];
-            clearSigNozEnv();
-        });
-        afterEach(() => {
-            restoreEnv(originalEnv);
-        });
-        it('should use local backend when signoz not configured', async () => {
-            mockStore.local = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'INFO',
-                    body: 'Test message',
-                },
-            ];
-            const result = await queryLogs({ backend: 'auto' }, getMockOptions());
-            assert.strictEqual(result.backend, 'local');
-        });
-        it('should use signoz backend when configured and available', async () => {
-            // Note: Constants are read at import time, so we can only test
-            // that the auto backend selection falls back to local when
-            // signoz is not configured via constants
-            mockStore.local = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'ERROR',
-                    body: 'Local error',
-                },
-            ];
-            const result = await queryLogs({ backend: 'auto' }, getMockOptions());
-            assert.ok(result.backend);
-        });
-        it('should fallback to signoz when local returns empty and signoz configured', async () => {
-            mockStore.local = [];
-            mockStore.signoz = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'ERROR',
-                    body: 'Remote error',
-                },
-            ];
-            const result = await queryLogs({ backend: 'auto' }, getMockOptions());
-            assert.ok(result.backend);
-            assert.ok(typeof result.count === 'number');
-        });
-    });
     // Test tool handler behavior (tool definition covered by validateToolDefinition above)
-    describe('queryLogsTool handler behavior', () => {
-        it('should accept valid input in handler', async () => {
+    void describe('queryLogsTool handler behavior', () => {
+        void it('should accept valid input in handler', async () => {
             mockStore.local = [];
-            const result = await queryLogsTool.handler({ backend: 'local' }, getMockOptions());
+            const result = await queryLogsTool.handler({}, getMockOptions());
             assert.ok(result);
             assert.ok(result.backend);
             assert.ok(typeof result.count === 'number');
         });
     });
     // Test error handling and edge cases
-    describe('error handling and edge cases', () => {
+    void describe('error handling and edge cases', () => {
         beforeEach(() => {
             mockStore.local = [];
-            mockStore.signoz = [];
-            clearSigNozEnv();
-        });
-        afterEach(() => {
-            restoreEnv(originalEnv);
-        });
-        it('should return no backend available when signoz requested but not configured', async () => {
-            // Use _hasSigNozConfig override to simulate signoz not being configured
-            // This triggers lines 93-100 returning "no backend available"
-            const result = await queryLogs({ backend: 'signoz' }, {
-                localBackend: createMockLocalBackend(),
-                _hasSigNozConfig: false,
-                // No signozBackend provided
-            });
-            assert.strictEqual(result.backend, 'none');
-            assert.strictEqual(result.count, 0);
-            assert.deepStrictEqual(result.logs, []);
-            assert.strictEqual(result.error, 'No backend available');
         });
-        it('should handle missing optional parameters', async () => {
+        void it('should handle missing optional parameters', async () => {
             mockStore.local = [];
             const result = await queryLogs({
-                backend: 'local',
-                // No optional parameters
+            // No optional parameters
             }, getMockOptions());
             assert.ok(result);
-            assert.strictEqual(result.backend, 'local');
+            assert.strictEqual(result.backend, 'mock-local');
         });
-        it('should handle combined filters (severity + search + traceId)', async () => {
+        void it('should handle combined filters (severity + search + traceId)', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
                     severity: 'ERROR',
                     body: 'Database connection error',
-                    traceId: 'trace-123',
+                    traceId: testTraceId(4),
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 severity: 'ERROR',
                 search: 'connection',
-                traceId: 'trace-123',
+                traceId: testTraceId(4),
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should handle date range with both start and end dates', async () => {
+        void it('should handle date range with both start and end dates', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-15T12:00:00Z',
@@ -406,45 +321,40 @@ describe('query-logs tool', () => {
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 startDate: '2026-01-01',
                 endDate: '2026-01-31',
             }, getMockOptions());
             assert.ok(result);
         });
-        it('should handle date range with only start date', async () => {
+        void it('should handle date range with only start date', async () => {
             mockStore.local = [];
             const result = await queryLogs({
-                backend: 'local',
                 startDate: '2026-01-01',
             }, getMockOptions());
             assert.ok(result);
         });
-        it('should handle date range with only end date', async () => {
+        void it('should handle date range with only end date', async () => {
             mockStore.local = [];
             const result = await queryLogs({
-                backend: 'local',
                 endDate: '2026-01-31',
             }, getMockOptions());
             assert.ok(result);
         });
-        it('should accept max limit value of 1000', async () => {
+        void it('should accept max limit value of 1000', async () => {
             mockStore.local = [];
             const result = await queryLogs({
-                backend: 'local',
                 limit: 1000,
             }, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
-        it('should reject limit values over 1000', () => {
+        void it('should reject limit values over 1000', () => {
             const result = queryLogsSchema.safeParse({
-                backend: 'local',
                 limit: 1001,
             });
             assert.strictEqual(result.success, false);
         });
-        it('should handle very small limit values', async () => {
+        void it('should handle very small limit values', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -453,12 +363,11 @@ describe('query-logs tool', () => {
                 },
             ];
             const result = await queryLogs({
-                backend: 'local',
                 limit: 1,
             }, getMockOptions());
             assert.ok(result);
         });
-        it('should handle logs with missing optional fields', async () => {
+        void it('should handle logs with missing optional fields', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -467,11 +376,11 @@ describe('query-logs tool', () => {
                     // No traceId, spanId, or attributes
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result);
             assert.ok(result.logs.length > 0);
         });
-        it('should handle logs with empty attributes', async () => {
+        void it('should handle logs with empty attributes', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -480,35 +389,26 @@ describe('query-logs tool', () => {
                     attributes: {},
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result);
         });
-        it('should handle result with no backend available', async () => {
+        void it('should handle empty local store', async () => {
             mockStore.local = [];
-            mockStore.signoz = [];
-            // Don't configure any backend
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result);
             assert.strictEqual(typeof result.count, 'number');
         });
     });
     // Test sessionId filtering
-    describe('sessionId filtering', () => {
+    void describe('sessionId filtering', () => {
         beforeEach(() => {
             mockStore.local = [];
-            mockStore.signoz = [];
-            process.env.SIGNOZ_URL = '';
-            process.env.SIGNOZ_API_KEY = '';
         });
-        afterEach(() => {
-            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
-            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
-        });
-        it('should accept sessionId parameter in schema', () => {
+        void it('should accept sessionId parameter in schema', () => {
             const result = queryLogsSchema.parse({ sessionId: 'session-abc-123' });
             assert.strictEqual(result.sessionId, 'session-abc-123');
         });
-        it('should filter logs by session.id attribute', async () => {
+        void it('should filter logs by session.id attribute', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -529,16 +429,16 @@ describe('query-logs tool', () => {
                     attributes: { 'session.id': 'session-abc-123', 'hook.name': 'error' },
                 },
             ];
-            const result = await queryLogs({ backend: 'local', sessionId: 'session-abc-123' }, getMockOptions());
-            assert.strictEqual(result.backend, 'local');
-            assert.strictEqual(result.count, 2);
-            assert.strictEqual(result.logs.length, 2);
+            const result = await queryLogs({ sessionId: 'session-abc-123' }, getMockOptions());
+            assert.strictEqual(result.backend, 'mock-local');
+            assert.strictEqual(result.count, COUNT_TWO);
+            assert.strictEqual(result.logs.length, COUNT_TWO);
             // All returned logs should have the matching session.id
             for (const log of result.logs) {
                 assert.strictEqual(log.attributes?.['session.id'], 'session-abc-123');
             }
         });
-        it('should return empty when no logs match sessionId', async () => {
+        void it('should return empty when no logs match sessionId', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -547,11 +447,11 @@ describe('query-logs tool', () => {
                     attributes: { 'session.id': 'session-other' },
                 },
             ];
-            const result = await queryLogs({ backend: 'local', sessionId: 'session-not-found' }, getMockOptions());
+            const result = await queryLogs({ sessionId: 'session-not-found' }, getMockOptions());
             assert.strictEqual(result.count, 0);
             assert.strictEqual(result.logs.length, 0);
         });
-        it('should filter logs without session.id attribute when sessionId provided', async () => {
+        void it('should filter logs without session.id attribute when sessionId provided', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -566,11 +466,11 @@ describe('query-logs tool', () => {
                     attributes: { 'session.id': 'session-abc-123' },
                 },
             ];
-            const result = await queryLogs({ backend: 'local', sessionId: 'session-abc-123' }, getMockOptions());
+            const result = await queryLogs({ sessionId: 'session-abc-123' }, getMockOptions());
             assert.strictEqual(result.count, 1);
             assert.strictEqual(result.logs[0].attributes?.['session.id'], 'session-abc-123');
         });
-        it('should not filter when sessionId not provided', async () => {
+        void it('should not filter when sessionId not provided', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -590,10 +490,10 @@ describe('query-logs tool', () => {
                     body: 'Log 3 no session',
                 },
             ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
-            assert.strictEqual(result.count, 3);
+            const result = await queryLogs({}, getMockOptions());
+            assert.strictEqual(result.count, COUNT_THREE);
         });
-        it('should combine sessionId with other filters', async () => {
+        void it('should combine sessionId with other filters', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -614,38 +514,15 @@ describe('query-logs tool', () => {
                     attributes: { 'session.id': 'session-b' },
                 },
             ];
-            const result = await queryLogs({ backend: 'local', sessionId: 'session-a', severity: 'ERROR' }, getMockOptions());
+            const result = await queryLogs({ sessionId: 'session-a', severity: 'ERROR' }, getMockOptions());
             // Backend filter applies severity, then sessionId filter applies
             // Since our mock returns all logs, sessionId filter will apply to all
             assert.ok(result);
             // The count should reflect sessionId filtering (2 logs with session-a)
             // Note: severity filtering happens in backend which we mock to return all
-            assert.strictEqual(result.count, 2);
+            assert.strictEqual(result.count, COUNT_TWO);
         });
-        it('should work with signoz backend', async () => {
-            mockStore.signoz = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'INFO',
-                    body: 'SigNoz log session A',
-                    attributes: { 'session.id': 'signoz-session-a' },
-                },
-                {
-                    timestamp: '2026-01-28T12:01:00Z',
-                    severity: 'INFO',
-                    body: 'SigNoz log session B',
-                    attributes: { 'session.id': 'signoz-session-b' },
-                },
-            ];
-            const result = await queryLogs({ backend: 'signoz', sessionId: 'signoz-session-a' }, {
-                ...getMockOptions(),
-                _hasSigNozConfig: true,
-            });
-            assert.strictEqual(result.backend, 'signoz');
-            assert.strictEqual(result.count, 1);
-            assert.strictEqual(result.logs[0].attributes?.['session.id'], 'signoz-session-a');
-        });
-        it('should update bySeverity counts after sessionId filtering', async () => {
+        void it('should update bySeverity counts after sessionId filtering', async () => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
@@ -666,129 +543,56 @@ describe('query-logs tool', () => {
                     attributes: { 'session.id': 'session-b' },
                 },
             ];
-            const result = await queryLogs({ backend: 'local', sessionId: 'session-a' }, getMockOptions());
+            const result = await queryLogs({ sessionId: 'session-a' }, getMockOptions());
             assert.strictEqual(result.bySeverity?.ERROR, 1);
             assert.strictEqual(result.bySeverity?.WARN, 1);
             assert.strictEqual(result.bySeverity?.['session-b'], undefined);
         });
     });
-    // Test severity filtering variations
-    describe('severity filtering', () => {
+    // Test severity filtering — one parameterized test with store fixtures
+    void describe('severity filtering', () => {
         beforeEach(() => {
             mockStore.local = [];
-            process.env.SIGNOZ_URL = '';
-            process.env.SIGNOZ_API_KEY = '';
         });
-        afterEach(() => {
-            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
-            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
+        void it('should filter logs by each severity level using store fixtures', async () => {
+            const severities = ['ERROR', 'WARN', 'INFO', 'DEBUG'];
+            for (const severity of severities) {
+                mockStore.local = [
+                    { timestamp: '2026-01-28T12:00:00Z', severity, body: `${severity} message` },
+                    { timestamp: '2026-01-28T12:01:00Z', severity: 'TRACE', body: 'Other' },
+                ];
+                const result = await queryLogs({ severity }, getMockOptions());
+                assert.ok(result, `expected result for severity ${severity}`);
+                assert.ok(Array.isArray(result.logs), `expected logs array for severity ${severity}`);
+            }
         });
-        it('should filter by ERROR severity', async () => {
+    });
+    // Test response structure — one comprehensive assertion
+    void describe('response structure', () => {
+        beforeEach(() => {
             mockStore.local = [
                 {
                     timestamp: '2026-01-28T12:00:00Z',
                     severity: 'ERROR',
-                    body: 'Error 1',
-                },
-                {
-                    timestamp: '2026-01-28T12:01:00Z',
-                    severity: 'INFO',
-                    body: 'Info',
+                    body: 'Error message',
+                    traceId: 'trace-123',
+                    spanId: 'span-456',
+                    attributes: { service: 'api' },
                 },
             ];
-            const result = await queryLogs({
-                backend: 'local',
-                severity: 'ERROR',
-            }, getMockOptions());
-            assert.ok(result);
-        });
-        it('should filter by WARN severity', async () => {
-            const result = await queryLogs({
-                backend: 'local',
-                severity: 'WARN',
-            }, getMockOptions());
-            assert.ok(result);
-        });
-        it('should filter by INFO severity', async () => {
-            const result = await queryLogs({
-                backend: 'local',
-                severity: 'INFO',
-            }, getMockOptions());
-            assert.ok(result);
         });
-        it('should filter by DEBUG severity', async () => {
-            const result = await queryLogs({
-                backend: 'local',
-                severity: 'DEBUG',
-            }, getMockOptions());
-            assert.ok(result);
-        });
-    });
-    // Test response structure
-    describe('response structure', () => {
-        beforeEach(() => {
-            mockStore.local = [];
-            process.env.SIGNOZ_URL = '';
-            process.env.SIGNOZ_API_KEY = '';
-        });
-        afterEach(() => {
-            process.env.SIGNOZ_URL = originalEnv.SIGNOZ_URL;
-            process.env.SIGNOZ_API_KEY = originalEnv.SIGNOZ_API_KEY;
-        });
-        it('should have backend property in response', async () => {
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+        void it('should return a complete response shape with all required and optional fields', async () => {
+            const result = await queryLogs({}, getMockOptions());
             assert.ok(result.backend);
-        });
-        it('should have count property in response', async () => {
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
-            assert.ok(typeof result.count === 'number');
-        });
-        it('should have logs array in response', async () => {
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
+            assert.strictEqual(typeof result.count, 'number');
             assert.ok(Array.isArray(result.logs));
-        });
-        it('should have bySeverity object in response', async () => {
-            mockStore.local = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'ERROR',
-                    body: 'Error',
-                },
-            ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
             assert.ok(result.bySeverity);
             assert.strictEqual(typeof result.bySeverity, 'object');
-        });
-        it('should have correct structure for individual log entries', async () => {
-            mockStore.local = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'ERROR',
-                    body: 'Error message',
-                    traceId: 'trace-123',
-                    attributes: { key: 'value' },
-                },
-            ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
             assert.ok(result.logs.length > 0);
             const log = result.logs[0];
             assert.ok(log.timestamp);
             assert.ok(log.severity);
             assert.ok(log.body);
-        });
-        it('should include optional log fields when present', async () => {
-            mockStore.local = [
-                {
-                    timestamp: '2026-01-28T12:00:00Z',
-                    severity: 'INFO',
-                    body: 'Message',
-                    traceId: 'trace-123',
-                    spanId: 'span-456',
-                    attributes: { service: 'api' },
-                },
-            ];
-            const result = await queryLogs({ backend: 'local' }, getMockOptions());
-            const log = result.logs[0];
             assert.ok(log.traceId);
             assert.ok(log.attributes);
         });