e2e

package
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Sep 9, 2026 License: Apache-2.0 Imports: 40 Imported by: 0

README

E2E testing

$ source .ate-dev-env.sh
$ go test -v ./internal/e2e/suites/... -args --e2e

Principles

  • Keep it simple -- use go test for the harness.
  • e2e tests live under internal/e2e/suites/<suite>
  • Each suite should implement TestMain using e2e.RunTestMain()
    • e2e tests will be skipped for ordinary unit tests unless the --e2e flag is set e.g. go test ./internal/e2e/suites/... -args --e2e
  • Helper libraries live under internal/e2e
  • Setup and Teardown are on a per-component basis and the component's author's responsibility.

Preconditions

The e2e tests assume you have a cluster set up with Agent Substrate installed, for example via hack/install-ate.sh --deploy-ate-system or hack/install-ate-kind.sh --deploy-ate-system.

Sandbox classes

The suites are runtime-agnostic: the same tests run against gVisor and against the micro-VM (kata + cloud-hypervisor) sandbox class. E2E_SANDBOX_CLASS selects which, by repointing every fixture at its variant --- see e2e.CounterFixture, e2e.EgressFixture and e2e.RenderFixtureManifest in sandbox.go. Unset means gVisor.

# gVisor (the default), against the demos install-ate-kind.sh deploys
$ hack/run-e2e-kind.sh -v -args --no-color

# micro-VM, against the counter-microvm and egress-microvm demos
$ E2E_SANDBOX_CLASS=microvm hack/run-e2e-kind.sh -v -args --no-color

The micro-VM lane needs its fixtures installed first, which also needs a node with /dev/kvm (hack/create-kind-cluster.sh detects one and labels the node):

$ hack/run-microvm-demo-kind.sh                        # counter-microvm + assets
$ hack/install-ate-kind.sh --deploy-demo-egress-microvm # egress-microvm

A handful of knobs override the class defaults, mostly for a cluster that installs the fixtures elsewhere: E2E_SUBSTRATE_TEMPLATE_ATESPACE / E2E_SUBSTRATE_TEMPLATE_NAME / E2E_SUBSTRATE_POOL_NAMESPACE / E2E_SUBSTRATE_POOL_NAME point the counter fixture somewhere else, and E2E_TEMPLATE_READY_TIMEOUT replaces the golden-snapshot budget (90s on gVisor, 10m on micro-VM, where the golden is a cloud-hypervisor cold boot plus a checkpoint).

After a failure

