Tests

One runner. Every layer.

Write tests as `.cuitty` test suites. Run HTTP assertions, gRPC calls, browser flows via Pilot, and unit tests through one runner, one audit trail, and one CI pipeline.

Get started Open playground

HTTP / REST

Assert on status, JSON paths, headers, and latency against any endpoint.

gRPC

Call protobuf services, assert on response fields, and measure latency.

Pilot (E2E)

Drive real browsers via Pilot playbooks. Selector healing, video recording, and failure summaries come free.

Unit

Delegate to Bun or Node test runners. Import existing test files and report results through the same pipeline.

Test runner

Watch a suite run. HTTP, Pilot, gRPC — one pipeline.

Click Run to watch the test runner execute a mixed suite. The "dashboard" test drives Pilot in headless mode and every Pilot step is video-recorded automatically.

auth-flowCI

◌login
◌dashboard
◌inventory
◌cleanup

0/4 passed

Click Run to execute the test suite

awaiting test output...

The `.cuitty` test_suite block.

`.ctest` files still import cleanly, but new suites use the shared Cuitty DSL so Tests can reference Pilot playbooks, secrets, captures, and future product blocks with the same parser and LSP.

cuitty {
  schema_version = 1
  project = "auth-flow"
  extensions = ["tests", "pilot"]
  targets = ["ctest"]
}

playbook "internal.auth.verify-dashboard" {
  version = "1.0.0"
  target = "portal"
  executor = "browser"
}

test_suite "auth-flow" {
  env {
    BASE_URL = "http://localhost:4310"
    AUTH_TOKEN = secret("tests/auth-token")
  }

  test "session-valid" {
    type = "http"
    request {
      method = "GET"
      url    = "${env.BASE_URL}/api/session"
      header "authorization" {
        value = "Bearer ${env.AUTH_TOKEN}"
      }
    }
    assert {
      status = 200
    }
    capture "session_user" {
      json_path = "$.user.id"
    }
  }

  test "dashboard-playbook" {
    type     = "pilot"
    depends  = ["session-valid"]
    playbook = ref("playbook.internal.auth.verify-dashboard")
  }
}

Test Studio

Explore tests locally.

A Prisma Studio-style local UI for running, inspecting, and debugging tests interactively. See captured values flow between dependent tests, inspect response bodies, and replay Pilot recordings frame-by-frame.

CI Pipeline

Airflow-native scheduling.

Test suites register as Airflow DAGs. Run on push, on schedule, or on demand. Visual progress, retry logic, and artifact collection built in. Results report back to Code PR checks.

Integration pipeline

Code → Tests → Pilot → Video → Observe.

Every test run flows through a five-stage pipeline. Hover a stage to see what happens there.

Auto-rotate

Code

Tests are .ctest files committed to your Cuitty Code repo. CI triggers run on PR push via Airflow. Every test change is a versioned, reviewable diff.

→ to Tests

click a node to pin · hover to inspect

# .cuitty/tests/auth-flow.ctest
suite "auth-flow" {
  # CI runs this on every PR
}

Start testing with one `.cuitty` language.

HTTP, gRPC, browser E2E, and unit tests in the same `.cuitty` file, the same runner, the same CI pipeline, and the same audit trail.

See all Cuitty products →