nerdtest

Documentation

Index

• Constants
• Variables
• func BuildCtlCommand(helpers test.Helpers, args ...string) test.TestableCommand
• func EnsureContainerStarted(helpers test.Helpers, con string)
• func InspectContainer(helpers test.Helpers, name string) dockercompat.Container
• func InspectImage(helpers test.Helpers, name string) dockercompat.Image
• func InspectNetwork(helpers test.Helpers, name string) dockercompat.Network
• func InspectVolume(helpers test.Helpers, name string) native.Volume
• func IsDocker() bool
• func KubeCtlCommand(helpers test.Helpers, args ...string) test.TestableCommand
• func RegistryWithBasicAuth(data test.Data, helpers test.Helpers, user, pass string, port int, tls bool) *registry.Server
• func RegistryWithNoAuth(data test.Data, helpers test.Helpers, port int, tls bool) *registry.Server
• func RegistryWithTokenAuth(data test.Data, helpers test.Helpers, user, pass string, port int, tls bool) (*registry.Server, *registry.TokenAuthServer)
• func Setup() *test.Case

Constants

const (
	// It seems that at this moment, the busybox on windows image we are using has an outdated version of sleep
	// that does not support inf/infinity.
	// This constant is provided as a mean for tests to express the intention of sleep infinity without having to
	// worry about that and get windows compatibility.
	Infinity = "3600"
)

Variables

var BrokenTest = func(message string, req *test.Requirement) *test.Requirement {
	return &test.Requirement{
		Check: func(data test.Data, helpers test.Helpers) (bool, string) {
			ret, mess := req.Check(data, helpers)
			return ret, message + "\n" + mess
		},
		Setup:   req.Setup,
		Cleanup: req.Cleanup,
	}
}

BrokenTest marks a test as currently broken, with explanation provided in message, along with additional requirements / restrictions describing what it can run on.

var Build = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (bool, string) {

		ret := true
		mess := "buildkitd is enabled"

		if getTarget() == targetNerdctl {
			bkHostAddr, err := buildkitutil.GetBuildkitHost(defaultNamespace)
			if err != nil {
				ret = false
				mess = fmt.Sprintf("buildkitd is not enabled: %+v", err)
				return ret, mess
			}

			_, err = exec.LookPath("buildctl")
			if err != nil {
				ret = false
				mess = fmt.Sprintf("buildctl is not in the path: %+v", err)
				return ret, mess
			}
			helpers.Write(BuildkitHost, test.ConfigValue(bkHostAddr))
		}
		return ret, mess
	},
	Cleanup: func(data test.Data, helpers test.Helpers) {

	},
}

Build marks a test as suitable only if buildkitd is enabled (only tested for nerdctl obviously)

var BuildkitHost test.ConfigKey = "BuildkitHost"

var CGroup = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		ret = true
		mess = "cgroup is enabled"
		stdout := helpers.Capture("info", "--format", "{{ json . }}")
		var dinf dockercompat.Info
		err := json.Unmarshal([]byte(stdout), &dinf)
		assert.NilError(helpers.T(), err, "failed to parse docker info")
		switch dinf.CgroupDriver {
		case "none", "":
			ret = false
			mess = "cgroup is none"
		}
		return ret, mess
	},
}

CGroup requires that cgroup is enabled

var CgroupsAccessible = test.Require(
	CGroup,
	&test.Requirement{
		Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
			isRootLess := getTarget() == targetNerdctl && rootlessutil.IsRootless()
			if isRootLess {
				stdout := helpers.Capture("info", "--format", "{{ json . }}")
				var dinf dockercompat.Info
				err := json.Unmarshal([]byte(stdout), &dinf)
				assert.NilError(helpers.T(), err, "failed to parse docker info")
				return dinf.CgroupVersion == "2", "we are rootless, and cgroup version is not 2"
			}
			return true, ""
		},
	},
)

var DataRoot test.ConfigKey = "DataRoot"

var Debug test.ConfigKey = "Debug"

var Docker = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		ret = getTarget() == targetDocker
		if ret {
			mess = "current target is docker"
		} else {
			mess = "current target is not docker"
		}
		return ret, mess
	},
}

Docker marks a test as suitable solely for Docker and not Nerdctl Generally used as test.Not(nerdtest.Docker), which of course it the opposite

var DockerConfig test.ConfigKey = "DockerConfig"

var HostsDir test.ConfigKey = "HostsDir"

var HyperV = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		return false, "HyperV is a windows-only feature"
	},
}

var IPFS = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {

		helpers.Write(ipfs, enabled)

		return test.Binary("ipfs").Check(data, helpers)
	},
}

var IsFlaky = func(issueLink string) *test.Requirement {
	return &test.Requirement{
		Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {

			helpers.Write(flaky, only)
			ret = environmentIsForFlaky()
			if !ret {
				mess = "runner skips flaky compatible tests in the non-flaky environment"
			}
			return ret, mess
		},
	}
}

IsFlaky marks a test as randomly failing. This is an ambient requirement

var Namespace test.ConfigKey = "Namespace"

var NerdctlNeedsFixing = func(issueLink string) *test.Requirement {
	return &test.Requirement{
		Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
			ret = getTarget() == targetDocker
			if ret {
				mess = "current target is docker"
			} else {
				mess = "current target is nerdctl, but we will skip as nerdctl currently has issue: " + issueLink
			}
			return ret, mess
		},
	}
}

NerdctlNeedsFixing marks a test as unsuitable to be run for Nerdctl, because of a specific known issue which url must be passed as an argument

var NerdctlToml test.ConfigKey = "NerdctlToml"