A suite deletes the namespaces it created only when it passed. A failed run keeps them, because the failure is usually explained inside a worker pod (the ateom logs, and for a micro-VM worker the guest's console tail), and deleting the namespace takes those pods with it:

$ kubectl logs -n <kept-namespace> <worker-pod>

Nothing reclaims them afterwards, and each namespace holds a WorkerPool's worth of running pods, so clean up once you are done reading:

$ hack/cleanup-e2e.sh   # deletes every namespace labeled ate.dev/e2e

Creating a new test suite

Copy testmain_test.go from internal/e2e/suites/example into your new suite. It will look like this:

func run(m *testing.M) int {
	Setup()
	defer Teardown()
	// return allows the deferred Teardown to run.
	return e2e.RunTestMain(m)
}

func TestMain(m *testing.M) { os.Exit(run(m)) }

This will handle the standard flags and checks for running an e2e test suite.

Documentation

Index

Constants

View Source 
const (
	// EgressTrustBundleObjectName is the reconciler-owned ClusterTrustBundle.
	EgressTrustBundleObjectName = "egress-mitm.ate.dev:mitm:primary-bundle"
)

Constants of atecontroller's EgressMITMTrustReconciler (#946): the CA pool Secret it watches (the key is what `kubectl-ate admin make-ca-pool` writes) and the ClusterTrustBundle it derives from that pool — the backing object of the allowlisted "egress-mitm.ate.dev" bundle the probe fixture projects.

Suites provision the POOL and let the real reconciler publish the bundle, exercising the whole chain (pool -> reconciler -> bundle -> projection). Writing the bundle directly is not an option: the reconciler watches it and reverts or deletes hand-written contents.

View Source 
const NamespaceLabel = "ate.dev/e2e"

NamespaceLabel marks the namespaces the suites create, so leftovers from a failed run (which are kept deliberately — see RetainNamespaces) can be found and deleted later: `kubectl delete ns -l ate.dev/e2e`, or hack/cleanup-e2e.sh.

View Source 
const ProbeName = "probe"

ProbeName is the name of the probe fixture's WorkerPool and ActorTemplate, inside the atespace (and matching k8s namespace) DeployProbe returns.

View Source 
const SandboxClassMicroVM = "microvm"

SandboxClassMicroVM is the kata + cloud-hypervisor runtime, spelled as the WorkerPool/ActorTemplate spec.sandboxClass field spells it.

Variables

View Source 
var (
	RunE2E       bool
	KubeConfig   string
	KubeContext  string
	StorageClass string
)
View Source 
var (
	NoColor bool
)

noColor() disables colors for tests running in environments without colored output.

View Source 
var PlatformMetricPrefixes = []string{
	"ate_workerpool_workers",
	"ate_workerpool_desired_workers",
	"ate_workerpool_ready_workers",
	"ate_actor_crashes",
	"ate_actor_lifecycle_operation_duration",
	"ate_scheduler_assignment_duration",
	"ate_actor_restore_duration",
	"ate_actor_checkpoint_duration",
	"atenet_router_route_duration",
	"ate_scheduler_eligible_workers",
}

PlatformMetricPrefixes are the Prometheus metric-name prefixes (OTLP dots mapped to underscores) the substrate platform must emit. The Collector's prometheus exporter appends unit and type suffixes (e.g. _seconds_bucket, _bytes_count), so matching is by prefix. This slice grows as each metric slice lands and as more components are wired to push to the collector.

Functions

func CheckEnv 

func CheckEnv(keys ...string) (map[string]string, error)

CheckEnv checks the list of env vars exist and returns their value. If any env var is not set, it returns an error.

func CleanupNamespaces 

func CleanupNamespaces()

CleanupNamespaces deletes all registered namespaces using the K8s API. This should be called at the end of RunTestMain.

A backstop rather than the main path: tests release their own namespaces as they finish, so this only picks up ones whose cleanup never ran.

func CollectorHasService added in v0.1.0 

func CollectorHasService(scrape string, services ...string) bool

CollectorHasService reports whether any named service has pushed telemetry to the collector. Its prometheus exporter maps each pushed resource's service.name onto the job label, so a service that has exported at least one data point shows up there. Note the exporter never emits a service_name label, and a resource whose instruments have recorded nothing yet produces no series at all.

func Colorf 

func Colorf(format string, a ...any) string

Colorf renders a formatted string with color directives:

"Example text: <green>this is green</green>".

Unterminated directives will be treated as literals.

func CreateSubstrateCounterTemplate added in v0.1.0 

func CreateSubstrateCounterTemplate(ctx context.Context, t *testing.T, clients *Clients, namespace string, opts SubstrateTemplateOptions) *ateapipb.ActorTemplate

CreateSubstrateCounterTemplate creates a per-test WorkerPool CRD plus a substrate ActorTemplate copying the resolved runtime from the substrate counter demo for the sandbox class under test.

func CreateSubstrateTemplateFrom added in v0.1.0 

func CreateSubstrateTemplateFrom(ctx context.Context, t *testing.T, clients *Clients, namespace string, src SubstrateFixture, opts SubstrateTemplateOptions) *ateapipb.ActorTemplate

CreateSubstrateTemplateFrom creates a per-test WorkerPool CRD plus a substrate ActorTemplate copying the resolved runtime (sandbox config, ateom image, container images, sandbox size) from the installed fixture src. It registers cleanup of the template (which does not ride the k8s namespace GC the CRD templates did) and blocks until the golden snapshot exists.

func DeployProbe added in v0.1.0 

func DeployProbe(t *testing.T, bucket, name string, opts ...ProbeOption) (string, *ateapipb.ActorTemplate)

DeployProbe builds the probe fixture image and installs the fixture for the sandbox class under test, removing it when the test ends. name distinguishes the caller (by convention its suite name): each suite gets its own copy of the fixture, so no suite's cleanup can delete the fixture out from under another running concurrently. It returns the fixture's atespace (which also names the k8s namespace holding the pool) and the created ActorTemplate, already golden-snapshotted.

func DeploySubstrateFixture added in v0.1.0 

func DeploySubstrateFixture(t *testing.T, ctx context.Context, clients *Clients, manifests SubstrateFixtureManifests, bucket, name string, trustBundle bool) (string, []*ateapipb.ActorTemplate)

DeploySubstrateFixture installs a fixture for the sandbox class under test: it ko-applies the pool manifest, creates the fixture's atespace and ActorTemplates through the ate API (ko-resolving the templates' ko:// image references first), and blocks until every template's golden snapshot exists. name distinguishes the caller (by convention its suite name): each suite gets its own copy of the fixture, so no suite's cleanup can delete it out from under another running concurrently.

Everything is removed when the test ends. The substrate resources need explicit cleanup — unlike the CRD templates they replaced, they do not ride the k8s namespace GC — and a template leaked by an interrupted earlier run is cleared before creating its replacement, since templates are immutable.

Returns the fixture's atespace (the same string that names the k8s namespace holding the pool) and the created templates.

func DescribePodState added in v0.1.0 

func DescribePodState(pod *corev1.Pod) string

DescribePodState summarizes why a pod is not ready yet, one clause per container, for a timeout message.

func EnsureEgressTrustBundle added in v0.1.0 

func EnsureEgressTrustBundle(t *testing.T, ctx context.Context, clients *Clients)

EnsureEgressTrustBundle makes sure the egress trust bundle exists, then waits until the reconciler-published bundle is non-empty. It provisions a pool only when there is none and never replaces one it finds: the pool is cluster-wide, and the sdsmint gateway mounts the one the install created. A suite that needs to OWN the pool's contents (the identity suite's deterministic assertions and rotation) uses ReplaceEgressTrustPool.

