How do you write TDD-friendly tests in testo? Here's our take — no body pollution

[ShaDowMak]

We migrated our Go test suite from allure-go to testo. Along the way we built a
tiny package, testkit, that solves a specific problem: how to mark each test as
unit or integration without repeating the label in every test body.

The motivation was the TDD loop. Three kinds of noise kept getting in the way of a
fast red-green cycle:

• Every local run generated a fresh allure-results — eating memory and adding
  seconds to every iteration.
• Each test had to declare its layer and its parallelism (t.Layer("unit"),
  t.Parallel()), and you had to remember to do it consistently — forgetting a
  t.Parallel() silently broke the parallelism contract.
• All of it sat in the test body, so you had to read past the meta to see the
  actual logic.

testkit removes that noise entirely: call testkit.UnitTest / testkit.IntegrationTest
and the layer is set, parallelism is the default, and the body stays pure.

The problem

testo.Options(...) is global and not bound to a concrete T type. If you set the
layer via global options (testo.Options(allure.WithLabels(...))), then when unit
and integration tests run side by side, every test gets both labels — layers
don't separate.

The solution

The trick is to make the layer a scoped option, attached inside small prefilled
helpers instead of globally:

func layerTest(layer Layer, f func(T), options ...testoplugin.Option) func(*testing.T) {
    return testo.Test(f, append(
        []testoplugin.Option{allure.WithLabels(allure.NewLabel(layerLabel, string(layer)))},
        options...,
    )...)
}

func UnitTest(f func(T), options ...testoplugin.Option) func(*testing.T) {
    return layerTest(LayerUnit, f, options...)
}

func IntegrationTest(f func(T), options ...testoplugin.Option) func(*testing.T) {
    return layerTest(LayerIntegration, f, options...)
}

Scoped options apply only to the test they're attached to, so unit and integration
stay cleanly separated. The layer becomes declarative — you read it from the
wrapper name, not from the body — and it can't be forgotten.

Before / After

Before (allure-go), the test body was a mix of meta and logic — the "pollution"
this post is about:

runner.Run(t, "case", func(t provider.T) {
    t.Layer("unit")   // must remember for every test
    t.Parallel()      // must remember for every test
    sut := NewSUT(t)
    results, err := sut.Evaluate()
    require.NoError(t, err)
    assert.Empty(t, results)
})

After (testkit), the body is just the logic — no pollution:

func Test_Example(t *testing.T) {
    t.Run("Example unit-test", testkit.UnitTest(func(t testkit.T) {
        sut := NewSUT(t)
        results, err := sut.Evaluate()
        t.Require().NoError(err)
        t.Assert().Empty(results)
    }))
}

The layer and parallelism are handled by the wrapper, so the two must remember
lines are gone — and so is the risk of forgetting them.

The full package

package testkit

import (
    "os"
    "testing"

    "github.com/ozontech/testo"
    allure "github.com/ozontech/testo-allure"
    "github.com/ozontech/testo-toppings/parallel"
    "github.com/ozontech/testo/testoplugin"
)

type T struct {
    *testo.T
    *parallel.PluginParallel
    *allure.PluginAllure
}

type Suite = testo.Suite[T]

var WithSync = parallel.WithSync
var Options = testo.Options

type Layer string

const (
    LayerUnit        Layer = "unit"
    LayerIntegration Layer = "integration"
    layerLabel             = "layer"
)

func WithLayer(layer Layer) testoplugin.Option {
    return allure.WithLabels(allure.NewLabel(layerLabel, string(layer)))
}

func layerTest(layer Layer, f func(T), options ...testoplugin.Option) func(*testing.T) {
    return testo.Test(f, append(
        []testoplugin.Option{WithLayer(layer)},
        options...,
    )...)
}

func UnitTest(f func(T), options ...testoplugin.Option) func(*testing.T) {
    return layerTest(LayerUnit, f, options...)
}

func IntegrationTest(f func(T), options ...testoplugin.Option) func(*testing.T) {
    return layerTest(LayerIntegration, f, options...)
}

var _ = Options(
    allure.WithExcluded(os.Getenv("GITLAB_CI") != "true"),
    parallel.WithScope(parallel.SuiteTests|parallel.Suites|parallel.Tests),
)

Other choices worth mentioning

• T composes *testo.T, *parallel.PluginParallel and *allure.PluginAllure, so
  tests get parallelism + Allure metadata out of the box.
• Parallelism is opt-out rather than opt-in: everything runs in parallel by default;
  use testkit.WithSync only where tests share state.
• Allure report generation is enabled only in CI
  (allure.WithExcluded(os.Getenv("GITLAB_CI") != "true")). Locally the TDD loop
  stays fast and clean: no allure-results directory is produced, so there is
  nothing to clean up between runs. The report only shows up where it's actually
  used — CI.
• Suite is imported directly from testo rather than re-exported, so testkit
  doesn't break when the upstream Suite interface grows.

Feedback very welcome — especially on the layering approach and how it compares to
what others do with suites and tags.