@vibescope/mcp-server 0.5.0 → 0.5.2

package/src/handlers/types.test.ts

@@ -1,259 +1,259 @@
-import { describe, it, expect } from 'vitest';
-import {
-	success,
-	error,
-	isSuccess,
-	isError,
-	type HandlerResult,
-	type SuccessResult,
-	type ErrorResult,
-} from './types.js';
-
-describe('success', () => {
-	it('should create a success result with simple data', () => {
-		const result = success({ message: 'hello' });
-		expect(result.result).toEqual({ message: 'hello' });
-		expect(result.isError).toBeUndefined();
-	});
-
-	it('should create a success result with string data', () => {
-		const result = success('test string');
-		expect(result.result).toBe('test string');
-	});
-
-	it('should create a success result with number data', () => {
-		const result = success(42);
-		expect(result.result).toBe(42);
-	});
-
-	it('should create a success result with boolean data', () => {
-		const result = success(true);
-		expect(result.result).toBe(true);
-	});
-
-	it('should create a success result with null data', () => {
-		const result = success(null);
-		expect(result.result).toBeNull();
-	});
-
-	it('should create a success result with undefined data', () => {
-		const result = success(undefined);
-		expect(result.result).toBeUndefined();
-	});
-
-	it('should create a success result with array data', () => {
-		const result = success([1, 2, 3]);
-		expect(result.result).toEqual([1, 2, 3]);
-	});
-
-	it('should create a success result with nested object data', () => {
-		const data = {
-			tasks: [{ id: '1', title: 'Task 1' }],
-			total_count: 1,
-			metadata: { page: 1, limit: 10 },
-		};
-		const result = success(data);
-		expect(result.result).toEqual(data);
-	});
-
-	it('should preserve type information', () => {
-		interface TaskData {
-			id: string;
-			title: string;
-		}
-		const result: SuccessResult<TaskData> = success({ id: '1', title: 'Test' });
-		expect(result.result.id).toBe('1');
-		expect(result.result.title).toBe('Test');
-	});
-});
-
-describe('error', () => {
-	it('should create an error result with message only', () => {
-		const result = error('Something went wrong');
-		expect(result.result.error).toBe('Something went wrong');
-		expect(result.isError).toBe(true);
-	});
-
-	it('should create an error result with message and details', () => {
-		const result = error('Validation failed', { field: 'title', reason: 'too long' });
-		expect(result.result.error).toBe('Validation failed');
-		expect(result.result.field).toBe('title');
-		expect(result.result.reason).toBe('too long');
-		expect(result.isError).toBe(true);
-	});
-
-	it('should handle empty details object', () => {
-		const result = error('Error message', {});
-		expect(result.result.error).toBe('Error message');
-		expect(result.isError).toBe(true);
-	});
-
-	it('should handle complex details', () => {
-		const result = error('Multiple errors', {
-			errors: ['error1', 'error2'],
-			count: 2,
-			nested: { key: 'value' },
-		});
-		expect(result.result.error).toBe('Multiple errors');
-		expect(result.result.errors).toEqual(['error1', 'error2']);
-		expect(result.result.count).toBe(2);
-		expect(result.result.nested).toEqual({ key: 'value' });
-	});
-
-	it('should always set isError to true', () => {
-		const result1 = error('error1');
-		const result2 = error('error2', { detail: 'info' });
-		expect(result1.isError).toBe(true);
-		expect(result2.isError).toBe(true);
-	});
-});
-
-describe('isSuccess', () => {
-	it('should return true for success results', () => {
-		const result = success({ data: 'test' });
-		expect(isSuccess(result)).toBe(true);
-	});
-
-	it('should return true for success results with various data types', () => {
-		expect(isSuccess(success('string'))).toBe(true);
-		expect(isSuccess(success(123))).toBe(true);
-		expect(isSuccess(success(null))).toBe(true);
-		expect(isSuccess(success([]))).toBe(true);
-		expect(isSuccess(success({}))).toBe(true);
-	});
-
-	it('should return false for error results', () => {
-		const result = error('Something failed');
-		expect(isSuccess(result)).toBe(false);
-	});
-
-	it('should return false for error results with details', () => {
-		const result = error('Validation error', { field: 'name' });
-		expect(isSuccess(result)).toBe(false);
-	});
-
-	it('should narrow type correctly for success', () => {
-		const result: HandlerResult<{ id: string }> = success({ id: '123' });
-		if (isSuccess(result)) {
-			// TypeScript should know result.result is { id: string }
-			expect(result.result.id).toBe('123');
-		}
-	});
-
-	it('should work with explicitly typed results', () => {
-		const successResult: SuccessResult<number> = { result: 42 };
-		const errorResult: ErrorResult = { result: { error: 'fail' }, isError: true };
-
-		expect(isSuccess(successResult)).toBe(true);
-		expect(isSuccess(errorResult)).toBe(false);
-	});
-});
-
-describe('isError', () => {
-	it('should return true for error results', () => {
-		const result = error('Something failed');
-		expect(isError(result)).toBe(true);
-	});
-
-	it('should return true for error results with details', () => {
-		const result = error('Validation error', { field: 'name', code: 'INVALID' });
-		expect(isError(result)).toBe(true);
-	});
-
-	it('should return false for success results', () => {
-		const result = success({ data: 'test' });
-		expect(isError(result)).toBe(false);
-	});
-
-	it('should return false for success results with various data types', () => {
-		expect(isError(success('string'))).toBe(false);
-		expect(isError(success(123))).toBe(false);
-		expect(isError(success(null))).toBe(false);
-		expect(isError(success([]))).toBe(false);
-		expect(isError(success({}))).toBe(false);
-	});
-
-	it('should narrow type correctly for error', () => {
-		const result: HandlerResult<unknown> = error('Task not found');
-		if (isError(result)) {
-			// TypeScript should know result.result.error is string
-			expect(result.result.error).toBe('Task not found');
-		}
-	});
-
-	it('should work with explicitly typed results', () => {
-		const successResult: SuccessResult<number> = { result: 42 };
-		const errorResult: ErrorResult = { result: { error: 'fail' }, isError: true };
-
-		expect(isError(successResult)).toBe(false);
-		expect(isError(errorResult)).toBe(true);
-	});
-});
-
-describe('HandlerResult type usage', () => {
-	it('should work with discriminated union pattern', () => {
-		function processResult(result: HandlerResult<string>): string {
-			if (isSuccess(result)) {
-				return `Success: ${result.result}`;
-			} else {
-				return `Error: ${result.result.error}`;
-			}
-		}
-
-		expect(processResult(success('hello'))).toBe('Success: hello');
-		expect(processResult(error('failed'))).toBe('Error: failed');
-	});
-
-	it('should handle async handler patterns', async () => {
-		async function mockHandler(): Promise<HandlerResult<{ id: string }>> {
-			return success({ id: '123' });
-		}
-
-		const result = await mockHandler();
-		expect(isSuccess(result)).toBe(true);
-		if (isSuccess(result)) {
-			expect(result.result.id).toBe('123');
-		}
-	});
-
-	it('should handle error handler patterns', async () => {
-		async function mockErrorHandler(): Promise<HandlerResult<{ id: string }>> {
-			return error('Not found', { id: '123' });
-		}
-
-		const result = await mockErrorHandler();
-		expect(isError(result)).toBe(true);
-		if (isError(result)) {
-			expect(result.result.error).toBe('Not found');
-			expect(result.result.id).toBe('123');
-		}
-	});
-});
-
-describe('edge cases', () => {
-	it('should handle result with isError explicitly set to false', () => {
-		const result: SuccessResult<string> = { result: 'data', isError: false };
-		expect(isSuccess(result)).toBe(true);
-		expect(isError(result)).toBe(false);
-	});
-
-	it('should handle result without isError property', () => {
-		const result: SuccessResult<string> = { result: 'data' };
-		expect(isSuccess(result)).toBe(true);
-		expect(isError(result)).toBe(false);
-	});
-
-	it('should handle success with error-like data', () => {
-		// A success result that happens to contain an error message in its data
-		const result = success({ error: 'This is not an error result', data: 'some data' });
-		expect(isSuccess(result)).toBe(true);
-		expect(isError(result)).toBe(false);
-	});
-
-	it('should handle empty string error message', () => {
-		const result = error('');
-		expect(result.result.error).toBe('');
-		expect(result.isError).toBe(true);
-		expect(isError(result)).toBe(true);
-	});
-});
+import { describe, it, expect } from 'vitest';
+import {
+	success,
+	error,
+	isSuccess,
+	isError,
+	type HandlerResult,
+	type SuccessResult,
+	type ErrorResult,
+} from './types.js';
+
+describe('success', () => {
+	it('should create a success result with simple data', () => {
+		const result = success({ message: 'hello' });
+		expect(result.result).toEqual({ message: 'hello' });
+		expect(result.isError).toBeUndefined();
+	});
+
+	it('should create a success result with string data', () => {
+		const result = success('test string');
+		expect(result.result).toBe('test string');
+	});
+
+	it('should create a success result with number data', () => {
+		const result = success(42);
+		expect(result.result).toBe(42);
+	});
+
+	it('should create a success result with boolean data', () => {
+		const result = success(true);
+		expect(result.result).toBe(true);
+	});
+
+	it('should create a success result with null data', () => {
+		const result = success(null);
+		expect(result.result).toBeNull();
+	});
+
+	it('should create a success result with undefined data', () => {
+		const result = success(undefined);
+		expect(result.result).toBeUndefined();
+	});
+
+	it('should create a success result with array data', () => {
+		const result = success([1, 2, 3]);
+		expect(result.result).toEqual([1, 2, 3]);
+	});
+
+	it('should create a success result with nested object data', () => {
+		const data = {
+			tasks: [{ id: '1', title: 'Task 1' }],
+			total_count: 1,
+			metadata: { page: 1, limit: 10 },
+		};
+		const result = success(data);
+		expect(result.result).toEqual(data);
+	});
+
+	it('should preserve type information', () => {
+		interface TaskData {
+			id: string;
+			title: string;
+		}
+		const result: SuccessResult<TaskData> = success({ id: '1', title: 'Test' });
+		expect(result.result.id).toBe('1');
+		expect(result.result.title).toBe('Test');
+	});
+});
+
+describe('error', () => {
+	it('should create an error result with message only', () => {
+		const result = error('Something went wrong');
+		expect(result.result.error).toBe('Something went wrong');
+		expect(result.isError).toBe(true);
+	});
+
+	it('should create an error result with message and details', () => {
+		const result = error('Validation failed', { field: 'title', reason: 'too long' });
+		expect(result.result.error).toBe('Validation failed');
+		expect(result.result.field).toBe('title');
+		expect(result.result.reason).toBe('too long');
+		expect(result.isError).toBe(true);
+	});
+
+	it('should handle empty details object', () => {
+		const result = error('Error message', {});
+		expect(result.result.error).toBe('Error message');
+		expect(result.isError).toBe(true);
+	});
+
+	it('should handle complex details', () => {
+		const result = error('Multiple errors', {
+			errors: ['error1', 'error2'],
+			count: 2,
+			nested: { key: 'value' },
+		});
+		expect(result.result.error).toBe('Multiple errors');
+		expect(result.result.errors).toEqual(['error1', 'error2']);
+		expect(result.result.count).toBe(2);
+		expect(result.result.nested).toEqual({ key: 'value' });
+	});
+
+	it('should always set isError to true', () => {
+		const result1 = error('error1');
+		const result2 = error('error2', { detail: 'info' });
+		expect(result1.isError).toBe(true);
+		expect(result2.isError).toBe(true);
+	});
+});
+
+describe('isSuccess', () => {
+	it('should return true for success results', () => {
+		const result = success({ data: 'test' });
+		expect(isSuccess(result)).toBe(true);
+	});
+
+	it('should return true for success results with various data types', () => {
+		expect(isSuccess(success('string'))).toBe(true);
+		expect(isSuccess(success(123))).toBe(true);
+		expect(isSuccess(success(null))).toBe(true);
+		expect(isSuccess(success([]))).toBe(true);
+		expect(isSuccess(success({}))).toBe(true);
+	});
+
+	it('should return false for error results', () => {
+		const result = error('Something failed');
+		expect(isSuccess(result)).toBe(false);
+	});
+
+	it('should return false for error results with details', () => {
+		const result = error('Validation error', { field: 'name' });
+		expect(isSuccess(result)).toBe(false);
+	});
+
+	it('should narrow type correctly for success', () => {
+		const result: HandlerResult<{ id: string }> = success({ id: '123' });
+		if (isSuccess(result)) {
+			// TypeScript should know result.result is { id: string }
+			expect(result.result.id).toBe('123');
+		}
+	});
+
+	it('should work with explicitly typed results', () => {
+		const successResult: SuccessResult<number> = { result: 42 };
+		const errorResult: ErrorResult = { result: { error: 'fail' }, isError: true };
+
+		expect(isSuccess(successResult)).toBe(true);
+		expect(isSuccess(errorResult)).toBe(false);
+	});
+});
+
+describe('isError', () => {
+	it('should return true for error results', () => {
+		const result = error('Something failed');
+		expect(isError(result)).toBe(true);
+	});
+
+	it('should return true for error results with details', () => {
+		const result = error('Validation error', { field: 'name', code: 'INVALID' });
+		expect(isError(result)).toBe(true);
+	});
+
+	it('should return false for success results', () => {
+		const result = success({ data: 'test' });
+		expect(isError(result)).toBe(false);
+	});
+
+	it('should return false for success results with various data types', () => {
+		expect(isError(success('string'))).toBe(false);
+		expect(isError(success(123))).toBe(false);
+		expect(isError(success(null))).toBe(false);
+		expect(isError(success([]))).toBe(false);
+		expect(isError(success({}))).toBe(false);
+	});
+
+	it('should narrow type correctly for error', () => {
+		const result: HandlerResult<unknown> = error('Task not found');
+		if (isError(result)) {
+			// TypeScript should know result.result.error is string
+			expect(result.result.error).toBe('Task not found');
+		}
+	});
+
+	it('should work with explicitly typed results', () => {
+		const successResult: SuccessResult<number> = { result: 42 };
+		const errorResult: ErrorResult = { result: { error: 'fail' }, isError: true };
+
+		expect(isError(successResult)).toBe(false);
+		expect(isError(errorResult)).toBe(true);
+	});
+});
+
+describe('HandlerResult type usage', () => {
+	it('should work with discriminated union pattern', () => {
+		function processResult(result: HandlerResult<string>): string {
+			if (isSuccess(result)) {
+				return `Success: ${result.result}`;
+			} else {
+				return `Error: ${result.result.error}`;
+			}
+		}
+
+		expect(processResult(success('hello'))).toBe('Success: hello');
+		expect(processResult(error('failed'))).toBe('Error: failed');
+	});
+
+	it('should handle async handler patterns', async () => {
+		async function mockHandler(): Promise<HandlerResult<{ id: string }>> {
+			return success({ id: '123' });
+		}
+
+		const result = await mockHandler();
+		expect(isSuccess(result)).toBe(true);
+		if (isSuccess(result)) {
+			expect(result.result.id).toBe('123');
+		}
+	});
+
+	it('should handle error handler patterns', async () => {
+		async function mockErrorHandler(): Promise<HandlerResult<{ id: string }>> {
+			return error('Not found', { id: '123' });
+		}
+
+		const result = await mockErrorHandler();
+		expect(isError(result)).toBe(true);
+		if (isError(result)) {
+			expect(result.result.error).toBe('Not found');
+			expect(result.result.id).toBe('123');
+		}
+	});
+});
+
+describe('edge cases', () => {
+	it('should handle result with isError explicitly set to false', () => {
+		const result: SuccessResult<string> = { result: 'data', isError: false };
+		expect(isSuccess(result)).toBe(true);
+		expect(isError(result)).toBe(false);
+	});
+
+	it('should handle result without isError property', () => {
+		const result: SuccessResult<string> = { result: 'data' };
+		expect(isSuccess(result)).toBe(true);
+		expect(isError(result)).toBe(false);
+	});
+
+	it('should handle success with error-like data', () => {
+		// A success result that happens to contain an error message in its data
+		const result = success({ error: 'This is not an error result', data: 'some data' });
+		expect(isSuccess(result)).toBe(true);
+		expect(isError(result)).toBe(false);
+	});
+
+	it('should handle empty string error message', () => {
+		const result = error('');
+		expect(result.result.error).toBe('');
+		expect(result.isError).toBe(true);
+		expect(isError(result)).toBe(true);
+	});
+});