Godot vs Unity Testing: Choosing the Right QA Approach for Your Game

// Built-in — no installation needed.
// Create a test assembly definition (.asmdef) with TestAssemblies enabled
// Tests live in an Editor/Tests folder
// Open Test Runner window: Window → General → Test Runner

using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;

[TestFixture]
public class PlayerTests
{
    [Test]
    public void PlayerStartsWithFullHealth()
    {
        var player = new Player();
        Assert.AreEqual(100, player.Health);
    }

    [UnityTest]
    public IEnumerator PlayerTakesDamageOverTime()
    {
        var go = new GameObject();
        var player = go.AddComponent<PlayerComponent>();

        player.ApplyDot(10, duration: 1f);
        yield return new WaitForSeconds(1f);

        Assert.Less(player.Health, 100);
        Object.DestroyImmediate(go);
    }
}

# Install via Asset Library or git submodule
# Enable in Project → Project Settings → Plugins
# Create test scripts extending GutTest

extends GutTest

func before_each():
    player = Player.new()
    add_child(player)

func after_each():
    player.queue_free()

func test_player_starts_with_full_health():
    assert_eq(player.health, 100)

func test_player_takes_damage():
    player.take_damage(20)
    assert_eq(player.health, 80)

Unity Edit Mode test (no game loop):
- Simple assertion: ~1ms
- Component test (with GameObject): ~5-10ms

Unity Play Mode test (full game loop):
- Startup time: 2-5 seconds
- Per test overhead: minimal after startup

GUT unit test (engine starts, no scene):
- Startup time: 0.5-2 seconds
- Per test overhead: ~10-50ms

GUT integration test (with scene instantiation):
- Per test overhead: 100-500ms

# GitHub Actions — Unity requires license activation
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: game-ci/unity-test-runner@v4
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
        with:
          projectPath: .
          testMode: editmode

# GitHub Actions — no license required
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Download Godot
        run: |
          wget -q "https://github.com/godotengine/godot/releases/download/4.2.2-stable/Godot_v4.2.2-stable_linux.x86_64.zip"
          unzip -q Godot_*.zip
      - name: Run tests
        run: |
          ./Godot_v4.2.2-stable_linux.x86_64 --headless \
            -s addons/gut/gut_cmdln.gd \
            -gdir=res://test \
            -gexit_on_complete

[UnitySetUp]
public IEnumerator SetUp()
{
    // MUST destroy objects from previous tests
    foreach (var go in Object.FindObjectsOfType<GameObject>())
    {
        Object.DestroyImmediate(go);
    }
    yield return null;
}

func before_each():
    # Must reset autoloads explicitly
    GameState.reset()
    EventBus.disconnect_all()
    watch_signals(player)

using NSubstitute;

public class OrderServiceTests
{
    [Test]
    public void OrderService_ProcessesPayment()
    {
        var paymentGateway = Substitute.For<IPaymentGateway>();
        paymentGateway.Charge(Arg.Any<decimal>()).Returns(true);

        var service = new OrderService(paymentGateway);
        service.Process(new Order { Total = 50m });

        paymentGateway.Received(1).Charge(50m);
    }
}

func test_order_processes_payment():
    var payment_double = double(PaymentGateway).new()
    stub(payment_double, "charge").to_return(true)

    var service = OrderService.new()
    service.payment_gateway = payment_double
    service.process({"total": 50.0})

    assert_called(payment_double, "charge", [50.0])