create unit test

Author: codev911

package.json

@@ -27,7 +27,12 @@
   ],
   "scripts": {
     "build": "rm -rf dist && bun build src/index.ts --outdir ./dist --target bun --minify --external elysia && tsc",
-    "format": "prettier --write '**/*.ts' --ignore-path .gitignore"
+    "format": "prettier --write '**/*.ts' --ignore-path .gitignore",
+    "test": "bun test",
+    "test:unit": "bun test tests/unit",
+    "test:e2e": "bun test tests/e2e",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage"
   },
   "devDependencies": {
     "@types/bun": "latest",

tests/unit/http-exception-plugin.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'bun:test';
+import { Elysia } from 'elysia';
+import { httpExceptionPlugin } from '../../src/http-exception-plugin';
+import { 
+  HttpException, 
+  BadRequestException, 
+  UnauthorizedException,
+  NotFoundException,
+  InternalServerErrorException
+} from '../../src';
+
+describe('HTTP Exception Plugin', () => {
+  it('should return an Elysia instance', () => {
+    const plugin = httpExceptionPlugin();
+    expect(plugin).toBeInstanceOf(Elysia);
+  });
+
+  it('should be composable with other Elysia apps', () => {
+    const app = new Elysia();
+    const result = app.use(httpExceptionPlugin());
+    expect(result).toBeInstanceOf(Elysia);
+  });
+
+  it('should provide httpException decorator', () => {
+    const app = new Elysia().use(httpExceptionPlugin());
+    
+    // Check if the decorator is available in the app's decorator store
+    expect(app.decorator).toHaveProperty('httpException');
+  });
+
+  it('should handle HttpException in decorator', () => {
+    const plugin = httpExceptionPlugin();
+    const httpException = plugin.decorator.httpException;
+    
+    const error = new BadRequestException('Invalid input');
+    const response = httpException(error);
+    
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(400);
+  });
+
+  it('should handle generic errors in decorator', () => {
+    const plugin = httpExceptionPlugin();
+    const httpException = plugin.decorator.httpException;
+    
+    const error = new Error('Some error');
+    const response = httpException(error);
+    
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(500);
+  });
+
+  it('should handle non-error values in decorator', () => {
+    const plugin = httpExceptionPlugin();
+    const httpException = plugin.decorator.httpException;
+    
+    const response = httpException('Some error message');
+    
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(500);
+  });
+
+  it('should create plugin with correct name', () => {
+    const plugin = httpExceptionPlugin();
+    expect(plugin.config.name).toBe('elysia-http-exception');
+  });
+});

tests/unit/http-exception.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect } from 'bun:test';
+import { HttpException } from '../../src/exceptions/http-exception';
+import { HttpError } from '../../src/types/http-error';
+
+describe('HttpException', () => {
+  it('should create instance with string message', () => {
+    const exception = new HttpException(HttpError.BAD_REQUEST, 'Bad Request');
+    
+    expect(exception.statusCode).toBe(400);
+    expect(exception.message).toBe('Bad Request');
+    expect(exception.name).toBe('HttpException');
+    expect(exception instanceof Error).toBe(true);
+    expect(exception instanceof HttpException).toBe(true);
+  });
+
+  it('should create instance with object message', () => {
+    const messageObject = {
+      error: 'VALIDATION_FAILED',
+      field: 'email',
+      details: 'Invalid email format'
+    };
+    
+    const exception = new HttpException(HttpError.BAD_REQUEST, messageObject);
+    
+    expect(exception.statusCode).toBe(400);
+    expect(exception.data).toEqual(messageObject);
+  });
+
+  it('should create instance with Error object', () => {
+    const originalError = new Error('Original error message');
+    const exception = new HttpException(HttpError.INTERNAL_SERVER_ERROR, originalError);
+    
+    expect(exception.statusCode).toBe(500);
+    expect(exception.message).toBe('Original error message');
+  });
+
+  it('should return correct body for string message', () => {
+    const exception = new HttpException(HttpError.BAD_REQUEST, 'Bad Request');
+    const body = exception.toBody();
+    
+    expect(body).toEqual({
+      statusCode: 400,
+      message: 'Bad Request'
+    });
+  });
+
+  it('should return correct body for object message', () => {
+    const messageObject = {
+      error: 'VALIDATION_FAILED',
+      field: 'email'
+    };
+    
+    const exception = new HttpException(HttpError.BAD_REQUEST, messageObject);
+    const body = exception.toBody();
+    
+    expect(body).toEqual(messageObject);
+  });
+
+  it('should return correct body for Error object message', () => {
+    const originalError = new Error('Original error');
+    const exception = new HttpException(HttpError.INTERNAL_SERVER_ERROR, originalError);
+    const body = exception.toBody();
+    
+    expect(body).toEqual({
+      statusCode: 500,
+      message: 'Original error'
+    });
+  });
+
+  it('should handle null message', () => {
+    const exception = new HttpException(HttpError.BAD_REQUEST, null as any);
+    const body = exception.toBody();
+    
+    expect(body).toEqual({
+      statusCode: 400,
+      message: 'Bad Request'
+    });
+  });
+
+  it('should handle undefined message', () => {
+    const exception = new HttpException(HttpError.BAD_REQUEST, undefined as any);
+    const body = exception.toBody();
+    
+    expect(body).toEqual({
+      statusCode: 400,
+      message: 'Bad Request'
+    });
+  });
+
+  it('should preserve stack trace', () => {
+    const exception = new HttpException(HttpError.INTERNAL_SERVER_ERROR, 'Internal Error');
+    
+    expect(exception.stack).toBeDefined();
+    expect(typeof exception.stack).toBe('string');
+    expect(exception.stack).toContain('HttpException');
+  });
+
+  it('should be serializable to JSON', () => {
+    const exception = new HttpException(HttpError.BAD_REQUEST, { error: 'TEST_ERROR' });
+    const serialized = JSON.stringify(exception);
+    const parsed = JSON.parse(serialized);
+    
+    expect(parsed.statusCode).toBe(400);
+    expect(parsed.data).toEqual({ error: 'TEST_ERROR' });
+  });
+});