testing

type Action = rtesting.Action

type CommandTestCase struct {

	// Name is used to identify the record in the test results. A sub-test is created for each
	// record with this name.
	Name string
	// Skip suppresses the execution of this test record.
	Skip bool
	// Focus executes this record skipping all unfocused records. The containing test will fail to
	// prevent accidental check-in.
	Focus bool
	// Metadata contains arbitrary value that are stored with the test case
	Metadata map[string]interface{}

	// Config is passed into the command factory. Mosts tests should not need to set this field.
	// If not specified, a default Config is created with a FakeClient. The Config's client will
	// always be replaced with a FakeClient configured with the given objects and reactors to
	// intercept all calls to the fake client for comparison with the expected operations.
	Config *cli.Config
	// Transport to be used as result of HttpReestClient from the kubeconfig file
	// If not specified, when creating the rest client from kubeconfig, the transport will be nil by default
	KubeConfigTransport http.RoundTripper
	// BuilderObjects represents resources needed to build the fake builder. These
	// resources are passed in the http response to the fake builder.
	BuilderObjects []client.Object
	// GivenObjects represents resources that would already exist within Kubernetes. These
	// resources are passed directly to the fake client.
	GivenObjects []client.Object
	// WithReactors installs each ReactionFunc into each fake client. ReactionFuncs intercept
	// each call to the client providing the ability to mutate the resource or inject an error.
	WithReactors []ReactionFunc
	// ExecHelper is a test case that will intercept exec calls receiving their arguments and
	// environment. The helper is able to control stdio and the exit code of the process. Test
	// cases that need to orchestrate multiple exec calls within a single test should instead use
	// a mock.
	//
	// The value of ExecHelper must map to a test function in the same package taking the form
	// `fmt.Sprintf("TestHelperProcess_%s", ExecHelper)`. The test function should distinguish
	// between test exec invocations and vanilla test calls by the `GO_WANT_HELPER_PROCESS` env.
	//
	// “`
	// func TestHelperProcess_Example(t *testing.T) {
	//     if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
	//         return
	//     }
	//     // insert custom behavior
	//     os.Exit(0)
	// }
	// “`
	ExecHelper string

	// Args are passed directly to cobra before executing the command. This is the primary
	// interface to control the behavior of the cli.
	Args []string
	// Stdin injects stub data to be read via os.Stdin for the command.
	Stdin []byte

	// ExpectCreates asserts each resource with the resources passed to the Create method of the
	// fake client in order.
	ExpectCreates []client.Object
	// ExpectUpdates asserts each resource with the resources passed to the Update method of the
	// fake client in order.
	ExpectUpdates []client.Object
	// ExpectDeletes assert references to the Delete method of the fake client in order.
	// Unlike Create and Update, Delete does not receive a full resource, so a reference is used
	// instead. The Group will be blank for 'core' resources. The Resource is not a Kind, but
	// plural lowercase name of the resource.
	ExpectDeletes []rtesting.DeleteRef
	// ExpectDeleteCollections asserts references to the DeleteCollection method of the fake
	// client in order. DeleteCollections behaves similarly to Deletes. Unlike Delete,
	// DeleteCollection does not contain a resource Name, but may contain a LabelSelector.
	ExpectDeleteCollections []rtesting.DeleteCollectionRef

	// ShouldError indicates if the table record command execution should return an error. The
	// test will fail if this value does not reflect the returned error.
	ShouldError bool
	// ShouldPanic is true if and only if command is expected to panic. A panic should only be
	// used to indicate the cli is misconfigured.
	ShouldPanic bool
	// ExpectOutput performs a direct comparison of this content with the command's output showing
	// a diff of any changes. The comparison is ignored for empty strings and ignores a leading
	// new line.
	ExpectOutput string
	// Verify provides the command output and error for custom assertions.
	Verify func(t *testing.T, output string, err error)

	// Prepare is called before the command is executed. It is intended to prepare that broader
	// environment before the specific table record is executed. For example, changing the working
	// directory or setting mock expectations.
	Prepare func(t *testing.T, ctx context.Context, config *cli.Config, tc *CommandTestCase) (context.Context, error)
	// CleanUp is called after the table record is finished and all defined assertions complete.
	// It is intended to clean up any state created in the Prepare step or during the test
	// execution, or to make assertions for mocks.
	CleanUp func(t *testing.T, ctx context.Context, config *cli.Config, tc *CommandTestCase) error
	// WithConsoleInteractions receives function with an expect.Console that can be used to send characters and verify the output send to a fake console.
	WithConsoleInteractions func(t *testing.T, console *expect.Console)
}

type CommandTestSuite []CommandTestCase

type FakeCachedDiscoveryClient struct {
	discovery.DiscoveryInterface
	Groups             []*metav1.APIGroup
	Resources          []*metav1.APIResourceList
	PreferredResources []*metav1.APIResourceList
	Invalidations      int
}

type GetAction = rtesting.GetAction

type InduceFailureOpts = rtesting.InduceFailureOpts

type ReactionFunc = rtesting.ReactionFunc

type ValidatableTestCase struct {
	// Name is used to identify the record in the test results. A sub-test is created for each
	// record with this name.
	Name string
	// Skip suppresses the execution of this test record.
	Skip bool
	// Focus executes this record skipping all unfocused records. The containing test will fail to
	// prevent accidental check-in.
	Focus bool

	// Validatable to validate
	Validatable validation.Validatable

	// ExpectFieldErrors are the errors that should be returned from the validator.
	ExpectFieldErrors validation.FieldErrors

	// ShouldValidate is true if the validatable object is valid
	ShouldValidate bool

	// Prepare is called before the command is executed. It is intended to prepare that broader
	// environment before the specific table record is executed. For example, changing the working
	// directory or setting mock expectations.
	Prepare func(*testing.T, context.Context) (context.Context, error)
	// CleanUp is called after the table record is finished and all defined assertions complete.
	// It is intended to clean up any state created in the Prepare step or during the test
	// execution, or to make assertions for mocks.
	CleanUp func(*testing.T, context.Context) error
}

type ValidatableTestSuite []ValidatableTestCase