Back to godoc.org

Package testing

v0.0.0-...-5dfa7fa
Latest Go to latest

The latest major version is .

Published: Nov 4, 2019 | License: Apache-2.0 | Module: github.com/a-and/pkg

Overview

Package testing includes utilities for testing controllers.

Copyright 2019 The Knative Authors.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Package testing includes utilities for testing controllers.

Index

Examples

func Eventf

func Eventf(eventType, reason, messageFmt string, args ...interface{}) string

Eventf formats as FakeRecorder does.

func InduceFailure

func InduceFailure(verb, resource string) clientgotesting.ReactionFunc

InduceFailure is used in conjunction with TableTest's WithReactors field. Tests that want to induce a failure in a row of a TableTest would add:

WithReactors: []clientgotesting.ReactionFunc{
   // Makes calls to create revisions return an error.
   InduceFailure("create", "revisions"),
},

func KeyOrDie

func KeyOrDie(obj interface{}) string

KeyOrDie returns the string key of the Kubernetes object or panics if a key cannot be generated.

func PrependGenerateNameReactor

func PrependGenerateNameReactor(f *clientgotesting.Fake)

PrependGenerateNameReactor will instrument a client-go testing Fake with a reactor that simulates 'generateName' functionality

func SetupFakeContext

func SetupFakeContext(t *testing.T) (context.Context, []controller.Informer)

SetupFakeContext sets up the the Context and the fake informers for the tests.

func SetupFakeContextWithCancel

func SetupFakeContextWithCancel(t *testing.T) (context.Context, context.CancelFunc, []controller.Informer)

SetupFakeContextWithCancel sets up the the Context and the fake informers for the tests The provided context can be canceled using provided callback.

func ValidateCreates

func ValidateCreates(ctx context.Context, action clientgotesting.Action) (handled bool, ret runtime.Object, err error)

func ValidateUpdates

func ValidateUpdates(ctx context.Context, action clientgotesting.Action) (handled bool, ret runtime.Object, err error)

type ActionRecorder

type ActionRecorder interface {
	Actions() []clientgotesting.Action
}

ActionRecorder contains list of K8s request actions.

type ActionRecorderList

type ActionRecorderList []ActionRecorder

ActionRecorderList is a list of ActionRecorder objects.

func (ActionRecorderList) ActionsByVerb

func (l ActionRecorderList) ActionsByVerb() (Actions, error)

ActionsByVerb fills in Actions objects, sorting the actions by verb.

type Actions

type Actions struct {
	Gets              []clientgotesting.GetAction
	Creates           []clientgotesting.CreateAction
	Updates           []clientgotesting.UpdateAction
	Deletes           []clientgotesting.DeleteAction
	DeleteCollections []clientgotesting.DeleteCollectionAction
	Patches           []clientgotesting.PatchAction
}

Actions stores list of Actions recorded by the reactors.

type CreateHookFunc

type CreateHookFunc func(runtime.Object) HookResult

CreateHookFunc is a function for handling a Create hook. Its runtime.Object parameter will be the Kubernetes resource created. The resource can be cast to its actual type like this:

pod := obj.(*v1.Pod)

A return value of true marks the hook as completed. Returning false allows the hook to run again when the next resource of the requested type is created.

func ExpectNormalEventDelivery

func ExpectNormalEventDelivery(t *testing.T, messageRegexp string) CreateHookFunc

ExpectNormalEventDelivery returns a hook function that can be passed to a Hooks.OnCreate() call to verify that an event of type Normal was created matching the given regular expression. For this expectation to be effective the test must also call Hooks.WaitForHooks().

func ExpectWarningEventDelivery

func ExpectWarningEventDelivery(t *testing.T, messageRegexp string) CreateHookFunc

ExpectWarningEventDelivery returns a hook function that can be passed to a Hooks.OnCreate() call to verify that an event of type Warning was created matching the given regular expression. For this expectation to be effective the test must also call Hooks.WaitForHooks().

type DeleteHookFunc

type DeleteHookFunc func(string) HookResult

DeleteHookFunc is a function for handling a delete hook. Its name parameter will be the name of the resource deleted. The resource itself is not available to the reactor.

type EventList

type EventList struct {
	Recorder *record.FakeRecorder
}

EventList exports all events during reconciliation through fake event recorder with event channel with buffer of given size.

func (EventList) Events

func (l EventList) Events() []string

Events iterates over events received from channel in fake event recorder and returns all.

type Factory

type Factory func(*testing.T, *TableRow) (controller.Reconciler, ActionRecorderList, EventList, *FakeStatsReporter)

