Add test files and Docker configuration

- Jest configuration and test suites
- Docker deployment files
- Updated package.json with test scripts

Author: PhilflowIO

.dockerignore

@@ -0,0 +1,22 @@
+node_modules
+npm-debug.log
+.env
+.env.local
+.env.*.local
+.git
+.gitignore
+README.md
+CHANGELOG.md
+LICENSE
+CLAUDE.md
+*.md
+test-*.js
+debug-*.js
+cleanup.js
+full-test.js
+.vscode
+.idea
+*.swp
+*.swo
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,29 @@
+FROM node:18-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy source code
+COPY src ./src
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001 && \
+    chown -R nodejs:nodejs /app
+
+USER nodejs
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD node -e "require('http').get('http://localhost:3000/health', (r) => { process.exit(r.statusCode === 200 ? 0 : 1); }).on('error', () => process.exit(1));"
+
+# Start server
+CMD ["node", "src/index.js"]

__tests__/error-handler.test.js

@@ -0,0 +1,149 @@
+import { describe, test, expect } from '@jest/globals';
+import {
+  MCP_ERROR_CODES,
+  formatMCPError,
+  createToolErrorResponse,
+  createHTTPErrorResponse,
+  ValidationError,
+  AuthenticationError,
+  CalDAVError,
+  CardDAVError
+} from '../src/error-handler.js';
+
+describe('Error Handler Module', () => {
+  describe('MCP_ERROR_CODES', () => {
+    test('should have standard JSON-RPC error codes', () => {
+      expect(MCP_ERROR_CODES.PARSE_ERROR).toBe(-32700);
+      expect(MCP_ERROR_CODES.INVALID_REQUEST).toBe(-32600);
+      expect(MCP_ERROR_CODES.METHOD_NOT_FOUND).toBe(-32601);
+      expect(MCP_ERROR_CODES.INVALID_PARAMS).toBe(-32602);
+      expect(MCP_ERROR_CODES.INTERNAL_ERROR).toBe(-32603);
+    });
+
+    test('should have custom application error codes', () => {
+      expect(MCP_ERROR_CODES.CALDAV_ERROR).toBe(-32000);
+      expect(MCP_ERROR_CODES.CARDDAV_ERROR).toBe(-32001);
+      expect(MCP_ERROR_CODES.VALIDATION_ERROR).toBe(-32002);
+      expect(MCP_ERROR_CODES.AUTH_ERROR).toBe(-32003);
+    });
+  });
+
+  describe('Custom Error Classes', () => {
+    test('ValidationError should have correct properties', () => {
+      const error = new ValidationError('Test validation error', { field: 'test' });
+      expect(error.name).toBe('ValidationError');
+      expect(error.code).toBe(MCP_ERROR_CODES.VALIDATION_ERROR);
+      expect(error.message).toBe('Test validation error');
+      expect(error.details).toEqual({ field: 'test' });
+    });
+
+    test('AuthenticationError should have correct properties', () => {
+      const error = new AuthenticationError('Unauthorized');
+      expect(error.name).toBe('AuthenticationError');
+      expect(error.code).toBe(MCP_ERROR_CODES.AUTH_ERROR);
+    });
+
+    test('CalDAVError should have correct properties', () => {
+      const error = new CalDAVError('CalDAV connection failed');
+      expect(error.name).toBe('CalDAVError');
+      expect(error.code).toBe(MCP_ERROR_CODES.CALDAV_ERROR);
+    });
+
+    test('CardDAVError should have correct properties', () => {
+      const error = new CardDAVError('CardDAV connection failed');
+      expect(error.name).toBe('CardDAVError');
+      expect(error.code).toBe(MCP_ERROR_CODES.CARDDAV_ERROR);
+    });
+  });
+
+  describe('formatMCPError', () => {
+    test('should format error with explicit code', () => {
+      const error = new Error('Test error');
+      error.code = MCP_ERROR_CODES.INVALID_REQUEST;
+
+      const formatted = formatMCPError(error);
+
+      expect(formatted.code).toBe(MCP_ERROR_CODES.INVALID_REQUEST);
+      expect(formatted.message).toBe('Test error');
+      expect(formatted.data.type).toBe('Error');
+    });
+
+    test('should include stack trace when requested', () => {
+      const error = new Error('Test error');
+
+      const formatted = formatMCPError(error, true);
+
+      expect(formatted.data.stack).toBeDefined();
+      expect(typeof formatted.data.stack).toBe('string');
+    });
+
+    test('should not include stack trace by default', () => {
+      const error = new Error('Test error');
+
+      const formatted = formatMCPError(error, false);
+
+      expect(formatted.data.stack).toBeUndefined();
+    });
+
+    test('should detect error type from message', () => {
+      const error = new Error('caldav connection failed');
+
+      const formatted = formatMCPError(error);
+
+      expect(formatted.code).toBe(MCP_ERROR_CODES.CALDAV_ERROR);
+    });
+  });
+
+  describe('createToolErrorResponse', () => {
+    test('should create MCP-compliant error response', () => {
+      const error = new ValidationError('Invalid input');
+
+      const response = createToolErrorResponse(error);
+
+      expect(response.isError).toBe(true);
+      expect(response.content).toHaveLength(1);
+      expect(response.content[0].type).toBe('text');
+
+      const parsed = JSON.parse(response.content[0].text);
+      expect(parsed.code).toBe(MCP_ERROR_CODES.VALIDATION_ERROR);
+      expect(parsed.message).toBe('Invalid input');
+    });
+  });
+
+  describe('createHTTPErrorResponse', () => {
+    test('should map validation error to 400', () => {
+      const error = new ValidationError('Invalid input');
+
+      const response = createHTTPErrorResponse(error);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.error).toBe('Invalid input');
+      expect(response.body.code).toBe(MCP_ERROR_CODES.VALIDATION_ERROR);
+    });
+
+    test('should map auth error to 401', () => {
+      const error = new AuthenticationError('Unauthorized');
+
+      const response = createHTTPErrorResponse(error);
+
+      expect(response.statusCode).toBe(401);
+    });
+
+    test('should map method not found to 404', () => {
+      const error = new Error('Tool not found');
+      error.code = MCP_ERROR_CODES.METHOD_NOT_FOUND;
+
+      const response = createHTTPErrorResponse(error);
+
+      expect(response.statusCode).toBe(404);
+    });
+
+    test('should use custom status code if provided', () => {
+      const error = new Error('Custom error');
+
+      const response = createHTTPErrorResponse(error, 418);
+
+      expect(response.statusCode).toBe(418);
+    });
+  });
+});