var OnlyIPv6 = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		helpers.Write(ipv6, only)
		ret = environmentHasIPv6()
		if !ret {
			mess = "runner skips IPv6 compatible tests in the non-IPv6 environment"
		}
		return ret, mess
	},
}

OnlyIPv6 marks a test as suitable to be run exclusively inside an ipv6 environment This is an ambient requirement

var OnlyKubernetes = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		helpers.Write(kubernetes, only)
		if _, err := exec.LookPath("kubectl"); err != nil {
			return false, fmt.Sprintf("kubectl is not in the path: %+v", err)
		}
		ret = environmentHasKubernetes()
		if ret {
			helpers.Write(Namespace, "k8s.io")
		} else {
			mess = "runner skips Kubernetes compatible tests in the non-Kubernetes environment"
		}
		return ret, mess
	},
}

OnlyKubernetes marks a test as meant to be tested on Kubernetes This is an ambient requirement

var Private = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {

		namespace := data.Identifier("private")
		helpers.Write(Namespace, test.ConfigValue(namespace))
		data.Set("_deletenamespace", namespace)

		helpers.Write(modePrivate, enabled)
		return true, "private mode creates a dedicated namespace for nerdctl, and disable parallelism for docker"
	},

	Cleanup: func(data test.Data, helpers test.Helpers) {
		if getTarget() == targetNerdctl {

			containerList := strings.TrimSpace(helpers.Capture("ps", "-aq"))
			if containerList != "" {
				helpers.Ensure(append([]string{"rm", "-f"}, strings.Split(containerList, "\n")...)...)
			}
			helpers.Ensure("system", "prune", "-f", "--all", "--volumes")
			helpers.Anyhow("namespace", "remove", data.Get("_deletenamespace"))
		}
	},
}

Private makes a test run inside a dedicated namespace, with a private config.toml, hosts directory, and DOCKER_CONFIG path If the target is docker, parallelism is forcefully disabled

var Registry = test.Require(

	test.Linux,
	(func() *test.Requirement {

		return &test.Requirement{
			Check: func(data test.Data, helpers test.Helpers) (bool, string) {
				return true, ""
			},
			Setup: func(data test.Data, helpers test.Helpers) {

				registryImage := platform.RegistryImageStable
				up := os.Getenv("DISTRIBUTION_VERSION")
				if up != "" {
					if up[0:1] != "v" {
						up = "v" + up
					}
					registryImage = platform.RegistryImageNext + up
				}
				helpers.Ensure("pull", "--quiet", registryImage)
				helpers.Ensure("pull", "--quiet", platform.DockerAuthImage)
				helpers.Ensure("pull", "--quiet", platform.KuboImage)
			},
			Cleanup: func(data test.Data, helpers test.Helpers) {

			},
		}
	})(),
)

Registry marks a test as requiring a registry to be deployed

var Rootful = test.Not(Rootless)

Rootful marks a test as suitable only for rootful env

var Rootless = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {

		ret = getTarget() == targetNerdctl && rootlessutil.IsRootless()
		if ret {
			mess = "environment is root-less"
		} else {
			mess = "environment is root-ful"
		}
		return ret, mess
	},
}

Rootless marks a test as suitable only for the rootless environment

var Soci = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		ret = false
		mess = "soci is not enabled"
		stdout := helpers.Capture("info", "--format", "{{ json . }}")
		var dinf dockercompat.Info
		err := json.Unmarshal([]byte(stdout), &dinf)
		assert.NilError(helpers.T(), err, "failed to parse docker info")
		for _, p := range dinf.Plugins.Storage {
			if p == "soci" {
				ret = true
				mess = "soci is enabled"
			}
		}
		return ret, mess
	},
}

Soci requires that the soci snapshotter is enabled

var Stargz = &test.Requirement{
	Check: func(data test.Data, helpers test.Helpers) (ret bool, mess string) {
		ret = false
		mess = "stargz is not enabled"
		stdout := helpers.Capture("info", "--format", "{{ json . }}")
		var dinf dockercompat.Info
		err := json.Unmarshal([]byte(stdout), &dinf)
		assert.NilError(helpers.T(), err, "failed to parse docker info")
		for _, p := range dinf.Plugins.Storage {
			if p == "stargz" {
				ret = true
				mess = "stargz is enabled"
			}
		}

		helpers.Write(stargz, enabled)
		return ret, mess
	},
}

Functions

func BuildCtlCommand

func BuildCtlCommand(helpers test.Helpers, args ...string) test.TestableCommand

func EnsureContainerStarted

func EnsureContainerStarted(helpers test.Helpers, con string)

func InspectContainer

func InspectContainer(helpers test.Helpers, name string) dockercompat.Container

InspectContainer is a helper that can be used inside custom commands or Setup

func InspectImage

func InspectImage(helpers test.Helpers, name string) dockercompat.Image

func InspectNetwork

func InspectNetwork(helpers test.Helpers, name string) dockercompat.Network

func InspectVolume

func InspectVolume(helpers test.Helpers, name string) native.Volume

func IsDocker

func IsDocker() bool

func KubeCtlCommand

func KubeCtlCommand(helpers test.Helpers, args ...string) test.TestableCommand

func RegistryWithBasicAuth

func RegistryWithBasicAuth(data test.Data, helpers test.Helpers, user, pass string, port int, tls bool) *registry.Server

func RegistryWithNoAuth

func RegistryWithNoAuth(data test.Data, helpers test.Helpers, port int, tls bool) *registry.Server

func RegistryWithTokenAuth

func RegistryWithTokenAuth(data test.Data, helpers test.Helpers, user, pass string, port int, tls bool) (*registry.Server, *registry.TokenAuthServer)

func Setup

func Setup() *test.Case