# Testing Guide

This project uses [Bun Test](https://bun.sh/docs/cli/test) for focused, high-value testing of core business logic.

## Running Tests

```bash

# Run all tests

bun test

# Run tests in watch mode (for development)

bun test --watch

# Run tests with coverage report

bun test --coverage

```

## Test Philosophy

This project follows a **focused testing approach** that prioritizes:

1. **High Value**: Test core business logic and data validation

2. **Fast Execution**: No slow I/O operations or complex mocking

3. **Maintainability**: Simple, reliable tests that won't break with dependencies

4. **Clarity**: Each test has a clear purpose and validates real behavior

## What We Test ✅

### **Core Utilities** (100% Coverage)

- `src/utils/try-catch.test.ts` - Error handling wrapper functionality

- `src/utils/templates.test.ts` - Template configuration and Hono code generation

- `src/utils/constants.test.ts` - Application constants validation

- `src/types.test.ts` - TypeScript type definitions and interfaces

## What We DON'T Test ❌

**CLI Functions with External Dependencies:**

- File system operations (degit, fs-extra)

- Interactive prompts (consola)

- System commands (git, bun install)

- Process management (process.exit)

**Why:** These functions are integration points with the OS and external tools. Testing them would require complex mocking that provides little value and high maintenance overhead.

## Test Configuration

### `bunfig.toml`

```toml

[test]

coverage = true

timeout = 5000

[test.env]

NODE_ENV = "test"

```

### Package Scripts

- `bun test` - Run all tests

- `bun test --watch` - Watch mode for development

- `bun test --coverage` - Generate coverage reports

[test]

# Test configuration for Bun

coverage = true

timeout = 5000

# Environment variables for tests

[test.env]

NODE_ENV = "test"

    "start": "bun ./dist/index.js",

    "test": "bun test",

    "test:watch": "bun test --watch",

    "test:coverage": "bun test --coverage"

import { describe, it, expect } from "bun:test";

import type { TemplateInfo, ProjectOptions, ProjectResult } from "./types";

describe("TypeScript types", () => {

  it("should define correct type structures", () => {

    // Test that types can be instantiated correctly

    const templateInfo: TemplateInfo = {

      branch: "main",

      description: "Test template"

    };

    const options: ProjectOptions = {

      projectName: "test-project",

      linter: "biome"

    };

    const result: ProjectResult = {

      projectName: "test-project",

      gitInitialized: true,

      dependenciesInstalled: false,

      template: "default"

    };

    expect(templateInfo.branch).toBe("main");

    expect(options.linter).toBe("biome");

    expect(result.projectName).toBe("test-project");

  });

});

import { describe, it, expect } from "bun:test";

import { DEFAULT_REPO } from "./constants";

describe("constants", () => {

  it("should have correct default repository", () => {

    expect(DEFAULT_REPO).toBe("stevedylandev/bhvr");

  });

  it("should be a string", () => {

    expect(typeof DEFAULT_REPO).toBe("string");

  });

  it("should follow GitHub repo format", () => {

    expect(DEFAULT_REPO).toMatch(/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/);

  });

});

import { describe, it, expect } from "bun:test";

import { TEMPLATES, honoRpcTemplate, honoClientTemplate } from "./templates";

describe("Templates", () => {

	it("should have all required templates with correct structure", () => {

		const expectedTemplates = ["default", "tailwind", "shadcn"];

		expectedTemplates.forEach((templateName) => {

			expect(TEMPLATES).toHaveProperty(templateName);

			const template = TEMPLATES[templateName];

			expect(template).toHaveProperty("branch");

			expect(template).toHaveProperty("description");

			expect(typeof template?.branch).toBe("string");

			expect(typeof template?.description).toBe("string");

		});

	});

	it("should have valid Hono templates", () => {

		expect(honoRpcTemplate).toContain("import { Hono }");

		expect(honoRpcTemplate).toContain("export const app = new Hono()");

		expect(honoClientTemplate).toContain("import { hc }");

		expect(honoClientTemplate).toContain("export const hcWithType");

	});

});

import { describe, it, expect } from "bun:test";

import { tryCatch } from "./try-catch";

describe("tryCatch", () => {

  it("should return success result for resolved promise", async () => {

    const result = await tryCatch(Promise.resolve("success"));

    expect(result.data).toBe("success");

    expect(result.error).toBeNull();

  });

  it("should return failure result for rejected promise", async () => {

    const error = new Error("test error");

    const result = await tryCatch(Promise.reject(error));

    expect(result.data).toBeNull();

    expect(result.error).toBe(error);

  });

  it("should handle async function that throws", async () => {

    const asyncFunction = async () => {

      throw new Error("async error");

    };

    const result = await tryCatch(asyncFunction());

    expect(result.data).toBeNull();

    expect(result.error).toBeInstanceOf(Error);

    expect((result.error as Error).message).toBe("async error");

  });

  it("should handle different data types", async () => {

    const objectResult = await tryCatch(Promise.resolve({ id: 1, name: "test" }));

    const numberResult = await tryCatch(Promise.resolve(42));

    const booleanResult = await tryCatch(Promise.resolve(true));

    expect(objectResult.data).toEqual({ id: 1, name: "test" });

    expect(numberResult.data).toBe(42);

    expect(booleanResult.data).toBe(true);

  });

});