testcommon

package
v2.0.0-alpha.5 Latest Latest
Warning

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

 Go to latest Published: Dec 20, 2021 License: MIT Imports: 61 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ResourceNamerModeRandomBasedOnTestName = ResourceNamerMode("basedOnTestName")
	ResourceNamerModeRandom                = ResourceNamerMode("random")
)
View Source 
const LiveResourcePrefix = "asolivetest"

LiveResourcePrefix is the prefix reserved for resources used in tests that cannot be recorded. These resources must support parallel runs (can be triggered by multiple parallel PRs), so deleting existing resources any time a new run starts is not allowed. Instead, deletion should be time-based - delete any leaked resources older than X hours. These are generally run against either a real cluster or a kind cluster.

View Source 
const ResourcePrefix = "asotest"

ResourcePrefix is for resources which are used in the record/replay test infrastructure using envtest. These tests are not expected to be run live in parallel. In parallel runs should be done from the recordings. As such, for cleanup, we can delete any resources with this prefix without fear of disrupting an existing test pass. Again, this is ok because there's a single Github Action that runs with MaxParallelism == 1.

Variables

View Source 
var COUNT_HEADER string = "TEST-REQUEST-ATTEMPT"
View Source 
var DefaultTestRegion = "westus2" // Could make this an env variable if we wanted

Use WestUS2 as some things (such as VM quota) are hard to get in West US.

View Source 
var LogLevel = 5

TODO: I'm not sure the best way to configure this so for now I'm just going to set it to 5

View Source 
var OperationTimeoutRecording = 15 * time.Minute

OperationTimeoutRecording is the default timeout for a single operation when recording. This is so high primarily because deleting an AKS cluster takes a long time.

View Source 
var OperationTimeoutReplaying = 2 * time.Minute

OperationTimeoutReplaying is the default timeout for a single operation when replaying.

View Source 
var PollingIntervalRecording = 5 * time.Second

PollingIntervalRecording is the polling interval to use when recording.

View Source 
var PollingIntervalReplaying = 100 * time.Millisecond

PollingIntervalReplaying is the polling interval to use when replaying. TODO: Setting this really low sometimes seems to cause TODO: updating resource: Operation cannot be fulfilled: the object has been modified; please apply your changes to the latest version and try again. TODO: This happens when the test sees a Status update and makes an update to the resource while racing with the Spec update TODO: in azure_deployment_reconciler CommitUpdate. If we fix https://github.com/Azure/azure-service-operator/issues/1744 we can TODO: shorten this interval.

Functions

func AsOwner 

func AsOwner(obj client.Object) genruntime.KnownResourceReference

func CreateClient 

func CreateClient(scheme *runtime.Scheme) client.Client

func CreateDummyResource 

func CreateDummyResource() *v1alpha1api20210101.BatchAccount

func CreateResolver 

func CreateResolver(scheme *runtime.Scheme, testClient client.Client) (*genruntime.Resolver, error)

func CreateResourceGroup 

func CreateResourceGroup() *resources.ResourceGroup

func CreateScheme 

func CreateScheme() (*runtime.Scheme, error)

func CreateTestResourceGroupDefaultTags 

func CreateTestResourceGroupDefaultTags() map[string]string

func NewTestClient 

func NewTestClient(config *rest.Config, options client.Options) (client.Client, error)

NewTestClient is a thin wrapper around controller-runtime client.New, except that we repopulate the objects GVK since for some reason they do that in the cached client and not in the direct one...

func NewTestLogger 

func NewTestLogger(t *testing.T) logr.Logger

func SetupTeardownTestMain 

func SetupTeardownTestMain(
	m *testing.M,
	setup func() error,
	teardown func() error) int

func WaitFor 

func WaitFor(ctx context.Context, timeout time.Duration, check func(context.Context) (bool, error)) error

TODO: it's unfortunate we can't just use g.Eventually all the time

Types

type ARMMatcher 

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

func NewARMMatcher 

func NewARMMatcher(client *genericarmclient.GenericClient) *ARMMatcher

func (*ARMMatcher) BeDeleted 

func (m *ARMMatcher) BeDeleted(ctx context.Context) types.GomegaMatcher

