@appthrust/kest 0.1.2 → 0.3.0

package/README.md

@@ -71,6 +71,13 @@ const ns = await s.newNamespace();
 // All resources applied through `ns` are scoped to this namespace.
 ```
 
+You can also specify a custom prefix for the generated namespace name using `generateName`:
+
+```ts
+const ns = await s.newNamespace({ generateName: "foo-" });
+// Namespace name will be like "foo-d7kpn"
+```
+
 ### Automatic Cleanup (Reverse-Order, Blocking)
 
 Resources are deleted in the reverse order they were created (LIFO). Kest waits until each resource is fully removed before proceeding, preventing flaky failures caused by lingering resources or `Terminating` namespaces.
@@ -197,6 +204,61 @@ await ns.assertList<ConfigMap>({
 });
 ```
 
+### Absence Assertions
+
+Assert that a resource does not exist (e.g. after deletion or to verify a controller hasn't created something):
+
+```ts
+await ns.assertAbsence({
+  apiVersion: "v1",
+  kind: "ConfigMap",
+  name: "deleted-config",
+});
+```
+
+With retry-based polling to wait for a resource to disappear:
+
+```ts
+await ns.assertAbsence(
+  {
+    apiVersion: "apps/v1",
+    kind: "Deployment",
+    name: "my-app",
+  },
+  { timeout: "30s", interval: "1s" },
+);
+```
+
+### Label Resources
+
+Add, update, or remove labels on Kubernetes resources using `kubectl label`:
+
+```ts
+await ns.label({
+  apiVersion: "v1",
+  kind: "ConfigMap",
+  name: "my-config",
+  labels: {
+    env: "production",   // add a label
+    deprecated: null,    // remove a label
+  },
+});
+```
+
+To overwrite an existing label, set `overwrite: true`:
+
+```ts
+await ns.label({
+  apiVersion: "apps/v1",
+  kind: "Deployment",
+  name: "my-app",
+  labels: {
+    version: "v2",
+  },
+  overwrite: true,
+});
+```
+
 ### Shell Command Execution
 
 Run arbitrary shell commands with optional revert handlers for cleanup:
@@ -333,21 +395,24 @@ Entry point for defining a test scenario. The callback receives a `Scenario` obj
 
 The top-level API surface available in every test callback.
 
-| Method                                                                  | Description                                      |
-| ----------------------------------------------------------------------- | ------------------------------------------------ |
-| `apply(manifest, options?)`                                             | Apply a Kubernetes manifest and register cleanup |
-| `applyStatus(manifest, options?)`                                       | Apply a status subresource (server-side apply)   |
-| `get(resource, options?)`                                               | Fetch a resource by API version, kind, and name  |
-| `assert(resource, options?)`                                            | Fetch a resource and run assertions with retries |
-| `assertList(resource, options?)`                                        | Fetch a list of resources and run assertions     |
-| `newNamespace(name?, options?)`                                         | Create an ephemeral namespace                    |
-| `exec(input, options?)`                                                 | Execute shell commands with optional revert      |
-| `useCluster(ref)`                                                       | Create a cluster-bound API surface               |
-| `given(desc)` / `when(desc)` / `then(desc)` / `and(desc)` / `but(desc)` | BDD annotations for reporting                    |
+| Method                                                                  | Description                                       |
+| ----------------------------------------------------------------------- | ------------------------------------------------- |
+| `apply(manifest, options?)`                                             | Apply a Kubernetes manifest and register cleanup  |
+| `applyStatus(manifest, options?)`                                       | Apply a status subresource (server-side apply)    |
+| `delete(resource, options?)`                                            | Delete a resource by API version, kind, and name  |
+| `label(input, options?)`                                                | Add, update, or remove labels on a resource       |
+| `get(resource, options?)`                                               | Fetch a resource by API version, kind, and name   |
+| `assert(resource, options?)`                                            | Fetch a resource and run assertions with retries  |
+| `assertAbsence(resource, options?)`                                     | Assert that a resource does not exist             |
+| `assertList(resource, options?)`                                        | Fetch a list of resources and run assertions      |
+| `newNamespace(name?, options?)`                                         | Create an ephemeral namespace (supports `{ generateName }`) |
+| `exec(input, options?)`                                                 | Execute shell commands with optional revert       |
+| `useCluster(ref)`                                                       | Create a cluster-bound API surface                |
+| `given(desc)` / `when(desc)` / `then(desc)` / `and(desc)` / `but(desc)` | BDD annotations for reporting                     |
 
 ### Namespace / Cluster
 
-Returned by `newNamespace()` and `useCluster()` respectively. They expose the same core methods (`apply`, `applyStatus`, `get`, `assert`, `assertList`, `newNamespace`) scoped to their namespace or cluster context.
+Returned by `newNamespace()` and `useCluster()` respectively. They expose the same core methods (`apply`, `applyStatus`, `delete`, `label`, `get`, `assert`, `assertAbsence`, `assertList`) scoped to their namespace or cluster context. `Cluster` additionally supports `newNamespace`.
 
 ### Action Options
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appthrust/kest",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Kubernetes E2E testing framework designed for humans and AI alike",
   "type": "module",
   "module": "ts/index.ts",

package/ts/actions/apply-namespace.ts

@@ -1,13 +1,26 @@
 import { apply } from "./apply";
 import type { MutateDef } from "./types";
 
+/**
+ * Input for namespace creation.
+ *
+ * - `undefined` -- auto-generate a name like `kest-{random}`.
+ * - `string` -- use the exact name provided.
+ * - `{ generateName: string }` -- use the string as a prefix followed by
+ *   random characters (e.g. `{ generateName: "foo-" }` → `"foo-d7kpn"`).
+ */
+export type ApplyNamespaceInput =
+  | undefined
+  | string
+  | { readonly generateName: string };
+
 export const applyNamespace = {
   type: "mutate",
   name: "ApplyNamespace",
   mutate:
     ({ kubectl }) =>
-    async (namespaceName) => {
-      const name = namespaceName ?? `kest-${randomConsonantDigits(5)}`;
+    async (input) => {
+      const name = resolveNamespaceName(input);
       const { revert } = await apply.mutate({ kubectl })({
         apiVersion: "v1",
         kind: "Namespace",
@@ -17,7 +30,17 @@ export const applyNamespace = {
       });
       return { revert, output: name };
     },
-} satisfies MutateDef<undefined | string, string>;
+} satisfies MutateDef<ApplyNamespaceInput, string>;
+
+function resolveNamespaceName(input: ApplyNamespaceInput): string {
+  if (input === undefined) {
+    return `kest-${randomConsonantDigits(5)}`;
+  }
+  if (typeof input === "string") {
+    return input;
+  }
+  return `${input.generateName}${randomConsonantDigits(5)}`;
+}
 
 function randomConsonantDigits(length = 8): string {
   const chars = "bcdfghjklmnpqrstvwxyz0123456789";

package/ts/actions/assert-absence.ts

@@ -0,0 +1,36 @@
+import type { K8sResource, K8sResourceReference } from "../apis";
+import { toKubectlType } from "./kubectl-type";
+import type { Deps, QueryDef } from "./types";
+
+export const assertAbsence = {
+  type: "query",
+  name: "AssertAbsence",
+  query:
+    ({ kubectl }: Deps) =>
+    async <T extends K8sResource>(
+      resource: K8sResourceReference<T>
+    ): Promise<void> => {
+      try {
+        await kubectl.get(toKubectlType(resource), resource.name);
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return;
+        }
+        throw error;
+      }
+      throw new Error(
+        `Expected ${resource.kind} "${resource.name}" to be absent, but it exists`
+      );
+    },
+} satisfies QueryDef<K8sResourceReference, void>;
+
+/**
+ * Checks whether a kubectl error is a "NotFound" error.
+ *
+ * kubectl outputs `Error from server (NotFound):` when the resource does not
+ * exist, and the {@link RealKubectl} wrapper embeds that message in the
+ * thrown `Error`.
+ */
+function isNotFoundError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes("(NotFound)");
+}

package/ts/actions/delete.ts

@@ -0,0 +1,14 @@
+import type { K8sResource, K8sResourceReference } from "../apis";
+import { toKubectlType } from "./kubectl-type";
+import type { OneWayMutateDef } from "./types";
+
+export const deleteResource = {
+  type: "oneWayMutate",
+  name: "Delete",
+  mutate:
+    ({ kubectl }) =>
+    async <T extends K8sResource>(resource: K8sResourceReference<T>) => {
+      await kubectl.delete(toKubectlType(resource), resource.name);
+      return undefined;
+    },
+} satisfies OneWayMutateDef<K8sResourceReference, void>;

package/ts/actions/kubectl-type.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts an `apiVersion` + `kind` pair into the resource type string
+ * expected by kubectl subcommands (e.g. `get`, `delete`, `label`).
+ *
+ * - Core-group resources (`apiVersion: "v1"`) → `"ConfigMap"`
+ * - Non-core resources (`apiVersion: "apps/v1"`) → `"Deployment.v1.apps"`
+ */
+export function toKubectlType(resource: {
+  readonly apiVersion: string;
+  readonly kind: string;
+}): string {
+  const { kind, apiVersion } = resource;
+  const [group, version] = apiVersion.split("/");
+  if (version === undefined) {
+    // core group cannot include version in the type
+    return kind;
+  }
+  return [kind, version, group].filter(Boolean).join(".");
+}

package/ts/actions/label.ts

@@ -0,0 +1,20 @@
+import type { K8sResource, LabelInput } from "../apis";
+import { toKubectlType } from "./kubectl-type";
+import type { OneWayMutateDef } from "./types";
+
+export const label = {
+  type: "oneWayMutate",
+  name: "Label",
+  mutate:
+    ({ kubectl }) =>
+    async <T extends K8sResource>(input: LabelInput<T>) => {
+      const overrideContext = input.namespace
+        ? { namespace: input.namespace }
+        : undefined;
+      await kubectl.label(toKubectlType(input), input.name, input.labels, {
+        overwrite: input.overwrite,
+        context: overrideContext,
+      });
+      return undefined;
+    },
+} satisfies OneWayMutateDef<LabelInput, void>;

package/ts/apis/index.ts

@@ -13,7 +13,8 @@ import type { $ as BunDollar } from "bun";
  * Some actions also register cleanup ("revert") handlers which run during
  * scenario cleanup. For example, {@link Scenario.apply} registers a revert that
  * deletes the applied resource. One-way mutations such as
- * {@link Scenario.applyStatus} do not register a revert.
+ * {@link Scenario.applyStatus} and {@link Scenario.delete} do not register a
+ * revert.
  */
 
 /**
@@ -88,6 +89,63 @@ export interface Scenario {
     options?: undefined | ActionOptions
   ): Promise<void>;
 
+  /**
+   * Deletes a Kubernetes resource using `kubectl delete`.
+   *
+   * This action is retried when it throws.
+   *
+   * Note: this is a one-way mutation and does not register a cleanup handler.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param resource - Group/version/kind and name of the resource to delete.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await s.delete({
+   *   apiVersion: "v1",
+   *   kind: "ConfigMap",
+   *   name: "my-config",
+   * });
+   * ```
+   */
+  delete<T extends K8sResource>(
+    resource: K8sResourceReference<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
+  /**
+   * Adds, updates, or removes labels on a Kubernetes resource using
+   * `kubectl label`.
+   *
+   * Set a label value to a string to add/update it, or to `null` to remove it.
+   *
+   * This action is retried when it throws.
+   *
+   * Note: this is a one-way mutation and does not register a cleanup handler.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param input - Resource reference and label changes.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await s.label({
+   *   apiVersion: "v1",
+   *   kind: "ConfigMap",
+   *   name: "my-config",
+   *   labels: {
+   *     env: "production",  // add or update
+   *     deprecated: null,   // remove
+   *   },
+   * });
+   * ```
+   */
+  label<T extends K8sResource>(
+    input: LabelInput<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
   /**
    * Fetches a Kubernetes resource and returns it as a typed object.
    *
@@ -150,6 +208,32 @@ export interface Scenario {
     options?: undefined | ActionOptions
   ): Promise<T>;
 
+  /**
+   * Asserts that a Kubernetes resource does not exist.
+   *
+   * Internally, this uses `kubectl get` and expects it to fail with a
+   * "not found" error. If the resource exists, the assertion fails.
+   *
+   * This action is retried until the resource is absent or a timeout expires.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param resource - Group/version/kind and name of the resource.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await s.assertAbsence({
+   *   apiVersion: "v1",
+   *   kind: "ConfigMap",
+   *   name: "deleted-config",
+   * });
+   * ```
+   */
+  assertAbsence<T extends K8sResource>(
+    resource: K8sResourceReference<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
   /**
    * Lists Kubernetes resources of a given type and runs a test function.
    *
@@ -186,7 +270,11 @@ export interface Scenario {
    * `kest-abc12`). The namespace creation is a mutating action that registers a
    * cleanup handler; the namespace is deleted during scenario cleanup.
    *
-   * @param name - Optional namespace name to create.
+   * You can also pass `{ generateName: "prefix-" }` to generate a name with a
+   * custom prefix (e.g. `"prefix-d7kpn"`).
+   *
+   * @param name - Optional namespace name, or `{ generateName }` for prefixed
+   *   generation.
    * @param options - Retry options such as timeout and polling interval.
    *
    * @example
@@ -199,9 +287,15 @@ export interface Scenario {
    *   data: { mode: "namespaced" },
    * });
    * ```
+   *
+   * @example
+   * ```ts
+   * // Generate a namespace with a custom prefix (e.g. "foo-d7kpn")
+   * const ns = await s.newNamespace({ generateName: "foo-" });
+   * ```
    */
   newNamespace(
-    name?: undefined | string,
+    name?: undefined | string | { readonly generateName: string },
     options?: undefined | ActionOptions
   ): Promise<Namespace>;
 
@@ -370,6 +464,54 @@ export interface Cluster {
     options?: undefined | ActionOptions
   ): Promise<void>;
 
+  /**
+   * Deletes a Kubernetes resource in this cluster using `kubectl delete`.
+   *
+   * This action is retried when it throws.
+   *
+   * Note: this is a one-way mutation and does not register a cleanup handler.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param resource - Group/version/kind and name of the resource to delete.
+   * @param options - Retry options such as timeout and polling interval.
+   */
+  delete<T extends K8sResource>(
+    resource: K8sResourceReference<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
+  /**
+   * Adds, updates, or removes labels on a Kubernetes resource in this cluster
+   * using `kubectl label`.
+   *
+   * Set a label value to a string to add/update it, or to `null` to remove it.
+   *
+   * This action is retried when it throws.
+   *
+   * Note: this is a one-way mutation and does not register a cleanup handler.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param input - Resource reference and label changes.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await cluster.label({
+   *   apiVersion: "v1",
+   *   kind: "Namespace",
+   *   name: "my-team",
+   *   labels: {
+   *     team: "backend",
+   *     deprecated: null,
+   *   },
+   * });
+   * ```
+   */
+  label<T extends K8sResource>(
+    input: LabelInput<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
   /**
    * Fetches a Kubernetes resource by GVK and name.
    *
@@ -415,6 +557,27 @@ export interface Cluster {
     options?: undefined | ActionOptions
   ): Promise<T>;
 
+  /**
+   * Asserts that a Kubernetes resource does not exist in this cluster.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param resource - Group/version/kind and name of the resource.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await cluster.assertAbsence({
+   *   apiVersion: "v1",
+   *   kind: "Namespace",
+   *   name: "deleted-ns",
+   * });
+   * ```
+   */
+  assertAbsence<T extends K8sResource>(
+    resource: K8sResourceReference<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
   /**
    * Lists Kubernetes resources of a given type and runs a test function.
    *
@@ -441,7 +604,8 @@ export interface Cluster {
   /**
    * Creates a new namespace in this cluster and returns a namespaced API.
    *
-   * @param name - Optional namespace name to create.
+   * @param name - Optional namespace name, or `{ generateName }` for prefixed
+   *   generation.
    * @param options - Retry options such as timeout and polling interval.
    *
    * @example
@@ -454,9 +618,15 @@ export interface Cluster {
    *   data: { mode: "from-cluster" },
    * });
    * ```
+   *
+   * @example
+   * ```ts
+   * // Generate a namespace with a custom prefix
+   * const ns = await cluster.newNamespace({ generateName: "foo-" });
+   * ```
    */
   newNamespace(
-    name?: undefined | string,
+    name?: undefined | string | { readonly generateName: string },
     options?: undefined | ActionOptions
   ): Promise<Namespace>;
 }
@@ -480,6 +650,11 @@ export interface Cluster {
  *   causes `kubectl` to fail.
  */
 export interface Namespace {
+  /**
+   * The name of this namespace (e.g. `"kest-abc12"`).
+   */
+  readonly name: string;
+
   /**
    * Applies a Kubernetes manifest in this namespace and registers cleanup.
    *
@@ -534,6 +709,56 @@ export interface Namespace {
     options?: undefined | ActionOptions
   ): Promise<void>;
 
+  /**
+   * Deletes a Kubernetes resource in this namespace using `kubectl delete`.
+   *
+   * This action is retried when it throws.
+   *
+   * Note: this is a one-way mutation and does not register a cleanup handler.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param resource - Group/version/kind and name of the resource to delete.
+   * @param options - Retry options such as timeout and polling interval.
+   */
+  delete<T extends K8sResource>(
+    resource: K8sResourceReference<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
+  /**
+   * Adds, updates, or removes labels on a namespaced Kubernetes resource using
+   * `kubectl label`.
+   *
+   * The target namespace is controlled by this {@link Namespace} instance.
+   *
+   * Set a label value to a string to add/update it, or to `null` to remove it.
+   *
+   * This action is retried when it throws.
+   *
+   * Note: this is a one-way mutation and does not register a cleanup handler.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param input - Resource reference and label changes.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await ns.label({
+   *   apiVersion: "v1",
+   *   kind: "ConfigMap",
+   *   name: "my-config",
+   *   labels: {
+   *     env: "production",
+   *     deprecated: null,
+   *   },
+   * });
+   * ```
+   */
+  label<T extends K8sResource>(
+    input: LabelInput<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
   /**
    * Fetches a namespaced Kubernetes resource by GVK and name.
    *
@@ -579,6 +804,27 @@ export interface Namespace {
     options?: undefined | ActionOptions
   ): Promise<T>;
 
+  /**
+   * Asserts that a namespaced Kubernetes resource does not exist.
+   *
+   * @template T - The expected Kubernetes resource shape.
+   * @param resource - Group/version/kind and name of the resource.
+   * @param options - Retry options such as timeout and polling interval.
+   *
+   * @example
+   * ```ts
+   * await ns.assertAbsence({
+   *   apiVersion: "v1",
+   *   kind: "ConfigMap",
+   *   name: "deleted-config",
+   * });
+   * ```
+   */
+  assertAbsence<T extends K8sResource>(
+    resource: K8sResourceReference<T>,
+    options?: undefined | ActionOptions
+  ): Promise<void>;
+
   /**
    * Lists namespaced Kubernetes resources of a given type and runs a test.
    *
@@ -679,6 +925,57 @@ export interface K8sResourceReference<T extends K8sResource = K8sResource> {
   readonly name: string;
 }
 
+/**
+ * Input for {@link Scenario.label}, {@link Cluster.label}, and
+ * {@link Namespace.label}.
+ *
+ * Identifies a Kubernetes resource and the label changes to apply.
+ *
+ * - A label value of `string` adds or updates the label.
+ * - A label value of `null` removes the label.
+ */
+export interface LabelInput<T extends K8sResource = K8sResource> {
+  /**
+   * Kubernetes API version (e.g. `"v1"`, `"apps/v1"`).
+   */
+  readonly apiVersion: T["apiVersion"];
+
+  /**
+   * Kubernetes kind (e.g. `"ConfigMap"`, `"Deployment"`).
+   */
+  readonly kind: T["kind"];
+
+  /**
+   * `metadata.name` of the target resource.
+   */
+  readonly name: string;
+
+  /**
+   * Optional namespace override.
+   *
+   * When used on a {@link Namespace}-scoped API surface the namespace is
+   * already set; this field is mainly useful at the {@link Scenario} or
+   * {@link Cluster} level for namespaced resources.
+   */
+  readonly namespace?: undefined | string;
+
+  /**
+   * Label mutations to apply.
+   *
+   * - `"value"` -- add or update the label to the given value.
+   * - `null` -- remove the label.
+   */
+  readonly labels: Readonly<Record<string, string | null>>;
+
+  /**
+   * When `true`, passes `--overwrite` to allow updating labels that already
+   * exist on the resource.
+   *
+   * @default false
+   */
+  readonly overwrite?: undefined | boolean;
+}
+
 /**
  * A test definition for {@link Scenario.assert}.
  */

package/ts/kubectl/index.ts

@@ -135,6 +135,26 @@ export interface Kubectl {
     name: string,
     options?: KubectlDeleteOptions
   ): Promise<string>;
+
+  /**
+   * Adds, updates, or removes labels on a Kubernetes resource using
+   * `kubectl label <resource>/<name> key=value ... [--overwrite]`.
+   *
+   * Labels with a `null` value are removed (emitted as `key-`).
+   *
+   * @param resource - The resource type (e.g., "configmap", "deployment.v1.apps")
+   * @param name - The name of the resource to label
+   * @param labels - Label mutations (string to set, null to remove)
+   * @param options - Optional label options (overwrite, context)
+   * @returns The trimmed stdout from kubectl
+   * @throws Error if kubectl exits with non-zero code
+   */
+  label(
+    resource: string,
+    name: string,
+    labels: Readonly<Record<string, string | null>>,
+    options?: KubectlLabelOptions
+  ): Promise<string>;
 }
 
 export interface KubectlDeleteOptions {
@@ -146,6 +166,15 @@ export interface KubectlDeleteOptions {
   readonly context?: undefined | KubectlContext;
 }
 
+export interface KubectlLabelOptions {
+  /**
+   * If true, adds `--overwrite` to allow updating labels that already
+   * exist on the resource.
+   */
+  readonly overwrite?: undefined | boolean;
+  readonly context?: undefined | KubectlContext;
+}
+
 export class RealKubectl implements Kubectl {
   private readonly recorder: Recorder;
   private readonly cwd: undefined | string;
@@ -283,6 +312,31 @@ export class RealKubectl implements Kubectl {
     });
   }
 
+  async label(
+    resource: string,
+    name: string,
+    labels: Readonly<Record<string, string | null>>,
+    options?: KubectlLabelOptions
+  ): Promise<string> {
+    const args: [string, ...Array<string>] = ["label", `${resource}/${name}`];
+    for (const [key, value] of Object.entries(labels)) {
+      if (value === null) {
+        args.push(`${key}-`);
+      } else {
+        args.push(`${key}=${value}`);
+      }
+    }
+    if (options?.overwrite) {
+      args.push("--overwrite");
+    }
+    return await this.runKubectl({
+      args,
+      stdoutLanguage: "text",
+      stderrLanguage: "text",
+      overrideContext: options?.context,
+    });
+  }
+
   private async runKubectl(params: ExecParams): Promise<string> {
     const cmd = "kubectl";
     const ctx = { ...this.defaultContext, ...params.overrideContext };

package/ts/scenario/index.ts

@@ -1,10 +1,16 @@
 import { apply } from "../actions/apply";
-import { applyNamespace } from "../actions/apply-namespace";
+import {
+  type ApplyNamespaceInput,
+  applyNamespace,
+} from "../actions/apply-namespace";
 import { applyStatus } from "../actions/apply-status";
 import { assert } from "../actions/assert";
+import { assertAbsence } from "../actions/assert-absence";
 import { assertList } from "../actions/assert-list";
+import { deleteResource } from "../actions/delete";
 import { exec } from "../actions/exec";
 import { get } from "../actions/get";
+import { label } from "../actions/label";
 import type { MutateDef, OneWayMutateDef, QueryDef } from "../actions/types";
 import type {
   ActionOptions,
@@ -31,9 +37,12 @@ export function createScenario(deps: CreateScenarioOptions): InternalScenario {
   return {
     apply: createMutateFn(deps, apply),
     applyStatus: createOneWayMutateFn(deps, applyStatus),
+    delete: createOneWayMutateFn(deps, deleteResource),
+    label: createOneWayMutateFn(deps, label),
     exec: createMutateFn(deps, exec),
     get: createQueryFn(deps, get),
     assert: createQueryFn(deps, assert),
+    assertAbsence: createQueryFn(deps, assertAbsence),
     assertList: createQueryFn(deps, assertList),
     given: bdd.given(deps),
     when: bdd.when(deps),
@@ -180,7 +189,7 @@ const createQueryFn =
 const createNewNamespaceFn =
   (scenarioDeps: CreateScenarioOptions) =>
   async (
-    name?: undefined | string,
+    name?: ApplyNamespaceInput,
     options?: undefined | ActionOptions
   ): Promise<Namespace> => {
     const namespaceName = await createMutateFn(scenarioDeps, applyNamespace)(
@@ -191,10 +200,14 @@ const createNewNamespaceFn =
     const namespacedKubectl = kubectl.extends({ namespace: namespaceName });
     const namespacedDeps = { ...scenarioDeps, kubectl: namespacedKubectl };
     return {
+      name: namespaceName,
       apply: createMutateFn(namespacedDeps, apply),
       applyStatus: createOneWayMutateFn(namespacedDeps, applyStatus),
+      delete: createOneWayMutateFn(namespacedDeps, deleteResource),
+      label: createOneWayMutateFn(namespacedDeps, label),
       get: createQueryFn(namespacedDeps, get),
       assert: createQueryFn(namespacedDeps, assert),
+      assertAbsence: createQueryFn(namespacedDeps, assertAbsence),
       assertList: createQueryFn(namespacedDeps, assertList),
     };
   };
@@ -212,8 +225,11 @@ const createUseClusterFn =
     return {
       apply: createMutateFn(clusterDeps, apply),
       applyStatus: createOneWayMutateFn(clusterDeps, applyStatus),
+      delete: createOneWayMutateFn(clusterDeps, deleteResource),
+      label: createOneWayMutateFn(clusterDeps, label),
       get: createQueryFn(clusterDeps, get),
       assert: createQueryFn(clusterDeps, assert),
+      assertAbsence: createQueryFn(clusterDeps, assertAbsence),
       assertList: createQueryFn(clusterDeps, assertList),
       newNamespace: createNewNamespaceFn(clusterDeps),
     };