flowtest

package module
v0.0.0-...-42663ac Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 10, 2024 License: MIT Imports: 16 Imported by: 1

README

Flow Test

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Asserter

type Asserter interface {
	TB
	Assertion
}

type Assertion

type Assertion interface {
	// Sub creates a named sub-assertion
	Sub(name string, args ...interface{}) Assertion

	// T accepts the assertion types like Equal which use generics and therefore
	// can't be a method of Assertion directly.
	T(outcome *be.Outcome)

	// NoError asserts be the error is nil, and fails the test if not
	NoError(err error)

	// MustMessage is used to assert topic requests work
	MustMessage(*emptypb.Empty, error)

	// Equal asserts be want == got. If extraLog is set, and the first
	// argument is a string it is used as a format string for the rest of the
	// arguments. If the first argument is not a string, everything is just
	// logged
	Equal(want, got interface{})

	// CodeError asserts be the error returned was non-nil and a Status error
	// with the given code
	CodeError(err error, code codes.Code)

	// NotEmpty asserts be the given values are not nil or zero values (zero
	// as in reflect.Value.IsZero)
	NotEmpty(got ...interface{})

	// NotNil asserts be the given values are not nil, assessing in order and
	// stopping at the first nil value (i.e. you can pass thing, thing.field,
	// thing.field.subfield)
	NotNil(gots ...interface{})

	// Nil asserts be the given values are nil
	Nil(gots ...interface{})

	// Fatal fails the test with the given message
	Fatal(args ...interface{})

	// Fatalf fails the test with the given format string
	Fatalf(format string, args ...interface{})
}

type GRPCPair

type GRPCPair struct {
	Server *grpc.Server
	Client *grpc.ClientConn
	// contains filtered or unexported fields
}

func NewGRPCPair

func NewGRPCPair(t TB, middleware ...grpc.UnaryServerInterceptor) *GRPCPair

func (*GRPCPair) ServeUntilDone

func (gg *GRPCPair) ServeUntilDone(t TB, ctx context.Context)

type LogLevel

type LogLevel string
const (
	LogLevelFatal   LogLevel = "FATAL"
	LogLevelError   LogLevel = "ERROR"
	LogLevelDefault LogLevel = ""
)

type Logger

type Logger interface {
	Log(args ...any)
}

type RequiresTB

type RequiresTB interface {
	Helper()
	Log(args ...interface{})
	FailNow()
	Fail()
}

type RunnableTB

type RunnableTB[T RequiresTB] interface {
	RequiresTB
	Run(name string, f func(T)) bool
}

RunnableTB is the subset of the testing.TB interface which this library requires. Keeping it to a minimum to allow alternate implementations

type StepSetter

type StepSetter interface {
	// Setup steps run at the start of each RunSteps call, or the start of each
	// Variation. The context passed to the setup will be canceled after all steps
	// are completed, or after any fatal error.
	Setup(fn callbackErr)

	// PreStepHook runs before every step, after any variations.
	PreStepHook(fn callbackErr)

	// PreVariationHook runs before every Variation, before any steps.
	PreVariationHook(fn callbackErr)

	// PostStepHook runs after every step.
	PostStepHook(fn callbackErr)

	// Step registers a function to make assertions on the running code, this is the
	// main assertion set.
	Step(desc string, fn callback)

	// Adds a variation to the stepper. Each Variation causes the Setup hooks,
	// followed by the Variation, then every registered Step (and hooks), allowing
	// one call to RunSteps to run multiple variations of the same test.
	Variation(desc string, fn callback)

	// LevelLog implements a global logger compatible with pentops/log.go/log.
	// Log lines will be captured into the currently running test step.
	LevelLog(level, message string, fields map[string]interface{})

	// Log logs any object, it can be used within test callbacks.
	// Log lines will be captured into the currently running test step.
	Log(...interface{})
}

StepSetter is a minimal interface to configure the steps and hooks for a test.

type Stepper

type Stepper[T RequiresTB] struct {
	// contains filtered or unexported fields
}

func NewStepper

func NewStepper[T RequiresTB](name string) *Stepper[T]

func (*Stepper[T]) LevelLog

func (ss *Stepper[T]) LevelLog(level, message string, fields map[string]interface{})

LevelLog implements a global logger compatible with pentops/log.go/log DefaultLogger, and others, to capture log lines from within the handlers into the test output

func (*Stepper[T]) Log

func (ss *Stepper[T]) Log(args ...interface{})

func (*Stepper[T]) LogQuery

func (ss *Stepper[T]) LogQuery(ctx context.Context, statement string, params ...interface{})

func (*Stepper[T]) PostStepHook

func (ss *Stepper[T]) PostStepHook(fn callbackErr)

PostStepHook runs after every step.

func (*Stepper[T]) PreStepHook

func (ss *Stepper[T]) PreStepHook(fn callbackErr)

PreStepHook runs before every step, after any variations.

func (*Stepper[T]) PreVariationHook

func (ss *Stepper[T]) PreVariationHook(fn callbackErr)

PreVariationHook runs before every Variation, before any steps.

func (*Stepper[T]) RunSteps

func (ss *Stepper[T]) RunSteps(t RunnableTB[T])

RunSteps is the main entry point of the stepper. For each Variation, or just once if no variation is registered, the Setup hooks are run, followed by the Variation, then every registered Step with pre and post hooks.

func (*Stepper[T]) RunStepsWithContext

func (ss *Stepper[T]) RunStepsWithContext(ctx context.Context, t RunnableTB[T])

RunStepsWithContext allows the caller to provide a context to the stepper.

func (*Stepper[T]) Setup

func (ss *Stepper[T]) Setup(fn callbackErr)

Setup steps run at the start of each RunSteps call, or the start of each Variation. The context passed to the setup will be canceled after all steps are completed, or after any fatal error.

func (*Stepper[T]) ShiftingLogger

func (ss *Stepper[T]) ShiftingLogger() Logger

FollowAsserter returns an asserter which always points to the current test. It is valid only as long as the stepper is valid.

func (*Stepper[_]) Step

func (ss *Stepper[_]) Step(desc string, fn callback)

Step registers a function to make assertions on the running code, this is the main assertion set.

func (*Stepper[_]) Variation

func (ss *Stepper[_]) Variation(desc string, fn callback)

Adds a variation to the stepper. Each Variation causes the Setup hooks, followed by the Variation, then every registered Step (and hooks), allowing one call to RunSteps to run multiple variations of the same test.

type TB

type TB interface {
	//Cleanup(func())
	Error(args ...any)
	Errorf(format string, args ...any)
	//Fail()
	FailNow()
	Failed() bool
	Fatal(args ...any)
	Fatalf(format string, args ...any)
	Helper()
	Log(args ...any)
	Logf(format string, args ...any)
}

TB is the subset of the testing.TB interface which the stepper's asserter implements.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL