@wdio/image-comparison-core 1.0.0

package/dist/helpers/options.test.js

@@ -0,0 +1,428 @@
+import { describe, it, expect } from 'vitest';
+import { defaultOptions, methodCompareOptions, screenMethodCompareOptions, createBeforeScreenshotOptions, buildAfterScreenshotOptions } from './options.js';
+describe('options', () => {
+    describe('defaultOptions', () => {
+        it('should return the default options when no options are provided', () => {
+            expect(defaultOptions({})).toMatchSnapshot();
+        });
+        it('should return the provided options when options are provided', () => {
+            const options = {
+                addressBarShadowPadding: 1,
+                autoSaveBaseline: true,
+                formatImageName: '{foo}-{bar}',
+                savePerInstance: true,
+                toolBarShadowPadding: 1,
+                disableBlinkingCursor: true,
+                disableCSSAnimation: true,
+                fullPageScrollTimeout: 12345,
+                hideScrollBars: true,
+                blockOutSideBar: true,
+                blockOutStatusBar: true,
+                blockOutToolBar: true,
+                createJsonReportFiles: true,
+                diffPixelBoundingBoxProximity: 123,
+                ignoreAlpha: true,
+                ignoreAntialiasing: true,
+                ignoreColors: true,
+                ignoreLess: true,
+                ignoreNothing: true,
+                rawMisMatchPercentage: true,
+                returnAllCompareData: true,
+                saveAboveTolerance: 12,
+                scaleImagesToSameSize: true,
+                tabbableOptions: {
+                    circle: {
+                        backgroundColor: 'backgroundColor',
+                        borderColor: 'borderColor',
+                        borderWidth: 123,
+                        fontColor: 'fontColor',
+                        fontFamily: 'fontFamily',
+                        fontSize: 321,
+                        size: 567,
+                        showNumber: false,
+                    },
+                    line: {
+                        color: 'color',
+                        width: 987,
+                    },
+                },
+            };
+            expect(defaultOptions(options)).toMatchSnapshot();
+        });
+    });
+    describe('methodCompareOptions', () => {
+        it('should not return the method options when no options are provided', () => {
+            expect(methodCompareOptions({})).toMatchSnapshot();
+        });
+        it('should return the provided options when options are provided', () => {
+            const options = {
+                blockOut: [{ height: 1, width: 2, x: 3, y: 4 }],
+                ignoreAlpha: true,
+                ignoreAntialiasing: true,
+                ignoreColors: true,
+                ignoreLess: true,
+                ignoreNothing: true,
+                rawMisMatchPercentage: true,
+                returnAllCompareData: true,
+                saveAboveTolerance: 12,
+                scaleImagesToSameSize: true,
+            };
+            expect(methodCompareOptions(options)).toMatchSnapshot();
+        });
+    });
+    describe('screenMethodCompareOptions', () => {
+        it('should not return the screen method options when no options are provided', () => {
+            expect(screenMethodCompareOptions({})).toMatchSnapshot();
+        });
+        it('should return the provided options when options are provided', () => {
+            const options = {
+                blockOutSideBar: false,
+                blockOutStatusBar: false,
+                blockOutToolBar: false,
+                blockOut: [{ height: 1, width: 2, x: 3, y: 4 }],
+                ignoreAlpha: true,
+                ignoreAntialiasing: true,
+                ignoreColors: true,
+                ignoreLess: true,
+                ignoreNothing: true,
+                rawMisMatchPercentage: true,
+                returnAllCompareData: true,
+                saveAboveTolerance: 12,
+                scaleImagesToSameSize: true,
+            };
+            expect(screenMethodCompareOptions(options)).toMatchSnapshot();
+        });
+    });
+    describe('createBeforeScreenshotOptions', () => {
+        const mockElement = { tagName: 'DIV' };
+        const baseWicOptions = {
+            addressBarShadowPadding: 10,
+            toolBarShadowPadding: 20,
+        };
+        it('should create options with defaults when minimal options are provided', () => {
+            const result = createBeforeScreenshotOptions('testInstance', {}, baseWicOptions);
+            expect(result).toEqual({
+                instanceData: 'testInstance',
+                addressBarShadowPadding: 10,
+                toolBarShadowPadding: 20,
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                hideElements: [],
+                noScrollBars: false,
+                removeElements: [],
+                waitForFontsLoaded: false,
+            });
+        });
+        it('should prioritize methodOptions over wicOptions for overlapping properties', () => {
+            const methodOptions = {
+                disableBlinkingCursor: true,
+                disableCSSAnimation: true,
+                hideScrollBars: true,
+            };
+            const wicOptions = {
+                ...baseWicOptions,
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                hideScrollBars: false,
+            };
+            const result = createBeforeScreenshotOptions('testInstance', methodOptions, wicOptions);
+            expect(result.disableBlinkingCursor).toBe(true);
+            expect(result.disableCSSAnimation).toBe(true);
+            expect(result.noScrollBars).toBe(true);
+        });
+        it('should use wicOptions when methodOptions are undefined', () => {
+            const wicOptions = {
+                ...baseWicOptions,
+                disableBlinkingCursor: true,
+                enableLayoutTesting: true,
+                waitForFontsLoaded: true,
+            };
+            const result = createBeforeScreenshotOptions('testInstance', {}, wicOptions);
+            expect(result.disableBlinkingCursor).toBe(true);
+            expect(result.enableLayoutTesting).toBe(true);
+            expect(result.waitForFontsLoaded).toBe(true);
+        });
+        it('should handle element arrays from methodOptions', () => {
+            const hideElements = [mockElement];
+            const removeElements = [mockElement, mockElement];
+            const methodOptions = {
+                hideElements,
+                removeElements,
+            };
+            const result = createBeforeScreenshotOptions('testInstance', methodOptions, baseWicOptions);
+            expect(result.hideElements).toBe(hideElements);
+            expect(result.removeElements).toBe(removeElements);
+        });
+        it('should handle all boolean options set to true in methodOptions', () => {
+            const methodOptions = {
+                disableBlinkingCursor: true,
+                disableCSSAnimation: true,
+                enableLayoutTesting: true,
+                hideScrollBars: true,
+                waitForFontsLoaded: true,
+            };
+            const result = createBeforeScreenshotOptions('testInstance', methodOptions, baseWicOptions);
+            expect(result.disableBlinkingCursor).toBe(true);
+            expect(result.disableCSSAnimation).toBe(true);
+            expect(result.enableLayoutTesting).toBe(true);
+            expect(result.noScrollBars).toBe(true);
+            expect(result.waitForFontsLoaded).toBe(true);
+        });
+        it('should preserve instanceData exactly as passed', () => {
+            const complexInstanceData = { browser: 'chrome', version: '120', viewport: { width: 1920, height: 1080 } };
+            const result = createBeforeScreenshotOptions(complexInstanceData, {}, baseWicOptions);
+            expect(result.instanceData).toBe(complexInstanceData);
+        });
+    });
+    describe('buildAfterScreenshotOptions', () => {
+        const mockInstanceData = {
+            appName: 'testApp',
+            browserName: 'chrome',
+            browserVersion: '120.0.0',
+            deviceName: 'desktop',
+            devicePixelRatio: 2,
+            deviceRectangles: {
+                bottomBar: { height: 0, width: 0, x: 0, y: 0 },
+                homeBar: { height: 0, width: 0, x: 0, y: 0 },
+                leftSidePadding: { height: 0, width: 0, x: 0, y: 0 },
+                rightSidePadding: { height: 0, width: 0, x: 0, y: 0 },
+                screenSize: { height: 1080, width: 1920 },
+                statusBar: { height: 0, width: 0, x: 0, y: 0 },
+                statusBarAndAddressBar: { height: 0, width: 0, x: 0, y: 0 },
+                viewport: { height: 900, width: 1200, x: 0, y: 0 }
+            },
+            initialDevicePixelRatio: 2,
+            isAndroid: false,
+            isIOS: false,
+            isMobile: false,
+            logName: 'chrome',
+            name: 'chrome',
+            nativeWebScreenshot: false,
+            platformName: 'desktop',
+            platformVersion: '120.0.0'
+        };
+        const mockEnrichedInstanceData = {
+            ...mockInstanceData,
+            dimensions: {
+                body: {
+                    scrollHeight: 1000,
+                    offsetHeight: 1000
+                },
+                html: {
+                    clientWidth: 1200,
+                    scrollWidth: 1200,
+                    clientHeight: 900,
+                    scrollHeight: 1000,
+                    offsetHeight: 1000
+                },
+                window: {
+                    devicePixelRatio: 3,
+                    innerHeight: 800,
+                    innerWidth: 1100,
+                    isEmulated: false,
+                    isLandscape: true,
+                    outerHeight: 1000,
+                    outerWidth: 1200,
+                    screenHeight: 1440,
+                    screenWidth: 2560,
+                }
+            },
+            isAndroidChromeDriverScreenshot: false,
+            isAndroidNativeWebScreenshot: false,
+            isTestInBrowser: true,
+            isTestInMobileBrowser: false,
+            addressBarShadowPadding: 10,
+            toolBarShadowPadding: 20
+        };
+        const baseInput = {
+            base64Image: 'test-screenshot-data',
+            folders: { actualFolder: '/test/actual' },
+            tag: 'test-element',
+            isNativeContext: false,
+            instanceData: mockInstanceData,
+            wicOptions: {
+                formatImageName: '{tag}-{browserName}-{width}x{height}',
+                savePerInstance: false
+            }
+        };
+        it('should build options for native commands (no enriched data)', () => {
+            const input = {
+                ...baseInput,
+                isNativeContext: true
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result).toMatchSnapshot();
+            expect(result.isNativeContext).toBe(true);
+            expect(result.isLandscape).toBe(false);
+            expect(result.disableBlinkingCursor).toBeUndefined();
+            expect(result.hideElements).toBeUndefined();
+        });
+        it('should build options for web commands with enriched data', () => {
+            const beforeOptions = {
+                instanceData: mockInstanceData,
+                addressBarShadowPadding: 10,
+                toolBarShadowPadding: 20,
+                disableBlinkingCursor: true,
+                disableCSSAnimation: false,
+                enableLayoutTesting: true,
+                hideElements: [],
+                noScrollBars: true,
+                removeElements: [],
+                waitForFontsLoaded: false
+            };
+            const input = {
+                ...baseInput,
+                enrichedInstanceData: mockEnrichedInstanceData,
+                beforeOptions
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result).toMatchSnapshot();
+            expect(result.isNativeContext).toBe(false);
+            expect(result.isLandscape).toBe(true);
+            expect(result.disableBlinkingCursor).toBe(true);
+            expect(result.disableCSSAnimation).toBe(false);
+            expect(result.enableLayoutTesting).toBe(true);
+            expect(result.hideScrollBars).toBe(true);
+            expect(result.hideElements).toEqual([]);
+            expect(result.removeElements).toEqual([]);
+        });
+        it('should prioritize enriched data over instance data', () => {
+            const input = {
+                ...baseInput,
+                enrichedInstanceData: mockEnrichedInstanceData
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.fileName.devicePixelRatio).toBe(3);
+            expect(result.fileName.outerHeight).toBe(1000);
+            expect(result.fileName.screenHeight).toBe(1440);
+            expect(result.isLandscape).toBe(true);
+        });
+        it('should handle NaN values correctly', () => {
+            const enrichedWithNaN = {
+                ...mockEnrichedInstanceData,
+                dimensions: {
+                    ...mockEnrichedInstanceData.dimensions,
+                    window: {
+                        ...mockEnrichedInstanceData.dimensions.window,
+                        devicePixelRatio: undefined,
+                        outerHeight: undefined,
+                        outerWidth: undefined,
+                        screenHeight: undefined,
+                        screenWidth: undefined,
+                    }
+                }
+            };
+            const input = {
+                ...baseInput,
+                enrichedInstanceData: enrichedWithNaN
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.fileName.devicePixelRatio).toBe(2);
+            expect(result.fileName.outerHeight).toBeNaN();
+            expect(result.fileName.outerWidth).toBeNaN();
+            expect(result.fileName.screenHeight).toBe(1080);
+            expect(result.fileName.screenWidth).toBe(1920);
+        });
+        it('should handle missing enriched data gracefully', () => {
+            const input = {
+                ...baseInput,
+                enrichedInstanceData: undefined
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.fileName.devicePixelRatio).toBe(2);
+            expect(result.fileName.screenHeight).toBe(1080);
+            expect(result.fileName.screenWidth).toBe(1920);
+            expect(result.fileName.logName).toBe('chrome');
+            expect(result.fileName.name).toBe('chrome');
+            expect(result.isLandscape).toBe(false);
+        });
+        it('should handle element arrays from beforeOptions', () => {
+            const mockElement = { tagName: 'DIV' };
+            const beforeOptions = {
+                instanceData: mockInstanceData,
+                addressBarShadowPadding: 10,
+                toolBarShadowPadding: 20,
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                hideElements: [mockElement],
+                noScrollBars: false,
+                removeElements: [mockElement, mockElement],
+                waitForFontsLoaded: false
+            };
+            const input = {
+                ...baseInput,
+                beforeOptions
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.hideElements).toEqual([mockElement]);
+            expect(result.removeElements).toEqual([mockElement, mockElement]);
+        });
+        it('should build correct filePath structure', () => {
+            const input = {
+                ...baseInput,
+                wicOptions: {
+                    formatImageName: '{tag}-{logName}',
+                    savePerInstance: true
+                }
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.filePath).toEqual({
+                browserName: 'chrome',
+                deviceName: 'desktop',
+                isMobile: false,
+                savePerInstance: true
+            });
+        });
+        it('should build correct fileName structure with all properties', () => {
+            const input = {
+                ...baseInput,
+                enrichedInstanceData: mockEnrichedInstanceData
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.fileName).toEqual({
+                browserName: 'chrome',
+                browserVersion: '120.0.0',
+                deviceName: 'desktop',
+                devicePixelRatio: 3,
+                formatImageName: '{tag}-{browserName}-{width}x{height}',
+                isMobile: false,
+                isTestInBrowser: true,
+                logName: 'chrome',
+                name: 'chrome',
+                outerHeight: 1000,
+                outerWidth: 1200,
+                platformName: 'desktop',
+                platformVersion: '120.0.0',
+                screenHeight: 1440,
+                screenWidth: 2560,
+                tag: 'test-element'
+            });
+        });
+        it('should handle mobile device correctly', () => {
+            const mobileInstanceData = {
+                ...mockInstanceData,
+                isMobile: true,
+                deviceName: 'iPhone',
+                platformName: 'iOS'
+            };
+            const mobileEnrichedData = {
+                ...mockEnrichedInstanceData,
+                isMobile: true,
+                deviceName: 'iPhone',
+                platformName: 'iOS'
+            };
+            const input = {
+                ...baseInput,
+                instanceData: mobileInstanceData,
+                enrichedInstanceData: mobileEnrichedData
+            };
+            const result = buildAfterScreenshotOptions(input);
+            expect(result.filePath.isMobile).toBe(true);
+            expect(result.fileName.isMobile).toBe(true);
+            expect(result.fileName.deviceName).toBe('iPhone');
+            expect(result.platformName).toBe('iOS');
+        });
+    });
+});

