testing

type Action struct {
	ktesting.Action

	// If true, will not check the given object for equality.
	IgnoreObject bool
}

type ActionGenerator func() (Action, error)

type ActionTest struct {
	// Types contains the list of verbs that should be checked.
	// Defaults to write-only verbs.
	Verbs []string

	// Actions contains a list of actions that should exist in the result.
	// It is expected that they will be in the correct order.
	Actions []Action

	// ActionGenerators is like Actions except that generating an Action may fail
	// with an error. If specified, will take precedence over Actions.
	ActionGenerators []ActionGenerator
}

type CombinedActions struct {
	// List of actions that are expected on the kubernetes clientset.
	Kubernetes ActionTest

	// List of actions that are expected on the furiko clientset.
	Furiko ActionTest

	// If true, all actions will be ignored.
	Ignore bool
}

type CombinedReactors struct {
	// List of reactors for the kubernetes clientset.
	Kubernetes []*ktesting.SimpleReactor

	// List of reactors for the furiko clientset.
	Furiko []*ktesting.SimpleReactor
}

type CommandTest struct {
	// Name of the test case.
	Name string

	// Arguments to be passed to the command.
	Args []string

	// Fixtures to be created prior to calling the command.
	Fixtures []runtime.Object

	// Sets the current time.
	Now time.Time

	// Input rules for standard input.
	Stdin Input

	// Output rules for standard output.
	Stdout Output

	// Output rules for standard error.
	Stderr Output

	// Procedure for running custom assertions.
	Procedure func(t *testing.T, rc RunContext)

	// Whether an error is expected, and if so, specifies a function to check if the
	// error is equal.
	WantError assert.ErrorAssertionFunc

	// List of actions that we expect to see.
	WantActions CombinedActions
}

type CompleterTest struct {
	// Name of the test case.
	Name string

	// Completer under test.
	Completer completion.Completer

	// Fixtures to be created prior to calling the command.
	Fixtures []runtime.Object

	// Sets the current time.
	Now time.Time

	// Namespace to pass to the Completer.
	Namespace string

	// Expected completions, order is important.
	Want []string

	// Whether an error is expected, and if so, specifies a function to check if the
	// error is equal.
	WantError assert.ErrorAssertionFunc
}

type ControllerContext interface {
	controllercontext.Context
	GetHasSynced() []cache.InformerSynced
}

type Event struct {
	UID     types.UID
	Type    string
	Reason  string
	Message string
}

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

type Input struct {
	// If specified, the procedure will be called with a pseudo-TTY. The console
	// argument can be used to expect and send values to the TTY.
	Procedure func(console *console.Console)
}

type NameGetter interface {
	GetName() string
}

type ObjectGetter interface {
	GetObject() runtime.Object
}

type Output struct {
	// If specified, expects the output to match exactly.
	Exact string

	// If specified, expects the output to contain the given string.
	Contains string

	// If specified, expects the output to contain all the given strings.
	ContainsAll []string

	// If specified, expects the output to match the specified regexp.
	Matches *regexp.Regexp

	// If specified, expects the output to match all the given regular expressions.
	MatchesAll []*regexp.Regexp

	// If specified, expects that the output to NOT contain the given string.
	Excludes string

	// If specified, expects that the output to NOT contain any of the given strings.
	ExcludesAll []string

	// If non-nil, expects that the number of lines printed matches.
	NumLines *int
}

type PatchGetter interface {
	GetPatch() []byte
}

type ReconcilerTest struct {
	// Returns a new controller context.
	ContextFunc func(c controllercontext.Context, recorder record.EventRecorder) ControllerContext

	// Returns the reconciler to test and informer synced methods to wait for.
	ReconcilerFunc func(c ControllerContext) reconciler.Reconciler

	// Sets the current time.
	Now time.Time

	// Specifies the timeout for each test case. Defaults to 1 second.
	Timeout time.Duration

	// Stores to create.
	Stores []mock.StoreFactory
}

type ReconcilerTestCase struct {
	// Name of the test case.
	Name string

	// Target to be synced. It will be created before syncing.
	Target runtime.Object

	// Generator function that returns the Target. This generator will be called
	// lazily, evaluated only after all initialization is done. For example, if the
	// target depends on the clock to have already been mocked, use TargetGenerator
	// instead of Target.
	TargetGenerator func() runtime.Object

	// SyncTarget explicitly specifies the namespace and name to sync.
	// If left empty, will derive from Target.
	SyncTarget *SyncTarget

	// Other fixtures to be created prior to the sync.
	Fixtures []runtime.Object

	// Generator functions that returns Fixtures. The generators will be called
	// lazily, evaluated only after all initialization is done. For example, if the
	// target depends on the clock to have already been mocked, use FixtureGenerators
	// instead of Fixtures.
	FixtureGenerators []func() runtime.Object

	// Optionally specifies the current time to mock to override from the parent
	// ReconcilerTest.
	Now time.Time

	// Optionally specifies configs to set.
	Configs controllercontext.ConfigsMap

	// Optional list of Reactors, which intercepts clientset actions.
	Reactors CombinedReactors

	// Defines additional assertion functions.
	Assert func(t assert.TestingT, tt ReconcilerTestCase, ctrlContext ControllerContext)

	// List of actions that we expect to see.
	WantActions CombinedActions

	// List of events that we expect to see.
	WantEvents []Event

	// Whether an error is expected, and if so, specifies a function to check if the
	// error is equal.
	WantError assert.ErrorAssertionFunc
}

type RunContext struct {
	// Console to interact with the TTY.
	Console *console.Console

	// CtrlContext to interact with clientsets.
	CtrlContext *mock.Context

	// Context for the command. It will be canceled on interrupt.
	Context context.Context

	// Cancel the Context. Exposed to allow tests to interrupt the command midway.
	Cancel context.CancelFunc
}

type SyncTarget struct {
	Namespace string
	Name      string
}