faultbackend

type Backend ¶

type Backend struct {
	backend.Backend
	// contains filtered or unexported fields
}

Backend is a backend.Backend that applies [Rule]s to the operations passing through it, and records them. The zero value is not usable; call Wrap.

It deliberately forwards none of the optional backend capabilities (backend.Viewer, backend.Sizer, ReaderAt, ObjectCreator): every one of them has a mandatory fallback, so a wrapped backend exercises the same code as an unwrapped one, only slower.

func Wrap(b backend.Backend) *Backend

func (b *Backend) Add(r Rule) *Backend

func (b *Backend) CompareAndSwap(
	ctx context.Context, key string, expected backend.Version, data []byte,
) (backend.Version, bool, error)

func (b *Backend) Count(match func(Op) bool) int

func (b *Backend) Delete(ctx context.Context, key string) error

func (b *Backend) List(ctx context.Context, prefix string) ([]string, error)

func (b *Backend) Ops() []Op

func (b *Backend) PutIfAbsent(ctx context.Context, key string, data []byte) (bool, error)

func (b *Backend) Read(ctx context.Context, key string) ([]byte, error)

func (b *Backend) ReadVersioned(ctx context.Context, key string) ([]byte, backend.Version, error)

func (b *Backend) Reset()

func (b *Backend) Write(ctx context.Context, key string, data []byte) error

type Gate ¶

type Gate struct {
	// contains filtered or unexported fields
}

Gate suspends the backend operations matching it until the test releases them, so a test can state an interleaving instead of racing for it: arrange for the operation to arrive, drive the other goroutine to the point of interest, then release.

A gated operation blocks the goroutine that issued it inside the backend, so the code under test needs no hooks of its own.

func NewGate() *Gate

func (g *Gate) Await(tb testing.TB) Op

func (g *Gate) Release()

func (g *Gate) Rule(kind Kind, match func(Op) bool) Rule

type Kind ¶

type Kind int

Kind is the backend operation a Rule matches.

const (
	Read Kind = iota
	Write
	PutIfAbsent
	CompareAndSwap
	ReadVersioned
	List
	Delete
)

func (k Kind) String() string

type Op ¶

type Op struct {
	Kind Kind
	Key  string
}

Op is a single backend operation offered to a Rule.

type Rule ¶

type Rule struct {
	Kind  Kind
	Match func(Op) bool
	// Err, when non-nil, is returned instead of performing the operation.
	Err error
	// Before, when non-nil, runs before the operation. It may block, which is what suspends the
	// calling goroutine inside the backend (see [Gate]).
	Before func(Op)
	// Replace, when non-nil, rewrites the bytes a read returns. It models the failure a returned
	// error cannot: a store that hands back data which is not what was written, and says nothing.
	// It applies to [Read] alone; the wrapper implements no [backend.Viewer], so every read of an
	// object's bytes — including one made through [backend.ReadView] — passes through it.
	Replace func(Op, []byte) []byte
	// Times limits how many operations the rule applies to. Zero ⇒ unlimited.
	Times int
	// contains filtered or unexported fields
}

Rule decides what happens to the operations it matches. A rule with no Match matches every operation of its Kind.