__tests__/logger.test.js

@@ -0,0 +1,40 @@
+import { describe, test, expect } from '@jest/globals';
+import { logger, createContextLogger, createRequestLogger, createSessionLogger } from '../src/logger.js';
+
+describe('Logger Module', () => {
+  test('logger should be defined', () => {
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.error).toBe('function');
+    expect(typeof logger.debug).toBe('function');
+    expect(typeof logger.warn).toBe('function');
+  });
+
+  test('createContextLogger should create child logger with context', () => {
+    const childLogger = createContextLogger({ module: 'test' });
+    expect(childLogger).toBeDefined();
+    expect(typeof childLogger.info).toBe('function');
+  });
+
+  test('createRequestLogger should create child logger with requestId', () => {
+    const requestLogger = createRequestLogger('req-123');
+    expect(requestLogger).toBeDefined();
+    expect(typeof requestLogger.info).toBe('function');
+  });
+
+  test('createRequestLogger should accept additional context', () => {
+    const requestLogger = createRequestLogger('req-123', { userId: 'user-456' });
+    expect(requestLogger).toBeDefined();
+  });
+
+  test('createSessionLogger should create child logger with sessionId', () => {
+    const sessionLogger = createSessionLogger('session-789');
+    expect(sessionLogger).toBeDefined();
+    expect(typeof sessionLogger.info).toBe('function');
+  });
+
+  test('createSessionLogger should accept additional context', () => {
+    const sessionLogger = createSessionLogger('session-789', { ip: '127.0.0.1' });
+    expect(sessionLogger).toBeDefined();
+  });
+});

__tests__/validation.test.js

@@ -0,0 +1,106 @@
+import { describe, test, expect } from '@jest/globals';
+import {
+  validateInput,
+  sanitizeICalString,
+  sanitizeVCardString,
+  createEventSchema,
+  listEventsSchema
+} from '../src/validation.js';
+
+describe('Validation Module', () => {
+  describe('sanitizeICalString', () => {
+    test('should escape backslashes', () => {
+      const result = sanitizeICalString('test\\string');
+      expect(result).toBe('test\\\\string');
+    });
+
+    test('should escape semicolons', () => {
+      const result = sanitizeICalString('test;string');
+      expect(result).toBe('test\\;string');
+    });
+
+    test('should escape commas', () => {
+      const result = sanitizeICalString('test,string');
+      expect(result).toBe('test\\,string');
+    });
+
+    test('should escape newlines', () => {
+      const result = sanitizeICalString('test\nstring');
+      expect(result).toBe('test\\nstring');
+    });
+
+    test('should handle empty string', () => {
+      const result = sanitizeICalString('');
+      expect(result).toBe('');
+    });
+
+    test('should handle null/undefined', () => {
+      expect(sanitizeICalString(null)).toBe('');
+      expect(sanitizeICalString(undefined)).toBe('');
+    });
+  });
+
+  describe('sanitizeVCardString', () => {
+    test('should work same as sanitizeICalString', () => {
+      const input = 'test;with,special\\chars\n';
+      expect(sanitizeVCardString(input)).toBe(sanitizeICalString(input));
+    });
+  });
+
+  describe('validateInput', () => {
+    test('should validate correct event data', () => {
+      const validData = {
+        calendar_url: 'https://example.com/calendar/',
+        time_range_start: '2025-01-01T00:00:00.000Z',
+        time_range_end: '2025-12-31T23:59:59.999Z',
+      };
+
+      const result = validateInput(listEventsSchema, validData);
+      expect(result).toEqual(validData);
+    });
+
+    test('should throw on invalid URL', () => {
+      const invalidData = {
+        calendar_url: 'not-a-url',
+      };
+
+      expect(() => validateInput(listEventsSchema, invalidData)).toThrow('Validation failed');
+    });
+
+    test('should validate event creation with all fields', () => {
+      const validEvent = {
+        calendar_url: 'https://example.com/calendar/',
+        summary: 'Test Event',
+        start_date: '2025-10-15T10:00:00.000Z',
+        end_date: '2025-10-15T11:00:00.000Z',
+        description: 'Test description',
+        location: 'Test location',
+      };
+
+      const result = validateInput(createEventSchema, validEvent);
+      expect(result).toEqual(validEvent);
+    });
+
+    test('should reject event with end before start', () => {
+      const invalidEvent = {
+        calendar_url: 'https://example.com/calendar/',
+        summary: 'Test Event',
+        start_date: '2025-10-15T11:00:00.000Z',
+        end_date: '2025-10-15T10:00:00.000Z', // Before start!
+      };
+
+      expect(() => validateInput(createEventSchema, invalidEvent)).toThrow('End date must be after start date');
+    });
+
+    test('should reject event with too long summary', () => {
+      const invalidEvent = {
+        calendar_url: 'https://example.com/calendar/',
+        summary: 'x'.repeat(501), // Max is 500
+        start_date: '2025-10-15T10:00:00.000Z',
+        end_date: '2025-10-15T11:00:00.000Z',
+      };
+
+      expect(() => validateInput(createEventSchema, invalidEvent)).toThrow('Validation failed');
+    });
+  });
+});

docker-compose.yml

@@ -0,0 +1,30 @@
+version: '3.8'
+
+services:
+  tsdav-mcp:
+    build: .
+    container_name: tsdav-mcp-server
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+    env_file:
+      - .env
+    healthcheck:
+      test: ["CMD", "node", "-e", "require('http').get('http://localhost:3000/health', (r) => { process.exit(r.statusCode === 200 ? 0 : 1); }).on('error', () => process.exit(1));"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+      start_period: 5s
+    networks:
+      - mcp-network
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+networks:
+  mcp-network:
+    driver: bridge

jest.config.js

@@ -0,0 +1,15 @@
+export default {
+  testEnvironment: 'node',
+  transform: {},
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  testMatch: ['**/__tests__/**/*.test.js', '**/*.test.js'],
+  collectCoverageFrom: [
+    'src/**/*.js',
+    '!src/index.js', // Skip server startup
+    '!src/server-stdio.js', // Skip server startup
+  ],
+  coverageDirectory: 'coverage',
+  verbose: true,
+};