@react-native-harness/runtime 1.0.0-alpha.1

package/dist/rntl/spies.js

@@ -0,0 +1,553 @@
+import * as sinon from 'sinon';
+// 'any' is needed to accept 'any' functions
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const sandbox = sinon.createSandbox();
+export const clearAllSpies = () => {
+    sandbox.restore();
+};
+export const fn = (implementation) => {
+    const stub = sandbox.stub();
+    // Arrays to track instances and contexts manually
+    const instances = [];
+    const contexts = [];
+    // Store the original implementation
+    const originalImplementation = implementation;
+    // Create a wrapper that captures context and instances
+    const wrappedFunction = function (...args) {
+        // Capture the context (this value)
+        contexts.push(this);
+        // If called as constructor, capture the instance
+        if (new.target) {
+            const instance = Object.create(this.constructor?.prototype || {});
+            instances.push(instance);
+            // If there's an implementation, call it in constructor context
+            if (originalImplementation) {
+                const result = originalImplementation.apply(instance, args);
+                return result !== undefined ? result : instance;
+            }
+            return instance;
+        }
+        // Normal function call - call the original implementation if available
+        if (originalImplementation) {
+            return originalImplementation.apply(this, args);
+        }
+        // No implementation, return undefined
+        return undefined;
+    };
+    // Set up the initial behavior
+    stub.callsFake(wrappedFunction);
+    const jestSpy = Object.assign(stub, {
+        mock: {
+            calls: [],
+            instances,
+            contexts,
+            results: [],
+            lastCall: null,
+        },
+        mockClear: () => {
+            // Clear sinon internal data (the getters will now return empty arrays)
+            stub.resetHistory();
+            // Clear other mock tracking data that we manage directly
+            instances.length = 0;
+            contexts.length = 0;
+            return jestSpy;
+        },
+        mockReset: () => {
+            jestSpy.mockClear();
+            stub.resetBehavior();
+            return jestSpy;
+        },
+        mockRestore: () => {
+            if (stub.restore) {
+                stub.restore();
+            }
+            return jestSpy;
+        },
+        mockReturnValue: (value) => {
+            // Update the wrapper to always return the specified value
+            const returnWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return value !== undefined ? value : instance;
+                }
+                return value;
+            };
+            stub.callsFake(returnWrapper);
+            return jestSpy;
+        },
+        mockReturnValueOnce: (value) => {
+            stub
+                .onCall(stub.callCount)
+                .callsFake(function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return value !== undefined ? value : instance;
+                }
+                return value;
+            });
+            return jestSpy;
+        },
+        mockResolvedValue: (value) => {
+            const promiseWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.resolve(value);
+                }
+                return Promise.resolve(value);
+            };
+            stub.callsFake(promiseWrapper);
+            return jestSpy;
+        },
+        mockResolvedValueOnce: (value) => {
+            stub
+                .onCall(stub.callCount)
+                .callsFake(function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.resolve(value);
+                }
+                return Promise.resolve(value);
+            });
+            return jestSpy;
+        },
+        mockRejectedValue: (value) => {
+            const rejectWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.reject(value);
+                }
+                return Promise.reject(value);
+            };
+            stub.callsFake(rejectWrapper);
+            return jestSpy;
+        },
+        mockRejectedValueOnce: (value) => {
+            stub
+                .onCall(stub.callCount)
+                .callsFake(function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.reject(value);
+                }
+                return Promise.reject(value);
+            });
+            return jestSpy;
+        },
+        mockImplementation: (fn) => {
+            // Update the wrapper to use the new implementation
+            const newWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create(fn.prototype || {});
+                    instances.push(instance);
+                    const result = fn.apply(instance, args);
+                    return result !== undefined ? result : instance;
+                }
+                return fn.apply(this, args);
+            };
+            stub.callsFake(newWrapper);
+            return jestSpy;
+        },
+        mockImplementationOnce: (fn) => {
+            stub.onCall(stub.callCount).callsFake(fn);
+            return jestSpy;
+        },
+        // Convenience methods for Jest compatibility
+        toHaveBeenCalled: () => stub.called,
+        toHaveBeenCalledTimes: (expected) => stub.callCount === expected,
+        toHaveBeenCalledWith: (...args) => {
+            return stub
+                .getCalls()
+                .some((call) => call.args.length === args.length &&
+                call.args.every((arg, index) => arg === args[index]));
+        },
+        toHaveBeenLastCalledWith: (...args) => {
+            const calls = stub.getCalls();
+            if (calls.length === 0)
+                return false;
+            const lastCall = calls[calls.length - 1];
+            return (lastCall.args.length === args.length &&
+                lastCall.args.every((arg, index) => arg === args[index]));
+        },
+        toHaveBeenNthCalledWith: (nthCall, ...args) => {
+            const calls = stub.getCalls();
+            if (nthCall < 1 || nthCall > calls.length)
+                return false;
+            const call = calls[nthCall - 1];
+            return (call.args.length === args.length &&
+                call.args.every((arg, index) => arg === args[index]));
+        },
+        toHaveReturnedWith: (value) => {
+            return stub.getCalls().some((call) => call.returnValue === value);
+        },
+        toHaveLastReturnedWith: (value) => {
+            const calls = stub.getCalls();
+            if (calls.length === 0)
+                return false;
+            return calls[calls.length - 1].returnValue === value;
+        },
+        toHaveNthReturnedWith: (nthCall, value) => {
+            const calls = stub.getCalls();
+            if (nthCall < 1 || nthCall > calls.length)
+                return false;
+            return calls[nthCall - 1].returnValue === value;
+        },
+        toHaveReturnedTimes: (expected) => {
+            return (stub.getCalls().filter((call) => !call.exception).length === expected);
+        },
+        // Promise-specific helpers
+        toHaveResolvedWith: async (value) => {
+            const calls = stub.getCalls();
+            for (const call of calls) {
+                if (call.returnValue && typeof call.returnValue.then === 'function') {
+                    try {
+                        const resolved = await call.returnValue;
+                        if (resolved === value)
+                            return true;
+                    }
+                    catch {
+                        // Promise rejected, skip
+                    }
+                }
+            }
+            return false;
+        },
+        toHaveRejectedWith: async (value) => {
+            const calls = stub.getCalls();
+            for (const call of calls) {
+                if (call.returnValue && typeof call.returnValue.catch === 'function') {
+                    try {
+                        await call.returnValue;
+                        // Promise resolved, skip
+                    }
+                    catch (error) {
+                        if (error === value)
+                            return true;
+                    }
+                }
+            }
+            return false;
+        },
+        mockReturnThis: () => {
+            const thisWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return instance;
+                }
+                return this;
+            };
+            stub.callsFake(thisWrapper);
+            return jestSpy;
+        },
+    });
+    // Override the mock object's getters to provide real-time data
+    Object.defineProperty(jestSpy.mock, 'calls', {
+        get: () => {
+            return stub.getCalls().map((call) => call.args);
+        },
+        enumerable: true,
+    });
+    Object.defineProperty(jestSpy.mock, 'lastCall', {
+        get: () => {
+            const calls = stub.getCalls().map((call) => call.args);
+            return calls.length > 0 ? calls[calls.length - 1] : null;
+        },
+        enumerable: true,
+    });
+    Object.defineProperty(jestSpy.mock, 'results', {
+        get: () => {
+            return stub.getCalls().map((call) => {
+                if (call.exception) {
+                    return { type: 'throw', value: call.exception };
+                }
+                return { type: 'return', value: call.returnValue };
+            });
+        },
+        enumerable: true,
+    });
+    return jestSpy;
+};
+export const spyOn = (obj, method) => {
+    const stub = sandbox.stub(obj, method);
+    // Arrays to track instances and contexts manually
+    const instances = [];
+    const contexts = [];
+    // Store original method to capture context and instances
+    const originalMethod = obj[method];
+    // Create a wrapper that captures context and instances
+    const spyWrapper = function (...args) {
+        // Capture the context (this value)
+        contexts.push(this);
+        // If called as constructor, capture the instance
+        if (new.target && typeof originalMethod === 'function') {
+            const instance = Object.create(originalMethod.prototype || {});
+            instances.push(instance);
+            // Call original method as constructor
+            return originalMethod.apply(instance, args) || instance;
+        }
+        // Normal function call - use the original method
+        return originalMethod.apply(this, args);
+    };
+    // Set up the spy wrapper
+    stub.callsFake(spyWrapper);
+    const jestSpy = Object.assign(stub, {
+        mock: {
+            calls: [],
+            instances,
+            contexts,
+            results: [],
+            lastCall: null,
+        },
+        mockClear: () => {
+            // Clear sinon internal data (the getters will now return empty arrays)
+            stub.resetHistory();
+            // Clear other mock tracking data that we manage directly
+            jestSpy.mock.instances = [];
+            jestSpy.mock.contexts = [];
+            jestSpy.mock.calls = [];
+            jestSpy.mock.results = [];
+            jestSpy.mock.lastCall = null;
+            return jestSpy;
+        },
+        mockReset: () => {
+            jestSpy.mockClear();
+            stub.resetBehavior();
+            return jestSpy;
+        },
+        mockRestore: () => {
+            if (stub.restore) {
+                stub.restore();
+            }
+            return jestSpy;
+        },
+        mockReturnValue: (value) => {
+            const returnWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return value !== undefined ? value : instance;
+                }
+                return value;
+            };
+            stub.callsFake(returnWrapper);
+            return jestSpy;
+        },
+        mockReturnValueOnce: (value) => {
+            stub
+                .onCall(stub.callCount)
+                .callsFake(function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return value !== undefined ? value : instance;
+                }
+                return value;
+            });
+            return jestSpy;
+        },
+        mockResolvedValue: (value) => {
+            const promiseWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.resolve(value);
+                }
+                return Promise.resolve(value);
+            };
+            stub.callsFake(promiseWrapper);
+            return jestSpy;
+        },
+        mockResolvedValueOnce: (value) => {
+            stub
+                .onCall(stub.callCount)
+                .callsFake(function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.resolve(value);
+                }
+                return Promise.resolve(value);
+            });
+            return jestSpy;
+        },
+        mockRejectedValue: (value) => {
+            const rejectWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.reject(value);
+                }
+                return Promise.reject(value);
+            };
+            stub.callsFake(rejectWrapper);
+            return jestSpy;
+        },
+        mockRejectedValueOnce: (value) => {
+            stub
+                .onCall(stub.callCount)
+                .callsFake(function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return Promise.reject(value);
+                }
+                return Promise.reject(value);
+            });
+            return jestSpy;
+        },
+        mockImplementation: (fn) => {
+            // Update the wrapper to use the new implementation
+            const newWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target && typeof fn === 'function') {
+                    const instance = Object.create(fn.prototype || {});
+                    instances.push(instance);
+                    const result = fn.apply(instance, args);
+                    return result !== undefined ? result : instance;
+                }
+                return fn.apply(this, args);
+            };
+            stub.callsFake(newWrapper);
+            return jestSpy;
+        },
+        mockImplementationOnce: (fn) => {
+            stub.onCall(stub.callCount).callsFake(fn);
+            return jestSpy;
+        },
+        // Convenience methods for Jest compatibility
+        toHaveBeenCalled: () => stub.called,
+        toHaveBeenCalledTimes: (expected) => stub.callCount === expected,
+        toHaveBeenCalledWith: (...args) => {
+            return stub
+                .getCalls()
+                .some((call) => call.args.length === args.length &&
+                call.args.every((arg, index) => arg === args[index]));
+        },
+        toHaveBeenLastCalledWith: (...args) => {
+            const calls = stub.getCalls();
+            if (calls.length === 0)
+                return false;
+            const lastCall = calls[calls.length - 1];
+            return (lastCall.args.length === args.length &&
+                lastCall.args.every((arg, index) => arg === args[index]));
+        },
+        toHaveBeenNthCalledWith: (nthCall, ...args) => {
+            const calls = stub.getCalls();
+            if (nthCall < 1 || nthCall > calls.length)
+                return false;
+            const call = calls[nthCall - 1];
+            return (call.args.length === args.length &&
+                call.args.every((arg, index) => arg === args[index]));
+        },
+        toHaveReturnedWith: (value) => {
+            return stub.getCalls().some((call) => call.returnValue === value);
+        },
+        toHaveLastReturnedWith: (value) => {
+            const calls = stub.getCalls();
+            if (calls.length === 0)
+                return false;
+            return calls[calls.length - 1].returnValue === value;
+        },
+        toHaveNthReturnedWith: (nthCall, value) => {
+            const calls = stub.getCalls();
+            if (nthCall < 1 || nthCall > calls.length)
+                return false;
+            return calls[nthCall - 1].returnValue === value;
+        },
+        toHaveReturnedTimes: (expected) => {
+            return (stub.getCalls().filter((call) => !call.exception).length === expected);
+        },
+        // Promise-specific helpers
+        toHaveResolvedWith: async (value) => {
+            const calls = stub.getCalls();
+            for (const call of calls) {
+                if (call.returnValue && typeof call.returnValue.then === 'function') {
+                    try {
+                        const resolved = await call.returnValue;
+                        if (resolved === value)
+                            return true;
+                    }
+                    catch {
+                        // Promise rejected, skip
+                    }
+                }
+            }
+            return false;
+        },
+        toHaveRejectedWith: async (value) => {
+            const calls = stub.getCalls();
+            for (const call of calls) {
+                if (call.returnValue && typeof call.returnValue.catch === 'function') {
+                    try {
+                        await call.returnValue;
+                        // Promise resolved, skip
+                    }
+                    catch (error) {
+                        if (error === value)
+                            return true;
+                    }
+                }
+            }
+            return false;
+        },
+        mockReturnThis: () => {
+            const thisWrapper = function (...args) {
+                contexts.push(this);
+                if (new.target) {
+                    const instance = Object.create({});
+                    instances.push(instance);
+                    return instance;
+                }
+                return this;
+            };
+            stub.callsFake(thisWrapper);
+            return jestSpy;
+        },
+    });
+    Object.defineProperty(jestSpy.mock, 'calls', {
+        get: () => {
+            return stub.getCalls().map((call) => call.args);
+        },
+        enumerable: true,
+    });
+    Object.defineProperty(jestSpy.mock, 'lastCall', {
+        get: () => {
+            const calls = stub.getCalls().map((call) => call.args);
+            return calls.length > 0 ? calls[calls.length - 1] : null;
+        },
+        enumerable: true,
+    });
+    Object.defineProperty(jestSpy.mock, 'results', {
+        get: () => {
+            return stub.getCalls().map((call) => {
+                if (call.exception) {
+                    return { type: 'throw', value: call.exception };
+                }
+                return { type: 'return', value: call.returnValue };
+            });
+        },
+        enumerable: true,
+    });
+    return jestSpy;
+};
+export const spy = sinon.spy;

