Go - Varianz

The Go test integration is the varianztest package in the SDK module — no separate install:

import (
    "testing"
    "time"

    vt "go.varianz.io/sdk/varianztest"
)

func TestPriceOverride(t *testing.T) {
    session := vt.NewSession(t, "http://localhost:50051")

    session.Insert(vt.Cel("pricing/calculate-price", "42"))
    session.AwaitSyncOrFail(5 * time.Second)

    // Trigger with the session header
    resp := callService(t, "/price", body,
        map[string]string{"x-varianz-id": session.SessionID()})

    assert.Equal(t, 42.0, resp["total"])
}

vt.NewSession(t, endpoint) registers cleanup with t — stages are removed and the session destroyed when the test ends. Run go test with the standard environment (VARIANZ_ENABLED=true, and VARIANZ_INSECURE_ALLOW_PLAINTEXT=true for a plaintext local coordinator).

Initialise the SDK in the test binary, and run go test -v.go test never runs main(), so when the VPoints live in the test process nothing connects them to the coordinator unless you call vz.Init() yourself — normally from TestMain:

func TestMain(m *testing.M) {
    if err := vz.Init(); err != nil {
        log.Fatal(err)
    }
    defer vz.Close()
    os.Exit(m.Run())
}

Without it every stage is inert and the only notice is a teardown warning. That warning, and every other Varianz diagnostic, goes to the test log, which go test discards for a passing package. The lines worth grepping for:

No subscribers received the N staged instruction(s) — the service process never connected.
failed to compile; it was NOT attached and will not run — the stage is inert.
executed with active stages but no session id — the session did not reach the call context.

Stage examples

vt.Cel("pricing/calculate-price", "42")                              // constant override
vt.Cel("pricing/calculate-price", "invoke() * 2")                    // transform the real result
vt.Cel("pricing/calculate-price", "args.base_price + args.quantity") // read inputs
vt.Cel("pricing/calculate-price", "ctx.applyTax(invoke(), 0.1)")     // context function
vt.Cel("pricing/calculate-price", `sample("result", invoke())`)      // probe

Field names in args follow the Go SDK’s field-naming rules — BasePrice is args.base_price unless tagged otherwise.

Session API

Method	Description
`vt.NewSession(t, endpoint)`	Create a session with auto-cleanup
`SessionID()`	32-char hex session ID
`Insert(stage)`	Insert a stage (use `vt.Cel(target, expr)`)
`AwaitSync(timeout)`	Wait for subscriber confirmation, returns the result
`AwaitSyncOrFail(timeout)`	Wait; fail the test on timeout only — validation issues are advisory and do not fail the barrier (why); see zero-subscriber semantics
`AssertSample(ident)`	Start a fluent sample assertion
`Samples()`	The raw sample hub

Sample assertions

session.AssertSample("result").
    Within(10 * time.Second).
    Exists().
    HasCount(1).
    HasValue("total", 100.0)

HasValue takes a dot path into the sampled value ("" for the value itself); Samples() on the assertion returns the collected raw samples when you need custom checks.

In-process calls

When the code under test is in the same process, put the session on the context instead of a header:

ctx := varianz.WithSession(context.Background(), session.SessionID())
got, err := CalculatePrice(ctx, req)

Getting started

Core concepts

Guides

SDK reference

Testing

Reference

Go

Stage examples

Session API

Sample assertions

In-process calls

​Stage examples

​Session API

​Sample assertions

​In-process calls

Stage examples

Session API

Sample assertions

In-process calls