@eventvisor/core 0.0.2

package/lib/linter/testSchema.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestSchema = getTestSchema;
+const z = __importStar(require("zod"));
+// eslint-disable-next-line
+function getTestSchema(deps) {
+    return z.object({
+        archived: z.boolean().optional(),
+    });
+}
+//# sourceMappingURL=testSchema.js.map

package/lib/linter/testSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testSchema.js","sourceRoot":"","sources":["../../src/linter/testSchema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,sCAIC;AARD,uCAAyB;AAGzB,2BAA2B;AAC3B,SAAgB,aAAa,CAAC,IAAkB;IAC9C,OAAO,CAAC,CAAC,MAAM,CAAC;QACd,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KACjC,CAAC,CAAC;AACL,CAAC"}

package/lib/linter/transformsSchema.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod";
+import { Dependencies } from "../dependencies";
+export declare function getTransformsSchema(deps: Dependencies): z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<{
+        toString: "toString";
+        concat: "concat";
+        trim: "trim";
+        set: "set";
+        remove: "remove";
+        append: "append";
+        increment: "increment";
+        decrement: "decrement";
+        rename: "rename";
+        toInteger: "toInteger";
+        toDouble: "toDouble";
+        toBoolean: "toBoolean";
+        spread: "spread";
+    }>;
+    target: z.ZodOptional<z.ZodString>;
+    targetMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    value: z.ZodOptional<z.ZodAny>;
+    separator: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    attribute: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    state: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    effect: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    payload: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    lookup: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>>;

package/lib/linter/transformsSchema.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransformsSchema = getTransformsSchema;
+const z = __importStar(require("zod"));
+const sourceSchema_1 = require("./sourceSchema");
+function getTransformsSchema(deps) {
+    return z.array(z.object({
+        // .refine() is intentionally not called here for now, since not all transforms need sources
+        // @TODO: make it stricter based on transform types
+        ...(0, sourceSchema_1.getSourceBaseSchema)(deps).shape,
+        type: z.enum([
+            "increment",
+            "decrement",
+            "concat", // @TODO: rename to `join`?
+            "remove",
+            "rename",
+            "set",
+            "trim",
+            "toInteger",
+            "toDouble",
+            "toString",
+            "toBoolean",
+            "spread",
+            "append",
+        ]),
+        target: z.string().optional(),
+        targetMap: z.record(z.string(), z.any()).optional(),
+        value: z.any().optional(),
+        // transform type specific params
+        separator: z.string().optional(),
+    }));
+}
+//# sourceMappingURL=transformsSchema.js.map

package/lib/linter/transformsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformsSchema.js","sourceRoot":"","sources":["../../src/linter/transformsSchema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,kDA6BC;AAlCD,uCAAyB;AAGzB,iDAAqD;AAErD,SAAgB,mBAAmB,CAAC,IAAkB;IACpD,OAAO,CAAC,CAAC,KAAK,CACZ,CAAC,CAAC,MAAM,CAAC;QACP,4FAA4F;QAC5F,mDAAmD;QACnD,GAAG,IAAA,kCAAmB,EAAC,IAAI,CAAC,CAAC,KAAK;QAClC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;YACX,WAAW;YACX,WAAW;YACX,QAAQ,EAAE,2BAA2B;YACrC,QAAQ;YACR,QAAQ;YACR,KAAK;YACL,MAAM;YACN,WAAW;YACX,UAAU;YACV,UAAU;YACV,WAAW;YACX,QAAQ;YACR,QAAQ;SACT,CAAC;QACF,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE;QACnD,KAAK,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAEzB,iCAAiC;QACjC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACjC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/lib/tester/createTestInstance.d.ts

@@ -0,0 +1,16 @@
+import type { DatafileContent, WithLookups, Value, Step } from "@eventvisor/types";
+import { Eventvisor } from "@eventvisor/sdk";
+import type { TestProjectOptions } from "./testProject";
+export interface CreateTestInstanceResult {
+    e: Eventvisor;
+    getBodiesByDestination: () => Record<string, Value[]>;
+    getBodiesBySingleDestination: (destinationName: string) => Value[] | undefined;
+    getCalledStepsByEffect: () => Record<string, Step[]>;
+    getCalledStepsBySingleEffect: (effectName: string) => Step[] | undefined;
+}
+export interface CreateTestInstanceOptions {
+    datafile: DatafileContent;
+    cliOptions: TestProjectOptions;
+    withLookups?: WithLookups;
+}
+export declare function createTestInstance(options: CreateTestInstanceOptions): CreateTestInstanceResult;

