alex/homeassistant-mcp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: update TypeScript configuration and test utilities for improved type safety

Browse Source 
- Modify tsconfig.json to relax strict type checking for gradual migration
- Update test files to use more flexible type checking and mocking
- Add type-safe mock and test utility functions
- Improve error handling and type inference in test suites
- Export Tool interface and tools list for better testing support
This commit is contained in:
jango-blockchained
2025-02-05 09:16:21 +01:00
parent eefbf790c3
commit 4e9ebbbc2c
21 changed files with 526 additions and 532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
__tests__/security/index.test.ts
View File

@@ -17,7 +17,7 @@ describe('Security Module', () => {
const testToken = 'test-token';
const encryptionKey = 'test-encryption-key-that-is-long-enough';
it('should encrypt and decrypt tokens', () => {
test('should encrypt and decrypt tokens', () => {
const encrypted = TokenManager.encryptToken(testToken, encryptionKey);
expect(encrypted).toContain('aes-256-gcm:');
@@ -25,20 +25,20 @@ describe('Security Module', () => {
expect(decrypted).toBe(testToken);
});
it('should validate tokens correctly', () => {
test('should validate tokens correctly', () => {
const validToken = jwt.sign({ data: 'test' }, TEST_SECRET, { expiresIn: '1h' });
const result = TokenManager.validateToken(validToken);
expect(result.valid).toBe(true);
expect(result.error).toBeUndefined();
});
it('should handle empty tokens', () => {
test('should handle empty tokens', () => {
const result = TokenManager.validateToken('');
expect(result.valid).toBe(false);
expect(result.error).toBe('Invalid token format');
});
it('should handle expired tokens', () => {
test('should handle expired tokens', () => {
const now = Math.floor(Date.now() / 1000);
const payload = {
data: 'test',
@@ -51,13 +51,13 @@ describe('Security Module', () => {
expect(result.error).toBe('Token has expired');
});
it('should handle invalid token format', () => {
test('should handle invalid token format', () => {
const result = TokenManager.validateToken('invalid-token');
expect(result.valid).toBe(false);
expect(result.error).toBe('Invalid token format');
});
it('should handle missing JWT secret', () => {
test('should handle missing JWT secret', () => {
delete process.env.JWT_SECRET;
const payload = { data: 'test' };
const token = jwt.sign(payload, 'some-secret');
@@ -66,7 +66,7 @@ describe('Security Module', () => {
expect(result.error).toBe('JWT secret not configured');
});
it('should handle rate limiting for failed attempts', () => {
test('should handle rate limiting for failed attempts', () => {
const invalidToken = 'x'.repeat(64);
const testIp = '127.0.0.1';
@@ -111,7 +111,7 @@ describe('Security Module', () => {
mockNext = mock(() => { });
});
it('should pass valid requests', () => {
test('should pass valid requests', () => {
if (mockRequest.headers) {
mockRequest.headers.authorization = 'Bearer valid-token';
}
@@ -123,7 +123,7 @@ describe('Security Module', () => {
expect(mockNext).toHaveBeenCalled();
});
it('should reject invalid content type', () => {
test('should reject invalid content type', () => {
if (mockRequest.headers) {
mockRequest.headers['content-type'] = 'text/plain';
}
@@ -139,7 +139,7 @@ describe('Security Module', () => {
});
});
it('should reject missing token', () => {
test('should reject missing token', () => {
if (mockRequest.headers) {
delete mockRequest.headers.authorization;
}
@@ -155,7 +155,7 @@ describe('Security Module', () => {
});
});
it('should reject invalid request body', () => {
test('should reject invalid request body', () => {
mockRequest.body = null;
validateRequest(mockRequest, mockResponse, mockNext);
@@ -197,7 +197,7 @@ describe('Security Module', () => {
mockNext = mock(() => { });
});
it('should sanitize HTML tags from request body', () => {
test('should sanitize HTML tags from request body', () => {
sanitizeInput(mockRequest, mockResponse, mockNext);
expect(mockRequest.body).toEqual({
@@ -209,7 +209,7 @@ describe('Security Module', () => {
expect(mockNext).toHaveBeenCalled();
});
it('should handle non-object body', () => {
test('should handle non-object body', () => {
mockRequest.body = 'string body';
sanitizeInput(mockRequest, mockResponse, mockNext);
expect(mockNext).toHaveBeenCalled();
@@ -235,7 +235,7 @@ describe('Security Module', () => {
mockNext = mock(() => { });
});
it('should handle errors in production mode', () => {
test('should handle errors in production mode', () => {
process.env.NODE_ENV = 'production';
const error = new Error('Test error');
errorHandler(error, mockRequest, mockResponse, mockNext);
@@ -248,7 +248,7 @@ describe('Security Module', () => {
});
});
it('should include error message in development mode', () => {
test('should include error message in development mode', () => {
process.env.NODE_ENV = 'development';
const error = new Error('Test error');
errorHandler(error, mockRequest, mockResponse, mockNext);
@@ -265,7 +265,7 @@ describe('Security Module', () => {
});
describe('Rate Limiter', () => {
it('should limit requests after threshold', async () => {
test('should limit requests after threshold', async () => {
const mockContext = {
request: new Request('http://localhost', {
headers: new Headers({
@@ -292,7 +292,7 @@ describe('Security Module', () => {
});
describe('Security Headers', () => {
it('should set security headers', async () => {
test('should set security headers', async () => {
const mockHeaders = new Headers();
const mockContext = {
request: new Request('http://localhost', {

34
__tests__/security/middleware.test.ts
View File

@@ -9,31 +9,31 @@ import {
describe('Security Middleware Utilities', () => {
describe('Rate Limiter', () => {
it('should allow requests under threshold', () => {
test('should allow requests under threshold', () => {
const ip = '127.0.0.1';
expect(() => checkRateLimit(ip, 10)).not.toThrow();
expect(() => checkRateLimtest(ip, 10)).not.toThrow();
});
it('should throw when requests exceed threshold', () => {
test('should throw when requests exceed threshold', () => {
const ip = '127.0.0.2';
// Simulate multiple requests
for (let i = 0; i < 11; i++) {
if (i < 10) {
expect(() => checkRateLimit(ip, 10)).not.toThrow();
expect(() => checkRateLimtest(ip, 10)).not.toThrow();
} else {
expect(() => checkRateLimit(ip, 10)).toThrow('Too many requests from this IP, please try again later');
expect(() => checkRateLimtest(ip, 10)).toThrow('Too many requests from this IP, please try again later');
}
}
});
it('should reset rate limit after window expires', async () => {
test('should reset rate limit after window expires', async () => {
const ip = '127.0.0.3';
// Simulate multiple requests
for (let i = 0; i < 11; i++) {
if (i < 10) {
expect(() => checkRateLimit(ip, 10, 50)).not.toThrow();
expect(() => checkRateLimtest(ip, 10, 50)).not.toThrow();
}
}
@@ -41,12 +41,12 @@ describe('Security Middleware Utilities', () => {
await new Promise(resolve => setTimeout(resolve, 100));
// Should be able to make requests again
expect(() => checkRateLimit(ip, 10, 50)).not.toThrow();
expect(() => checkRateLimtest(ip, 10, 50)).not.toThrow();
});
});
describe('Request Validation', () => {
it('should validate content type', () => {
test('should validate content type', () => {
const mockRequest = new Request('http://localhost', {
method: 'POST',
headers: {
@@ -57,7 +57,7 @@ describe('Security Middleware Utilities', () => {
expect(() => validateRequestHeaders(mockRequest)).not.toThrow();
});
it('should reject invalid content type', () => {
test('should reject invalid content type', () => {
const mockRequest = new Request('http://localhost', {
method: 'POST',
headers: {
@@ -68,7 +68,7 @@ describe('Security Middleware Utilities', () => {
expect(() => validateRequestHeaders(mockRequest)).toThrow('Content-Type must be application/json');
});
it('should reject large request bodies', () => {
test('should reject large request bodies', () => {
const mockRequest = new Request('http://localhost', {
method: 'POST',
headers: {
@@ -82,13 +82,13 @@ describe('Security Middleware Utilities', () => {
});
describe('Input Sanitization', () => {
it('should sanitize HTML tags', () => {
test('should sanitize HTML tags', () => {
const input = '<script>alert("xss")</script>Hello';
const sanitized = sanitizeValue(input);
expect(sanitized).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;Hello');
});
it('should sanitize nested objects', () => {
test('should sanitize nested objects', () => {
const input = {
text: '<script>alert("xss")</script>Hello',
nested: {
@@ -104,7 +104,7 @@ describe('Security Middleware Utilities', () => {
});
});
it('should preserve non-string values', () => {
test('should preserve non-string values', () => {
const input = {
number: 123,
boolean: true,
@@ -116,7 +116,7 @@ describe('Security Middleware Utilities', () => {
});
describe('Security Headers', () => {
it('should apply security headers', () => {
test('should apply security headers', () => {
const mockRequest = new Request('http://localhost');
const headers = applySecurityHeaders(mockRequest);
@@ -129,7 +129,7 @@ describe('Security Middleware Utilities', () => {
});
describe('Error Handling', () => {
it('should handle errors in production mode', () => {
test('should handle errors in production mode', () => {
const error = new Error('Test error');
const result = handleError(error, 'production');
@@ -140,7 +140,7 @@ describe('Security Middleware Utilities', () => {
});
});
it('should include error details in development mode', () => {
test('should include error details in development mode', () => {
const error = new Error('Test error');
const result = handleError(error, 'development');

40
__tests__/security/token-manager.test.ts
View File

@@ -16,36 +16,36 @@ describe('TokenManager', () => {
const validToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoxNjE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
describe('Token Encryption/Decryption', () => {
it('should encrypt and decrypt tokens successfully', () => {
test('should encrypt and decrypt tokens successfully', () => {
const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
expect(decrypted).toBe(validToken);
});
it('should generate different encrypted values for same token', () => {
test('should generate different encrypted values for same token', () => {
const encrypted1 = TokenManager.encryptToken(validToken, encryptionKey);
const encrypted2 = TokenManager.encryptToken(validToken, encryptionKey);
expect(encrypted1).not.toBe(encrypted2);
});
it('should handle empty tokens', () => {
test('should handle empty tokens', () => {
expect(() => TokenManager.encryptToken('', encryptionKey)).toThrow('Invalid token');
expect(() => TokenManager.decryptToken('', encryptionKey)).toThrow('Invalid encrypted token');
});
it('should handle empty encryption keys', () => {
test('should handle empty encryption keys', () => {
expect(() => TokenManager.encryptToken(validToken, '')).toThrow('Invalid encryption key');
expect(() => TokenManager.decryptToken(validToken, '')).toThrow('Invalid encryption key');
});
it('should fail decryption with wrong key', () => {
test('should fail decryption with wrong key', () => {
const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
expect(() => TokenManager.decryptToken(encrypted, 'wrong-key-32-chars-long!!!!!!!!')).toThrow();
});
});
describe('Token Validation', () => {
it('should validate correct tokens', () => {
test('should validate correct tokens', () => {
const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600 };
const token = jwt.sign(payload, TEST_SECRET);
const result = TokenManager.validateToken(token);
@@ -53,7 +53,7 @@ describe('TokenManager', () => {
expect(result.error).toBeUndefined();
});
it('should reject expired tokens', () => {
test('should reject expired tokens', () => {
const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000) - 7200, exp: Math.floor(Date.now() / 1000) - 3600 };
const token = jwt.sign(payload, TEST_SECRET);
const result = TokenManager.validateToken(token);
@@ -61,13 +61,13 @@ describe('TokenManager', () => {
expect(result.error).toBe('Token has expired');
});
it('should reject malformed tokens', () => {
test('should reject malformed tokens', () => {
const result = TokenManager.validateToken('invalid-token');
expect(result.valid).toBe(false);
expect(result.error).toBe('Token length below minimum requirement');
});
it('should reject tokens with invalid signature', () => {
test('should reject tokens with invalid signature', () => {
const payload = { sub: '123', name: 'Test User', iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600 };
const token = jwt.sign(payload, 'different-secret');
const result = TokenManager.validateToken(token);
@@ -75,7 +75,7 @@ describe('TokenManager', () => {
expect(result.error).toBe('Invalid token signature');
});
it('should handle tokens with missing expiration', () => {
test('should handle tokens with missing expiration', () => {
const payload = { sub: '123', name: 'Test User' };
const token = jwt.sign(payload, TEST_SECRET);
const result = TokenManager.validateToken(token);
@@ -83,7 +83,7 @@ describe('TokenManager', () => {
expect(result.error).toBe('Token missing required claims');
});
it('should handle undefined and null inputs', () => {
test('should handle undefined and null inputs', () => {
const undefinedResult = TokenManager.validateToken(undefined);
expect(undefinedResult.valid).toBe(false);
expect(undefinedResult.error).toBe('Invalid token format');
@@ -95,26 +95,26 @@ describe('TokenManager', () => {
});
describe('Security Features', () => {
it('should use secure encryption algorithm', () => {
test('should use secure encryption algorithm', () => {
const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
expect(encrypted).toContain('aes-256-gcm');
});
it('should prevent token tampering', () => {
test('should prevent token tampering', () => {
const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
const tampered = encrypted.slice(0, -5) + 'xxxxx';
expect(() => TokenManager.decryptToken(tampered, encryptionKey)).toThrow();
});
it('should use unique IVs for each encryption', () => {
test('should use unique IVs for each encryption', () => {
const encrypted1 = TokenManager.encryptToken(validToken, encryptionKey);
const encrypted2 = TokenManager.encryptToken(validToken, encryptionKey);
const iv1 = encrypted1.split(':')[1];
const iv2 = encrypted2.split(':')[1];
const iv1 = encrypted1.spltest(':')[1];
const iv2 = encrypted2.spltest(':')[1];
expect(iv1).not.toBe(iv2);
});
it('should handle large tokens', () => {
test('should handle large tokens', () => {
const largeToken = 'x'.repeat(10000);
const encrypted = TokenManager.encryptToken(largeToken, encryptionKey);
const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
@@ -123,19 +123,19 @@ describe('TokenManager', () => {
});
describe('Error Handling', () => {
it('should throw descriptive errors for invalid inputs', () => {
test('should throw descriptive errors for invalid inputs', () => {
expect(() => TokenManager.encryptToken(null as any, encryptionKey)).toThrow('Invalid token');
expect(() => TokenManager.encryptToken(validToken, null as any)).toThrow('Invalid encryption key');
expect(() => TokenManager.decryptToken('invalid-base64', encryptionKey)).toThrow('Invalid encrypted token');
});
it('should handle corrupted encrypted data', () => {
test('should handle corrupted encrypted data', () => {
const encrypted = TokenManager.encryptToken(validToken, encryptionKey);
const corrupted = encrypted.replace(/[a-zA-Z]/g, 'x');
expect(() => TokenManager.decryptToken(corrupted, encryptionKey)).toThrow();
});
it('should handle invalid base64 input', () => {
test('should handle invalid base64 input', () => {
expect(() => TokenManager.decryptToken('not-base64!@#$%^', encryptionKey)).toThrow();
});
});