pepr 0.34.1 → 0.36.0

package/src/lib/queue.test.ts

@@ -1,58 +1,152 @@
-import { beforeEach, describe, expect, jest, test } from "@jest/globals";
-import { KubernetesObject } from "@kubernetes/client-node";
+import { afterEach, describe, expect, jest, it } from "@jest/globals";
 import { WatchPhase } from "kubernetes-fluent-client/dist/fluent/types";
 import { Queue } from "./queue";
 
+import Log from "./logger";
+jest.mock("./logger");
+
 describe("Queue", () => {
-  let queue: Queue<KubernetesObject>;
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("is uniquely identifiable", () => {
+    const name = "kind/namespace";
+    const queue = new Queue(name);
+
+    const label = queue.label();
+
+    expect(label).toEqual(
+      expect.objectContaining({
+        // given name of queue
+        name,
+
+        // unique, generated value (to disambiguate similarly-named queues)
+        // <epoch timestamp (ms)>-<4 char hex>
+        uid: expect.stringMatching(/[0-9]{13}-[0-9a-f]{4}/),
+      }),
+    );
+  });
+
+  it("exposes runtime stats", async () => {
+    const name = "kind/namespace";
+    const queue = new Queue(name);
+
+    expect(queue.stats()).toEqual(
+      expect.objectContaining({
+        queue: queue.label(),
+        stats: { length: 0 },
+      }),
+    );
+
+    const kubeObj = { metadata: { name: "test-nm", namespace: "test-ns" } };
+    const watchCb = () =>
+      new Promise<void>(res => {
+        setTimeout(res, 100);
+      });
+
+    await Promise.all([
+      queue.enqueue(kubeObj, WatchPhase.Added, watchCb),
+      queue.enqueue(kubeObj, WatchPhase.Added, watchCb),
+      queue.enqueue(kubeObj, WatchPhase.Added, watchCb),
+      queue.enqueue(kubeObj, WatchPhase.Added, watchCb),
+    ]);
+
+    const logDebug = Log.debug as jest.Mock;
+    const stats = logDebug.mock.calls
+      .flat()
+      .map(m => JSON.stringify(m))
+      .filter(m => m.includes('"stats":'));
 
-  beforeEach(() => {
-    queue = new Queue();
+    [
+      '"length":1', // 1st entry runs near-immediately, so queue won't fill
+      '"length":1', // afterward, queue fills & unfills as callbacks process
+      '"length":2',
+      '"length":3',
+      '"length":3',
+      '"length":2',
+      '"length":1',
+      '"length":0',
+    ].map((exp, idx) => {
+      expect(stats[idx]).toEqual(expect.stringContaining(exp));
+    });
   });
 
-  test("enqueue should add a pod to the queue and return a promise", async () => {
-    const pod = {
-      metadata: { name: "test-pod", namespace: "test-pod" },
-    };
-    const promise = queue.enqueue(pod, WatchPhase.Added);
+  it("resolves when an enqueued event dequeues without error", async () => {
+    const name = "kind/namespace";
+    const queue = new Queue(name);
+
+    const kubeObj = { metadata: { name: "test-nm", namespace: "test-ns" } };
+    const watchCb = () =>
+      new Promise<void>(res => {
+        setTimeout(res, 10);
+      });
+
+    const promise = queue.enqueue(kubeObj, WatchPhase.Added, watchCb);
     expect(promise).toBeInstanceOf(Promise);
-    await promise;
+
+    await expect(promise).resolves.not.toThrow();
   });
 
-  test("dequeue should process pods in FIFO order", async () => {
-    const mockPod = {
-      metadata: { name: "test-pod", namespace: "test-namespace" },
-    };
-    const mockPod2 = {
-      metadata: { name: "test-pod-2", namespace: "test-namespace-2" },
-    };
-
-    // Enqueue two packages
-    const promise1 = queue.enqueue(mockPod, WatchPhase.Added);
-    const promise2 = queue.enqueue(mockPod2, WatchPhase.Modified);
-
-    // Wait for both promises to resolve
-    await promise1;
-    await promise2;
+  it("rejects when an enqueued event dequeues with error", async () => {
+    const name = "kind/namespace";
+    const queue = new Queue(name);
+
+    const kubeObj = { metadata: { name: "test-nm", namespace: "test-ns" } };
+    const watchCb = () =>
+      new Promise<void>((_, reject) => {
+        setTimeout(() => {
+          reject("oof");
+        }, 10);
+      });
+
+    const promise = queue.enqueue(kubeObj, WatchPhase.Added, watchCb);
+    expect(promise).toBeInstanceOf(Promise);
+
+    await expect(promise).rejects.toBe("oof");
   });
 
-  test("dequeue should handle errors in pod processing", async () => {
-    const mockPod = {
-      metadata: { name: "test-pod", namespace: "test-namespace" },
-    };
-    const error = new Error("reconciliation failed");
-    jest.spyOn(queue, "setReconcile").mockRejectedValueOnce(error as never);
-
-    try {
-      await queue.enqueue(mockPod, WatchPhase.Added);
-    } catch (e) {
-      expect(e).toBe(error);
-    }
-
-    // Ensure that the queue is ready to process the next pod
-    const mockPod2 = {
-      metadata: { name: "test-pod-2", namespace: "test-namespace-2" },
-    };
-    await queue.enqueue(mockPod2, WatchPhase.Modified);
+  it("processes events in FIFO order", async () => {
+    const name = "kind/namespace";
+    const queue = new Queue(name);
+
+    const kubeObj = { metadata: { name: "test-nm", namespace: "test-ns" } };
+    const watchA = () =>
+      new Promise<void>(resolve => {
+        setTimeout(() => {
+          Log.info("watchA");
+          resolve();
+        }, 15);
+      });
+    const watchB = () =>
+      new Promise<void>(resolve => {
+        setTimeout(() => {
+          Log.info("watchB");
+          resolve();
+        }, 10);
+      });
+    const watchC = () =>
+      new Promise<void>(resolve => {
+        setTimeout(() => {
+          Log.info("watchC");
+          resolve();
+        }, 5);
+      });
+
+    await Promise.all([
+      queue.enqueue(kubeObj, WatchPhase.Added, watchA),
+      queue.enqueue(kubeObj, WatchPhase.Added, watchB),
+      queue.enqueue(kubeObj, WatchPhase.Added, watchC),
+    ]);
+
+    const logInfo = Log.info as jest.Mock;
+    const calls = logInfo.mock.calls
+      .flat()
+      .map(m => JSON.stringify(m))
+      .filter(m => /"watch[ABC]"/.test(m));
+
+    ['"watchA"', '"watchB"', '"watchC"'].map((exp, idx) => {
+      expect(calls[idx]).toEqual(expect.stringContaining(exp));
+    });
   });
 });

package/src/lib/queue.ts

@@ -2,11 +2,15 @@
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 import { KubernetesObject } from "@kubernetes/client-node";
 import { WatchPhase } from "kubernetes-fluent-client/dist/fluent/types";
+import { randomBytes } from "node:crypto";
 import Log from "./logger";
 
+type WatchCallback = (obj: KubernetesObject, phase: WatchPhase) => Promise<void>;
+
 type QueueItem<K extends KubernetesObject> = {
   item: K;
-  type: WatchPhase;
+  phase: WatchPhase;
+  callback: WatchCallback;
   resolve: (value: void | PromiseLike<void>) => void;
   reject: (reason?: string) => void;
 };
@@ -15,16 +19,27 @@ type QueueItem<K extends KubernetesObject> = {
  * Queue is a FIFO queue for reconciling
  */
 export class Queue<K extends KubernetesObject> {
+  #name: string;
+  #uid: string;
   #queue: QueueItem<K>[] = [];
   #pendingPromise = false;
-  #reconcile?: (obj: KubernetesObject, type: WatchPhase) => Promise<void>;
 
-  constructor() {
-    this.#reconcile = async () => await new Promise(resolve => resolve());
+  constructor(name: string) {
+    this.#name = name;
+    this.#uid = `${Date.now()}-${randomBytes(2).toString("hex")}`;
+  }
+
+  label() {
+    return { name: this.#name, uid: this.#uid };
   }
 
-  setReconcile(reconcile: (obj: KubernetesObject, type: WatchPhase) => Promise<void>) {
-    this.#reconcile = reconcile;
+  stats() {
+    return {
+      queue: this.label(),
+      stats: {
+        length: this.#queue.length,
+      },
+    };
   }
 
   /**
@@ -32,12 +47,23 @@ export class Queue<K extends KubernetesObject> {
    * reconciled.
    *
    * @param item The object to reconcile
+   * @param type The watch phase requested for reconcile
+   * @param reconcile The callback to enqueue for reconcile
    * @returns A promise that resolves when the object is reconciled
    */
-  enqueue(item: K, type: WatchPhase) {
-    Log.debug(`Enqueueing ${item.metadata!.namespace}/${item.metadata!.name}`);
+  enqueue(item: K, phase: WatchPhase, reconcile: WatchCallback) {
+    const note = {
+      queue: this.label(),
+      item: {
+        name: item.metadata?.name,
+        namespace: item.metadata?.namespace,
+        resourceVersion: item.metadata?.resourceVersion,
+      },
+    };
+    Log.debug(note, "Enqueueing");
     return new Promise<void>((resolve, reject) => {
-      this.#queue.push({ item, type, resolve, reject });
+      this.#queue.push({ item, phase, callback: reconcile, resolve, reject });
+      Log.debug(this.stats(), "Queue stats - push");
       return this.#dequeue();
     });
   }
@@ -68,16 +94,25 @@ export class Queue<K extends KubernetesObject> {
       this.#pendingPromise = true;
 
       // Reconcile the element
-      if (this.#reconcile) {
-        Log.debug(`Reconciling ${element.item.metadata!.name}`);
-        await this.#reconcile(element.item, element.type);
-      }
+      const note = {
+        queue: this.label(),
+        item: {
+          name: element.item.metadata?.name,
+          namespace: element.item.metadata?.namespace,
+          resourceVersion: element.item.metadata?.resourceVersion,
+        },
+      };
+      Log.debug(note, "Reconciling");
+      await element.callback(element.item, element.phase);
+      Log.debug(note, "Reconciled");
 
       element.resolve();
     } catch (e) {
       Log.debug(`Error reconciling ${element.item.metadata!.name}`, { error: e });
       element.reject(e);
     } finally {
+      Log.debug(this.stats(), "Queue stats - shift");
+
       // Reset the pending promise flag
       Log.debug("Resetting pending promise and dequeuing");
       this.#pendingPromise = false;

package/src/lib/types.ts

@@ -94,6 +94,7 @@ export type Binding = {
     namespaces: string[];
     labels: Record<string, string>;
     annotations: Record<string, string>;
+    deletionTimestamp: boolean;
   };
   readonly mutateCallback?: MutateAction<GenericClass, InstanceType<GenericClass>>;
   readonly validateCallback?: ValidateAction<GenericClass, InstanceType<GenericClass>>;
@@ -137,6 +138,8 @@ export type BindingFilter<T extends GenericClass> = CommonActionChain<T> & {
    * @param value
    */
   WithAnnotation: (key: string, value?: string) => BindingFilter<T>;
+  /** Only apply the action if the resource has a deletionTimestamp. */
+  WithDeletionTimestamp: () => BindingFilter<T>;
 };
 
 export type BindingWithName<T extends GenericClass> = BindingFilter<T> & {

package/src/lib/watch-processor.test.ts

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { afterAll, beforeEach, describe, expect, it, jest } from "@jest/globals";
 import { GenericClass, K8s, KubernetesObject, kind } from "kubernetes-fluent-client";
 import { K8sInit, WatchPhase } from "kubernetes-fluent-client/dist/fluent/types";
 import { WatchCfg, WatchEvent, Watcher } from "kubernetes-fluent-client/dist/fluent/watch";
 import { Capability } from "./capability";
-import { setupWatch, logEvent } from "./watch-processor";
+import { setupWatch, logEvent, queueKey, getOrCreateQueue } from "./watch-processor";
 import Log from "./logger";
 import { metricsCollector } from "./metrics";
 
@@ -40,6 +40,7 @@ describe("WatchProcessor", () => {
       bindings: [
         {
           isWatch: true,
+          isQueue: false,
           model: "someModel",
           filters: {},
           event: "Create",
@@ -88,13 +89,20 @@ describe("WatchProcessor", () => {
       resyncFailureMax: 5,
       resyncDelaySec: 5,
       lastSeenLimitSeconds: 300,
-      relistIntervalSec: 1800,
+      relistIntervalSec: 600,
     };
 
     capabilities.push({
       bindings: [
-        { isWatch: true, model: "someModel", filters: { name: "bleh" }, event: "Create", watchCallback: jest.fn() },
-        { isWatch: false, model: "someModel", filters: {}, event: "Create", watchCallback: jest.fn() },
+        {
+          isWatch: true,
+          isQueue: true,
+          model: "someModel",
+          filters: { name: "bleh" },
+          event: "Create",
+          watchCallback: jest.fn(),
+        },
+        { isWatch: false, isQueue: false, model: "someModel", filters: {}, event: "Create", watchCallback: jest.fn() },
       ],
     } as unknown as Capability);
 
@@ -320,3 +328,91 @@ describe("logEvent function", () => {
     expect(Log.debug).toHaveBeenCalledWith(`Watch event ${WatchEvent.DATA_ERROR} received. ${message}.`);
   });
 });
+
+describe("queueKey", () => {
+  const withKindNsName = { kind: "Pod", metadata: { namespace: "my-ns", name: "my-name" } } as KubernetesObject;
+  const withKindNs = { kind: "Pod", metadata: { namespace: "my-ns" } } as KubernetesObject;
+  const withKindName = { kind: "Pod", metadata: { name: "my-name" } } as KubernetesObject;
+  const withNsName = { metadata: { namespace: "my-ns", name: "my-name" } } as KubernetesObject;
+  const withKind = { kind: "Pod" } as KubernetesObject;
+  const withNs = { metadata: { namespace: "my-ns" } } as KubernetesObject;
+  const withName = { metadata: { name: "my-name" } } as KubernetesObject;
+  const withNone = {} as KubernetesObject;
+
+  const original = process.env.PEPR_RECONCILE_STRATEGY;
+
+  it.each([
+    ["kind", withKindNsName, "Pod"],
+    ["kind", withKindNs, "Pod"],
+    ["kind", withKindName, "Pod"],
+    ["kind", withNsName, "UnknownKind"],
+    ["kind", withKind, "Pod"],
+    ["kind", withNs, "UnknownKind"],
+    ["kind", withName, "UnknownKind"],
+    ["kind", withNone, "UnknownKind"],
+    ["kindNs", withKindNsName, "Pod/my-ns"],
+    ["kindNs", withKindNs, "Pod/my-ns"],
+    ["kindNs", withKindName, "Pod/cluster-scoped"],
+    ["kindNs", withNsName, "UnknownKind/my-ns"],
+    ["kindNs", withKind, "Pod/cluster-scoped"],
+    ["kindNs", withNs, "UnknownKind/my-ns"],
+    ["kindNs", withName, "UnknownKind/cluster-scoped"],
+    ["kindNs", withNone, "UnknownKind/cluster-scoped"],
+    ["kindNsName", withKindNsName, "Pod/my-ns/my-name"],
+    ["kindNsName", withKindNs, "Pod/my-ns/Unnamed"],
+    ["kindNsName", withKindName, "Pod/cluster-scoped/my-name"],
+    ["kindNsName", withNsName, "UnknownKind/my-ns/my-name"],
+    ["kindNsName", withKind, "Pod/cluster-scoped/Unnamed"],
+    ["kindNsName", withNs, "UnknownKind/my-ns/Unnamed"],
+    ["kindNsName", withName, "UnknownKind/cluster-scoped/my-name"],
+    ["kindNsName", withNone, "UnknownKind/cluster-scoped/Unnamed"],
+    ["global", withKindNsName, "global"],
+    ["global", withKindNs, "global"],
+    ["global", withKindName, "global"],
+    ["global", withNsName, "global"],
+    ["global", withKind, "global"],
+    ["global", withNs, "global"],
+    ["global", withName, "global"],
+    ["global", withNone, "global"],
+  ])("PEPR_RECONCILE_STRATEGY='%s' over '%j' becomes '%s'", (strat, obj, key) => {
+    process.env.PEPR_RECONCILE_STRATEGY = strat;
+    expect(queueKey(obj)).toBe(key);
+  });
+
+  afterAll(() => {
+    process.env.PEPR_RECONCILE_STRATEGY = original;
+  });
+});
+
+describe("getOrCreateQueue", () => {
+  it("creates a Queue instance on first call", () => {
+    const obj: KubernetesObject = {
+      kind: "queue",
+      metadata: {
+        name: "nm",
+        namespace: "ns",
+      },
+    };
+
+    const firstQueue = getOrCreateQueue(obj);
+    expect(firstQueue.label()).toBeDefined();
+  });
+
+  it("returns same Queue instance on subsequent calls", () => {
+    const obj: KubernetesObject = {
+      kind: "queue",
+      metadata: {
+        name: "nm",
+        namespace: "ns",
+      },
+    };
+
+    const firstQueue = getOrCreateQueue(obj);
+    expect(firstQueue.label()).toBeDefined();
+
+    const secondQueue = getOrCreateQueue(obj);
+    expect(secondQueue.label()).toBeDefined();
+
+    expect(firstQueue).toBe(secondQueue);
+  });
+});

package/src/lib/watch-processor.ts

@@ -9,6 +9,43 @@ import { Queue } from "./queue";
 import { Binding, Event } from "./types";
 import { metricsCollector } from "./metrics";
 
+// stores Queue instances
+const queues: Record<string, Queue<KubernetesObject>> = {};
+
+/**
+ * Get the key for an entry in the queues
+ *
+ * @param obj The object to derive a key from
+ * @returns The key to a Queue in the list of queues
+ */
+export function queueKey(obj: KubernetesObject) {
+  const options = ["kind", "kindNs", "kindNsName", "global"];
+  const d3fault = "kind";
+
+  let strat = process.env.PEPR_RECONCILE_STRATEGY || d3fault;
+  strat = options.includes(strat) ? strat : d3fault;
+
+  const ns = obj.metadata?.namespace ?? "cluster-scoped";
+  const kind = obj.kind ?? "UnknownKind";
+  const name = obj.metadata?.name ?? "Unnamed";
+
+  const lookup: Record<string, string> = {
+    kind: `${kind}`,
+    kindNs: `${kind}/${ns}`,
+    kindNsName: `${kind}/${ns}/${name}`,
+    global: "global",
+  };
+  return lookup[strat];
+}
+
+export function getOrCreateQueue(obj: KubernetesObject) {
+  const key = queueKey(obj);
+  if (!queues[key]) {
+    queues[key] = new Queue<KubernetesObject>(key);
+  }
+  return queues[key];
+}
+
 // Watch configuration
 const watchCfg: WatchCfg = {
   resyncFailureMax: process.env.PEPR_RESYNC_FAILURE_MAX ? parseInt(process.env.PEPR_RESYNC_FAILURE_MAX, 10) : 5,
@@ -18,7 +55,7 @@ const watchCfg: WatchCfg = {
     : 300,
   relistIntervalSec: process.env.PEPR_RELIST_INTERVAL_SECONDS
     ? parseInt(process.env.PEPR_RELIST_INTERVAL_SECONDS, 10)
-    : 1800,
+    : 600,
 };
 
 // Map the event to the watch phase
@@ -54,16 +91,16 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
   const phaseMatch: WatchPhase[] = eventToPhaseMap[binding.event] || eventToPhaseMap[Event.Any];
 
   // The watch callback is run when an object is received or dequeued
-
   Log.debug({ watchCfg }, "Effective WatchConfig");
-  const watchCallback = async (obj: KubernetesObject, type: WatchPhase) => {
+
+  const watchCallback = async (obj: KubernetesObject, phase: WatchPhase) => {
     // First, filter the object based on the phase
-    if (phaseMatch.includes(type)) {
+    if (phaseMatch.includes(phase)) {
       try {
         // Then, check if the object matches the filter
         const filterMatch = filterNoMatchReason(binding, obj, capabilityNamespaces);
         if (filterMatch === "") {
-          await binding.watchCallback?.(obj, type);
+          await binding.watchCallback?.(obj, phase);
         } else {
           Log.debug(filterMatch);
         }
@@ -74,19 +111,15 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
     }
   };
 
-  const queue = new Queue();
-  queue.setReconcile(watchCallback);
-
   // Setup the resource watch
-  const watcher = K8s(binding.model, binding.filters).Watch(async (obj, type) => {
-    Log.debug(obj, `Watch event ${type} received`);
+  const watcher = K8s(binding.model, binding.filters).Watch(async (obj, phase) => {
+    Log.debug(obj, `Watch event ${phase} received`);
 
-    // If the binding is a queue, enqueue the object
     if (binding.isQueue) {
-      await queue.enqueue(obj, type);
+      const queue = getOrCreateQueue(obj);
+      await queue.enqueue(obj, phase, watchCallback);
     } else {
-      // Otherwise, run the watch callback directly
-      await watchCallback(obj, type);
+      await watchCallback(obj, phase);
     }
   }, watchCfg);
 
@@ -130,8 +163,8 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
   }
 }
 
-export function logEvent(type: WatchEvent, message: string = "", obj?: KubernetesObject) {
-  const logMessage = `Watch event ${type} received${message ? `. ${message}.` : "."}`;
+export function logEvent(event: WatchEvent, message: string = "", obj?: KubernetesObject) {
+  const logMessage = `Watch event ${event} received${message ? `. ${message}.` : "."}`;
   if (obj) {
     Log.debug(obj, logMessage);
   } else {

package/src/sdk/sdk.test.ts

@@ -11,6 +11,7 @@ import { beforeEach, describe, it, jest } from "@jest/globals";
 import { GenericKind } from "kubernetes-fluent-client";
 import { K8s, kind } from "kubernetes-fluent-client";
 import { Mock } from "jest-mock";
+import { V1OwnerReference } from "@kubernetes/client-node";
 
 jest.mock("kubernetes-fluent-client", () => ({
   K8s: jest.fn(),
@@ -163,23 +164,55 @@ describe("writeEvent", () => {
 });
 
 describe("getOwnerRefFrom", () => {
-  it("should return the owner reference for the CRD", () => {
-    const cr = {
+  const customResource = {
+    apiVersion: "v1",
+    kind: "Package",
+    metadata: { name: "test", namespace: "default", uid: "1" },
+  };
+
+  const ownerRef = [
+    {
       apiVersion: "v1",
       kind: "Package",
-      metadata: { name: "test", namespace: "default", uid: "1" },
-    };
-    const ownerRef = getOwnerRefFrom(cr as GenericKind);
-    expect(ownerRef).toEqual([
-      {
-        apiVersion: "v1",
-        kind: "Package",
-        name: "test",
-        uid: "1",
-      },
-    ]);
+      name: "test",
+      uid: "1",
+    },
+  ];
+
+  const ownerRefWithController = ownerRef.map(item => ({
+    ...item,
+    controller: true,
+  }));
+  const ownerRefWithBlockOwnerDeletion = ownerRef.map(item => ({
+    ...item,
+    blockOwnerDeletion: false,
+  }));
+  const ownerRefWithAllFields = ownerRef.map(item => ({
+    ...item,
+    blockOwnerDeletion: true,
+    controller: false,
+  }));
+
+  test.each([
+    [true, false, ownerRefWithAllFields],
+    [false, undefined, ownerRefWithBlockOwnerDeletion],
+    [undefined, true, ownerRefWithController],
+    [undefined, undefined, ownerRef],
+  ])(
+    "should return owner reference for the CRD for combinations of V1OwnerReference fields - Optionals: blockOwnerDeletion (%s), controller (%s)",
+    (blockOwnerDeletion, controller, expected) => {
+      const result = getOwnerRefFrom(customResource, blockOwnerDeletion, controller);
+      expect(result).toStrictEqual(expected);
+    },
+  );
+
+  it("should support all defined fields in the V1OwnerReference type", () => {
+    const V1OwnerReferenceFieldCount = Object.getOwnPropertyNames(V1OwnerReference).length;
+    const result = getOwnerRefFrom(customResource, false, true);
+    expect(Object.keys(result[0]).length).toEqual(V1OwnerReferenceFieldCount);
   });
 });
+
 describe("sanitizeResourceName Fuzzing Tests", () => {
   test("should handle any random string input", () => {
     fc.assert(

package/src/sdk/sdk.ts

@@ -79,18 +79,27 @@ export async function writeEvent(
 
 /**
  * Get the owner reference for a custom resource
- * @param cr the custom resource to get the owner reference for
- * @returns the owner reference for the custom resource
+ * @param customResource the custom resource to get the owner reference for
+ * @param blockOwnerDeletion if true, AND if the owner has the "foregroundDeletion" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed.
+ * @param controller if true, this reference points to the managing controller.
+ * @returns the owner reference array for the custom resource
  */
-export function getOwnerRefFrom(cr: GenericKind): V1OwnerReference[] {
-  const { name, uid } = cr.metadata!;
+export function getOwnerRefFrom(
+  customResource: GenericKind,
+  blockOwnerDeletion?: boolean,
+  controller?: boolean,
+): V1OwnerReference[] {
+  const { apiVersion, kind, metadata } = customResource;
+  const { name, uid } = metadata!;
 
   return [
     {
-      apiVersion: cr.apiVersion!,
-      kind: cr.kind!,
+      apiVersion: apiVersion!,
+      kind: kind!,
       uid: uid!,
       name: name!,
+      ...(blockOwnerDeletion !== undefined && { blockOwnerDeletion }),
+      ...(controller !== undefined && { controller }),
     },
   ];
 }