# How to Set Up and Configure the QA Testing Framework in Claude Code Game Studios

> Easily set up and configure the QA testing framework for Claude Code Game Studios. Run the test-setup command for automated scaffolding, runner configuration, and CI pipeline setup.

- Repository: [Donchitos/Claude-Code-Game-Studios](https://github.com/Donchitos/Claude-Code-Game-Studios)
- Tags: how-to-guide
- Published: 2026-04-16

---

**Run the `/test-setup` command to automatically scaffold a language- and engine-specific `tests/` hierarchy, configure the appropriate test runner, and wire a GitHub Actions CI pipeline for continuous integration.**

The Claude Code Game Studios repository provides a sophisticated QA testing framework that automates the creation of testing infrastructure for game projects. To set up and configure the QA testing framework, developers use the `/test-setup` skill, which detects the game engine from [`technical-preferences.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/technical-preferences.md) and generates the complete testing scaffold including unit, integration, performance, and playtest directories.

## What `/test-setup` Does to Configure Your QA Framework

According to the `CCGS Skill Testing Framework/skills/utility/test-setup.md` source specification, the `/test-setup` skill performs a sequence of automated steps to establish the testing environment.

### Engine Detection

The skill first reads [`technical-preferences.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/technical-preferences.md) (or checks the engine set by `/setup-engine`) to determine whether the project uses **Godot**, **Unity**, or **Unreal Engine**. This detection step ensures that all subsequent configurations match the project's language and runtime requirements.

### Directory Structure Creation

Based on the detected engine, the skill generates the appropriate directory tree:

- **Godot/GDScript**: Creates `tests/unit/`, `tests/integration/`, `tests/performance/`, and `tests/playtest/`
- **Unity**: Creates `Tests/` with Unity-style `.asmdef` assembly definition files
- **Unreal**: Creates an Unreal headless runner folder structure

### Test Runner Configuration

The skill writes engine-specific runner configurations:

- **Godot**: Adds `tests/gdunit4_runner.gd` and a matching CI command (`godot --headless --script …`)
- **Unity**: Creates `Tests/Tests.asmdef` and `Tests/Editor/EditorTests.asmdef`
- **Unreal**: Adds a shell script that launches the headless test binary

### CI/CD Pipeline Integration

Finally, the skill writes [`.github/workflows/tests.yml`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/.github/workflows/tests.yml) according to the [`.claude/skills/test-setup/SKILL.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/.claude/skills/test-setup/SKILL.md) specification. This workflow runs the engine-specific test command on every push and pull request to the `main` branch.

## How to Invoke the QA Testing Framework Setup

To set up and configure the QA testing framework, use the following commands in a Claude-powered session or via the CLI that forwards commands to Claude.

Run the setup once per project:

```bash
/test-setup

```

If you need to force regeneration of the framework (for example, after changing game engines):

```bash
/test-setup force

```

The agent will prompt for permission with "May I write …?" before creating any files, following the Claude collaboration protocol defined in the skill specification.

## Engine-Specific QA Configurations

### Godot (GDScript) Setup

For Godot projects, the framework creates a GDUnit4-compatible structure. The generated `tests/gdunit4_runner.gd` script enables headless execution using:

```bash
godot --headless --script tests/gdunit4_runner.gd

```

Example test file generated at `tests/unit/gameplay/test_movement_formulas.gd`:

```gdscript
extends GdUnitTestSuite

func test_walk_speed() -> void:
    var speed = calculate_walk_speed(terrain = "normal")
    assert_eq(speed, 5.0)

func test_run_speed_on_slope() -> void:
    var speed = calculate_run_speed(terrain = "slope")
    assert_lt(speed, 8.0)

```

### Unity (C#) Setup

For Unity projects, the framework generates assembly definition files (`Tests.asmdef` and `EditorTests.asmdef`) that organize test assemblies separately from production code. Tests run via the Unity Test Runner or command line:

```bash
dotnet test Tests/Tests.csproj

```

### Unreal Engine Setup

For Unreal projects, the skill creates a headless runner folder containing a shell script that launches the automation test binary without rendering:

```bash
./run_headless_tests.sh

```

## Verifying the QA Testing Framework

After `/test-setup` completes, verify the installation by running tests locally:

**Godot:**

```bash
godot --headless --script tests/gdunit4_runner.gd

```

**Unity:**

```bash
dotnet test Tests/Tests.csproj

```

**Unreal:**

```bash
./run_headless_tests.sh

```

The GitHub Action defined in [`.github/workflows/tests.yml`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/.github/workflows/tests.yml) triggers automatically on pushes and pull requests to `main`, running the engine-specific command in an Ubuntu environment.

If a `tests/` tree already exists when you run `/test-setup`, the skill enters verification mode and only checks that configuration matches engine standards without overwriting existing test code.

## Summary

- **Run `/test-setup`** once per project to automatically scaffold the complete QA testing framework for Godot, Unity, or Unreal Engine.
- The skill detects your engine from [`technical-preferences.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/technical-preferences.md), creates the `tests/` directory hierarchy, writes engine-specific runner configurations, and adds a GitHub Actions CI pipeline.
- **Use `/test-setup force`** only if you need to regenerate the framework after changing engines.
- Verify your setup by running the engine-specific test command locally; the CI workflow runs automatically on every push to `main`.

## Frequently Asked Questions

### Can I run `/test-setup` multiple times on the same project?

Running `/test-setup` a second time activates verification mode. According to the skill specification at `CCGS Skill Testing Framework/skills/utility/test-setup.md`, the framework checks that existing configurations match engine standards without overwriting your test code. Only use `/test-setup force` to deliberately regenerate the scaffolding.

### What happens if I already have tests in my project?

If a `tests/` directory already exists, the skill enters verification mode. It validates that your current setup matches the detected engine's standards (Godot, Unity, or Unreal) but preserves all existing test files and code. This prevents accidental deletion of your test suite while ensuring the configuration is correct.

### How do I force regenerate the test framework?

Append the `force` flag to the command: `/test-setup force`. Use this only when you have deliberately changed game engines (for example, migrating from Unity to Godot) and need to replace the existing test scaffolding with configurations appropriate for the new engine.

### Which game engines are supported by the QA testing framework?

The framework supports three major game engines: **Godot** (using GDScript and GDUnit4), **Unity** (using C# and the Unity Test Runner), and **Unreal Engine** (using the headless automation test binary). The engine is automatically detected from [`technical-preferences.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/technical-preferences.md) or the `/setup-engine` command.