func FColorf 

func FColorf(f io.Writer, format string, a ...any) error

FColorf writes a formatted string with color directives to the given writer.

func FColorfln 

func FColorfln(f io.Writer, format string, a ...any) error

FColorfln writes a formatted string with color directives to the given writer, followed by a newline.

func FindRepoRoot 

func FindRepoRoot() (string, error)

FindRepoRoot traverses directories upward starting from the current working directory to locate the repository root containing the go.mod file.

func FixtureName added in v0.1.0 

func FixtureName(base string) string

FixtureName suffixes a fixture's name for the sandbox class under test, so the gVisor and micro-VM lanes never share one. That matters most for the namespaces a suite creates and deletes itself: the two lanes run one after the other, and a namespace still Terminating from the previous one would fail the next one's apply. ${FIXTURE_SUFFIX} does the same job inside the fixture manifests.

func IsMicroVM added in v0.1.0 

func IsMicroVM() bool

IsMicroVM reports whether the suites are pointed at the micro-VM fixtures. Assertions that only hold for one runtime gate on this.

func MissingPlatformMetrics added in v0.1.0 

func MissingPlatformMetrics(scrape string, prefixes []string) []string

MissingPlatformMetrics returns the prefixes with no matching series in the Prometheus exposition text. A metric matches when its name equals a prefix or begins with prefix+"_"; the underscore boundary stops "ate_actor_restore" from matching an unrelated "ate_actor_restored".

func PreflightChecks 

func PreflightChecks() error

PreflightChecks checks that the test environment is ready for the test suite.

func RegisterSuiteCleanup added in v0.1.0 

func RegisterSuiteCleanup(fn func())

func RenderFixtureManifest added in v0.1.0 

func RenderFixtureManifest(t *testing.T, relPath, bucket, name string) string

RenderFixtureManifest renders the manifest template at relPath (repo-relative, under internal/e2e/fixtures) for the sandbox class under test, writes it into the test's temp dir and returns that path. Both an apply and a later delete can then consume the same file, with no shell involved.

name distinguishes the caller (by convention its suite name) and is appended to ${FIXTURE_SUFFIX}: suite packages run as concurrent processes, so each caller must get its own copy of a fixture or one suite's cleanup deletes it out from under another.

One template serves both sandbox classes so the two variants of a fixture cannot drift apart. See renderManifest for the placeholder kinds a template can carry.

func ReplaceEgressTrustPool added in v0.1.0 

