@wdio/image-comparison-core 1.0.0

package/dist/commands/saveAppScreen.test.js

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import saveAppScreen from './saveAppScreen.js';
+import { buildAfterScreenshotOptions } from '../helpers/options.js';
+import { BASE_CHECK_OPTIONS, createMethodOptions, createTestOptions } from '../mocks/mocks.js';
+import { DEVICE_RECTANGLES } from '../helpers/constants.js';
+vi.mock('../methods/screenshots.js', () => ({
+    takeBase64Screenshot: vi.fn().mockResolvedValue('base64-screenshot-data')
+}));
+vi.mock('../methods/images.js', () => ({
+    makeCroppedBase64Image: vi.fn().mockResolvedValue('cropped-base64-screenshot-data')
+}));
+vi.mock('../helpers/afterScreenshot.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-screen.png'
+    })
+}));
+vi.mock('../helpers/options.js', () => ({
+    buildAfterScreenshotOptions: vi.fn().mockReturnValue({
+        actualFolder: '/test/actual',
+        base64Image: 'base64-screenshot-data',
+        filePath: {
+            browserName: 'test-browser',
+            deviceName: 'test-device',
+            isMobile: true,
+            savePerInstance: false,
+        },
+        fileName: {
+            browserName: 'test-browser',
+            browserVersion: '17.0',
+            deviceName: 'test-device',
+            devicePixelRatio: 2,
+            formatImageName: '{tag}-{logName}-{width}x{height}-dpr-{dpr}',
+            isMobile: true,
+            isTestInBrowser: false,
+            logName: 'test-log',
+            name: 'test-device',
+            outerHeight: NaN,
+            outerWidth: NaN,
+            platformName: 'iOS',
+            platformVersion: '17.0',
+            screenHeight: 812,
+            screenWidth: 375,
+            tag: 'test-screen',
+        },
+        isNativeContext: true,
+        isLandscape: false,
+        platformName: 'iOS',
+    })
+}));
+describe('saveAppScreen', () => {
+    let takeBase64ScreenshotSpy;
+    let makeCroppedBase64ImageSpy;
+    let afterScreenshotSpy;
+    let buildAfterScreenshotOptionsSpy;
+    const baseOptions = {
+        browserInstance: { isAndroid: false, isMobile: false },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: {
+            ...BASE_CHECK_OPTIONS.instanceData,
+            devicePixelRatio: 2,
+            deviceRectangles: {
+                ...DEVICE_RECTANGLES,
+                screenSize: {
+                    width: 375,
+                    height: 812
+                }
+            }
+        },
+        isNativeContext: true,
+        saveScreenOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: createMethodOptions({
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                enableLegacyScreenshotMethod: false,
+                hideScrollBars: true,
+                hideElements: [],
+                removeElements: [],
+                waitForFontsLoaded: true,
+            })
+        },
+        tag: 'test-screen'
+    };
+    beforeEach(async () => {
+        const { takeBase64Screenshot } = await import('../methods/screenshots.js');
+        const { makeCroppedBase64Image } = await import('../methods/images.js');
+        const afterScreenshot = (await import('../helpers/afterScreenshot.js')).default;
+        takeBase64ScreenshotSpy = vi.mocked(takeBase64Screenshot);
+        makeCroppedBase64ImageSpy = vi.mocked(makeCroppedBase64Image);
+        afterScreenshotSpy = vi.mocked(afterScreenshot);
+        buildAfterScreenshotOptionsSpy = vi.mocked(buildAfterScreenshotOptions);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should execute saveAppScreen with basic options', async () => {
+        const result = await saveAppScreen(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(takeBase64ScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+        expect(makeCroppedBase64ImageSpy).not.toHaveBeenCalled();
+    });
+    it('should handle iOS device with bezel corners', async () => {
+        const options = createTestOptions(baseOptions, {
+            browserInstance: { isAndroid: false, isMobile: true },
+            instanceData: {
+                ...BASE_CHECK_OPTIONS.instanceData,
+                deviceName: 'iPhone 12',
+                isAndroid: false,
+                isIOS: true,
+                isMobile: true,
+                platformName: 'iOS',
+                platformVersion: '14.0',
+                deviceRectangles: {
+                    ...DEVICE_RECTANGLES,
+                    screenSize: {
+                        width: 390,
+                        height: 844
+                    }
+                }
+            },
+            saveScreenOptions: {
+                wic: {
+                    ...BASE_CHECK_OPTIONS.wic,
+                    addIOSBezelCorners: true
+                },
+                method: createMethodOptions()
+            }
+        });
+        await saveAppScreen(options);
+        expect(takeBase64ScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(makeCroppedBase64ImageSpy.mock.calls[0]).toMatchSnapshot();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle Android device correctly', async () => {
+        const options = createTestOptions(baseOptions, {
+            browserInstance: { isAndroid: true, isMobile: true },
+            instanceData: {
+                ...BASE_CHECK_OPTIONS.instanceData,
+                deviceName: 'Pixel 4',
+                isAndroid: true,
+                isIOS: false,
+                isMobile: true,
+                platformName: 'Android',
+                platformVersion: '11.0',
+                deviceRectangles: {
+                    ...DEVICE_RECTANGLES,
+                    screenSize: {
+                        width: 412,
+                        height: 915
+                    }
+                }
+            }
+        });
+        await saveAppScreen(options);
+        expect(takeBase64ScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(makeCroppedBase64ImageSpy).not.toHaveBeenCalled();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle non-native context correctly', async () => {
+        const options = createTestOptions(baseOptions, {
+            isNativeContext: false
+        });
+        await saveAppScreen(options);
+        expect(takeBase64ScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(makeCroppedBase64ImageSpy).not.toHaveBeenCalled();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle custom image naming', async () => {
+        const options = createTestOptions(baseOptions, {
+            saveScreenOptions: {
+                wic: {
+                    ...BASE_CHECK_OPTIONS.wic,
+                    formatImageName: '{tag}-{browserName}-{deviceName}'
+                },
+                method: createMethodOptions()
+            }
+        });
+        await saveAppScreen(options);
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle save per instance', async () => {
+        const options = createTestOptions(baseOptions, {
+            saveScreenOptions: {
+                wic: {
+                    ...BASE_CHECK_OPTIONS.wic,
+                    savePerInstance: true
+                },
+                method: createMethodOptions()
+            }
+        });
+        await saveAppScreen(options);
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle custom screen sizes', async () => {
+        const options = createTestOptions(baseOptions, {
+            instanceData: {
+                ...BASE_CHECK_OPTIONS.instanceData,
+                deviceRectangles: {
+                    ...DEVICE_RECTANGLES,
+                    screenSize: {
+                        width: 1920,
+                        height: 1080
+                    }
+                }
+            }
+        });
+        await saveAppScreen(options);
+        expect(takeBase64ScreenshotSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(afterScreenshotSpy.mock.calls[0]).toMatchSnapshot();
+    });
+});

package/dist/commands/saveElement.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenshotOutput } from '../helpers/afterScreenshot.interfaces.js';
+import type { InternalSaveElementMethodOptions } from './save.interfaces.js';
+/**
+ * Saves an image of an element
+ */
+export default function saveElement({ browserInstance, element, folders, instanceData, isNativeContext, saveElementOptions, tag, }: InternalSaveElementMethodOptions): Promise<ScreenshotOutput>;
+//# sourceMappingURL=saveElement.d.ts.map

package/dist/commands/saveElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveElement.d.ts","sourceRoot":"","sources":["../../src/commands/saveElement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAChF,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAI5E;;GAEG;AACH,wBAA8B,WAAW,CACrC,EACI,eAAe,EACf,OAAO,EACP,OAAO,EACP,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,GAAG,GACN,EAAE,gCAAgC,GACpC,OAAO,CAAC,gBAAgB,CAAC,CAI3B"}

package/dist/commands/saveElement.js

@@ -0,0 +1,10 @@
+import saveAppElement from './saveAppElement.js';
+import saveWebElement from './saveWebElement.js';
+/**
+ * Saves an image of an element
+ */
+export default async function saveElement({ browserInstance, element, folders, instanceData, isNativeContext, saveElementOptions, tag, }) {
+    return isNativeContext
+        ? saveAppElement({ browserInstance, element, folders, instanceData, saveElementOptions, isNativeContext, tag })
+        : saveWebElement({ browserInstance, element, folders, instanceData, saveElementOptions, tag });
+}

package/dist/commands/saveElement.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=saveElement.test.d.ts.map

package/dist/commands/saveElement.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveElement.test.d.ts","sourceRoot":"","sources":["../../src/commands/saveElement.test.ts"],"names":[],"mappings":""}

package/dist/commands/saveElement.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import saveElement from './saveElement.js';
+import { BASE_CHECK_OPTIONS, createMethodOptions } from '../mocks/mocks.js';
+vi.mock('./saveAppElement.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-app-element.png'
+    })
+}));
+vi.mock('./saveWebElement.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-web-element.png'
+    })
+}));
+describe('saveElement', () => {
+    let saveAppElementSpy;
+    let saveWebElementSpy;
+    const baseOptions = {
+        browserInstance: { isAndroid: false, isMobile: false },
+        element: {
+            elementId: 'test-element',
+            selector: '#test-element',
+            isDisplayed: vi.fn().mockResolvedValue(true),
+            getSize: vi.fn().mockResolvedValue({ width: 100, height: 100 }),
+            getLocation: vi.fn().mockResolvedValue({ x: 0, y: 0 })
+        },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: true,
+        saveElementOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: createMethodOptions()
+        },
+        tag: 'test-element'
+    };
+    beforeEach(async () => {
+        const saveAppElement = (await import('./saveAppElement.js')).default;
+        const saveWebElement = (await import('./saveWebElement.js')).default;
+        saveAppElementSpy = vi.mocked(saveAppElement);
+        saveWebElementSpy = vi.mocked(saveWebElement);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should execute saveAppElement when isNativeContext is true', async () => {
+        const result = await saveElement(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(saveAppElementSpy.mock.calls[0]).toMatchSnapshot();
+        expect(saveWebElementSpy).not.toHaveBeenCalled();
+    });
+    it('should execute saveWebElement when isNativeContext is false', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: false
+        };
+        const result = await saveElement(options);
+        expect(result).toMatchSnapshot();
+        expect(saveWebElementSpy.mock.calls[0]).toMatchSnapshot();
+        expect(saveAppElementSpy).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/saveFullPageScreen.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenshotOutput } from '../helpers/afterScreenshot.interfaces.js';
+import type { InternalSaveFullPageMethodOptions } from './save.interfaces.js';
+/**
+ * Saves an image of the full page
+ */
+export default function saveFullPageScreen({ browserInstance, instanceData, folders, tag, saveFullPageOptions, isNativeContext, }: InternalSaveFullPageMethodOptions): Promise<ScreenshotOutput>;
+//# sourceMappingURL=saveFullPageScreen.d.ts.map

package/dist/commands/saveFullPageScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveFullPageScreen.d.ts","sourceRoot":"","sources":["../../src/commands/saveFullPageScreen.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAGhF,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,sBAAsB,CAAA;AAI7E;;GAEG;AACH,wBAA8B,kBAAkB,CAC5C,EACI,eAAe,EACf,YAAY,EACZ,OAAO,EACP,GAAG,EACH,mBAAmB,EACnB,eAAe,GAClB,EAAE,iCAAiC,GACrC,OAAO,CAAC,gBAAgB,CAAC,CAuE3B"}

package/dist/commands/saveFullPageScreen.js

@@ -0,0 +1,60 @@
+import beforeScreenshot from '../helpers/beforeScreenshot.js';
+import afterScreenshot from '../helpers/afterScreenshot.js';
+import { takeFullPageScreenshots } from '../methods/takeFullPageScreenshots.js';
+import { makeFullPageBase64Image } from '../methods/images.js';
+import { getMethodOrWicOption, canUseBidiScreenshot } from '../helpers/utils.js';
+import { createBeforeScreenshotOptions, buildAfterScreenshotOptions } from '../helpers/options.js';
+/**
+ * Saves an image of the full page
+ */
+export default async function saveFullPageScreen({ browserInstance, instanceData, folders, tag, saveFullPageOptions, isNativeContext, }) {
+    // 1. Check if the method is supported in native context
+    if (isNativeContext) {
+        throw new Error('The method saveFullPageScreen is not supported in native context for native mobile apps!');
+    }
+    // 2. Set some variables
+    const { formatImageName, savePerInstance } = saveFullPageOptions.wic;
+    const enableLegacyScreenshotMethod = getMethodOrWicOption(saveFullPageOptions.method, saveFullPageOptions.wic, 'enableLegacyScreenshotMethod');
+    const fullPageScrollTimeout = getMethodOrWicOption(saveFullPageOptions.method, saveFullPageOptions.wic, 'fullPageScrollTimeout');
+    const hideAfterFirstScroll = saveFullPageOptions.method.hideAfterFirstScroll || [];
+    const userBasedFullPageScreenshot = getMethodOrWicOption(saveFullPageOptions.method, saveFullPageOptions.wic, 'userBasedFullPageScreenshot');
+    // 3.  Prepare the screenshot
+    const beforeOptions = createBeforeScreenshotOptions(instanceData, saveFullPageOptions.method, saveFullPageOptions.wic);
+    const enrichedInstanceData = await beforeScreenshot(browserInstance, beforeOptions, true);
+    const { dimensions: { window: { devicePixelRatio, innerHeight, isEmulated: _isEmulated, isLandscape, screenHeight, screenWidth, }, }, isAndroid, isAndroidChromeDriverScreenshot, isAndroidNativeWebScreenshot, isIOS, } = enrichedInstanceData;
+    // 4.  Take the screenshot
+    const fullPageScreenshotOptions = {
+        addressBarShadowPadding: beforeOptions.addressBarShadowPadding,
+        devicePixelRatio: devicePixelRatio || NaN,
+        deviceRectangles: instanceData.deviceRectangles,
+        fullPageScrollTimeout,
+        hideAfterFirstScroll,
+        innerHeight: innerHeight || NaN,
+        isAndroid,
+        isAndroidChromeDriverScreenshot,
+        isAndroidNativeWebScreenshot,
+        isIOS,
+        isLandscape,
+        screenHeight: screenHeight || NaN,
+        screenWidth: screenWidth || NaN,
+        toolBarShadowPadding: beforeOptions.toolBarShadowPadding,
+    };
+    const shouldUseBidi = canUseBidiScreenshot(browserInstance) && (!userBasedFullPageScreenshot || !enableLegacyScreenshotMethod);
+    const screenshotsData = await takeFullPageScreenshots(browserInstance, fullPageScreenshotOptions, shouldUseBidi);
+    // 5.  Get the final image - either direct BiDi or stitched from multiple screenshots
+    const fullPageBase64Image = (screenshotsData.fullPageHeight === -1 && screenshotsData.fullPageWidth === -1)
+        ? screenshotsData.data[0].screenshot // BiDi screenshot - use directly
+        : await makeFullPageBase64Image(screenshotsData, { devicePixelRatio: devicePixelRatio || NaN, isLandscape });
+    // 6.  Return the data
+    const afterOptions = buildAfterScreenshotOptions({
+        base64Image: fullPageBase64Image,
+        folders,
+        tag,
+        isNativeContext: false,
+        instanceData,
+        enrichedInstanceData,
+        beforeOptions,
+        wicOptions: { formatImageName, savePerInstance }
+    });
+    return afterScreenshot(browserInstance, afterOptions);
+}

package/dist/commands/saveFullPageScreen.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=saveFullPageScreen.test.d.ts.map

package/dist/commands/saveFullPageScreen.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveFullPageScreen.test.d.ts","sourceRoot":"","sources":["../../src/commands/saveFullPageScreen.test.ts"],"names":[],"mappings":""}