package/lib/tester/createTestInstance.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestInstance = createTestInstance;
+const sdk_1 = require("@eventvisor/sdk");
+function createTestInstance(options) {
+    const { datafile, cliOptions, withLookups } = options;
+    /**
+     * Log level
+     */
+    let logLevel = "error";
+    if (cliOptions.verbose) {
+        logLevel = "debug";
+    }
+    else if (cliOptions.quiet) {
+        logLevel = "fatal";
+    }
+    /**
+     * Transport names
+     */
+    const transportNames = new Set();
+    const destinationNames = Object.keys(datafile.destinations);
+    for (const destinationName of destinationNames) {
+        const destination = datafile.destinations[destinationName];
+        if (destination.transport) {
+            transportNames.add(destination.transport);
+        }
+    }
+    /**
+     * Storage names
+     */
+    const storageNames = new Set();
+    const attributes = Object.keys(datafile.attributes);
+    for (const attributeName of attributes) {
+        const attribute = datafile.attributes[attributeName];
+        if (attribute.persist) {
+            const persists = (0, sdk_1.getComplexPersists)(attribute.persist);
+            for (const persist of persists) {
+                storageNames.add(persist.storage);
+            }
+        }
+    }
+    /**
+     * Handler names
+     */
+    const handlerNames = new Set();
+    const effects = Object.keys(datafile.effects);
+    for (const effectName of effects) {
+        const effect = datafile.effects[effectName];
+        // handler
+        if (effect.steps) {
+            for (const step of effect.steps) {
+                if (step.handler) {
+                    handlerNames.add(step.handler);
+                }
+            }
+        }
+        // storage
+        if (effect.persist) {
+            const persists = (0, sdk_1.getComplexPersists)(effect.persist);
+            for (const persist of persists) {
+                storageNames.add(persist.storage);
+            }
+        }
+    }
+    /**
+     * Modules
+     */
+    const modules = [];
+    const bodiesByDestination = {};
+    const calledStepsByEffect = {};
+    const lookupsMap = {};
+    for (const [key, value] of Object.entries(withLookups || {})) {
+        const [moduleName, ...keyParts] = key.split(".");
+        const lookupKey = keyParts.join(".");
+        if (typeof lookupsMap[moduleName] === "undefined") {
+            lookupsMap[moduleName] = {};
+        }
+        lookupsMap[moduleName][lookupKey] = value;
+    }
+    const allModuleNames = Array.from(handlerNames)
+        .concat(Array.from(transportNames))
+        .concat(Object.keys(lookupsMap))
+        .concat(Array.from(storageNames));
+    for (const moduleName of allModuleNames) {
+        const moduleObj = { name: moduleName };
+        // transport
+        if (transportNames.has(moduleName)) {
+            moduleObj.transport = (options) => {
+                const { destinationName, payload } = options;
+                if (typeof bodiesByDestination[destinationName] === "undefined") {
+                    bodiesByDestination[destinationName] = [];
+                }
+                bodiesByDestination[destinationName].push(payload);
+                return Promise.resolve();
+            };
+        }
+        // storage
+        if (storageNames.has(moduleName)) {
+            const storageData = {};
+            moduleObj.readFromStorage = (options) => {
+                const { key } = options;
+                return Promise.resolve(storageData[key]);
+            };
+            moduleObj.writeToStorage = (options) => {
+                const { key, value } = options;
+                storageData[key] = value;
+                return Promise.resolve();
+            };
+        }
+        // handler
+        if (handlerNames.has(moduleName)) {
+            moduleObj.handle = (options) => {
+                const { effectName, step } = options;
+                if (typeof calledStepsByEffect[effectName] === "undefined") {
+                    calledStepsByEffect[effectName] = [];
+                }
+                calledStepsByEffect[effectName].push(step);
+                return Promise.resolve();
+            };
+        }
+        // lookup
+        Object.keys(lookupsMap).forEach((moduleName) => {
+            if (moduleName === moduleObj.name) {
+                moduleObj.lookup = (options) => {
+                    const { key } = options;
+                    return Promise.resolve(lookupsMap[moduleName][key]);
+                };
+            }
+        });
+        modules.push(moduleObj);
+    }
+    /**
+     * Instance
+     */
+    const e = new sdk_1.Eventvisor({
+        datafile,
+        logLevel,
+        modules,
+    });
+    return {
+        e,
+        // destinations
+        getBodiesByDestination: () => {
+            return bodiesByDestination;
+        },
+        getBodiesBySingleDestination: (destinationName) => {
+            return bodiesByDestination[destinationName];
+        },
+        // effects
+        getCalledStepsByEffect: () => {
+            return calledStepsByEffect;
+        },
+        getCalledStepsBySingleEffect: (effectName) => {
+            return calledStepsByEffect[effectName];
+        },
+    };
+}
+//# sourceMappingURL=createTestInstance.js.map

