@roku-sdk/ads 0.0.0-stage → 2.19.0

package/src/__tests__/ads.test.tsx

@@ -0,0 +1,735 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, test } from "@jest/globals";
+import { registerInternStringApi } from "@roku-sdk/common/string-interner";
+import { transactionManager } from "@roku-sdk/common/transaction";
+import type { DomNode, InternStringApi, StructuredDataApi, TreeManipulationApi } from "@roku-sdk/interfaces";
+import type { Component } from "@roku-sdk/solid";
+import { createSignal, makeSolidRenderer } from "@roku-sdk/solid";
+import { createDomNode } from "@roku-sdk/solid/src/dom-node";
+
+import { Ads, type AdsCommand, type IAdsProps } from "../ads";
+
+type Captured = Record<string, CapturedEntry>;
+
+type CapturedEntry =
+    | { kind: "bool"; value: boolean }
+    | { kind: "string"; value: string }
+    | { kind: "object"; value: Record<string, unknown> }
+    | { kind: "nodeRef"; value: string }
+    | { kind: "eventHandler" };
+
+const commitEarly = transactionManager.commitEarly;
+
+const SAMPLE_AD_URL =
+    "https://pubads.g.doubleclick.net/gampad/ads?iu=/21775744923/external/vmap_ad_samples&output=vmap";
+
+function captureAdsProps(buildProps: () => IAdsProps): { tagName: string; props: Captured } {
+    const internForward = new Map<string, object>();
+    const internReverse = new Map<object, string>();
+    let internRef = 0;
+    const mockIntern: InternStringApi = {
+        internString: (str: string): object => {
+            const existing = internForward.get(str);
+            if (existing) return existing;
+            const ref = { id: ++internRef };
+            internForward.set(str, ref);
+            internReverse.set(ref, str);
+            return ref;
+        }
+    };
+    registerInternStringApi(mockIntern);
+
+    const resolveInterned = (ref: unknown): string => {
+        if (ref && typeof ref === "object") {
+            const s = internReverse.get(ref as object);
+            if (s !== undefined) return s;
+        }
+        return String(ref);
+    };
+
+    const nodeTag = new WeakMap<object, string>();
+    let nodeCounter = 0;
+
+    const mockSd: StructuredDataApi = {
+        createObject: () => ({}),
+        createArray: () => [],
+        insertBool: (o, p, v) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = v;
+        },
+        insertNull: (o, p) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = null;
+        },
+        insertInt: (o, p, v) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = v;
+        },
+        insertFloat: (o, p, v) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = v;
+        },
+        insertString: (o, p, v) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = v;
+        },
+        insertObject: (o, p, v) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = v;
+        },
+        insertArray: (o, p, v) => {
+            (o as Record<string, unknown>)[resolveInterned(p)] = v;
+        },
+        insertNodeRef: () => undefined,
+        appendBool: (a, v) => {
+            (a as unknown[]).push(v);
+        },
+        appendNull: a => {
+            (a as unknown[]).push(null);
+        },
+        appendInt: (a, v) => {
+            (a as unknown[]).push(v);
+        },
+        appendFloat: (a, v) => {
+            (a as unknown[]).push(v);
+        },
+        appendString: (a, v) => {
+            (a as unknown[]).push(typeof v === "string" ? v : resolveInterned(v));
+        },
+        appendObject: (a, v) => {
+            (a as unknown[]).push(v);
+        },
+        appendArray: (a, v) => {
+            (a as unknown[]).push(v);
+        },
+        appendNodeRef: () => undefined,
+        getArray: () => undefined,
+        getObject: () => undefined
+    };
+
+    type Entry = { nodeRef: object; propName: string; entry: CapturedEntry };
+    const allCalls: Entry[] = [];
+    let rootTagName = "";
+
+    const push = (nodeRef: unknown, propRef: unknown, entry: CapturedEntry) => {
+        if (!nodeRef || typeof nodeRef !== "object") return;
+        allCalls.push({ nodeRef: nodeRef as object, propName: resolveInterned(propRef), entry });
+    };
+
+    const mockTm: TreeManipulationApi = {
+        createNode: (_anchor, tagRef) => {
+            const ref: object = { id: ++nodeCounter };
+            const tagName = resolveInterned(tagRef);
+            nodeTag.set(ref, tagName);
+            if (!rootTagName) rootTagName = tagName;
+            return ref;
+        },
+        appendNode: () => undefined,
+        insertNodeBefore: () => undefined,
+        removeNode: () => undefined,
+        setNodePropNull: (_a, n, p) => push(n, p, { kind: "string", value: "null" }),
+        setNodePropBool: (_a, n, p, v) => push(n, p, { kind: "bool", value: v }),
+        setNodePropInt: (_a, n, p, v) => push(n, p, { kind: "string", value: String(v) }),
+        setNodePropFloat: (_a, n, p, v) => push(n, p, { kind: "string", value: String(v) }),
+        setNodePropString: (_a, n, p, v) => push(n, p, { kind: "string", value: v }),
+        setNodePropObject: (_a, n, p, v) => push(n, p, { kind: "object", value: v as Record<string, unknown> }),
+        setNodePropArray: () => undefined,
+        setNodePropNodeRef: (_a, n, p, v) => {
+            const refId = v && typeof v === "object" && "id" in v ? String((v as { id: number }).id) : "unknown";
+            push(n, p, { kind: "nodeRef", value: `<ref:${refId}>` });
+        },
+        removeNodeProp: () => undefined,
+        updateNodeProps: () => undefined,
+        removeNodeProps: () => undefined,
+        registerFieldChangeHandler: (_a, n, p) => push(n, p, { kind: "eventHandler" }),
+        unregisterFieldHandler: () => undefined,
+        setFocus: () => undefined
+    };
+
+    const { renderer } = makeSolidRenderer(mockTm, mockSd, mockSd);
+    const anchorName = { id: 0 };
+
+    const anchorNode: DomNode = { r: {}, n: anchorName } as DomNode;
+    const props = buildProps();
+    const dispose = renderer.render((() => <Ads {...props} />) as unknown as () => DomNode, anchorNode);
+    commitEarly();
+
+    const rootDom = anchorNode.c && anchorNode.c[0];
+    const rootNodeRef = rootDom?.r as object | undefined;
+
+    dispose();
+
+    const captured: Captured = {};
+    if (rootNodeRef) {
+        for (const { nodeRef, propName, entry } of allCalls) {
+            if (nodeRef === rootNodeRef) captured[propName] = entry;
+        }
+    }
+
+    const sorted: Captured = {};
+    for (const key of Object.keys(captured).sort()) {
+        sorted[key] = captured[key];
+    }
+
+    return { tagName: rootTagName, props: sorted };
+}
+
+function buildSampleProps(): IAdsProps {
+    const adView = createDomNode("rectangle", { id: 100 });
+    const contentView = createDomNode("video", { id: 101 });
+
+    return {
+        debugOutput: true,
+        command: "getAds",
+        adUrl: SAMPLE_AD_URL,
+        adView,
+        contentView,
+        onAdsState: () => {},
+        onGetAdsResult: () => {},
+        onShowAdsResult: () => {}
+    };
+}
+
+function buildSsaiProps(): IAdsProps {
+    const contentView = createDomNode("video", { id: 201 });
+
+    return {
+        debugOutput: true,
+        command: "stitchedAdsInit",
+        adUrl: SAMPLE_AD_URL,
+        contentView,
+        onAdsState: () => {},
+        onGetAdsResult: () => {},
+        onStitchedAdResult: () => {}
+    };
+}
+
+const SAMPLE_CONTENT_METADATA = {
+    url: "http://example.com/content.m3u8",
+    length: 600
+};
+
+function buildCsasProps(): IAdsProps {
+    const adView = createDomNode("rectangle", { id: 401 });
+
+    return {
+        debugOutput: true,
+        command: "constructStitchedStream",
+        adUrl: SAMPLE_AD_URL,
+        adView,
+        contentMetadata: SAMPLE_CONTENT_METADATA,
+        onAdsState: () => {},
+        onGetAdsResult: () => {},
+        onConstructStitchedStreamResult: () => {},
+        onRenderStitchedStreamResult: () => {}
+    };
+}
+
+const SAMPLE_CONTENT_GENRE = "Entertainment";
+const SAMPLE_CONTENT_ID = "CSASAdSample";
+
+function buildAudienceMeasurementProps(): IAdsProps {
+    return {
+        enableAdMeasurements: true,
+        contentGenre: SAMPLE_CONTENT_GENRE,
+        contentId: SAMPLE_CONTENT_ID
+    };
+}
+
+describe("Ads", () => {
+    test("renders the ads SceneGraph Task node", () => {
+        const { tagName } = captureAdsProps(buildSampleProps);
+        expect(tagName).toBe("ads");
+    });
+
+    test("forwards scalar props to the underlying ads node", () => {
+        const { props } = captureAdsProps(buildSampleProps);
+
+        expect(props).toMatchObject({
+            adUrl: { kind: "string", value: SAMPLE_AD_URL },
+            command: { kind: "string", value: "getAds" },
+            debugOutput: { kind: "bool", value: true }
+        });
+    });
+
+    test("forwards node refs for adView and contentView", () => {
+        const { props } = captureAdsProps(buildSampleProps);
+
+        expect(props.adView).toEqual({ kind: "nodeRef", value: "<ref:100>" });
+        expect(props.contentView).toEqual({ kind: "nodeRef", value: "<ref:101>" });
+    });
+
+    test("registers RAF callback fields on the ads node", () => {
+        const { props } = captureAdsProps(buildSampleProps);
+
+        expect(props.adsState).toEqual({ kind: "eventHandler" });
+        expect(props.getAdsResult).toEqual({ kind: "eventHandler" });
+        expect(props.showAdsResult).toEqual({ kind: "eventHandler" });
+    });
+
+    test("forwards adCounter as the assocarray RAF reads its ad counter from", () => {
+        const { props } = captureAdsProps(() => ({
+            command: "showAds",
+            adCounter: { start: 1, total: 4 }
+        }));
+
+        expect(props.adCounter).toEqual({ kind: "object", value: { start: 1, total: 4 } });
+    });
+
+    test("omits adCounter when it is not given, so RAF keeps its own count", () => {
+        const { props } = captureAdsProps(() => ({ command: "showAds" }));
+
+        expect(props.adCounter).toBeUndefined();
+    });
+
+    describe("CSAS", () => {
+        test("forwards constructStitchedStream command to the underlying ads node", () => {
+            const { props } = captureAdsProps(buildCsasProps);
+
+            expect(props.command).toEqual({ kind: "string", value: "constructStitchedStream" });
+        });
+
+        test("forwards contentMetadata for stitched stream construction", () => {
+            const { props } = captureAdsProps(buildCsasProps);
+
+            expect(props.contentMetadata).toEqual({ kind: "object", value: SAMPLE_CONTENT_METADATA });
+        });
+
+        test("forwards adView for stitched stream rendering", () => {
+            const { props } = captureAdsProps(buildCsasProps);
+
+            expect(props.adView).toEqual({ kind: "nodeRef", value: "<ref:401>" });
+        });
+
+        test("registers constructStitchedStreamResult callback on the ads node", () => {
+            const { props } = captureAdsProps(buildCsasProps);
+
+            expect(props.constructStitchedStreamResult).toEqual({ kind: "eventHandler" });
+        });
+
+        test("registers renderStitchedStreamResult callback on the ads node", () => {
+            const { props } = captureAdsProps(buildCsasProps);
+
+            expect(props.renderStitchedStreamResult).toEqual({ kind: "eventHandler" });
+        });
+
+        test("forwards renderStitchedStream command to the underlying ads node", () => {
+            const { props } = captureAdsProps(() => ({
+                ...buildCsasProps(),
+                command: "renderStitchedStream"
+            }));
+
+            expect(props.command).toEqual({ kind: "string", value: "renderStitchedStream" });
+        });
+
+        test("forwards only CSAS-relevant props when contentView and showAds handlers are omitted", () => {
+            const { props } = captureAdsProps(() => ({
+                command: "constructStitchedStream",
+                adView: createDomNode("rectangle", { id: 501 }),
+                contentMetadata: SAMPLE_CONTENT_METADATA,
+                onConstructStitchedStreamResult: () => {},
+                onRenderStitchedStreamResult: () => {}
+            }));
+
+            expect(Object.keys(props).sort()).toEqual([
+                "adView",
+                "command",
+                "constructStitchedStreamResult",
+                "contentMetadata",
+                "renderStitchedStreamResult"
+            ]);
+            expect(props.command).toEqual({ kind: "string", value: "constructStitchedStream" });
+            expect(props.adView).toEqual({ kind: "nodeRef", value: "<ref:501>" });
+            expect(props.contentMetadata).toEqual({ kind: "object", value: SAMPLE_CONTENT_METADATA });
+            expect(props.constructStitchedStreamResult).toEqual({ kind: "eventHandler" });
+            expect(props.renderStitchedStreamResult).toEqual({ kind: "eventHandler" });
+        });
+    });
+
+    describe("audience measurement", () => {
+        test("forwards enableAdMeasurements to the underlying ads node", () => {
+            const { props } = captureAdsProps(() => ({
+                ...buildAudienceMeasurementProps(),
+                enableAdMeasurements: true
+            }));
+
+            expect(props.enableAdMeasurements).toEqual({ kind: "bool", value: true });
+        });
+
+        test("forwards enableAdMeasurements=false when measurement is disabled", () => {
+            const { props } = captureAdsProps(() => ({
+                ...buildAudienceMeasurementProps(),
+                enableAdMeasurements: false
+            }));
+
+            expect(props.enableAdMeasurements).toEqual({ kind: "bool", value: false });
+        });
+
+        test("forwards contentGenre to the underlying ads node", () => {
+            const { props } = captureAdsProps(buildAudienceMeasurementProps);
+
+            expect(props.contentGenre).toEqual({ kind: "string", value: SAMPLE_CONTENT_GENRE });
+        });
+
+        test("forwards contentId to the underlying ads node", () => {
+            const { props } = captureAdsProps(buildAudienceMeasurementProps);
+
+            expect(props.contentId).toEqual({ kind: "string", value: SAMPLE_CONTENT_ID });
+        });
+
+        test("forwards all audience measurement props together", () => {
+            const { props } = captureAdsProps(buildAudienceMeasurementProps);
+
+            expect(props).toMatchObject({
+                enableAdMeasurements: { kind: "bool", value: true },
+                contentGenre: { kind: "string", value: SAMPLE_CONTENT_GENRE },
+                contentId: { kind: "string", value: SAMPLE_CONTENT_ID }
+            });
+        });
+
+        test("forwards only audience measurement props when other props are omitted", () => {
+            const { props } = captureAdsProps(buildAudienceMeasurementProps);
+
+            expect(Object.keys(props).sort()).toEqual(["contentGenre", "contentId", "enableAdMeasurements"]);
+        });
+
+        test("updates audience measurement props reactively when signals change", () => {
+            const internForward = new Map<string, object>();
+            const internReverse = new Map<object, string>();
+            let internRef = 0;
+            registerInternStringApi({
+                internString: (str: string): object => {
+                    const existing = internForward.get(str);
+                    if (existing) return existing;
+                    const ref = { id: ++internRef };
+                    internForward.set(str, ref);
+                    internReverse.set(ref, str);
+                    return ref;
+                }
+            });
+
+            const resolveInterned = (ref: unknown): string => {
+                if (ref && typeof ref === "object") {
+                    const s = internReverse.get(ref as object);
+                    if (s !== undefined) return s;
+                }
+                return String(ref);
+            };
+
+            const boolValues: boolean[] = [];
+            const stringValues: Record<string, string[]> = {
+                contentGenre: [],
+                contentId: []
+            };
+
+            const mockSd: StructuredDataApi = {
+                createObject: () => ({}),
+                createArray: () => [],
+                insertBool: () => undefined,
+                insertNull: () => undefined,
+                insertInt: () => undefined,
+                insertFloat: () => undefined,
+                insertString: () => undefined,
+                insertObject: () => undefined,
+                insertArray: () => undefined,
+                insertNodeRef: () => undefined,
+                appendBool: () => undefined,
+                appendNull: () => undefined,
+                appendInt: () => undefined,
+                appendFloat: () => undefined,
+                appendString: () => undefined,
+                appendObject: () => undefined,
+                appendArray: () => undefined,
+                appendNodeRef: () => undefined,
+                getArray: () => undefined,
+                getObject: () => undefined
+            };
+
+            const mockTm: TreeManipulationApi = {
+                createNode: (_anchor, tagRef) => ({ id: 1, tag: resolveInterned(tagRef) }),
+                appendNode: () => undefined,
+                insertNodeBefore: () => undefined,
+                removeNode: () => undefined,
+                setNodePropNull: () => undefined,
+                setNodePropBool: (_a, _n, p, v) => {
+                    if (resolveInterned(p) === "enableAdMeasurements") boolValues.push(v);
+                },
+                setNodePropInt: () => undefined,
+                setNodePropFloat: () => undefined,
+                setNodePropString: (_a, _n, p, v) => {
+                    const prop = resolveInterned(p);
+                    if (prop in stringValues) stringValues[prop].push(v);
+                },
+                setNodePropObject: () => undefined,
+                setNodePropArray: () => undefined,
+                setNodePropNodeRef: () => undefined,
+                removeNodeProp: () => undefined,
+                updateNodeProps: () => undefined,
+                removeNodeProps: () => undefined,
+                registerFieldChangeHandler: () => undefined,
+                unregisterFieldHandler: () => undefined,
+                setFocus: () => undefined
+            };
+
+            const { renderer } = makeSolidRenderer(mockTm, mockSd, mockSd);
+            const anchorName = { id: 0 };
+
+            const [enableAdMeasurements, setEnableAdMeasurements] = createSignal(false);
+            const [contentGenre, setContentGenre] = createSignal("");
+            const [contentId, setContentId] = createSignal("");
+            const anchorNode: DomNode = { r: {}, n: anchorName } as DomNode;
+            const dispose = renderer.render(
+                (() => (
+                    <Ads
+                        enableAdMeasurements={enableAdMeasurements()}
+                        contentGenre={contentGenre()}
+                        contentId={contentId()}
+                    />
+                )) as unknown as () => DomNode,
+                anchorNode
+            );
+
+            commitEarly();
+            expect(boolValues).toEqual([false]);
+            expect(stringValues.contentGenre).toEqual([""]);
+            expect(stringValues.contentId).toEqual([""]);
+
+            setEnableAdMeasurements(true);
+            setContentGenre(SAMPLE_CONTENT_GENRE);
+            setContentId(SAMPLE_CONTENT_ID);
+            commitEarly();
+            expect(boolValues).toEqual([false, true]);
+            expect(stringValues.contentGenre).toEqual(["", SAMPLE_CONTENT_GENRE]);
+            expect(stringValues.contentId).toEqual(["", SAMPLE_CONTENT_ID]);
+
+            dispose();
+        });
+    });
+
+    describe("SSAI", () => {
+        test("forwards stitchedAdsInit command to the underlying ads node", () => {
+            const { props } = captureAdsProps(buildSsaiProps);
+
+            expect(props.command).toEqual({ kind: "string", value: "stitchedAdsInit" });
+        });
+
+        test("forwards contentView without adView for stitched playback", () => {
+            const { props } = captureAdsProps(buildSsaiProps);
+
+            expect(props.contentView).toEqual({ kind: "nodeRef", value: "<ref:201>" });
+            expect(props.adView).toBeUndefined();
+        });
+
+        test("registers stitchedAdResult callback on the ads node", () => {
+            const { props } = captureAdsProps(buildSsaiProps);
+
+            expect(props.stitchedAdResult).toEqual({ kind: "eventHandler" });
+        });
+
+        test("registers stitchedAdsInitResult callback on the ads node", () => {
+            const { props } = captureAdsProps(() => ({
+                command: "stitchedAdsInit",
+                contentView: createDomNode("video", { id: 301 }),
+                onStitchedAdsInitResult: () => {}
+            }));
+
+            expect(props.stitchedAdsInitResult).toEqual({ kind: "eventHandler" });
+        });
+
+        test("forwards only SSAI-relevant props when adView and showAds handlers are omitted", () => {
+            const { props } = captureAdsProps(() => ({
+                command: "stitchedAdsInit",
+                contentView: createDomNode("video", { id: 301 }),
+                onStitchedAdResult: () => {}
+            }));
+
+            expect(Object.keys(props).sort()).toEqual(["command", "contentView", "stitchedAdResult"]);
+            expect(props.command).toEqual({ kind: "string", value: "stitchedAdsInit" });
+            expect(props.contentView).toEqual({ kind: "nodeRef", value: "<ref:301>" });
+            expect(props.stitchedAdResult).toEqual({ kind: "eventHandler" });
+        });
+    });
+
+    test("forwards only provided props", () => {
+        const { props } = captureAdsProps(() => ({ command: "showAds" }));
+
+        expect(Object.keys(props)).toEqual(["command"]);
+        expect(props.command).toEqual({ kind: "string", value: "showAds" });
+    });
+
+    test("updates command reactively when the prop signal changes", () => {
+        const { commandValues, setCommand, commit, dispose } = renderWithCommandRecorder("getAds");
+
+        commit();
+        expect(commandValues).toEqual(["getAds"]);
+
+        setCommand("showAds");
+        commit();
+        expect(commandValues).toEqual(["getAds", "showAds"]);
+
+        setCommand("stitchedAdsInit");
+        commit();
+        expect(commandValues).toEqual(["getAds", "showAds", "stitchedAdsInit"]);
+
+        setCommand("constructStitchedStream");
+        commit();
+        expect(commandValues).toEqual(["getAds", "showAds", "stitchedAdsInit", "constructStitchedStream"]);
+
+        setCommand("renderStitchedStream");
+        commit();
+        expect(commandValues).toEqual([
+            "getAds",
+            "showAds",
+            "stitchedAdsInit",
+            "constructStitchedStream",
+            "renderStitchedStream"
+        ]);
+
+        dispose();
+    });
+
+    /**
+     * The repeat is what `csai.tsx` guards by resetting through `"none"`, and
+     * until now nothing measured it. The first test is the control: without it,
+     * a harness that had lost its reactivity would pass the second one for the
+     * wrong reason.
+     */
+    describe("a repeated command value", () => {
+        test("reaches the node again when the value differs", () => {
+            const { commandValues, setCommand, commit, dispose } = renderWithCommandRecorder("showAds");
+
+            commit();
+            setCommand("getAds");
+            commit();
+
+            expect(commandValues).toEqual(["showAds", "getAds"]);
+
+            dispose();
+        });
+
+        test("is not written a second time", () => {
+            const { commandValues, setCommand, commit, dispose } = renderWithCommandRecorder("showAds");
+
+            commit();
+            setCommand("showAds");
+            commit();
+
+            expect(commandValues).toEqual(["showAds"]);
+
+            dispose();
+        });
+
+        test("lands once it is reset through none", () => {
+            const { commandValues, setCommand, commit, dispose } = renderWithCommandRecorder("showAds");
+
+            commit();
+            setCommand("none");
+            commit();
+            setCommand("showAds");
+            commit();
+
+            expect(commandValues).toEqual(["showAds", "none", "showAds"]);
+
+            dispose();
+        });
+    });
+});
+
+/**
+ * Renders `<Ads>` with a signal-driven `command` and records every value that
+ * reaches the underlying node, in order. Ordered writes are what distinguish
+ * "written twice" from "written once", which the prop-capture harness above
+ * cannot see because it keeps only the last value per prop.
+ */
+function renderWithCommandRecorder(initial: AdsCommand): {
+    commandValues: string[];
+    setCommand: (value: AdsCommand) => void;
+    commit: () => void;
+    dispose: () => void;
+} {
+    const internForward = new Map<string, object>();
+    const internReverse = new Map<object, string>();
+    let internRef = 0;
+    registerInternStringApi({
+        internString: (str: string): object => {
+            const existing = internForward.get(str);
+            if (existing) return existing;
+            const ref = { id: ++internRef };
+            internForward.set(str, ref);
+            internReverse.set(ref, str);
+            return ref;
+        }
+    });
+
+    const resolveInterned = (ref: unknown): string => {
+        if (ref && typeof ref === "object") {
+            const s = internReverse.get(ref as object);
+            if (s !== undefined) return s;
+        }
+        return String(ref);
+    };
+
+    const commandValues: string[] = [];
+    const mockSd: StructuredDataApi = {
+        createObject: () => ({}),
+        createArray: () => [],
+        insertBool: () => undefined,
+        insertNull: () => undefined,
+        insertInt: () => undefined,
+        insertFloat: () => undefined,
+        insertString: () => undefined,
+        insertObject: () => undefined,
+        insertArray: () => undefined,
+        insertNodeRef: () => undefined,
+        appendBool: () => undefined,
+        appendNull: () => undefined,
+        appendInt: () => undefined,
+        appendFloat: () => undefined,
+        appendString: () => undefined,
+        appendObject: () => undefined,
+        appendArray: () => undefined,
+        appendNodeRef: () => undefined,
+        getArray: () => undefined,
+        getObject: () => undefined
+    };
+
+    const mockTm: TreeManipulationApi = {
+        createNode: (_anchor, tagRef) => ({ id: 1, tag: resolveInterned(tagRef) }),
+        appendNode: () => undefined,
+        insertNodeBefore: () => undefined,
+        removeNode: () => undefined,
+        setNodePropNull: () => undefined,
+        setNodePropBool: () => undefined,
+        setNodePropInt: () => undefined,
+        setNodePropFloat: () => undefined,
+        setNodePropString: (_a, _n, p, v) => {
+            if (resolveInterned(p) === "command") commandValues.push(v);
+        },
+        setNodePropObject: () => undefined,
+        setNodePropArray: () => undefined,
+        setNodePropNodeRef: () => undefined,
+        removeNodeProp: () => undefined,
+        updateNodeProps: () => undefined,
+        removeNodeProps: () => undefined,
+        registerFieldChangeHandler: () => undefined,
+        unregisterFieldHandler: () => undefined,
+        setFocus: () => undefined
+    };
+
+    const { renderer } = makeSolidRenderer(mockTm, mockSd, mockSd);
+    const anchorName = { id: 0 };
+
+    const [command, setCommand] = createSignal<AdsCommand>(initial);
+    const anchorNode: DomNode = { r: {}, n: anchorName } as DomNode;
+    const dispose = renderer.render((() => <Ads command={command()} />) as unknown as () => DomNode, anchorNode);
+
+    return {
+        commandValues,
+        setCommand: (value: AdsCommand) => setCommand(value),
+        commit: commitEarly,
+        dispose
+    };
+}
+
+describe("Ads exports", () => {
+    test("Ads is a SolidJS component function", () => {
+        expect(typeof Ads).toBe("function");
+        expect((Ads as Component<IAdsProps>).length).toBe(1);
+    });
+});