package
0.0.0-20200122233423-62801f1d34cf
Repository: https://github.com/vishvananda/pkg.git
Documentation: pkg.go.dev

# README

Test

This directory contains tests and testing docs.

Running unit tests

To run all unit tests:

go test ./...

Test library

You can use the test library in this dir to:

Use common test flags

These flags are useful for running against an existing cluster, making use of your existing environment setup.

By importing knative.dev/pkg/test you get access to a global variable called test.Flags which holds the values of the command line flags.

logger.Infof("Using namespace %s", test.Flags.Namespace)

See e2e_flags.go.

Output logs

When tests are run with --logverbose option, debug logs will be emitted to stdout.

We are using a generic FormatLogger that can be passed in any existing logger that satisfies it. Test can use the generic logging methods to log info and error logs. All the common methods accept generic FormatLogger as a parameter and tests can pass in t.Logf like this:

_, err = pkgTest.WaitForEndpointState(
    clients.KubeClient,
    t.Logf,
    ...),

See logging.go.

Check Knative Serving resources

WARNING: this code also exists in knative/serving.

After creating Knative Serving resources or making changes to them, you will need to wait for the system to realize those changes. You can use the Knative Serving CRD check and polling methods to check the resources are either in or reach the desired state.

The WaitFor* functions use the kubernetes wait package. To poll they use PollImmediate and the return values of the function you provide behave the same as ConditionFunc: a bool to indicate if the function should stop or continue polling, and an error to indicate if there has been an error.

For example, you can poll a Configuration object to find the name of the Revision that was created for it:

var revisionName string
err := test.WaitForConfigurationState(
    clients.ServingClient, configName, func(c *v1alpha1.Configuration) (bool, error) {
        if c.Status.LatestCreatedRevisionName != "" {
            revisionName = c.Status.LatestCreatedRevisionName
            return true, nil
        }
        return false, nil
    }, "ConfigurationUpdatedWithRevision")

See kube_checks.go.

Ensure test cleanup

To ensure your test is cleaned up, you should defer cleanup to execute after your test completes and also ensure the cleanup occurs if the test is interrupted:

defer tearDown(clients)
test.CleanupOnInterrupt(func() { tearDown(clients) })

See cleanup.go.

Flags

Importing the test library adds flags that are useful for end to end tests that need to run against a cluster.

Tests importing knative.dev/pkg/test recognize these flags:

Specifying kubeconfig

By default the tests will use the kubeconfig file at ~/.kube/config. If there is an error getting the current user, it will use kubeconfig instead as the default value. You can specify a different config file with the argument --kubeconfig.

To run tests with a non-default kubeconfig file:

go test ./test --kubeconfig /my/path/kubeconfig

Specifying cluster

The --cluster argument lets you use a different cluster than your specified kubeconfig's active context.

go test ./test --cluster your-cluster-name

The current cluster names can be obtained by running:

kubectl config get-clusters

Specifying ingress endpoint

The --ingressendpoint argument lets you specify a static url to use as the ingress server during tests. This is useful for Kubernetes configurations which do not provide external IPs.

go test ./test --ingressendpoint <k8s-controller-ip>:32380

Specifying namespace

The --namespace argument lets you specify the namespace to use for the tests. By default, tests will use serving-tests.

go test ./test --namespace your-namespace-name

Output verbose logs

The --logverbose argument lets you see verbose test logs and k8s logs.

go test ./test --logverbose

Specifying docker repo

The --dockerrepo argument lets you specify a uri of the docker repo where you have uploaded the test image to using uploadtestimage.sh. Defaults to $KO_DOCKER_REPO

go test ./test --dockerrepo myspecialdockerrepo

Specifying tag

The --tag argument lets you specify the version tag for the test images.

go test ./test --tag v1.0

Specifying image template

The --imagetemplate argument lets you specify a template to generate the reference to an image from the test. Defaults to {{.Repository}}/{{.Name}}:{{.Tag}}

go test ./test --imagetemplate {{.Repository}}/{{.Name}}:{{.Tag}}

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License.

# Packages

No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
Package logstream lets end-to-end tests incorporate controller logs into the error output of tests.
No description provided by the author
Package monitoring provides common methods for all the monitoring components used in the tests This package exposes following methods: CheckPortAvailability(port int) error Checks if the given port is available GetPods(kubeClientset *kubernetes.Clientset, app string) (*v1.PodList, error) Gets the list of pods that satisfy the lable selector app=<app> Cleanup(pid int) error Kill the current port forwarding process running in the background PortForward(logf logging.FormatLogger, podList *v1.PodList, localPort, remotePort int) (int, error) Create a background process that will port forward the first pod from the local to remote port It returns the process id for the background process created.
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
Package zipkin adds Zipkin tracing support that can be used in conjunction with SpoofingClient to log zipkin traces for requests that have encountered server errors i.e HTTP request that have HTTP status between 500 to 600.

# Functions

BuildClientConfig builds the client config specified by the config path and the cluster name.
CleanupOnInterrupt will execute the function cleanup if an interrupt signal is caught.
ClusterRoleBinding returns ClusterRoleBinding for given subject and role.
CoreV1ObjectReference returns a corev1.ObjectReference for the given name, kind and apiversion.
DeploymentScaledToZeroFunc returns a func that evaluates if a deployment has scaled to 0 pods.
EventuallyMatchesBody checks that the response body *eventually* matches the expected body.
GetConfigMap gets the configmaps for a given namespace.
ImagePath is a helper function to transform an image name into an image reference that can be pulled.
IsOneOfStatusCodes checks that the response code is equal to the given one.
IsStatusOK checks that the response code is a 200.
MatchesAllOf combines multiple ResponseCheckers to one ResponseChecker with a logical AND.
MatchesBody checks that the *first* response body matches the "expected" body, otherwise failing.
NewKubeClient instantiates and returns several clientsets required for making request to the kube client specified by the combination of clusterName and configPath.
NewSpoofingClient returns a spoofing client to make requests.
NginxPod returns nginx pod defined in given namespace.
PodRunning will check the status conditions of the pod and return true if it's Running.
PodsRunning will check the status conditions of the pod list and return true all pods are Running.
Retrying modifies a ResponseChecker to retry certain response codes.
ServiceAccount returns ServiceAccount object in given namespace.
SetupLoggingFlags initializes the logging libraries at runtime.
WaitForAllPodsRunning waits for all the pods to be in running state.
WaitForDeploymentState polls the status of the Deployment called name from client every interval until inState returns `true` indicating it is done, returns an error or timeout.
WaitForEndpointState will poll an endpoint until inState indicates the state is achieved, or default timeout is reached.
WaitForEndpointStateWithTimeout will poll an endpoint until inState indicates the state is achieved or the provided timeout is achieved.
WaitForLogContent waits until logs for given Pod/Container include the given content.
WaitForPodListState polls the status of the PodList from client every interval until inState returns `true` indicating it is done, returns an error or timeout.
WaitForPodRunning waits for the given pod to be in running state.
WaitForPodState polls the status of the specified Pod from client every interval until inState returns `true` indicating it is done, returns an error or timeout.
WaitForServiceHasAtLeastOneEndpoint polls the status of the specified Service from client every interval until number of service endpoints = numOfEndpoints.
WithHeader will add the provided headers to the request.

# Variables

Flags holds the command line flags or defaults for settings in the user's environment.

# Structs

EnvironmentFlags define the flags that are needed to run the e2e tests.
KubeClient holds instances of interfaces for making requests to kubernetes client.

# Interfaces

No description provided by the author
No description provided by the author

# Type aliases

RequestOption enables configuration of requests when polling for endpoint states.