package/lib/tester/createTestInstance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTestInstance.js","sourceRoot":"","sources":["../../src/tester/createTestInstance.ts"],"names":[],"mappings":"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"}

package/lib/tester/executeTest.d.ts

@@ -0,0 +1,24 @@
+import type { DatafileContent, Test } from "@eventvisor/types";
+import type { TestProjectOptions } from "./testProject";
+import type { Dependencies } from "../dependencies";
+export interface TestAssertionResult {
+    passed: boolean;
+    description?: string;
+    errors?: string[];
+}
+export interface TestAssertionResult {
+    passed: boolean;
+    description?: string;
+    errors?: string[];
+}
+export interface TestResult {
+    passed: boolean;
+    assertions: TestAssertionResult[];
+}
+export interface ExecuteTestOptions {
+    deps: Dependencies;
+    datafileContent: DatafileContent;
+    test: Test;
+    cliOptions: TestProjectOptions;
+}
+export declare function executeTest(options: ExecuteTestOptions): Promise<TestResult>;

package/lib/tester/executeTest.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTest = executeTest;
+const createTestInstance_1 = require("./createTestInstance");
+async function executeTest(options) {
+    const { datafileContent, test, cliOptions } = options;
+    const testResult = {
+        passed: true,
+        assertions: [],
+    };
+    let testPassed = true;
+    /**
+     * Attribute
+     */
+    if ("attribute" in test) {
+        // attribute test spec
+        const attributeName = test.attribute;
+        const assertions = test.assertions;
+        for (const assertion of assertions) {
+            // @TODO: apply matrix
+            if (cliOptions.assertionPattern &&
+                !assertion.description?.includes(cliOptions.assertionPattern)) {
+                continue;
+            }
+            let assertionPassed = true;
+            const { e } = (0, createTestInstance_1.createTestInstance)({
+                datafile: datafileContent,
+                cliOptions,
+                withLookups: assertion.withLookups,
+            });
+            if (assertion.setAttribute) {
+                await e.setAttributeAsync(attributeName, assertion.setAttribute);
+            }
+            const previouslySetAttribute = e.getAttributeValue(attributeName);
+            const isAttributeSet = e.isAttributeSet(attributeName);
+            const testAssertionResult = {
+                passed: assertionPassed,
+                description: assertion.description,
+                errors: [],
+            };
+            // expectedToBeValid
+            if (typeof assertion.expectedToBeValid === "boolean") {
+                if ((assertion.expectedToBeValid === true && !isAttributeSet) ||
+                    (assertion.expectedToBeValid === false && isAttributeSet)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedToBeValid: expected ${assertion.expectedToBeValid}, received ${!assertion.expectedToBeValid}`);
+                }
+            }
+            // expectedToBeSet
+            if (typeof assertion.expectedToBeSet === "boolean") {
+                if ((assertion.expectedToBeSet === true && !isAttributeSet) ||
+                    (assertion.expectedToBeSet === false && isAttributeSet)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedToBeSet: expected ${assertion.expectedToBeSet}, received ${!assertion.expectedToBeSet}`);
+                }
+            }
+            if (assertion.expectedAttribute) {
+                if (!checkIfObjectsAreDeepEqual(previouslySetAttribute, assertion.expectedAttribute)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedAttribute: \n  expected: ${JSON.stringify(assertion.expectedAttribute)}\n  received: ${JSON.stringify(previouslySetAttribute)}`);
+                }
+            }
+            testAssertionResult.passed = assertionPassed;
+            if (!assertionPassed) {
+                testPassed = false;
+            }
+            testResult.assertions.push(testAssertionResult);
+        }
+    }
+    /**
+     * Effect
+     */
+    if ("effect" in test) {
+        const effectName = test.effect;
+        const assertions = test.assertions;
+        for (const assertion of assertions) {
+            // @TODO: apply matrix
+            if (cliOptions.assertionPattern &&
+                !assertion.description?.includes(cliOptions.assertionPattern)) {
+                continue;
+            }
+            let assertionPassed = true;
+            const { e, getCalledStepsBySingleEffect } = (0, createTestInstance_1.createTestInstance)({
+                datafile: datafileContent,
+                cliOptions,
+                withLookups: assertion.withLookups,
+            });
+            await e.onReady();
+            if (assertion.actions) {
+                for (const action of assertion.actions) {
+                    if (action.type === "track") {
+                        await e.trackAsync(action.name, action.value);
+                    }
+                    else if (action.type === "setAttribute") {
+                        await e.setAttributeAsync(action.name, action.value);
+                    }
+                }
+            }
+            const testAssertionResult = {
+                passed: assertionPassed,
+                description: assertion.description,
+                errors: [],
+            };
+            // expectedState
+            if (assertion.expectedState) {
+                const latestState = e.getStateValue(effectName);
+                if (!checkIfObjectsAreDeepEqual(latestState, assertion.expectedState)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedState: \n  expected: ${JSON.stringify(assertion.expectedState)}\n  received: ${JSON.stringify(latestState)}`);
+                }
+            }
+            // expectedHandlersToBeCalled
+            if (assertion.expectedToBeCalled) {
+                const calledSteps = getCalledStepsBySingleEffect(effectName);
+                for (const expectedToBeCalled of assertion.expectedToBeCalled) {
+                    const { handler, times } = expectedToBeCalled;
+                    const calledStepsForHandler = calledSteps?.filter((step) => step.handler === handler);
+                    if (times) {
+                        if (calledStepsForHandler?.length !== times) {
+                            assertionPassed = false;
+                            testAssertionResult.errors?.push(`expectedToBeCalled: expected handler "${handler}" to be called ${times} times, received ${calledStepsForHandler?.length} times`);
+                        }
+                    }
+                    else {
+                        if (!calledStepsForHandler?.length || calledStepsForHandler.length === 0) {
+                            assertionPassed = false;
+                            testAssertionResult.errors?.push(`expectedToBeCalled: expected handler "${handler}" to be called at least once`);
+                        }
+                    }
+                }
+            }
+            testAssertionResult.passed = assertionPassed;
+            if (!assertionPassed) {
+                testPassed = false;
+            }
+            testResult.assertions.push(testAssertionResult);
+        }
+    }
+    /**
+     * Event
+     */
+    if ("event" in test) {
+        const eventName = test.event;
+        const assertions = test.assertions;
+        for (const assertion of assertions) {
+            // @TODO: apply matrix
+            if (cliOptions.assertionPattern &&
+                !assertion.description?.includes(cliOptions.assertionPattern)) {
+                continue;
+            }
+            let assertionPassed = true;
+            const { e } = (0, createTestInstance_1.createTestInstance)({
+                datafile: datafileContent,
+                cliOptions,
+                withLookups: assertion.withLookups,
+            });
+            let trackedEvent = null;
+            if (assertion.track) {
+                trackedEvent = await e.trackAsync(eventName, assertion.track);
+            }
+            if (assertion.actions) {
+                for (const action of assertion.actions) {
+                    if (action.type === "track") {
+                        await e.trackAsync(action.name, action.value);
+                    }
+                    else if (action.type === "setAttribute") {
+                        await e.setAttributeAsync(action.name, action.value);
+                    }
+                }
+            }
+            const testAssertionResult = {
+                passed: assertionPassed,
+                description: assertion.description,
+                errors: [],
+            };
+            // expectedToBeValid
+            if (typeof assertion.expectedToBeValid === "boolean") {
+                if ((assertion.expectedToBeValid === true && !trackedEvent) ||
+                    (assertion.expectedToBeValid === false && trackedEvent)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedToBeValid: expected ${assertion.expectedToBeValid}, received ${!assertion.expectedToBeValid}`);
+                }
+            }
+            // expectedToContinue
+            if (assertion.expectedToContinue) {
+                // @TODO: implement
+            }
+            // expectedEvent
+            if (assertion.expectedEvent) {
+                if (!checkIfObjectsAreDeepEqual(trackedEvent, assertion.expectedEvent)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedEvent: \n  expected: ${JSON.stringify(assertion.expectedEvent)}\n  received: ${JSON.stringify(trackedEvent)}`);
+                }
+            }
+            // expectedDestinations
+            if (assertion.expectedDestinations) {
+                // if (!assertion.expectedDestinations.includes(m.getDestinationName())) {
+                //   assertionPassed = false;
+                //   testAssertionResult.errors?.push(
+                //     `expectedDestinations: expected ${assertion.expectedDestinations.join(", ")}, received ${m.getDestinationName()}`,
+                //   );
+                // }
+            }
+            // expectedDestinationsByTag
+            if (assertion.expectedDestinationsByTag) {
+                // @TODO: implement
+            }
+            testAssertionResult.passed = assertionPassed;
+            if (!assertionPassed) {
+                testPassed = false;
+            }
+            testResult.assertions.push(testAssertionResult);
+        }
+    }
+    /**
+     * Destination
+     */
+    if ("destination" in test) {
+        const destinationName = test.destination;
+        const assertions = test.assertions;
+        for (const assertion of assertions) {
+            // @TODO: apply matrix
+            if (cliOptions.assertionPattern &&
+                !assertion.description?.includes(cliOptions.assertionPattern)) {
+                continue;
+            }
+            let assertionPassed = true;
+            const { e, getBodiesBySingleDestination } = (0, createTestInstance_1.createTestInstance)({
+                datafile: datafileContent,
+                cliOptions,
+                withLookups: assertion.withLookups,
+            });
+            if (assertion.actions) {
+                for (const action of assertion.actions) {
+                    if (action.type === "track") {
+                        await e.trackAsync(action.name, action.value);
+                    }
+                    else if (action.type === "setAttribute") {
+                        await e.setAttributeAsync(action.name, action.value);
+                    }
+                }
+            }
+            const testAssertionResult = {
+                passed: assertionPassed,
+                description: assertion.description,
+                errors: [],
+            };
+            // expectedToBeTransported
+            if (typeof assertion.expectedToBeTransported === "boolean") {
+                const bodies = getBodiesBySingleDestination(destinationName);
+                if ((assertion.expectedToBeTransported === false && bodies && bodies.length > 0) ||
+                    (assertion.expectedToBeTransported === true && (!bodies || bodies.length === 0))) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedToBeTransported: expected ${assertion.expectedToBeTransported}, received ${!assertion.expectedToBeTransported}`);
+                }
+            }
+            // expectedBody
+            if (assertion.expectedBody) {
+                const bodies = getBodiesBySingleDestination(destinationName);
+                if (!checkIfObjectsAreDeepEqual(bodies && bodies[0], assertion.expectedBody)) {
+                    assertionPassed = false;
+                    testAssertionResult.errors?.push(`expectedBody: \n  expected: ${JSON.stringify(assertion.expectedBody, null, 2)}\n  received: ${JSON.stringify(bodies && bodies[0], null, 2)}`);
+                }
+            }
+            // @TODO: expectedBodies
+            testAssertionResult.passed = assertionPassed;
+            if (!assertionPassed) {
+                testPassed = false;
+            }
+            testResult.assertions.push(testAssertionResult);
+        }
+    }
+    testResult.passed = testPassed;
+    return testResult;
+}
+function checkIfObjectsAreDeepEqual(a, b) {
+    // Handle null/undefined cases
+    if (a === null || b === null || a === undefined || b === undefined) {
+        return a === b;
+    }
+    // Handle primitive types
+    if (typeof a !== "object" || typeof b !== "object") {
+        return a === b;
+    }
+    // Handle arrays
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return a.every((item, index) => checkIfObjectsAreDeepEqual(item, b[index]));
+    }
+    // Handle objects
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    return aKeys.every((key) => {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) {
+            return false;
+        }
+        return checkIfObjectsAreDeepEqual(a[key], b[key]);
+    });
+}
+//# sourceMappingURL=executeTest.js.map