package/dist/rntl/userEvent.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@react-native-harness/interaction-engine';
+export declare const userEvent: {
+    press: (elementRef: ElementRef, options?: Omit<{
+        elementRef: ElementRef;
+    }, "elementRef"> | undefined) => Promise<void>;
+    longPress: (elementRef: ElementRef, options?: Omit<{
+        elementRef: ElementRef;
+    }, "elementRef"> | undefined) => Promise<void>;
+    type: (elementRef: ElementRef, options?: Omit<{
+        elementRef: ElementRef;
+        text: string;
+    }, "elementRef"> | undefined) => Promise<void>;
+    clear: (elementRef: ElementRef, options?: Omit<{
+        elementRef: ElementRef;
+    }, "elementRef"> | undefined) => Promise<void>;
+    scroll: (elementRef: ElementRef, options?: Omit<{
+        elementRef: ElementRef;
+        direction: "up" | "down" | "left" | "right";
+        distance: number;
+    }, "elementRef"> | undefined) => Promise<void>;
+};
+//# sourceMappingURL=userEvent.d.ts.map

package/dist/rntl/userEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userEvent.d.ts","sourceRoot":"","sources":["../../src/rntl/userEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,UAAU,EACX,MAAM,0CAA0C,CAAC;AAkBlD,eAAO,MAAM,SAAS;wBAbN,UAAU;;;4BAAV,UAAU;;;uBAAV,UAAU;;;;wBAAV,UAAU;;;yBAAV,UAAU;;;;;CAmBzB,CAAC"}

