/**
* Phase 05 Bug Fixes Tests - Low Priority Cleanup
*
* Tests for:
* - MEMORY_LEAK_004: Array growth efficiency in metrics
* - RACE_CONDITION_004: Metrics timestamp consistency
* - TYPE_SAFETY_003: Enum validation in error middleware
* - CONFIG_VALIDATION_001: Boolean parsing clarity
* - LOGGER_REDUNDANCY: Console method consistency
* - BUG-011: Hidden files prevention (verified existing)
* - BUG-013: Tags validation with deduplication
* - BUG-014: Base64 validation strengthening
* - BUG-015: Cache hit counter overflow protection
*/
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
// ============================================================
// MEMORY_LEAK_004: Array Growth Efficiency Tests
// ============================================================
describe('MEMORY_LEAK_004: Metrics Array Growth', () => {
// We'll test the metrics behavior indirectly since MetricsCollector is a class
it('should trim array before adding when at capacity', async () => {
// Import fresh to avoid singleton issues
const { getMetrics } = await import('../src/utils/metrics.js');
const metrics = getMetrics();
// Reset metrics to start fresh
metrics.reset();
// Record 101 errors (more than maxRecentErrors of 100)
for (let i = 0; i < 105; i++) {
metrics.recordError(`Test error ${i}`, 'test');
}
// Get summary and check recent errors count
const summary = metrics.getSummary();
// Should have at most 100 recent errors (trimmed)
// Note: getSummary only returns last 10 in the output
expect(summary.errors.total).toBe(105);
expect(summary.errors.recentErrors.length).toBeLessThanOrEqual(10);
});
});
// ============================================================
// RACE_CONDITION_004: Metrics Timestamp Consistency Tests
// ============================================================
describe('RACE_CONDITION_004: Metrics Timestamp Consistency', () => {
it('should include timestamp in metrics summary', async () => {
const { getMetrics } = await import('../src/utils/metrics.js');
const metrics = getMetrics();
const summary = metrics.getSummary();
// Should have timestamp field
expect(summary.timestamp).toBeDefined();
expect(typeof summary.timestamp).toBe('string');
// Should be valid ISO date
const parsedDate = new Date(summary.timestamp);
expect(parsedDate.getTime()).not.toBeNaN();
});
it('should have consistent timestamp within single summary call', async () => {
const { getMetrics } = await import('../src/utils/metrics.js');
const metrics = getMetrics();
const summary = metrics.getSummary();
const timestampMs = new Date(summary.timestamp).getTime();
// Uptime should be calculated from same timestamp
// This is an approximation check - uptime + startTime should roughly equal timestamp
expect(summary.uptime).toBeGreaterThan(0);
expect(typeof summary.uptime).toBe('number');
});
});
// ============================================================
// TYPE_SAFETY_003: Enum Validation Tests
// ============================================================
describe('TYPE_SAFETY_003: Error Category Validation', () => {
it('should return suggestions for valid error categories', async () => {
const { getRecoverySuggestions, ErrorCategory } = await import('../src/utils/error-middleware.js');
// Test all valid categories
const categories = [
ErrorCategory.VALIDATION,
ErrorCategory.CONNECTION,
ErrorCategory.EXECUTION,
ErrorCategory.TIMEOUT,
ErrorCategory.SECURITY,
ErrorCategory.RATE_LIMIT,
ErrorCategory.INTERNAL,
ErrorCategory.NOT_FOUND,
ErrorCategory.EXTERNAL
];
for (const category of categories) {
const suggestions = getRecoverySuggestions(category);
expect(Array.isArray(suggestions)).toBe(true);
expect(suggestions.length).toBeGreaterThan(0);
}
});
it('should fallback to INTERNAL suggestions for invalid category', async () => {
const { getRecoverySuggestions, ErrorCategory } = await import('../src/utils/error-middleware.js');
// Force an invalid category (simulating runtime type bypass)
const invalidCategory = 'invalid_category' as ErrorCategory;
const suggestions = getRecoverySuggestions(invalidCategory);
// Should return INTERNAL suggestions as fallback
const internalSuggestions = getRecoverySuggestions(ErrorCategory.INTERNAL);
expect(suggestions).toEqual(internalSuggestions);
});
});
// ============================================================
// CONFIG_VALIDATION_001: Boolean Parsing Tests
// ============================================================
describe('CONFIG_VALIDATION_001: Boolean Parsing', () => {
const originalEnv = process.env;
beforeEach(() => {
// Clear the config singleton
vi.resetModules();
process.env = { ...originalEnv };
});
afterEach(() => {
process.env = originalEnv;
});
it('should parse explicit true values', async () => {
const trueValues = ['true', 'TRUE', 'True', '1', 'yes', 'YES'];
for (const value of trueValues) {
vi.resetModules();
process.env.RATE_LIMIT_ENABLED = value;
const { getConfig, resetConfig } = await import('../src/utils/config.js');
resetConfig();
const config = getConfig();
expect(config.rateLimit.enabled).toBe(true);
}
});
it('should parse explicit false values', async () => {
const falseValues = ['false', 'FALSE', 'False', '0', 'no', 'NO'];
for (const value of falseValues) {
vi.resetModules();
process.env.RATE_LIMIT_ENABLED = value;
const { getConfig, resetConfig } = await import('../src/utils/config.js');
resetConfig();
const config = getConfig();
expect(config.rateLimit.enabled).toBe(false);
}
});
it('should use default for undefined value', async () => {
vi.resetModules();
delete process.env.RATE_LIMIT_ENABLED;
const { getConfig, resetConfig } = await import('../src/utils/config.js');
resetConfig();
const config = getConfig();
// Default is true
expect(config.rateLimit.enabled).toBe(true);
});
it('should use default for ambiguous value', async () => {
vi.resetModules();
process.env.RATE_LIMIT_ENABLED = 'maybe';
const { getConfig, resetConfig } = await import('../src/utils/config.js');
resetConfig();
const config = getConfig();
// Default is true for ambiguous
expect(config.rateLimit.enabled).toBe(true);
});
});
// ============================================================
// BUG-011: Hidden Files Prevention Tests (Verification)
// ============================================================
describe('BUG-011: Hidden Files Prevention', () => {
it('should reject paths starting with dot', async () => {
const { filePathSchema } = await import('../src/utils/validators.js');
expect(() => filePathSchema.parse('.env')).toThrow();
expect(() => filePathSchema.parse('.ssh/id_rsa')).toThrow();
expect(() => filePathSchema.parse('.gitignore')).toThrow();
});
it('should reject paths containing hidden directories', async () => {
const { filePathSchema } = await import('../src/utils/validators.js');
expect(() => filePathSchema.parse('foo/.hidden/bar')).toThrow();
expect(() => filePathSchema.parse('assets/.secret')).toThrow();
});
it('should allow paths without hidden components', async () => {
const { filePathSchema } = await import('../src/utils/validators.js');
expect(filePathSchema.parse('assets/model.blend')).toBe('assets/model.blend');
expect(filePathSchema.parse('textures/diffuse.png')).toBe('textures/diffuse.png');
});
});
// ============================================================
// BUG-013: Tags Validation Tests
// ============================================================
describe('BUG-013: Tags Validation with Deduplication', () => {
it('should accept valid tags array', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
const result = tagsSchema.parse(['tag1', 'tag2', 'tag3']);
expect(result).toEqual(['tag1', 'tag2', 'tag3']);
});
it('should remove duplicate tags', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
const result = tagsSchema.parse(['tag1', 'tag2', 'tag1', 'tag3', 'tag2']);
expect(result).toEqual(['tag1', 'tag2', 'tag3']);
});
it('should reject more than 20 tags', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
const tooManyTags = Array.from({ length: 21 }, (_, i) => `tag${i}`);
expect(() => tagsSchema.parse(tooManyTags)).toThrow(/Maximum 20 tags/);
});
it('should reject tags with invalid characters', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
expect(() => tagsSchema.parse(['valid', 'in valid'])).toThrow();
expect(() => tagsSchema.parse(['tag@special'])).toThrow();
});
it('should reject empty tags', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
expect(() => tagsSchema.parse(['valid', ''])).toThrow();
});
it('should use empty array as default', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
expect(tagsSchema.parse(undefined)).toEqual([]);
});
});
// ============================================================
// BUG-014: Base64 Validation Tests
// ============================================================
describe('BUG-014: Base64 Validation', () => {
it('should accept valid base64 strings', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
// "Hello" in base64
expect(base64Schema.parse('SGVsbG8=')).toBe('SGVsbG8=');
// "Hello World" in base64
expect(base64Schema.parse('SGVsbG8gV29ybGQ=')).toBe('SGVsbG8gV29ybGQ=');
// No padding needed (length is multiple of 4)
expect(base64Schema.parse('YWJj')).toBe('YWJj'); // "abc"
});
it('should accept base64 with double padding', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
// "a" in base64
expect(base64Schema.parse('YQ==')).toBe('YQ==');
});
it('should reject base64 with invalid length', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
// Length not multiple of 4
expect(() => base64Schema.parse('SGVsbG8')).toThrow();
expect(() => base64Schema.parse('ab')).toThrow();
expect(() => base64Schema.parse('abc')).toThrow();
});
it('should reject base64 with invalid characters', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
expect(() => base64Schema.parse('SGVs!G8=')).toThrow();
expect(() => base64Schema.parse('SGVs@G8=')).toThrow();
});
it('should reject base64 with improper padding', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
// Padding in wrong position
expect(() => base64Schema.parse('SG=VsbG8')).toThrow();
expect(() => base64Schema.parse('=SGVsbG8')).toThrow();
});
it('should reject empty base64', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
expect(() => base64Schema.parse('')).toThrow();
});
});
// ============================================================
// BUG-015: Cache Hit Counter Overflow Tests
// ============================================================
describe('BUG-015: Cache Hit Counter Overflow', () => {
it('should increment hit counter normally', async () => {
vi.resetModules();
const { ResponseCache } = await import('../src/utils/cache.js');
const cache = new ResponseCache();
cache.set('test-key', 'test-value');
// Access multiple times
for (let i = 0; i < 10; i++) {
cache.get('test-key');
}
// Stats should reflect hits
const stats = cache.getStats();
expect(stats.hits).toBe(10);
});
it('should handle hit counter near MAX_SAFE_INTEGER', async () => {
vi.resetModules();
const { ResponseCache } = await import('../src/utils/cache.js');
const cache = new ResponseCache();
cache.set('test-key', 'test-value');
// Simulate a cache entry with near-overflow hits
// We can't actually test MAX_SAFE_INTEGER iterations,
// but we can verify the logic is present by checking the code structure
// Access once to ensure it works
const value = cache.get('test-key');
expect(value).toBe('test-value');
});
});
// ============================================================
// Integration Tests
// ============================================================
describe('Phase 05: Integration Tests', () => {
it('should handle complete error flow with recovery suggestions', async () => {
const { wrapError, getRecoverySuggestions, ErrorCategory } = await import('../src/utils/error-middleware.js');
const originalError = new Error('Connection refused');
const wrappedError = wrapError(originalError, 'Test operation');
expect(wrappedError.category).toBe(ErrorCategory.CONNECTION);
expect(wrappedError.message).toContain('Connection refused');
const suggestions = getRecoverySuggestions(wrappedError.category);
expect(suggestions.length).toBeGreaterThan(0);
});
it('should handle metrics with errors and timestamps', async () => {
const { getMetrics } = await import('../src/utils/metrics.js');
const metrics = getMetrics();
metrics.reset();
// Record some activity
metrics.recordToolInvocation('test_tool', true, 100);
metrics.recordToolInvocation('test_tool', false, 200);
metrics.recordError('Test error', 'test');
const summary = metrics.getSummary();
expect(summary.timestamp).toBeDefined();
expect(summary.uptime).toBeGreaterThan(0);
expect(summary.errors.total).toBeGreaterThan(0);
expect(summary.tools['test_tool']).toBeDefined();
});
it('should handle cache with various operations', async () => {
vi.resetModules();
const { ResponseCache } = await import('../src/utils/cache.js');
const cache = new ResponseCache();
// Test set, get, stats
cache.set('key1', 'value1');
cache.set('key2', 'value2');
expect(cache.get('key1')).toBe('value1');
expect(cache.get('key1')).toBe('value1'); // Second hit
expect(cache.get('nonexistent')).toBeUndefined();
const stats = cache.getStats();
expect(stats.hits).toBe(2);
expect(stats.misses).toBe(1);
expect(stats.size).toBe(2);
});
});
// ============================================================
// Edge Case Tests
// ============================================================
describe('Phase 05: Edge Cases', () => {
it('should handle empty tags array', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
expect(tagsSchema.parse([])).toEqual([]);
});
it('should handle single tag with deduplication', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
const result = tagsSchema.parse(['single', 'single', 'single']);
expect(result).toEqual(['single']);
});
it('should handle base64 padding edge cases', async () => {
const { base64Schema } = await import('../src/utils/validators.js');
// Single padding
expect(base64Schema.parse('YWI=')).toBe('YWI='); // "ab"
// Double padding
expect(base64Schema.parse('YQ==')).toBe('YQ=='); // "a"
// No padding
expect(base64Schema.parse('YWJj')).toBe('YWJj'); // "abc"
});
it('should handle max length tags', async () => {
const { tagsSchema } = await import('../src/utils/validators.js');
const maxLengthTag = 'a'.repeat(32);
expect(tagsSchema.parse([maxLengthTag])).toEqual([maxLengthTag]);
const tooLongTag = 'a'.repeat(33);
expect(() => tagsSchema.parse([tooLongTag])).toThrow();
});
});
