Are There Tests Included in the oblien/openship Repository?

Yes, the oblien/openship repository maintains a comprehensive test suite using Vitest and Jest, with unit, integration, and end-to-end tests distributed across the monorepo's apps and packages.

The oblien/openship project follows modern monorepo architecture, organizing multiple applications and shared packages under a unified codebase. Understanding whether tests are included in the oblien/openship repository is crucial for contributors evaluating code quality and deployment safety. The codebase demonstrates mature engineering practices through extensive test coverage that validates CLI workflows, API integrations, and database operations.

Test Suite Structure and Coverage

The repository organizes tests using standard *.test.ts and *.spec.ts naming conventions co-located with source code. This structure ensures that unit tests, integration scenarios, and utility validations remain synchronized with their corresponding implementations across the CLI, API, dashboard, and database packages.

CLI Unit Tests

The command-line interface includes dedicated unit tests for critical provisioning workflows. In apps/cli/test/unit/instance-provision.test.ts, the test suite validates instance provisioning logic to ensure commands execute correctly before deployment.

// Representative structure from apps/cli/test/unit/instance-provision.test.ts
import { describe, it, expect } from 'vitest';
import { provisionInstance } from '../../src/commands/provision';

describe('instance provision', () => {
  it('should provision instance with valid config', async () => {
    const result = await provisionInstance({ name: 'test-instance' });
    expect(result.status).toBe('success');
  });
});

API Integration Tests

The API layer contains integration tests for external service interactions. The file apps/api/test/modules/github/tokenFor.test.ts verifies GitHub token handling logic, ensuring secure authentication flows function correctly against external APIs.

// Representative structure from apps/api/test/modules/github/tokenFor.test.ts
import { describe, it, expect } from 'vitest';
import { tokenFor } from '../../../src/modules/github/tokenFor';

describe('tokenFor', () => {
  it('should return valid GitHub token', async () => {
    const token = await tokenFor({ repository: 'oblien/openship' });
    expect(token).toBeDefined();
    expect(token.startsWith('ghp_')).toBe(true);
  });
});

Dashboard Utility Tests

Frontend utilities undergo rigorous validation to support UI reliability. The apps/dashboard/src/utils/deploymentPhaseDetector.test.ts file specifically tests deployment-phase detection algorithms used by the dashboard interface to determine application states.

Database Testing Configuration

The packages/db directory implements sophisticated testing infrastructure using PGlite, an in-memory PostgreSQL implementation. This approach enables fast, isolated database tests without external dependencies.

The configuration in packages/db/vitest.config.ts extends default timeouts specifically for database operations, demonstrating intentional infrastructure design for data-layer testing.

// packages/db/vitest.config.ts
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    testTimeout: 30000,
    hookTimeout: 30000,
    globals: true,
  },
});

Database repository tests such as packages/db/src/repos/webhook-delivery.repo.test.ts execute against this PGlite instance, validating data access patterns and repository methods in isolation.

Summary

• The oblien/openship repository includes extensive automated tests across apps/cli, apps/api, apps/dashboard, and packages/db
• Test files follow *.test.ts and *.spec.ts naming conventions co-located with source code
• Vitest serves as the primary testing framework with Jest used in specific legacy contexts
• Database tests utilize PGlite for in-memory PostgreSQL simulation, configured in packages/db/vitest.config.ts
• Key test files include instance-provision.test.ts, tokenFor.test.ts, and deploymentPhaseDetector.test.ts

Frequently Asked Questions

What testing frameworks does oblien/openship use?

The repository primarily uses Vitest for test execution, though some packages utilize Jest depending on specific requirements. Both frameworks support TypeScript and run across the monorepo structure via configuration files like packages/db/vitest.config.ts.

Does the repository include database tests?

Yes, the packages/db directory contains comprehensive database tests including repository-level validations like webhook-delivery.repo.test.ts. These tests run against PGlite, an in-memory PostgreSQL implementation, ensuring database logic works correctly without external service dependencies.

Where are the CLI tests located?

CLI-specific tests reside in the apps/cli/test/ directory, with unit tests such as instance-provision.test.ts validating command-line workflows and provisioning logic before production deployment.

Are integration tests included for the API?

Yes, the API application includes integration tests in apps/api/test/modules/, including github/tokenFor.test.ts which validates external service integration and token management workflows critical for GitHub operations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}