wefttest

func Args ¶

func Args(v any) string

Args marshals v as the JSON arguments of a scripted Call:

wefttest.Call{Name: "lookup", Args: wefttest.Args(lookupIn{Order: 42})}

A value that cannot be marshalled is a test-construction bug and panics at the call site naming the type.

package main

import (
	"context"
	"fmt"

	"github.com/weftgo/weft/core"
	"github.com/weftgo/weft/core/wefttest"
)

type lookupIn struct {
	OrderID int `json:"order_id"`
}

func main() {
	model := wefttest.Script(
		wefttest.ToolCalls(
			wefttest.Call{Name: "lookup_order", Args: wefttest.Args(lookupIn{OrderID: 42})},
		),
	)
	for ev, err := range model.Stream(context.Background(), core.ModelRequest{}) {
		if err != nil {
			fmt.Println("stream error:", err)
			return
		}
		if call, ok := ev.(core.ModelToolCall); ok {
			fmt.Printf("%s %s\n", call.Name, call.Args)
		}
	}
}

Output:
lookup_order {"order_id":42}

func ConformInfo ¶

func ConformInfo(m core.ModelMiddleware) error

ConformInfo reports nil when middleware m forwards the inner model's identity unchanged — the convention ModelMiddleware documents ("implementations should forward Info") — and an error naming the offender otherwise. Use it in a middleware's own test suite to turn the documented convention into a checked fact.

func ConformInfoT ¶

func ConformInfoT(t testing.TB, m core.ModelMiddleware)

ConformInfoT is ConformInfo as a test helper: it fails t instead of returning an error.

func Flatten ¶

func Flatten(evs []core.Event) []core.Event

Flatten returns evs with every Nested event replaced by its inner event, recursively — the child's events as the child emitted them — for asserting a nested run's behaviour without unwrapping by hand.

evs := collect(parentStream)
want := []core.Event{core.RunStart{}, core.StepStart{}, ...}
slices.Equal(want, Flatten(evs))

func Golden ¶

func Golden(t testing.TB, path string, got []byte)

Golden compares got against the committed golden file at path. With -update it writes got (creating parent directories) and logs which files it created or changed, so a regeneration run says what was stale rather than rewriting everything silently; an up-to-date file is left untouched. Otherwise a mismatch fails the test with a line diff, and a missing file fails with a hint to regenerate. Note the flag goes after the package list (`go test ./... -update`): placed before it, the go tool routes it to the wrong package's binary.

func TestManifest(t *testing.T) {
	b, err := core.Manifest(newAgent())
	if err != nil { t.Fatal(err) }
	wefttest.Golden(t, "weft.json", b)
}

func Record ¶

func Record(t testing.TB, dir string, inner core.Model) core.Model

Record returns a Model that plays inner and records every request and the stream inner produced for it under dir/<t.Name()>/, one JSON file per request in conversation order, for Replay to answer later. It is the deliberate, local, key-holding half of record/replay: call it from a test only when re-recording, never in CI. The test's directory is replaced, not merged.

The recording switch belongs to the suite that holds the provider key, not to wefttest — Golden's -update rewrites a comparison, while Record spends money. The recommended shape (WEFT_RECORD is the suggested name, so suites converge on one spelling):

func model(t *testing.T) core.Model {
    if os.Getenv("WEFT_RECORD") != "" { // the suite's own switch; wefttest never reads it
        return wefttest.Record(t, "testdata/replay", openai.New(os.Getenv("OPENAI_API_KEY"), "gpt-5"))
    }
    return wefttest.Replay(t, "testdata/replay")
}

Record never checks WEFT_MODEL_REQUESTS: inner does, so a recording made under deny stores the denial's error text and the diff shows it.

func Replay ¶

func Replay(t testing.TB, dir string) core.Model

Replay returns a Model that answers each request from the fixture Record wrote for it under dir/<t.Name()>/, matched by the request's key (messages, tool names, thinking level and the sequential flag — not the system prompt). It makes no request, holds no key, and ignores WEFT_MODEL_REQUESTS like every wefttest model. A request with no fixture fails the stream with ErrNoFixture naming what was wanted; repeated identical requests replay in recorded order.

The fixtures are pretty-printed JSON a reviewer reads in a diff — the request's messages (a changed prompt shows as a changed fixture) and the model's events — so re-recording is the review, exactly as ADR 0013 says for wire fixtures.

package main

import ()

func main() {
	// The suite's model(t), one line at the call site:
	//
	//	func model(t *testing.T) core.Model {
	//	    if os.Getenv("WEFT_RECORD") != "" { // the suite's own switch
	//	        return wefttest.Record(t, "testdata/replay", myAdapter)
	//	    }
	//	    return wefttest.Replay(t, "testdata/replay")
	//	}
	//
	//	agt := core.New(model(t), tools...)
	//	res, err := agt.Generate(context.Background(), core.Prompt("Refund order 1234."))
	//	fmt.Println(res.Text(), err)
	//
	// A request the recording does not answer fails loudly with
	// wefttest.ErrNoFixture naming the directory and the first user
	// text — re-record with WEFT_RECORD once, commit the fixtures, and
	// every later run replays without a key or a network.
}

Output: