@avimate/msfs-jest-utils 1.0.0

package/dist/mocks/SDKClasses.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Mock implementations of MSFS SDK classes for testing.
+ *
+ * These mocks provide the minimal interface needed for components to work in tests.
+ */
+/**
+ * Mock DisplayComponent base class
+ */
+export declare class MockDisplayComponent<P = any> {
+    props: P;
+    context?: any;
+    constructor(props: P);
+    onBeforeRender?(): void;
+    onAfterRender?(vnode?: any): void;
+    render(): any;
+    destroy?(): void;
+}
+/**
+ * Mock FSComponent utilities
+ */
+export declare const MockFSComponent: {
+    buildComponent: (type: any, props: any, ...children: any[]) => any;
+    Fragment: (props: any, ...children: any[]) => any;
+    render: (vnode: any, container: HTMLElement | Element) => Element | null;
+    createRef: <T = any>() => {
+        instance: T | null;
+    };
+};
+/**
+ * Setup SDK classes as globals
+ */
+export declare function setupSDKClasses(): void;

package/dist/mocks/SDKClasses.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Mock implementations of MSFS SDK classes for testing.
+ *
+ * These mocks provide the minimal interface needed for components to work in tests.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockFSComponent = exports.MockDisplayComponent = void 0;
+exports.setupSDKClasses = setupSDKClasses;
+/**
+ * Mock DisplayComponent base class
+ */
+class MockDisplayComponent {
+    constructor(props) {
+        this.props = props;
+    }
+    onBeforeRender() { }
+    onAfterRender(vnode) { }
+    render() {
+        return null;
+    }
+    destroy() { }
+}
+exports.MockDisplayComponent = MockDisplayComponent;
+/**
+ * Mock FSComponent utilities
+ */
+exports.MockFSComponent = {
+    buildComponent: (type, props, ...children) => {
+        if (typeof type === 'function') {
+            // If it's a component class, instantiate it
+            return new type(props);
+        }
+        // If it's a string (HTML/SVG tag), return a VNode-like object
+        return {
+            type,
+            props: props || {},
+            children: children || [],
+            instance: null,
+        };
+    },
+    Fragment: (props, ...children) => {
+        return {
+            type: 'Fragment',
+            props: props || {},
+            children: children || [],
+        };
+    },
+    render: (vnode, container) => {
+        if (!vnode)
+            return null;
+        // Simple rendering logic for tests
+        if (typeof vnode.type === 'string') {
+            // HTML/SVG element
+            const element = document.createElementNS(vnode.type === 'svg' || ['g', 'circle', 'line', 'text', 'polygon'].includes(vnode.type)
+                ? 'http://www.w3.org/2000/svg'
+                : 'http://www.w3.org/1999/xhtml', vnode.type);
+            // Set attributes
+            if (vnode.props) {
+                Object.keys(vnode.props).forEach(key => {
+                    if (key === 'class') {
+                        element.setAttribute('class', vnode.props[key]);
+                    }
+                    else if (key === 'key' || key === 'ref') {
+                        // Skip React-like props
+                    }
+                    else {
+                        element.setAttribute(key, String(vnode.props[key]));
+                    }
+                });
+            }
+            // Set text content if it's a text node
+            if (vnode.children && vnode.children.length === 1 && typeof vnode.children[0] === 'string') {
+                element.textContent = vnode.children[0];
+            }
+            else if (vnode.children) {
+                // Recursively render children
+                vnode.children.forEach((child) => {
+                    if (child) {
+                        const childElement = exports.MockFSComponent.render(child, element);
+                        if (childElement) {
+                            element.appendChild(childElement);
+                        }
+                    }
+                });
+            }
+            vnode.instance = element;
+            container.appendChild(element);
+            return element;
+        }
+        else if (typeof vnode.type === 'function') {
+            // Component
+            const component = new vnode.type(vnode.props);
+            const childVNode = component.render();
+            if (childVNode) {
+                return exports.MockFSComponent.render(childVNode, container);
+            }
+        }
+        return null;
+    },
+    createRef: () => {
+        return { instance: null };
+    },
+};
+/**
+ * Setup SDK classes as globals
+ */
+function setupSDKClasses() {
+    const globalObj = globalThis;
+    // Make DisplayComponent available globally
+    if (typeof globalObj.DisplayComponent === 'undefined') {
+        globalObj.DisplayComponent = MockDisplayComponent;
+    }
+    // Make FSComponent available globally
+    if (typeof globalObj.FSComponent === 'undefined') {
+        globalObj.FSComponent = exports.MockFSComponent;
+    }
+}

package/dist/mocks/SimVarMock.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Mock implementation of SimVar API for testing MSFS instruments.
+ *
+ * This provides a complete simulation of the SimVar system, allowing you to:
+ * - Set and get SimVar values
+ * - Register SimVars for efficient access
+ * - Simulate different data types (number, string, bool, structs)
+ * - Track SimVar access for testing
+ */
+export interface SimVarValue {
+    value: any;
+    unit: string;
+    dataSource?: string;
+    accessCount?: number;
+    lastAccessTime?: number;
+}
+export interface SimVarAccessLog {
+    name: string;
+    unit: string;
+    operation: 'get' | 'set';
+    value?: any;
+    timestamp: number;
+}
+/**
+ * Mock SimVar implementation for testing
+ */
+export declare class SimVarMock {
+    private static instance;
+    private simVars;
+    private registeredIds;
+    private registeredSimVars;
+    private nextRegisteredId;
+    private accessLog;
+    private maxLogSize;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): SimVarMock;
+    /**
+     * Initialize default SimVars with common values
+     */
+    private initializeDefaults;
+    /**
+     * Get a SimVar value
+     */
+    getSimVarValue(name: string, unit: string, dataSource?: string): any;
+    /**
+     * Set a SimVar value
+     */
+    setSimVarValue(name: string, unit: string, value: any, dataSource?: string): void;
+    /**
+     * Register a SimVar for efficient access
+     */
+    getRegisteredId(name: string, unit: string, dataSource?: string): number;
+    /**
+     * Get value using registered ID
+     */
+    getValueReg(registeredId: number): any;
+    /**
+     * Set value using registered ID
+     */
+    setValueReg(registeredId: number, value: any): void;
+    /**
+     * Get access log
+     */
+    getAccessLog(): SimVarAccessLog[];
+    /**
+     * Clear access log
+     */
+    clearAccessLog(): void;
+    /**
+     * Get all SimVars
+     */
+    getAllSimVars(): Map<string, SimVarValue>;
+    /**
+     * Reset all SimVars to defaults
+     */
+    reset(): void;
+    /**
+     * Get SimVar by name (first match)
+     */
+    getSimVar(name: string): SimVarValue | undefined;
+    /**
+     * Check if SimVar exists
+     */
+    hasSimVar(name: string, unit: string, dataSource?: string): boolean;
+    private getKey;
+    private parseKey;
+    private getDefaultValue;
+    private coerceValue;
+    private logAccess;
+}
+/**
+ * Global SimVar mock instance
+ */
+export declare const simVarMock: SimVarMock;

package/dist/mocks/SimVarMock.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Mock implementation of SimVar API for testing MSFS instruments.
+ *
+ * This provides a complete simulation of the SimVar system, allowing you to:
+ * - Set and get SimVar values
+ * - Register SimVars for efficient access
+ * - Simulate different data types (number, string, bool, structs)
+ * - Track SimVar access for testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simVarMock = exports.SimVarMock = void 0;
+/**
+ * Mock SimVar implementation for testing
+ */
+class SimVarMock {
+    constructor() {
+        this.simVars = new Map();
+        this.registeredIds = new Map();
+        this.registeredSimVars = new Map();
+        this.nextRegisteredId = 0;
+        this.accessLog = [];
+        this.maxLogSize = 10000;
+        this.initializeDefaults();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!SimVarMock.instance) {
+            SimVarMock.instance = new SimVarMock();
+        }
+        return SimVarMock.instance;
+    }
+    /**
+     * Initialize default SimVars with common values
+     */
+    initializeDefaults() {
+        // Common aircraft state SimVars
+        this.setSimVarValue('PLANE LATITUDE', 'degrees', 0);
+        this.setSimVarValue('PLANE LONGITUDE', 'degrees', 0);
+        this.setSimVarValue('PLANE ALTITUDE', 'feet', 0);
+        this.setSimVarValue('AIRSPEED INDICATED', 'knots', 0);
+        this.setSimVarValue('VERTICAL SPEED', 'feet per minute', 0);
+        this.setSimVarValue('PLANE HEADING DEGREES TRUE', 'degrees', 0);
+        this.setSimVarValue('PLANE PITCH DEGREES', 'degrees', 0);
+        this.setSimVarValue('PLANE BANK DEGREES', 'degrees', 0);
+        this.setSimVarValue('SIM ON GROUND', 'bool', 1);
+        this.setSimVarValue('ENGINE RPM:1', 'Rpm', 0);
+        this.setSimVarValue('GENERAL ENG THROTTLE LEVER POSITION:1', 'percent', 0);
+    }
+    /**
+     * Get a SimVar value
+     */
+    getSimVarValue(name, unit, dataSource = '') {
+        const key = this.getKey(name, unit, dataSource);
+        const simVar = this.simVars.get(key);
+        this.logAccess(name, unit, 'get', simVar?.value);
+        if (simVar) {
+            simVar.accessCount = (simVar.accessCount || 0) + 1;
+            simVar.lastAccessTime = Date.now();
+            return simVar.value;
+        }
+        // Return default based on unit type
+        return this.getDefaultValue(unit);
+    }
+    /**
+     * Set a SimVar value
+     */
+    setSimVarValue(name, unit, value, dataSource = '') {
+        const key = this.getKey(name, unit, dataSource);
+        const existing = this.simVars.get(key);
+        this.simVars.set(key, {
+            value: this.coerceValue(value, unit),
+            unit,
+            dataSource,
+            accessCount: existing?.accessCount || 0,
+            lastAccessTime: Date.now()
+        });
+        this.logAccess(name, unit, 'set', value);
+    }
+    /**
+     * Register a SimVar for efficient access
+     */
+    getRegisteredId(name, unit, dataSource = '') {
+        const key = this.getKey(name, unit, dataSource);
+        if (this.registeredSimVars.has(key)) {
+            return this.registeredSimVars.get(key);
+        }
+        const id = this.nextRegisteredId++;
+        this.registeredSimVars.set(key, id);
+        this.registeredIds.set(id, key);
+        // Initialize if not exists
+        if (!this.simVars.has(key)) {
+            this.setSimVarValue(name, unit, this.getDefaultValue(unit), dataSource);
+        }
+        return id;
+    }
+    /**
+     * Get value using registered ID
+     */
+    getValueReg(registeredId) {
+        const key = this.registeredIds.get(registeredId);
+        if (!key) {
+            return null;
+        }
+        const simVar = this.simVars.get(key);
+        if (simVar) {
+            simVar.accessCount = (simVar.accessCount || 0) + 1;
+            simVar.lastAccessTime = Date.now();
+            return simVar.value;
+        }
+        return null;
+    }
+    /**
+     * Set value using registered ID
+     */
+    setValueReg(registeredId, value) {
+        const key = this.registeredIds.get(registeredId);
+        if (!key) {
+            return;
+        }
+        const [name, unit, dataSource] = this.parseKey(key);
+        this.setSimVarValue(name, unit, value, dataSource);
+    }
+    /**
+     * Get access log
+     */
+    getAccessLog() {
+        return [...this.accessLog];
+    }
+    /**
+     * Clear access log
+     */
+    clearAccessLog() {
+        this.accessLog = [];
+    }
+    /**
+     * Get all SimVars
+     */
+    getAllSimVars() {
+        return new Map(this.simVars);
+    }
+    /**
+     * Reset all SimVars to defaults
+     */
+    reset() {
+        this.simVars.clear();
+        this.registeredIds.clear();
+        this.registeredSimVars.clear();
+        this.nextRegisteredId = 0;
+        this.accessLog = [];
+        this.initializeDefaults();
+    }
+    /**
+     * Get SimVar by name (first match)
+     */
+    getSimVar(name) {
+        for (const [key, value] of this.simVars.entries()) {
+            if (key.startsWith(`${name}|`)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check if SimVar exists
+     */
+    hasSimVar(name, unit, dataSource = '') {
+        return this.simVars.has(this.getKey(name, unit, dataSource));
+    }
+    getKey(name, unit, dataSource) {
+        return `${name}|${unit}|${dataSource}`;
+    }
+    parseKey(key) {
+        const parts = key.split('|');
+        return [parts[0], parts[1], parts[2] || ''];
+    }
+    getDefaultValue(unit) {
+        if (unit.toLowerCase().includes('bool')) {
+            return 0;
+        }
+        if (unit.toLowerCase().includes('string')) {
+            return '';
+        }
+        return 0;
+    }
+    coerceValue(value, unit) {
+        if (unit.toLowerCase().includes('bool')) {
+            return value ? 1 : 0;
+        }
+        if (unit.toLowerCase().includes('string')) {
+            return String(value);
+        }
+        return Number(value);
+    }
+    logAccess(name, unit, operation, value) {
+        this.accessLog.push({
+            name,
+            unit,
+            operation,
+            value,
+            timestamp: Date.now()
+        });
+        // Keep log size manageable
+        if (this.accessLog.length > this.maxLogSize) {
+            this.accessLog = this.accessLog.slice(-this.maxLogSize);
+        }
+    }
+}
+exports.SimVarMock = SimVarMock;
+/**
+ * Global SimVar mock instance
+ */
+exports.simVarMock = SimVarMock.getInstance();

package/dist/mocks/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MSFS Unit Test Framework - Mocks
+ *
+ * Provides mock implementations of MSFS APIs for testing instruments without the simulator.
+ */
+export * from './SimVarMock';
+export * from './CoherentMock';
+export * from './SDKAdapter';
+export * from './MSFSGlobals';

package/dist/mocks/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * MSFS Unit Test Framework - Mocks
+ *
+ * Provides mock implementations of MSFS APIs for testing instruments without the simulator.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SimVarMock"), exports);
+__exportStar(require("./CoherentMock"), exports);
+__exportStar(require("./SDKAdapter"), exports);
+__exportStar(require("./MSFSGlobals"), exports);

package/dist/setupTests.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Jest setup file - runs before all tests
+ *
+ * This file is automatically loaded by Jest (configured in jest.config.js)
+ *
+ * IMPORTANT: Order matters! Setup must happen in this order:
+ * 1. TextEncoder/TextDecoder polyfills
+ * 2. JSX type definitions (for TypeScript)
+ * 3. MSFS globals (BaseInstrument, DisplayComponent, FSComponent, etc.)
+ * 4. SimVar and Coherent mocks
+ * 5. SDK can now be imported safely
+ */
+export {};

package/dist/setupTests.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Jest setup file - runs before all tests
+ *
+ * This file is automatically loaded by Jest (configured in jest.config.js)
+ *
+ * IMPORTANT: Order matters! Setup must happen in this order:
+ * 1. TextEncoder/TextDecoder polyfills
+ * 2. JSX type definitions (for TypeScript)
+ * 3. MSFS globals (BaseInstrument, DisplayComponent, FSComponent, etc.)
+ * 4. SimVar and Coherent mocks
+ * 5. SDK can now be imported safely
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// ============================================
+// STEP 0: Load JSX type definitions
+// ============================================
+/// <reference path="./mocks/jsx.d.ts" />
+// ============================================
+// STEP 1: Polyfills for Node.js environment
+// ============================================
+const util_1 = require("util");
+if (typeof globalThis.TextEncoder === 'undefined') {
+    globalThis.TextEncoder = util_1.TextEncoder;
+}
+if (typeof globalThis.TextDecoder === 'undefined') {
+    globalThis.TextDecoder = util_1.TextDecoder;
+}
+if (typeof global.TextEncoder === 'undefined') {
+    global.TextEncoder = util_1.TextEncoder;
+}
+if (typeof global.TextDecoder === 'undefined') {
+    global.TextDecoder = util_1.TextDecoder;
+}
+// ============================================
+// STEP 2: Setup MSFS globals FIRST
+// This must happen before any SDK imports
+// ============================================
+const { setupMSFSGlobals } = require('./mocks/MSFSGlobals');
+setupMSFSGlobals();
+// ============================================
+// STEP 3: Setup SimVar and Coherent mocks
+// ============================================
+const { SimVarMock } = require('./mocks/SimVarMock');
+const { CoherentMock } = require('./mocks/CoherentMock');
+const simVarMock = SimVarMock.getInstance();
+const coherentMock = CoherentMock.getInstance();
+const globalObj = globalThis;
+// Setup SimVar mock
+if (typeof globalObj.SimVar === 'undefined') {
+    globalObj.SimVar = {
+        GetSimVarValue: (name, unit, dataSource = '') => {
+            return simVarMock.getSimVarValue(name, unit, dataSource);
+        },
+        SetSimVarValue: (name, unit, value, dataSource = '') => {
+            return Promise.resolve(simVarMock.setSimVarValue(name, unit, value, dataSource));
+        },
+        GetRegisteredId: (name, unit, dataSource = '') => {
+            return simVarMock.getRegisteredId(name, unit, dataSource);
+        },
+    };
+}
+// Setup simvar global (used by SDK internally)
+if (typeof globalObj.simvar === 'undefined') {
+    globalObj.simvar = {
+        getValueReg: (id) => simVarMock.getValueReg(id),
+        getValueReg_String: (id) => simVarMock.getValueReg(id),
+        getValue_LatLongAlt: () => ({ lat: 0, long: 0, alt: 0 }),
+        getValue_LatLongAltPBH: () => ({ lat: 0, long: 0, alt: 0, pitch: 0, bank: 0, heading: 0 }),
+        getValue_PBH: () => ({ pitch: 0, bank: 0, heading: 0 }),
+        getValue_PID_STRUCT: () => ({ p: 0, i: 0, d: 0 }),
+        getValue_XYZ: () => ({ x: 0, y: 0, z: 0 }),
+    };
+}
+// Setup Coherent mock
+if (typeof globalObj.Coherent === 'undefined') {
+    globalObj.Coherent = {
+        call: (method, ...args) => coherentMock.call(method, ...args),
+        on: (eventName, callback) => coherentMock.on(eventName, callback),
+        off: (eventName, callback) => coherentMock.off(eventName, callback),
+    };
+}
+// Setup fetch mock (for agent logging in production code)
+if (typeof globalObj.fetch === 'undefined') {
+    globalObj.fetch = async (url, init) => {
+        // Mock fetch - just return a successful response
+        // This prevents errors when code tries to log to agent endpoints
+        return Promise.resolve({
+            ok: true,
+            status: 200,
+            statusText: 'OK',
+            headers: new Headers(),
+            url: typeof url === 'string' ? url : url.toString(),
+            redirected: false,
+            type: 'default',
+            body: null,
+            bodyUsed: false,
+            clone: () => {
+                throw new Error('Not implemented');
+            },
+            arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+            blob: () => Promise.resolve(new Blob()),
+            formData: () => Promise.resolve(new FormData()),
+            json: () => Promise.resolve({}),
+            text: () => Promise.resolve(''),
+            bytes: () => Promise.resolve(new Uint8Array(0)),
+        });
+    };
+}

package/dist/test-utils/ComponentTestHelper.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Helper utilities for testing FSComponent components.
+ *
+ * Provides utilities to render components, query DOM, and test component behavior.
+ */
+import { VNode } from '@microsoft/msfs-sdk';
+import { TestEnvironment } from './TestEnvironment';
+export declare class ComponentTestHelper {
+    private env;
+    private container;
+    constructor(env: TestEnvironment);
+    /**
+     * Render a component to DOM
+     */
+    renderComponent<P>(ComponentClass: new (props: P) => any, // Use 'any' to avoid version conflicts
+    props: P): {
+        component: any;
+        element: HTMLElement;
+        vnode: VNode;
+    };
+    /**
+     * Query selector within container
+     */
+    querySelector(selector: string): Element | null;
+    /**
+     * Query selector all within container
+     */
+    querySelectorAll(selector: string): NodeListOf<Element>;
+    /**
+     * Get container element
+     */
+    getContainer(): HTMLElement;
+    /**
+     * Clean up - remove container from DOM
+     */
+    cleanup(): void;
+    /**
+     * Wait for async updates (useful for Subject subscriptions)
+     */
+    waitForUpdate(ms?: number): Promise<void>;
+    /**
+     * Get text content of element
+     */
+    getTextContent(selector: string): string | null;
+    /**
+     * Check if element has class
+     */
+    hasClass(selector: string, className: string): boolean;
+    /**
+     * Get attribute value
+     */
+    getAttribute(selector: string, attrName: string): string | null;
+    /**
+     * Get computed style property
+     */
+    getStyle(selector: string, property: string): string;
+    /**
+     * Query SVG element by selector
+     */
+    querySelectorSVG(selector: string): SVGElement | null;
+    /**
+     * Query all SVG elements by selector
+     */
+    querySelectorAllSVG(selector: string): SVGElement[];
+    /**
+     * Get SVG attribute value
+     */
+    getSVGAttribute(selector: string, attrName: string): string | null;
+    /**
+     * Check if SVG element exists and has specific attribute value
+     */
+    hasSVGAttribute(selector: string, attrName: string, value: string): boolean;
+}