Factory returns a Reconciler.Interface to perform reconciliation in table test, ActionRecorderList/EventList to capture k8s actions/events produced during reconciliation and FakeStatsReporter to capture stats.

type FakeClock

type FakeClock struct {
	Time time.Time
}

func (FakeClock) Now

func (c FakeClock) Now() time.Time

type FakeStatsReporter

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

FakeStatsReporter is a fake implementation of StatsReporter

func (*FakeStatsReporter) GetServiceReadyStats

func (r *FakeStatsReporter) GetServiceReadyStats() map[string]int

func (*FakeStatsReporter) ReportServiceReady

func (r *FakeStatsReporter) ReportServiceReady(namespace, service string, d time.Duration) error

type FakeTracker

type FakeTracker struct {
	sync.Mutex
	// contains filtered or unexported fields
}

FakeTracker implements Tracker.

func (*FakeTracker) OnChanged

func (*FakeTracker) OnChanged(interface{})

OnChanged implements OnChanged.

func (*FakeTracker) References

func (n *FakeTracker) References() []corev1.ObjectReference

References returns the list of objects being tracked

func (*FakeTracker) Track

func (n *FakeTracker) Track(ref corev1.ObjectReference, obj interface{}) error

Track implements Track.

type GenerateNameReactor

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

GenerateNameReactor will simulate the k8s API server and generate a name for resources who's metadata.generateName property is set. This happens only for CreateAction types

This generator is deterministic (unliked k8s) and uses a global counter to help make test names predictable

func (*GenerateNameReactor) Handles

func (r *GenerateNameReactor) Handles(action clientgotesting.Action) bool

Handles contains all the logic to generate the name and mutates the create action object

This is a hack as 'React' is passed a DeepCopy of the action hence this is the only opportunity to 'mutate' the action in the ReactionChain and have to continue executing additional reactors

We should push changes upstream to client-go to help us with mocking

func (*GenerateNameReactor) React

func (r *GenerateNameReactor) React(action clientgotesting.Action) (handled bool, ret runtime.Object, err error)

React is noop-function

type HookResult

type HookResult bool

HookResult is the return value of hook functions.

const (
	// HookComplete indicates the hook function completed, and WaitForHooks should
	// not wait for it.
	HookComplete HookResult = true
	// HookIncomplete indicates the hook function is incomplete, and WaitForHooks
	// should wait for it to complete.
	HookIncomplete HookResult = false
)

type Hooks

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

Hooks is a utility struct that simplifies controller testing with fake clients. A Hooks struct allows attaching hook functions to actions (create, update, delete) on a specified resource type within a fake client and ensuring that all hooks complete in a timely manner.

Example

Code:

h := NewHooks()
f := fake.NewSimpleClientset()

h.OnCreate(&f.Fake, "pods", func(obj runtime.Object) HookResult {
	pod := obj.(*v1.Pod)
	fmt.Printf("Pod %s has restart policy %v\n", pod.Name, pod.Spec.RestartPolicy)
	return true
})

h.OnUpdate(&f.Fake, "pods", func(obj runtime.Object) HookResult {
	pod := obj.(*v1.Pod)
	fmt.Printf("Pod %s restart policy was updated to %v\n", pod.Name, pod.Spec.RestartPolicy)
	return true
})

h.OnDelete(&f.Fake, "pods", func(name string) HookResult {
	fmt.Printf("Pod %s was deleted\n", name)
	return true
})

pod := &v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
		Name: "test-pod",
	},
	Spec: v1.PodSpec{
		RestartPolicy: v1.RestartPolicyAlways,
	},
}
f.CoreV1().Pods("test").Create(pod)

updatedPod := pod.DeepCopy()
updatedPod.Spec.RestartPolicy = v1.RestartPolicyNever
f.CoreV1().Pods("test").Update(updatedPod)

f.CoreV1().Pods("test").Delete(pod.Name, &metav1.DeleteOptions{})
if err := h.WaitForHooks(time.Second); err != nil {
	log.Fatal(err)
}
Pod test-pod has restart policy Always
Pod test-pod restart policy was updated to Never
Pod test-pod was deleted

func NewHooks

func NewHooks() *Hooks

NewHooks returns a Hooks struct that can be used to attach hooks to one or more fake clients and wait for all hooks to complete. TODO(grantr): Allow validating that a hook never fires

func (*Hooks) OnCreate

func (h *Hooks) OnCreate(fake *kubetesting.Fake, resource string, rf CreateHookFunc)

OnCreate attaches a create hook to the given Fake. The hook function is executed every time a resource of the given type is created.