package/dist/helpers/utils.d.ts

@@ -0,0 +1,134 @@
+import type { BaseExecuteCompareOptions, BuildBaseExecuteCompareOptionsOptions, BuildFolderOptionsOptions, CommonCheckVariables, ComparisonFilePaths, ExecuteNativeClickOptions, ExtractCommonCheckVariablesOptions, FolderOptions, FormatFileNameOptions, GetAddressBarShadowPaddingOptions, GetAndCreatePathOptions, GetIosBezelImageNames, GetMobileScreenSizeOptions, GetMobileViewPortPositionOptions, GetToolBarShadowPaddingOptions, LoadBase64HtmlOptions, PrepareComparisonFilePathsOptions, ScreenshotSize } from './utils.interfaces.js';
+import type { ClassOptions, CompareOptions } from './options.interfaces.js';
+import type { DeviceRectangles } from '../methods/rectangles.interfaces.js';
+import type { BaseDimensions } from '../base.interfaces.js';
+/**
+ * Get and create a folder
+ */
+export declare function getAndCreatePath(folder: string, options: GetAndCreatePathOptions): string;
+/**
+ * Format the filename
+ */
+export declare function formatFileName(options: FormatFileNameOptions): string;
+/**
+ * Checks if the test is executed in a browser
+ * checking for app is not sufficient because different vendors have different
+ * custom names and or solutions for the app
+ */
+export declare function checkTestInBrowser(browserName: string): boolean;
+/**
+ * Checks if the test is executed in a browser on a mobile phone
+ */
+export declare function checkTestInMobileBrowser(isMobile: boolean, browserName: string): boolean;
+/**
+ * Checks if this is a native webscreenshot on android
+ */
+export declare function checkAndroidNativeWebScreenshot(isAndroid: boolean, nativeWebscreenshot: boolean): boolean;
+/**
+ * Checks if this is an Android chromedriver screenshot
+ */
+export declare function checkAndroidChromeDriverScreenshot(isAndroid: boolean, nativeWebScreenshot: boolean): boolean;
+/**
+ * Get the address bar shadow padding. This is only needed for Android native webscreenshot and iOS
+ */
+export declare function getAddressBarShadowPadding(options: GetAddressBarShadowPaddingOptions): number;
+/**
+ * Get the tool bar shadow padding. Add some extra padding for iOS when we have a home bar
+ */
+export declare function getToolBarShadowPadding(options: GetToolBarShadowPaddingOptions): number;
+/**
+ * Calculate the data based on the device pixel ratio
+ */
+export declare function calculateDprData<T>(data: T, devicePixelRatio: number): T;
+/**
+ * Wait for an amount of milliseconds
+ */
+export declare function waitFor(milliseconds: number): Promise<void>;
+/**
+ * Get the size of a screenshot in pixels without the device pixel ratio
+ */
+export declare function getBase64ScreenshotSize(screenshot: string, devicePixelRation?: number): ScreenshotSize;
+/**
+ * Get the device pixel ratio
+ */
+export declare function getDevicePixelRatio(screenshot: string, deviceScreenSize: BaseDimensions): number;
+/**
+ * Get the iOS bezel image names
+ */
+export declare function getIosBezelImageNames(normalizedDeviceName: string): GetIosBezelImageNames;
+/**
+ * Validate that the item is an object
+ */
+export declare function isObject(item: unknown): item is object | Function;
+/**
+ * Validate if it's storybook
+ */
+export declare function isStorybook(): boolean;
+/**
+ * Check if we want to update baseline images
+ */
+export declare function updateVisualBaseline(): boolean;
+/**
+ * Log the deprecated root compareOptions (at `ClassOptions` level)
+ * and returns non-undefined ones to be added back to the config
+ */
+export declare function logAllDeprecatedCompareOptions(options: ClassOptions): Partial<CompareOptions>;
+/**
+ * Get the mobile screen size, this is different for native and webview
+ */
+export declare function getMobileScreenSize({ browserInstance, isIOS, isNativeContext, }: GetMobileScreenSizeOptions): Promise<BaseDimensions>;
+/**
+ * Load a base64 HTML page in the browser
+ */
+export declare function loadBase64Html({ browserInstance, isIOS }: LoadBase64HtmlOptions): Promise<void>;
+/**
+ * Execute a native click
+ */
+export declare function executeNativeClick({ browserInstance, isIOS, x, y }: ExecuteNativeClickOptions): Promise<void>;
+/**
+ * Get the mobile viewport position, we determine this by:
+ * 1. Loading a base64 HTML page
+ * 2. Injecting an overlay on top of the webview with an event listener that stores the click position in the webview
+ * 3. Clicking on the overlay in the center of the screen with a native click
+ * 4. Getting the data from the overlay and removing it
+ * 5. Calculating the position of the viewport based on the click position of the native click vs the overlay
+ * 6. Returning the calculated values
+ */
+export declare function getMobileViewPortPosition({ browserInstance, initialDeviceRectangles, isAndroid, isIOS, isNativeContext, nativeWebScreenshot, screenHeight, screenWidth, }: GetMobileViewPortPositionOptions): Promise<DeviceRectangles>;
+/**
+ * Get the value of a method or the default value
+ */
+export declare function getMethodOrWicOption<T, K extends keyof T>(method: Partial<T> | undefined, wic: T, key: K): T[K];
+/**
+ * Determine if the Bidi screenshot can be used
+ */
+export declare function canUseBidiScreenshot(browserInstance: WebdriverIO.Browser): boolean;
+/**
+ * Helper function to safely check boolean properties with proper defaults
+ */
+export declare function getBooleanOption(options: ClassOptions, key: keyof ClassOptions, defaultValue: boolean): boolean;
+/**
+ * Helper function to create conditional property objects for cleaner spread operations
+ */
+export declare function createConditionalProperty<T>(condition: boolean, key: string, value: T): Record<string, T> | {};
+/**
+ * Check if resizeDimensions has any non-zero values (indicating it's been changed from default)
+ */
+export declare function hasResizeDimensions(resizeDimensions: any): boolean;
+/**
+ * Extracts common variables used across all check methods to reduce duplication
+ */
+export declare function extractCommonCheckVariables(options: ExtractCommonCheckVariablesOptions): CommonCheckVariables;
+/**
+ * Builds folder options object used across all check methods to reduce duplication
+ */
+export declare function buildFolderOptions(options: BuildFolderOptionsOptions): FolderOptions;
+/**
+ * Builds base execute compare options object used across all check methods to reduce duplication
+ */
+export declare function buildBaseExecuteCompareOptions(options: BuildBaseExecuteCompareOptionsOptions): BaseExecuteCompareOptions;
+/**
+ * Prepare all file paths needed for image comparison
+ */
+export declare function prepareComparisonFilePaths(options: PrepareComparisonFilePathsOptions): ComparisonFilePaths;
+//# sourceMappingURL=utils.d.ts.map

package/dist/helpers/utils.d.ts.map

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