func ReplaceEgressTrustPool(t *testing.T, ctx context.Context, clients *Clients, cn string) string

ReplaceEgressTrustPool installs a fresh single-CA pool, waits for the reconciler to publish the derived bundle, and returns the PEM of the new CA's root certificate — exactly what a trustBundle projection must then deliver. cn keeps successive pools distinguishable in failure output. Create-or-replace keeps reruns self-healing after a failed prior run.

func ResumeActorAwaitCapacity added in v0.1.0 

func ResumeActorAwaitCapacity(t *testing.T, ctx context.Context, clients *Clients, req *ateapipb.ResumeActorRequest) (*ateapipb.ResumeActorResponse, error)

ResumeActorAwaitCapacity resumes the actor, retrying while its worker pool is saturated. The control plane returns ResourceExhausted when no worker is free and expects callers to wait (the router's parking resumer retries the same condition); suites running concurrently against shared pools make that a normal state in e2e, not a failure. Any other error, or saturation outlasting the wait budget, is returned to the caller. Each retry is logged so a pass that had to wait stays visible in the test output.

func RetainNamespaces added in v0.1.0 

func RetainNamespaces()

RetainNamespaces leaves the registered namespaces in the cluster and reports them, instead of deleting them. Used when the suite failed: the namespaces' worker pods hold the ateom (and, for micro-VM workers, guest) logs a post-mortem needs, and they are deleted long before anyone can read them.

Passing tests have already released theirs, so what is left is the failures' — exactly what a post-mortem wants to look at.

func RunCmd 

func RunCmd(t *testing.T, name string, args ...string)

RunCmd executes the given command with arguments, piping stdout and stderr to standard outputs, and fails the test if the command returns an error.

func RunCmdOutput added in v0.1.0 

func RunCmdOutput(t *testing.T, env []string, name string, args ...string) []byte

RunCmdOutput executes the given command with custom environment variables appended to the current process environment, streaming stderr like RunCmd does, and returns the captured stdout. Fails the test if the command returns an error.

func RunCmdWithEnv 

func RunCmdWithEnv(t *testing.T, env []string, name string, args ...string)

RunCmdWithEnv executes the given command with custom environment variables appended to the current process environment, and fails the test if it returns an error.

func RunTestMain 

func RunTestMain(m *testing.M) int

RunTestMain should be used to run your e2e test suite.

func SandboxClass added in v0.1.0 

func SandboxClass() string

SandboxClass returns the sandbox class under test, "" for gVisor. CI sets E2E_SANDBOX_CLASS=microvm for the micro-VM lane and leaves it unset for the gVisor one, so a single knob repoints every suite's fixtures.

func ScrapeCollectorMetrics added in v0.1.0 

func ScrapeCollectorMetrics(ctx context.Context) (string, error)

ScrapeCollectorMetrics port-forwards the kind stack's OTel Collector and reads its Prometheus exporter surface, returning the raw exposition text.

func TargetInfoLabel added in v0.1.0 

func TargetInfoLabel(scrape, service, label string) string

TargetInfoLabel returns one resource attribute of a service, or "" when it is absent. The Prometheus exporter keeps resource attributes off the series and publishes them once per resource in target_info, keyed by job.

func TemplateReadyTimeout added in v0.1.0 

func TemplateReadyTimeout(t *testing.T) time.Duration

TemplateReadyTimeout is how long to wait for an ActorTemplate's golden snapshot. A micro-VM golden (a cloud-hypervisor cold boot plus checkpoint, on nested KVM in CI) takes several times what a gVisor one does, so the default follows the class under test. E2E_TEMPLATE_READY_TIMEOUT overrides it.

func TemplateRef added in v0.1.0 

func TemplateRef(at *ateapipb.ActorTemplate) *ateapipb.ObjectRef

TemplateRef builds the substrate template reference an Actor carries.

func WaitForPodReady added in v0.1.0 

func WaitForPodReady(t *testing.T, ctx context.Context, namespace, name string, timeout time.Duration)

WaitForPodReady blocks until the pod passes its readiness probe, and fails the test with the pod's last observed state if it does not within timeout.

A suite that skipped this and dialed straight away would race the readiness probe, and a fixture that is still pulling its image or crash-looping would then be reported as whatever the code under test does with a refused connection. Reporting the container's own waiting/terminated reason instead is the whole point of the poll: it is the difference between "ImagePullBackOff" and an unexplained timeout.

func WaitForSubstrateTemplateReady added in v0.1.0 

func WaitForSubstrateTemplateReady(ctx context.Context, t *testing.T, clients *Clients, atespace, name string)

WaitForSubstrateTemplateReady blocks until the substrate ActorTemplate's golden snapshot exists. The timeout follows the sandbox class under test (see TemplateReadyTimeout).

Types

type Clients 

type Clients struct {
	K8s          *kubernetes.Clientset
	CRD          *apiextensionsclientset.Clientset
	SubstrateK8s *versioned.Clientset
	SubstrateAPI *ateclient.Client
}

func GetClients 

func GetClients() *Clients

GetClients returns the shared E2E clients. It panics if the clients have not been initialized.

func NewClients 

func NewClients(ctx context.Context) (*Clients, error)

func (*Clients) Close 

func (c *Clients) Close()

type ColorWriter 

type ColorWriter struct {
	W    io.Writer
	ANSI string
}

ColorWriter wraps an io.Writer and forces all writes to be colored with the given ANSI code. It respects noColor().

func (*ColorWriter) Write 

func (cw *ColorWriter) Write(p []byte) (n int, err error)

Write writes p to the underlying writer, wrapped in the ANSI color code and reset code.

type Fixture added in v0.1.0 

type Fixture struct {
	Namespace string
	Name      string
	// DeployWith is the install flag or script that creates the fixture, so a
	// missing one reports how to fix it rather than just failing.
	DeployWith string
}

Fixture identifies an installed WorkerPool + ActorTemplate pair (both carry the same name) that suites either create Actors from directly or copy the resolved runtime — sandbox class, ateom image, container images — out of.

func EgressFixture added in v0.1.0 

func EgressFixture() Fixture

EgressFixture returns the egress demo for the sandbox class under test.

type IndentWriter 

type IndentWriter struct {
	W   io.Writer
	Val string
	// contains filtered or unexported fields
}

IndentWriter wraps an io.Writer and indents each line of output.

func NewIndentWriter 

func NewIndentWriter(w io.Writer, indent string) *IndentWriter

NewIndentWriter creates a new IndentWriter.

func (*IndentWriter) Write 

func (iw *IndentWriter) Write(p []byte) (n int, err error)

Write writes p to the underlying writer, inserting the indent string at the start of each line.

type Namespace 

type Namespace struct {
	Name string
}

func CreateNamespace 

func CreateNamespace(t *testing.T) *Namespace

CreateNamespace creates a new namespace with a randomized name using the K8s API. The namespace is deleted when the test finishes, unless it failed — see the cleanup registered below.

type ParkingStatusz added in v0.1.0 

type ParkingStatusz struct {
	Enabled   bool   `json:"enabled"`
	Active    int    `json:"active"`
	MaxParked int    `json:"max_parked"`
	MaxWait   string `json:"max_wait"`
}

ParkingStatusz mirrors the "parking" section of /statusz?format=json.

type ProbeOption added in v0.1.0 

type ProbeOption func(*probeConfig)

ProbeOption adjusts what DeployProbe installs.

func WithTrustBundle added in v0.1.0 

func WithTrustBundle() ProbeOption

WithTrustBundle projects the egress trust bundle into the probe's system-info volume, ensuring the cluster-scoped bundle exists first.

Only suites that ASSERT the projection ask for it. The bundle is derived from a single cluster-wide Secret, so a suite that merely needs a probe must not depend on it: it would then fail whenever the suite that owns the pool finishes and takes the bundle with it. For the same reason two suites that opt in must not run concurrently — CI runs the egress ones in their own step, leaving the identity suite the only opt-in in the standard lanes.

type RouterClient added in v0.1.0 

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

RouterClient sends HTTP requests to actors through the ingress atenet-router, the same way real traffic arrives (so the request is routed and, if needed, the actor is resumed). It port-forwards the router Service, mirroring the approach in internal/ateclient.

func NewRouterClient added in v0.1.0 

func NewRouterClient(ctx context.Context) (*RouterClient, error)

NewRouterClient establishes a port-forward to the ingress atenet-router. Call Close to tear it down.

func (*RouterClient) BaseURL added in v0.1.0 

func (c *RouterClient) BaseURL() string

BaseURL returns the local router port-forward address.

func (*RouterClient) Close added in v0.1.0 

func (c *RouterClient) Close()

Close stops the port-forward tunnel(s).

func (*RouterClient) Connect added in v0.1.0 

func (c *RouterClient) Connect(ctx context.Context, actorRef resources.ActorRef, port int) (net.Conn, error)

Connect opens a CONNECT tunnel through the router to port on actorRef, exercising atenet-router's arbitrary-port ingress support: the target port travels in the CONNECT authority (e.g. "my-actor.team-a...:9090"), the same way a real client reaches a port other than an actor's primary one. On a non-2xx response the returned error carries the status and body, mirroring atunnel.Client.DialContext's handling of the same failure mode on the egress side. The caller owns the returned connection and must Close it; the underlying port-forward is torn down by RouterClient.Close.

func (*RouterClient) Get added in v0.1.0 

func (c *RouterClient) Get(ctx context.Context, actorRef resources.ActorRef, path string) (*http.Response, error)

Get issues GET path to actor through the router, setting the actor's DNS Host so the router routes (and resumes) it. The caller must close the body.

func (*RouterClient) PostJSON added in v0.1.0 

func (c *RouterClient) PostJSON(ctx context.Context, actorRef resources.ActorRef, path string, body []byte) (*http.Response, error)

PostJSON issues a POST with a JSON body to an Actor through the router. The caller must close the response body.

type Server added in v0.1.0 

type Server struct {
	// Namespace is the namespace the server was deployed into, for a suite that
	// wants to port-forward to it or read its logs on failure.
	Namespace string
	// ClusterIP is the Service's address. Deliberately not its DNS name: an IP
	// keeps a caller inside a sandbox off that sandbox's resolver, and makes
	// the authority in a gateway's access log exactly what the test deployed.
	ClusterIP string
	Port      int
}

Server is a deployed ServerPod, as the address a caller dials it at.

func DeployServerPod added in v0.1.0 

func DeployServerPod(t *testing.T, ctx context.Context, spec ServerPod) Server

DeployServerPod builds spec's image, applies the shared server manifest, waits for readiness and returns the address to dial.

It registers no cleanup: everything the manifest creates is namespaced, so it goes with the namespace CreateNamespace made — and, on failure, is retained with it for `kubectl logs`.

func (Server) Address added in v0.1.0 

func (s Server) Address() string

Address is the host:port to dial the server at.

type ServerPod added in v0.1.0 

type ServerPod struct {
	// Name names the Pod, its container and the Service alike, and is what
	// appears in kubectl output when a test fails.
	Name string
	// ImportPath is the server binary's package, as a ko:// reference. The
	// template's contract is that the binary takes --listen=:<port>, which is
	// how one manifest serves fixtures that share nothing else.
	ImportPath string
	// Args are passed to the binary ahead of --listen=:<port>, which the
	// template always appends. One image (internal/e2e/fixtures/testserver)
	// backs every server, so this is where a caller names the subcommand that
	// picks its behavior -- []string{"grpc"}, say.
	Args []string
	// Port is what the Service publishes, so an address a suite grafts into an
	// assertion — a CONNECT authority in a gateway's access log, say — is this
	// number.
	Port int
	// TargetPort is what the binary listens on, defaulting to Port. Set it to
	// publish a port the container -- uid 65532, every capability dropped --
	// cannot bind, such as 80; the Service maps Port down to it.
	TargetPort int
	// Namespace deploys into an existing namespace instead of a fresh one, for
	// a suite that has to populate that namespace first: credentials the pod
	// mounts have to exist before it is scheduled, and DeployServerPod cannot
	// hand back a namespace it has not created yet.
	Namespace string
	// GRPCProbe asks kubelet to probe with the gRPC health protocol instead of
	// an HTTP GET. A gRPC server answers an HTTP request with a protocol error,
	// so a server speaking grpc must set this and register the health service.
	GRPCProbe bool
	// HealthPath is the HTTP readiness path, defaulting to /healthz. Ignored
	// when GRPCProbe is set.
	HealthPath string
	// Volumes and VolumeMounts carry whatever credentials the server needs.
	// Typed, rather than more YAML in the template, so the Secret names here
	// sit beside the code that creates them instead of drifting from it.
	Volumes      []corev1.Volume
	VolumeMounts []corev1.VolumeMount
}

ServerPod describes a plain server to stand up beside the code under test: the origin an Actor's egress lands on, or the probe that dials a gateway. Everything those have in common — the pod shape, the Service, the security context — lives in the shared template, so a suite only names what differs.

type StatuszClient added in v0.1.0 

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

StatuszClient reads the atenet router's /statusz page over a port-forward, for suites that assert on router-internal state (e.g. the request-parking gauge) without going through the metrics pipeline.

func NewStatuszClient added in v0.1.0 

func NewStatuszClient(ctx context.Context) (*StatuszClient, error)

NewStatuszClient establishes a port-forward to the router's status port. Call Close to tear it down.

func (*StatuszClient) Close added in v0.1.0 

func (c *StatuszClient) Close()

Close tears down the port-forward.

func (*StatuszClient) Parking added in v0.1.0 

func (c *StatuszClient) Parking(ctx context.Context) (*ParkingStatusz, error)

Parking fetches the current request-parking snapshot.

type SubstrateFixture added in v0.1.0 

type SubstrateFixture struct {
	// Atespace and Name locate the ActorTemplate for GetActorTemplate.
	Atespace string
	Name     string
	// PoolNamespace and PoolName locate the WorkerPool CRD.
	PoolNamespace string
	PoolName      string
	// DeployWith is the install flag or script that creates the fixture, so a
	// missing one reports how to fix it rather than just failing.
	DeployWith string
}

SubstrateFixture identifies an installed substrate ActorTemplate (the proto resource created through the ate API, not the CRD) plus the CRD WorkerPool backing it. Suites copy the resolved runtime — container images, sandbox config, sandbox size — out of the template, and the ateom image and sandbox class out of the pool.

func SubstrateCounterFixture added in v0.1.0 

func SubstrateCounterFixture() SubstrateFixture

SubstrateCounterFixture returns the substrate-resource counter demo for the sandbox class under test. E2E_SUBSTRATE_TEMPLATE_ATESPACE / E2E_SUBSTRATE_TEMPLATE_NAME / E2E_SUBSTRATE_POOL_NAMESPACE / E2E_SUBSTRATE_POOL_NAME override it, for a cluster that installs the fixture somewhere else.

type SubstrateFixtureManifests added in v0.1.0 

type SubstrateFixtureManifests struct {
	// Pool declares the k8s side: a Namespace plus the WorkerPool CRD.
	Pool string
	// Template declares one or more protojson-shaped ActorTemplate
	// documents, separated by ---.
	Template string
}

SubstrateFixtureManifests names the two manifest templates a substrate fixture is built from (both repo-relative, under internal/e2e/fixtures).

type SubstrateTemplateOptions added in v0.1.0 

type SubstrateTemplateOptions struct {
	// Atespace and Name locate the new template. The atespace is created if
	// missing; Name must be unique within it (atespaces are shared across a
	// suite's tests, unlike the k8s namespaces the CRD templates lived in).
	Atespace string
	Name     string
	// PoolName and PoolReplicas shape the WorkerPool CRD created in the test's
	// k8s namespace.
	PoolName     string
	PoolReplicas int32
	// Labels tie the template's workerSelector to the pool, keeping this
	// pool's workers invisible to other namespaces' actors.
	Labels map[string]string
	// SnapshotsConfig for the new template; nil copies the source's.
	SnapshotsConfig *ateapipb.SnapshotsConfig
	// Modify, when set, edits the template before it is created.
	Modify func(*ateapipb.ActorTemplate)
}

SubstrateTemplateOptions shapes CreateSubstrateTemplateFrom.

Source Files

View all Source files

Directories

Path Synopsis
fixtures
probe command
Command probe is a minimal introspection actor used by the e2e suites.
 Command probe is a minimal introspection actor used by the e2e suites.
testserver command
Command testserver is the one binary behind every plain helper pod the egress e2e suites stand up.
 Command testserver is the one binary behind every plain helper pod the egress e2e suites stand up.

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.