kubernetes: k8s.io/kubernetes/staging/src/k8s.io/apimachinery/pkg/api/apitesting/roundtrip Index | Files

package roundtrip

import "k8s.io/kubernetes/staging/src/k8s.io/apimachinery/pkg/api/apitesting/roundtrip"

Index

Package Files

compatibility.go roundtrip.go

Variables

var FuzzIters = flag.Int("fuzz-iters", 20, "How many fuzzing iterations to do.")

func CompatibilityTestFuzzer Uses

func CompatibilityTestFuzzer(scheme *runtime.Scheme, fuzzFuncs []interface{}) *fuzz.Fuzzer

CompatibilityTestFuzzer returns a fuzzer for the given scheme: - fixed seed (deterministic output that lets us generate the same fixtures on every run) - 0 nil chance (populate all fields) - 1 numelements (populate and bound all lists) - 20 max depth (don't recurse infinitely) - meta fuzzing functions added - custom fuzzing functions to make strings and managedFields more readable in fixtures

func CompatibilityTestObject Uses

func CompatibilityTestObject(scheme *runtime.Scheme, gvk schema.GroupVersionKind, fuzzFuncs []interface{}) (runtime.Object, error)

CompatibilityTestObject returns a deterministically fuzzed object for the specified GVK

func GlobalNonRoundTrippableTypes Uses

func GlobalNonRoundTrippableTypes() sets.String

GlobalNonRoundTrippableTypes returns the kinds that are effectively reserved across all GroupVersions. They don't roundtrip and thus can be excluded in any custom/downstream roundtrip tests

kinds := scheme.AllKnownTypes()
for gvk := range kinds {
    if roundtrip.GlobalNonRoundTrippableTypes().Has(gvk.Kind) {
        continue
    }
    t.Run(gvk.Group+"."+gvk.Version+"."+gvk.Kind, func(t *testing.T) {
        // roundtrip test
    })
}

func RoundTripExternalTypes Uses

func RoundTripExternalTypes(t *testing.T, scheme *runtime.Scheme, codecFactory runtimeserializer.CodecFactory, fuzzer *fuzz.Fuzzer, nonRoundTrippableTypes map[schema.GroupVersionKind]bool)

RoundTripExternalTypes applies the round-trip test to all external round-trippable Kinds in the scheme. It will skip all the GroupVersionKinds in the nonRoundTripExternalTypes list .

func RoundTripExternalTypesWithoutProtobuf Uses

func RoundTripExternalTypesWithoutProtobuf(t *testing.T, scheme *runtime.Scheme, codecFactory runtimeserializer.CodecFactory, fuzzer *fuzz.Fuzzer, nonRoundTrippableTypes map[schema.GroupVersionKind]bool)

RoundTripExternalTypesWithoutProtobuf applies the round-trip test to all external round-trippable Kinds in the scheme. It will skip all the GroupVersionKinds in the nonRoundTripExternalTypes list.

func RoundTripProtobufTestForAPIGroup Uses

func RoundTripProtobufTestForAPIGroup(t *testing.T, installFn InstallFunc, fuzzingFuncs fuzzer.FuzzerFuncs)

RoundTripProtobufTestForAPIGroup is convenient to call from your install package to make sure that a "bare" install of your group provides enough information to round trip

func RoundTripProtobufTestForScheme Uses

func RoundTripProtobufTestForScheme(t *testing.T, scheme *runtime.Scheme, fuzzingFuncs fuzzer.FuzzerFuncs)

RoundTripProtobufTestForScheme is convenient to call if you already have a scheme and want to make sure that its well-formed

func RoundTripSpecificKind Uses

func RoundTripSpecificKind(t *testing.T, gvk schema.GroupVersionKind, scheme *runtime.Scheme, codecFactory runtimeserializer.CodecFactory, fuzzer *fuzz.Fuzzer, nonRoundTrippableTypes map[schema.GroupVersionKind]bool)

func RoundTripSpecificKindWithoutProtobuf Uses

func RoundTripSpecificKindWithoutProtobuf(t *testing.T, gvk schema.GroupVersionKind, scheme *runtime.Scheme, codecFactory runtimeserializer.CodecFactory, fuzzer *fuzz.Fuzzer, nonRoundTrippableTypes map[schema.GroupVersionKind]bool)

func RoundTripTestForAPIGroup Uses

func RoundTripTestForAPIGroup(t *testing.T, installFn InstallFunc, fuzzingFuncs fuzzer.FuzzerFuncs)

RoundTripTestForAPIGroup is convenient to call from your install package to make sure that a "bare" install of your group provides enough information to round trip

func RoundTripTestForScheme Uses

func RoundTripTestForScheme(t *testing.T, scheme *runtime.Scheme, fuzzingFuncs fuzzer.FuzzerFuncs)

RoundTripTestForScheme is convenient to call if you already have a scheme and want to make sure that its well-formed

func RoundTripTypes Uses

func RoundTripTypes(t *testing.T, scheme *runtime.Scheme, codecFactory runtimeserializer.CodecFactory, fuzzer *fuzz.Fuzzer, nonRoundTrippableTypes map[schema.GroupVersionKind]bool)

func RoundTripTypesWithoutProtobuf Uses

func RoundTripTypesWithoutProtobuf(t *testing.T, scheme *runtime.Scheme, codecFactory runtimeserializer.CodecFactory, fuzzer *fuzz.Fuzzer, nonRoundTrippableTypes map[schema.GroupVersionKind]bool)

RoundTripTypesWithoutProtobuf applies the round-trip test to all round-trippable Kinds in the scheme. It will skip all the GroupVersionKinds in the skip list.

type CompatibilityTestOptions Uses

type CompatibilityTestOptions struct {
    // Scheme is used to create new objects for fuzzing, decoding, and for constructing serializers.
    // Required.
    Scheme *runtime.Scheme

    // TestDataDir points to a directory containing compatibility test data.
    // Complete() populates this with "testdata" if unset.
    TestDataDir string

    // TestDataDirCurrentVersion points to a directory containing compatibility test data for the current version.
    // Complete() populates this with "<TestDataDir>/HEAD" if unset.
    // Within this directory, `<group>.<version>.<kind>.[json|yaml|pb]` files are required to exist, and are:
    // * verified to match serialized FuzzedObjects[GVK]
    // * verified to decode without error
    // * verified to round-trip byte-for-byte when re-encoded
    // * verified to be semantically equal when decoded into memory
    TestDataDirCurrentVersion string

    // TestDataDirsPreviousVersions is a list of directories containing compatibility test data for previous versions.
    // Complete() populates this with "<TestDataDir>/v*" directories if nil.
    // Within these directories, `<group>.<version>.<kind>.[json|yaml|pb]` files are optional. If present, they are:
    // * verified to decode without error
    // * verified to round-trip byte-for-byte when re-encoded (or to match a `<group>.<version>.<kind>.[json|yaml|pb].after_roundtrip.[json|yaml|pb]` file if it exists)
    // * verified to be semantically equal when decoded into memory
    TestDataDirsPreviousVersions []string

    // Kinds is a list of fully qualified kinds to test.
    // Complete() populates this with Scheme.AllKnownTypes() if unset.
    Kinds []schema.GroupVersionKind

    // FuzzedObjects is an optional set of fuzzed objects to use for verifying HEAD fixtures.
    // Complete() populates this with the result of CompatibilityTestObject(Kinds[*], Scheme, FuzzFuncs) for any missing kinds.
    // Objects must be deterministically fuzzed and identical on every invocation.
    FuzzedObjects map[schema.GroupVersionKind]runtime.Object

    // FuzzFuncs is an optional set of custom fuzzing functions to use to construct FuzzedObjects.
    // They *must* not use any random source other than the passed-in fuzzer.
    FuzzFuncs []interface{}

    JSON  runtime.Serializer
    YAML  runtime.Serializer
    Proto runtime.Serializer
}

CompatibilityTestOptions holds configuration for running a compatibility test using in-memory objects and serialized files on disk representing the current code and serialized data from previous versions.

Example use: `NewCompatibilityTestOptions(scheme).Complete(t).Run(t)`

func NewCompatibilityTestOptions Uses

func NewCompatibilityTestOptions(scheme *runtime.Scheme) *CompatibilityTestOptions

func (*CompatibilityTestOptions) Complete Uses

func (c *CompatibilityTestOptions) Complete(t *testing.T) *CompatibilityTestOptions

func (*CompatibilityTestOptions) Run Uses

func (c *CompatibilityTestOptions) Run(t *testing.T)

type InstallFunc Uses

type InstallFunc func(scheme *runtime.Scheme)

Package roundtrip imports 32 packages (graph). Updated 2020-01-29. Refresh now. Tools for package owners.