package/dist/rntl/userEvent.js

@@ -0,0 +1,19 @@
+import { getClient } from './client.js';
+const getUserEventAction = (actionType) => {
+    return (elementRef, options) => {
+        return getClient().rpc.executeAction({
+            type: actionType,
+            payload: {
+                elementRef,
+                ...(options || {}),
+            },
+        });
+    };
+};
+export const userEvent = {
+    press: getUserEventAction('press'),
+    longPress: getUserEventAction('longPress'),
+    type: getUserEventAction('type'),
+    clear: getUserEventAction('clear'),
+    scroll: getUserEventAction('scroll'),
+};

package/dist/runner/errors.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedError } from '@react-native-harness/bridge';
+export declare class TestExecutionError extends Error {
+    file: string;
+    suite: string;
+    test: string;
+    constructor(error: unknown, file: string, suite: string, test: string);
+    toSerializedJSON(): SerializedError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/runner/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runner/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;gBAED,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IASrE,gBAAgB,IAAI,eAAe;CAcpC"}

package/dist/runner/errors.js

@@ -0,0 +1,23 @@
+export class TestExecutionError extends Error {
+    file;
+    suite;
+    test;
+    constructor(error, file, suite, test) {
+        super('Test execution error');
+        this.name = 'TestExecutionError';
+        this.file = file;
+        this.suite = suite;
+        this.test = test;
+        this.cause = error;
+    }
+    toSerializedJSON() {
+        const causeName = this.cause instanceof Error ? this.cause.name : 'Unknown name';
+        const causeMessage = this.cause instanceof Error ? this.cause.message : 'Unknown message';
+        const causeStack = this.cause instanceof Error ? this.cause.stack : undefined;
+        return {
+            name: causeName,
+            message: causeMessage,
+            stack: causeStack,
+        };
+    }
+}

package/dist/runner/factory.d.ts

@@ -0,0 +1,3 @@
+import { TestRunner } from './types.js';
+export declare const getTestRunner: () => TestRunner;
+//# sourceMappingURL=factory.d.ts.map

package/dist/runner/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/runner/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,eAAO,MAAM,aAAa,QAAO,UAehC,CAAC"}

package/dist/runner/factory.js

@@ -0,0 +1,17 @@
+import { getEmitter } from '../utils/emitter.js';
+import { runSuite } from './runSuite.js';
+export const getTestRunner = () => {
+    const events = getEmitter();
+    return {
+        events,
+        run: async (testSuite, testFilePath) => {
+            return runSuite(testSuite, {
+                events,
+                testFilePath,
+            });
+        },
+        dispose: () => {
+            events.clearAllListeners();
+        },
+    };
+};

package/dist/runner/hooks.d.ts

@@ -0,0 +1,4 @@
+import type { TestSuite } from '@react-native-harness/bridge';
+export type HookType = 'beforeEach' | 'afterEach' | 'beforeAll' | 'afterAll';
+export declare const runHooks: (suite: TestSuite, hookType: HookType) => Promise<void>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/runner/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/runner/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC;AAuC7E,eAAO,MAAM,QAAQ,GACnB,OAAO,SAAS,EAChB,UAAU,QAAQ,KACjB,OAAO,CAAC,IAAI,CAMd,CAAC"}