func (*Hooks) OnDelete

func (h *Hooks) OnDelete(fake *kubetesting.Fake, resource string, rf DeleteHookFunc)

OnDelete attaches a delete hook to the given Fake. The hook function is executed every time a resource of the given type is deleted.

func (*Hooks) OnUpdate

func (h *Hooks) OnUpdate(fake *kubetesting.Fake, resource string, rf UpdateHookFunc)

OnUpdate attaches an update hook to the given Fake. The hook function is executed every time a resource of the given type is updated.

func (*Hooks) WaitForHooks

func (h *Hooks) WaitForHooks(timeout time.Duration) error

WaitForHooks waits until all attached hooks have returned true at least once. If the given timeout expires before that happens, an error is returned. The registered actions will no longer be executed after WaitForHooks has returned.

type NullTracker

type NullTracker = FakeTracker

NullTracker implements Tracker

Alias is preserved for backwards compatibility

type ObjectSorter

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

func NewObjectSorter

func NewObjectSorter(scheme *runtime.Scheme) ObjectSorter

func (*ObjectSorter) AddObjects

func (o *ObjectSorter) AddObjects(objs ...runtime.Object)

func (*ObjectSorter) IndexerForObjectType

func (o *ObjectSorter) IndexerForObjectType(obj runtime.Object) cache.Indexer

func (*ObjectSorter) ObjectsForScheme

func (o *ObjectSorter) ObjectsForScheme(scheme *runtime.Scheme) []runtime.Object

func (*ObjectSorter) ObjectsForSchemeFunc

func (o *ObjectSorter) ObjectsForSchemeFunc(funcs ...func(scheme *runtime.Scheme) error) []runtime.Object

type TableRow

type TableRow struct {
	// Name is a descriptive name for this test suitable as a first argument to t.Run()
	Name string

	// Ctx is the context to pass to Reconcile. Defaults to context.Background()
	Ctx context.Context

	// Objects holds the state of the world at the onset of reconciliation.
	Objects []runtime.Object

	// Key is the parameter to reconciliation.
	// This has the form "namespace/name".
	Key string

	// WantErr holds whether we should expect the reconciliation to result in an error.
	WantErr bool

	// WantCreates holds the ordered list of Create calls we expect during reconciliation.
	WantCreates []runtime.Object

	// WantUpdates holds the ordered list of Update calls we expect during reconciliation.
	WantUpdates []clientgotesting.UpdateActionImpl

	// WantStatusUpdates holds the ordered list of Update calls, with `status` subresource set,
	// that we expect during reconciliation.
	WantStatusUpdates []clientgotesting.UpdateActionImpl

	// WantDeletes holds the ordered list of Delete calls we expect during reconciliation.
	WantDeletes []clientgotesting.DeleteActionImpl

	// WantDeleteCollections holds the ordered list of DeleteCollection calls we expect during reconciliation.
	WantDeleteCollections []clientgotesting.DeleteCollectionActionImpl

	// WantPatches holds the ordered list of Patch calls we expect during reconciliation.
	WantPatches []clientgotesting.PatchActionImpl

	// WantEvents holds the ordered list of events we expect during reconciliation.
	WantEvents []string

	// WantServiceReadyStats holds the ServiceReady stats we expect during reconciliation.
	WantServiceReadyStats map[string]int

	// WithReactors is a set of functions that are installed as Reactors for the execution
	// of this row of the table-driven-test.
	WithReactors []clientgotesting.ReactionFunc

	// For cluster-scoped resources like ClusterIngress, it does not have to be
	// in the same namespace with its child resources.
	SkipNamespaceValidation bool

	// PostConditions allows custom assertions to be made after reconciliation
	PostConditions []func(*testing.T, *TableRow)
}

TableRow holds a single row of our table test.

func (*TableRow) Test

func (r *TableRow) Test(t *testing.T, factory Factory)

Test executes the single table test.

type TableTest

type TableTest []TableRow

TableTest represents a list of TableRow tests instances.

func (TableTest) Test

func (tt TableTest) Test(t *testing.T, factory Factory)

Test executes the whole suite of the table tests.

type UpdateHookFunc

type UpdateHookFunc func(runtime.Object) HookResult

UpdateHookFunc is a function for handling an update hook. its runtime.Object parameter will be the Kubernetes resource updated. The resource can be cast to its actual type like this:

pod := obj.(*v1.Pod)

A return value of true marks the hook as completed. Returning false allows the hook to run again when the next resource of the requested type is updated.

Package Files

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier