name: Test CLI Options

on:

  push:

    branches: [ main ]

  pull_request:

    branches: [ main ]

jobs:

  test-cli-options:

    runs-on: ubuntu-latest

    strategy:

      fail-fast: false

      matrix:

        include:

          # Default template combinations

          - template: "default"

            rpc: true

            linter: "eslint"

            test_name: "Default + RPC + ESLint"

          - template: "default"

            rpc: true

            linter: "biome"

            test_name: "Default + RPC + Biome"

          - template: "default"

            rpc: false

            linter: "eslint"

            test_name: "Default + No RPC + ESLint"

          - template: "default"

            rpc: false

            linter: "biome"

            test_name: "Default + No RPC + Biome"

          # Tailwind template combinations

          - template: "tailwind"

            rpc: true

            linter: "eslint"

            test_name: "Tailwind + RPC + ESLint"

          - template: "tailwind"

            rpc: true

            linter: "biome"

            test_name: "Tailwind + RPC + Biome"

          - template: "tailwind"

            rpc: false

            linter: "eslint"

            test_name: "Tailwind + No RPC + ESLint"

          - template: "tailwind"

            rpc: false

            linter: "biome"

            test_name: "Tailwind + No RPC + Biome"

          # Shadcn template combinations

          - template: "shadcn"

            rpc: true

            linter: "eslint"

            test_name: "Shadcn + RPC + ESLint"

          - template: "shadcn"

            rpc: true

            linter: "biome"

            test_name: "Shadcn + RPC + Biome"

          - template: "shadcn"

            rpc: false

            linter: "eslint"

            test_name: "Shadcn + No RPC + ESLint"

          - template: "shadcn"

            rpc: false

            linter: "biome"

            test_name: "Shadcn + No RPC + Biome"

    steps:

      - name: Checkout repository

        uses: actions/checkout@v4

      - name: Setup Bun

        uses: oven-sh/setup-bun@v2

        with:

          bun-version: latest

      - name: Install dependencies

        run: bun install

      - name: Build CLI

        run: bun run build

      - name: Create test project - ${{ matrix.test_name }}

        run: |

          # Create project with specified options

          echo "Creating project with options:"

          echo "Template: ${{ matrix.template }}"

          echo "RPC: ${{ matrix.rpc }}"

          echo "Linter: ${{ matrix.linter }}"

          if [ "${{ matrix.rpc }}" = "true" ]; then

            ./dist/index.js test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }} \

              --yes \

              --template ${{ matrix.template }} \

              --rpc \

              --linter ${{ matrix.linter }}

          else

            ./dist/index.js test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }} \

              --yes \

              --template ${{ matrix.template }} \

              --linter ${{ matrix.linter }}

          fi

      - name: Install project dependencies

        run: |

          cd test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }}

          bun install

      - name: Build test project

        run: |

          cd test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }}

          bun run build

      - name: Verify build outputs

        run: |

          cd test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }}

          # Check that dist directories exist

          if [ ! -d "client/dist" ]; then

            echo "❌ Client build failed - dist directory not found"

            exit 1

          fi

          if [ ! -d "server/dist" ]; then

            echo "❌ Server build failed - dist directory not found"

            exit 1

          fi

          # Check for expected files

          if [ ! -f "client/dist/index.html" ]; then

            echo "❌ Client build incomplete - index.html not found"

            exit 1

          fi

          if [ ! -f "server/dist/index.js" ]; then

            echo "❌ Server build incomplete - index.js not found"

            exit 1

          fi

          echo "✅ Build verification passed for ${{ matrix.test_name }}"

      - name: Run linter on generated project

        run: |

          cd test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }}

          if [ "${{ matrix.linter }}" = "eslint" ]; then

            # Check if ESLint config exists and run it

            if [ -f ".eslintrc.json" ] || [ -f ".eslintrc.js" ] || [ -f "eslint.config.js" ]; then

              echo "Running ESLint..."

              bun run lint || echo "ESLint warnings/errors found but continuing..."

            fi

          elif [ "${{ matrix.linter }}" = "biome" ]; then

            # Check if Biome config exists and run it

            if [ -f "biome.json" ]; then

              echo "Running Biome..."

              bun run lint || echo "Biome warnings/errors found but continuing..."

            fi

          fi

      - name: Cleanup test project

        if: always()

        run: |

          rm -rf test-project-${{ matrix.template }}-${{ matrix.rpc }}-${{ matrix.linter }}

name: Test

on:

  push:

    branches: [ main ]

  pull_request:

    branches: [ main ]

jobs:

  test:

    runs-on: ubuntu-latest

    steps:

      - name: Checkout repository

        uses: actions/checkout@v4

      - name: Setup Bun

        uses: oven-sh/setup-bun@v2

        with:

          bun-version: latest

      - name: Install dependencies

        run: bun install

      - name: Run tests

        run: bun test

      - name: Run tests with coverage

        run: bun test --coverage

# 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);

  });

});