func (*ARMMatcher) BeProvisioned 

func (m *ARMMatcher) BeProvisioned(ctx context.Context) types.GomegaMatcher

type AzureBeDeletedMatcher 

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

func (*AzureBeDeletedMatcher) FailureMessage 

func (m *AzureBeDeletedMatcher) FailureMessage(actual interface{}) string

func (*AzureBeDeletedMatcher) Match 

func (m *AzureBeDeletedMatcher) Match(actual interface{}) (bool, error)

func (*AzureBeDeletedMatcher) MatchMayChangeInTheFuture 

func (m *AzureBeDeletedMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

MatchMayChangeInTheFuture implements OracleMatcher which of course isn't exported so we can't type-assert we implement it

func (*AzureBeDeletedMatcher) NegatedFailureMessage 

func (m *AzureBeDeletedMatcher) NegatedFailureMessage(actual interface{}) string

type AzureBeProvisionedMatcher 

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

func (*AzureBeProvisionedMatcher) FailureMessage 

func (m *AzureBeProvisionedMatcher) FailureMessage(actual interface{}) string

func (*AzureBeProvisionedMatcher) Match 

func (m *AzureBeProvisionedMatcher) Match(actual interface{}) (bool, error)

func (*AzureBeProvisionedMatcher) MatchMayChangeInTheFuture 

func (m *AzureBeProvisionedMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

MatchMayChangeInTheFuture implements OracleMatcher which of course isn't exported so we can't type-assert we implement it

func (*AzureBeProvisionedMatcher) NegatedFailureMessage 

func (m *AzureBeProvisionedMatcher) NegatedFailureMessage(actual interface{}) string

type BaseTestContextFactory 

type BaseTestContextFactory func(PerTestContext, config.Values) (*KubeBaseTestContext, error)

type BeDeletedMatcher 

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

func (*BeDeletedMatcher) FailureMessage 

func (m *BeDeletedMatcher) FailureMessage(actual interface{}) string

func (*BeDeletedMatcher) Match 

func (m *BeDeletedMatcher) Match(actual interface{}) (bool, error)

func (*BeDeletedMatcher) MatchMayChangeInTheFuture 

func (m *BeDeletedMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

MatchMayChangeInTheFuture implements OracleMatcher which of course isn't exported so we can't type-assert we implement it

func (*BeDeletedMatcher) NegatedFailureMessage 

func (m *BeDeletedMatcher) NegatedFailureMessage(actual interface{}) string

type DesiredStateMatcher 

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

func (*DesiredStateMatcher) FailureMessage 

func (m *DesiredStateMatcher) FailureMessage(actual interface{}) string

func (*DesiredStateMatcher) Match 

func (m *DesiredStateMatcher) Match(actual interface{}) (bool, error)

func (*DesiredStateMatcher) MatchMayChangeInTheFuture 

func (m *DesiredStateMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

MatchMayChangeInTheFuture implements OracleMatcher which of course isn't exported so we can't type-assert we implement it

func (*DesiredStateMatcher) NegatedFailureMessage 

func (m *DesiredStateMatcher) NegatedFailureMessage(actual interface{}) string

type KubeBaseTestContext 

type KubeBaseTestContext struct {
	PerTestContext

	KubeConfig *rest.Config
}

type KubeGlobalContext 

type KubeGlobalContext struct {
	TestContext
	// contains filtered or unexported fields
}

func NewKubeContext 

func NewKubeContext(
	useEnvTest bool,
	recordReplay bool,
	region string,
	nameConfig *ResourceNameConfig) (KubeGlobalContext, error)

func (KubeGlobalContext) Cleanup 

func (ctx KubeGlobalContext) Cleanup() error

func (KubeGlobalContext) ForTest 

func (ctx KubeGlobalContext) ForTest(t *testing.T) *KubePerTestContext

func (KubeGlobalContext) ForTestWithConfig 

func (ctx KubeGlobalContext) ForTestWithConfig(t *testing.T, cfg config.Values) *KubePerTestContext

type KubeMatcher 

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

TODO: Would we rather these just be on testcontext? Might read better

func NewKubeMatcher 

func NewKubeMatcher(verify *Verify, ctx context.Context) *KubeMatcher

func (*KubeMatcher) BeDeleted 

func (m *KubeMatcher) BeDeleted() types.GomegaMatcher

func (*KubeMatcher) BeFailed 

func (m *KubeMatcher) BeFailed() types.GomegaMatcher

func (*KubeMatcher) BeProvisioned 

func (m *KubeMatcher) BeProvisioned() types.GomegaMatcher

func (*KubeMatcher) BeProvisionedAfter 

func (m *KubeMatcher) BeProvisionedAfter(previousReadyCondition conditions.Condition) types.GomegaMatcher

type KubePerTestContext 

type KubePerTestContext struct {
	*KubeGlobalContext
	KubeBaseTestContext

	Ctx context.Context

	G      gomega.Gomega
	Verify *Verify
	Match  *KubeMatcher
	// contains filtered or unexported fields
}

func (*KubePerTestContext) AsExtensionOwner 

func (tc *KubePerTestContext) AsExtensionOwner(obj client.Object) genruntime.ArbitraryOwnerReference

func (*KubePerTestContext) CreateResource 

func (tc *KubePerTestContext) CreateResource(obj client.Object)

CreateResource creates a resource and registers it for cleanup. It does not wait for the resource to be created, use CreateResourceAndWait for that

func (*KubePerTestContext) CreateResourceAndWait 

func (tc *KubePerTestContext) CreateResourceAndWait(obj client.Object)

CreateResourceAndWait creates the resource in K8s and waits for it to change into the Provisioned state.

func (*KubePerTestContext) CreateResourceAndWaitForFailure 

func (tc *KubePerTestContext) CreateResourceAndWaitForFailure(obj client.Object)

CreateResourceAndWaitForFailure creates the resource in K8s and waits for it to change into the Failed state.

func (*KubePerTestContext) CreateResourceGroup 

func (tc *KubePerTestContext) CreateResourceGroup(rg *resources.ResourceGroup) (*resources.ResourceGroup, error)

CreateResourceGroup creates a new resource group and registers it to be deleted up when the test context is cleaned up.

func (*KubePerTestContext) CreateResourceGroupAndWait 

func (tc *KubePerTestContext) CreateResourceGroupAndWait(rg *resources.ResourceGroup) *resources.ResourceGroup

CreateResourceGroupAndWait creates the specified resource group, registers it to be deleted when the context is cleaned up, and waits for it to finish being created.

func (*KubePerTestContext) CreateResourceUntracked 

func (tc *KubePerTestContext) CreateResourceUntracked(obj client.Object)

CreateResourceUntracked creates a resource. This does not register the resource for cleanup. This should only be used with resources like Namespaces that cannot be deleted in envtest. See the documentation on registerCleanup for more details.

func (*KubePerTestContext) CreateResourcesAndWait 

func (tc *KubePerTestContext) CreateResourcesAndWait(objs ...client.Object)

CreateResourcesAndWait creates the resources in K8s and waits for them to change into the Provisioned state.

func (*KubePerTestContext) CreateTestResourceGroupAndWait 

func (tc *KubePerTestContext) CreateTestResourceGroupAndWait() *resources.ResourceGroup

func (*KubePerTestContext) DefaultOperationTimeout 

func (tc *KubePerTestContext) DefaultOperationTimeout() time.Duration

func (*KubePerTestContext) DeleteResourceAndWait 

func (tc *KubePerTestContext) DeleteResourceAndWait(obj client.Object)

DeleteResourceAndWait deletes the given resource in K8s and waits for it to update to the Deleted state.

func (*KubePerTestContext) DeleteResourcesAndWait 

func (tc *KubePerTestContext) DeleteResourcesAndWait(objs ...client.Object)

DeleteResourcesAndWait deletes the resources in K8s and waits for them to be deleted

func (*KubePerTestContext) Eventually 

func (tc *KubePerTestContext) Eventually(actual interface{}, intervals ...interface{}) gomega.AsyncAssertion

func (*KubePerTestContext) Expect 

func (tc *KubePerTestContext) Expect(actual interface{}) gomega.Assertion

func (*KubePerTestContext) GetResource 

func (tc *KubePerTestContext) GetResource(key types.NamespacedName, obj client.Object)

GetResource retrieves the current state of the resource from K8s (not from Azure).

func (*KubePerTestContext) ListResources 

func (tc *KubePerTestContext) ListResources(list client.ObjectList, opts ...client.ListOption)

ListResources retrieves list of objects for a given namespace and list options. On a successful call, Items field in the list will be populated with the result returned from the server.

func (KubePerTestContext) MakeObjectMeta 

func (tc KubePerTestContext) MakeObjectMeta(prefix string) ctrl.ObjectMeta

func (KubePerTestContext) MakeObjectMetaWithName 

func (tc KubePerTestContext) MakeObjectMetaWithName(name string) ctrl.ObjectMeta

func (KubePerTestContext) MakeReferenceFromResource 

func (tc KubePerTestContext) MakeReferenceFromResource(resource client.Object) genruntime.ResourceReference

func (KubePerTestContext) MakeReferencePtrFromResource 

func (tc KubePerTestContext) MakeReferencePtrFromResource(resource client.Object) *genruntime.ResourceReference

func (KubePerTestContext) NewTestResourceGroup 

func (tc KubePerTestContext) NewTestResourceGroup() *resources.ResourceGroup

func (*KubePerTestContext) OperationTimeout 

func (tc *KubePerTestContext) OperationTimeout() time.Duration

OperationTimeout returns a “nice” operation timeout. It will return DefaultOperationTimeout() unless we are close to test termination (deadline timeout), in which case we will return that. This improves the behaviour in the case where we are about to hit the deadline.

(If you hit the deadline 'go test' aborts everything and dumps the current task stacks to output. If gomega.Eventually hits its timeout it will produce a nicer error message and stack trace.)

func (*KubePerTestContext) Patch 

func (tc *KubePerTestContext) Patch(old client.Object, new client.Object)

func (*KubePerTestContext) PatchResourceAndWaitAfter 

func (tc *KubePerTestContext) PatchResourceAndWaitAfter(old client.Object, new client.Object, previousReadyCondition conditions.Condition)

PatchResourceAndWaitAfter patches the resource in K8s and waits for it to change into the Provisioned state from the provided previousState.

func (*KubePerTestContext) PollingInterval 

func (tc *KubePerTestContext) PollingInterval() time.Duration

PollingInterval returns the polling interval to use for Gomega Eventually

func (*KubePerTestContext) RunParallelSubtests 

func (tc *KubePerTestContext) RunParallelSubtests(tests ...Subtest)

RunParallelSubtests runs the given tests in parallel. They are given their own KubePerTestContext.

func (*KubePerTestContext) Subtest 

func (tc *KubePerTestContext) Subtest(t *testing.T) *KubePerTestContext

Subtest replaces any testing.T-specific types with new values

func (*KubePerTestContext) UpdateResource 

func (tc *KubePerTestContext) UpdateResource(obj client.Object)

UpdateResource updates the given resource in K8s.

type PerTestContext 

type PerTestContext struct {
	TestContext
	T *testing.T

	AzureClientRecorder *recorder.Recorder
	AzureClient         *genericarmclient.GenericClient
	AzureSubscription   string
	AzureMatch          *ARMMatcher
	Namer               ResourceNamer
	TestName            string
	Namespace           string
	// contains filtered or unexported fields
}

func (PerTestContext) GenerateSSHKey 

func (tc PerTestContext) GenerateSSHKey(size int) (*string, error)

GenerateSSHKey generates an SSH key.

func (PerTestContext) NewTestResourceGroup 

func (tc PerTestContext) NewTestResourceGroup() *resources.ResourceGroup

type PolicyFunc 

type PolicyFunc func(*policy.Request) (*http.Response, error)

PolicyFunc is a type that implements the Policy interface. Use this type when implementing a stateless policy as a first-class function.

func (PolicyFunc) Do 

func (pf PolicyFunc) Do(req *policy.Request) (*http.Response, error)

Do implements the Policy interface on PolicyFunc.

type ResourceNameConfig 

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

func NewResourceNameConfig 

func NewResourceNameConfig(prefix string, separator string, randomChars int, mode ResourceNamerMode) *ResourceNameConfig

func (ResourceNameConfig) NewResourceNamer 

func (rnc ResourceNameConfig) NewResourceNamer(testName string) ResourceNamer

NewResourceNamer returns a ResourceNamer that generates random suffixes based upon the test name

type ResourceNamer 

type ResourceNamer struct {
	ResourceNameConfig
	// contains filtered or unexported fields
}

func (ResourceNamer) GenerateName 

func (n ResourceNamer) GenerateName(prefix string) string

func (ResourceNamer) GeneratePassword 

func (n ResourceNamer) GeneratePassword() string

func (ResourceNamer) GenerateUUID 

func (n ResourceNamer) GenerateUUID() (uuid.UUID, error)

func (ResourceNamer) WithNumRandomChars 

func (n ResourceNamer) WithNumRandomChars(num int) ResourceNamer

WithNumRandomChars returns a copy of the ResourceNamer which will generate names with a random string of the given length included

func (ResourceNamer) WithSeparator 

func (n ResourceNamer) WithSeparator(separator string) ResourceNamer

WithSeparator returns a copy of the ResourceNamer with the given separator

func (ResourceNamer) WithTestName 

func (n ResourceNamer) WithTestName(testName string) ResourceNamer

WithTestName returns a new ResourceNamer configured based on the provided test name. If the original ResourceNamer was entirely random (mode == ResourceNamerModeRandom), the returned namer is not actually based on the test name and is instead still entirely random

type ResourceNamerMode 

type ResourceNamerMode string

type ResourceTracker 

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

func (*ResourceTracker) Resources 

func (r *ResourceTracker) Resources() []client.Object

func (*ResourceTracker) Track 

func (r *ResourceTracker) Track(obj client.Object)

type Subtest 

type Subtest struct {
	Name string
	Test func(testContext *KubePerTestContext)
}

type TestContext 

type TestContext struct {
	AzureRegion  string
	NameConfig   *ResourceNameConfig
	RecordReplay bool
}

func NewTestContext 

func NewTestContext(
	region string,
	recordReplay bool,
	nameConfig *ResourceNameConfig) TestContext

func (TestContext) ForTest 

func (tc TestContext) ForTest(t *testing.T) (PerTestContext, error)

type TestLogger 

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

TestLogger is a logr.Logger wrapper around t.Log, so that we can use it in the controller

func (*TestLogger) Enabled 

func (t *TestLogger) Enabled() bool

func (*TestLogger) Error 

func (t *TestLogger) Error(err error, msg string, keysAndValues ...interface{})

func (*TestLogger) Info 

func (t *TestLogger) Info(msg string, keysAndValues ...interface{})

func (*TestLogger) V 

func (t *TestLogger) V(level int) logr.Logger

func (*TestLogger) WithName 

func (t *TestLogger) WithName(name string) logr.Logger

func (*TestLogger) WithValues 

func (t *TestLogger) WithValues(keysAndValues ...interface{}) logr.Logger

type Verify 

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

func NewVerify 

func NewVerify(c client.Client) *Verify

func (*Verify) AllDeleted 

func (e *Verify) AllDeleted(ctx context.Context, objs []client.Object) (bool, error)

AllDeleted verifies that all of the specified objects are deleted

func (*Verify) Deleted 

func (e *Verify) Deleted(ctx context.Context, obj client.Object) (bool, error)

Deleted verifies that the object specified has been deleted

func (*Verify) Failed 

func (e *Verify) Failed(ctx context.Context, obj client.Object) (bool, error)

Failed verifies that the provisioning state of the resource is failed.

func (*Verify) HasState 

func (e *Verify) HasState(ctx context.Context, obj client.Object, desiredState metav1.ConditionStatus, desiredSeverity conditions.ConditionSeverity) (bool, error)

HasState verifies that the provisioning state of the resource the target state.

func (*Verify) Provisioned 

func (e *Verify) Provisioned(ctx context.Context, obj client.Object) (bool, error)

Provisioned verifies that the provisioning state of the resource is successful.

type WaitCondition 

type WaitCondition bool
const (
	WaitForCreation WaitCondition = true
	DoNotWait       WaitCondition = false
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.