@galaxy-stack/orbit-testing

Mô tả

Testing utilities cho Orbit framework với mock module builder và HTTP testing helpers.

Tính năng chính

1. Test Module Builder

import { Test, TestingModule } from '@galaxy-stack/orbit-testing';

describe('UserService', () => {
  let service: UserService;
  let module: TestingModule;

  beforeEach(async () => {
    module = await Test.createTestingModule({
      providers: [
        UserService,
        {
          provide: DatabaseService,
          useValue: createMock<DatabaseService>(),
        },
      ],
    }).compile();

    service = module.get(UserService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });
});

2. HTTP Testing

import { Test, TestHttpServer } from '@galaxy-stack/orbit-testing';

describe('UserController', () => {
  let app: TestHttpServer;

  beforeAll(async () => {
    const module = await Test.createTestingModule({
      controllers: [UserController],
      providers: [UserService],
    }).compile();

    app = module.createHttpServer();
  });

  it('GET /users', async () => {
    const response = await app.get('/users');
    
    expect(response.status).toBe(200);
    expect(response.body).toBeArray();
  });

  it('POST /users', async () => {
    const response = await app
      .post('/users')
      .send({ name: 'John', email: '[email protected]' });
    
    expect(response.status).toBe(201);
    expect(response.body.name).toBe('John');
  });
});

3. Mock Helpers

import { createMock, createSpyOn } from '@galaxy-stack/orbit-testing';

// Auto-mock all methods
const mockService = createMock<UserService>();
mockService.findOne.mockResolvedValue({ id: 1, name: 'John' });

// Spy on specific method
const spy = createSpyOn(service, 'findOne');
spy.mockResolvedValue({ id: 1 });

await service.findOne(1);
expect(spy).toHaveBeenCalledWith(1);

Provider Overrides

const module = await Test.createTestingModule({
  imports: [AppModule],
})
  .overrideProvider(DatabaseService)
  .useValue(mockDatabaseService)
  
  .overrideGuard(AuthGuard)
  .useValue({ canActivate: () => true })
  
  .overridePipe(ValidationPipe)
  .useValue({ transform: (value) => value })
  
  .compile();

TestResponse

interface TestResponse {
  status: number;
  headers: Headers;
  body: any;
  text: string;
  
  expect(status: number): TestResponse;
  expectHeader(name: string, value: string): TestResponse;
  expectBody(expected: any): TestResponse;
}

Integration Testing

describe('App (e2e)', () => {
  let app: TestHttpServer;

  beforeAll(async () => {
    const module = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = module.createHttpServer();
    await app.init();
  });

  afterAll(async () => {
    await app.close();
  });

  it('/ (GET)', async () => {
    const response = await app.get('/');
    expect(response.status).toBe(200);
  });
});

Test Configuration

// bun.test.ts
export default {
  testTimeout: 10000,
  bail: true,
  coverage: {
    enabled: true,
    threshold: {
      lines: 80,
      functions: 80,
      branches: 80,
    },
  },
};