@wdio/image-comparison-core 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @wdio/image-comparison-core
 
+## 1.1.2
+
+### Patch Changes
+
+- 0a2b6d0: ## #1111 Respect saveAboveTolerance when deciding to save actual images when alwaysSaveActualImage is false.
+
+  When `alwaysSaveActualImage` is `false`, the actual image is no longer written to disk if the mismatch is below the configured tolerance, avoiding extra actuals when the comparison still passes.
+
+  # Committers: 1
+
+  - Wim Selles ([@wswebcreation](https://github.com/wswebcreation))
+
+## 1.1.1
+
+### Patch Changes
+
+- 340fbe6: # 🐛 Bugfixes
+
+  ## #1098 Improve error message when baseline is missing and both flags are false
+
+  When `autoSaveBaseline = false` and `alwaysSaveActualImage = false` and a baseline image doesn't exist, the error message now provides clear guidance suggesting users set `alwaysSaveActualImage` to `true` if they need the actual image to create a baseline manually.
+
+  # Committers: 1
+
+  - Wim Selles ([@wswebcreation](https://github.com/wswebcreation))
+
+- e4e5b5c: # 🐛 Bugfixes
+
+  ## #1085 autoSaveBaseline collides with the new alwaysSaveActualImage flag
+
+  When `autoSaveBaseline` is `true` and `alwaysSaveActualImage` is `false`, actual images were still saved. This patch should fix that
+
+  # Committers: 1
+
+  - Wim Selles ([@wswebcreation](https://github.com/wswebcreation))
+
 ## 1.1.0
 
 ### Minor Changes

package/dist/methods/images.executeImageCompare.test.js

@@ -94,7 +94,7 @@ vi.mock('./images.js', async () => {
         addBlockOuts: vi.fn(),
     };
 });
-import { executeImageCompare } from './images.js';
+import { executeImageCompare, checkBaselineImageExists } from './images.js';
 import * as images from './images.js';
 describe('executeImageCompare', () => {
     const mockDeviceRectangles = {
@@ -597,6 +597,12 @@ describe('executeImageCompare', () => {
                 autoSaveBaseline: true,
             }
         };
+        vi.mocked(fsPromises.access).mockImplementation(async (path) => {
+            if (path === '/mock/baseline/test.png') {
+                throw new Error('File not found');
+            }
+            return undefined;
+        });
         vi.mocked(compareImages.default).mockResolvedValue({
             rawMisMatchPercentage: 0,
             misMatchPercentage: 0,
@@ -640,6 +646,72 @@ describe('executeImageCompare', () => {
         });
         expect(fsPromises.writeFile).toHaveBeenCalledWith('/mock/actual/test.png', Buffer.from(base64Image, 'base64'));
     });
+    it('should not save base64 actual when diff is below saveAboveTolerance', async () => {
+        const base64Image = Buffer.from('base64-image').toString('base64');
+        const optionsWithTolerance = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+            },
+            compareOptions: {
+                ...mockOptions.compareOptions,
+                wic: {
+                    ...mockOptions.compareOptions.wic,
+                    saveAboveTolerance: 0.1,
+                },
+            },
+        };
+        vi.mocked(compareImages.default).mockResolvedValue({
+            rawMisMatchPercentage: 0.05,
+            misMatchPercentage: 0.05,
+            getBuffer: vi.fn().mockResolvedValue(Buffer.from('diff-image-data')),
+            diffBounds: { left: 0, top: 0, right: 0, bottom: 0 },
+            analysisTime: 10,
+            diffPixels: []
+        });
+        await executeImageCompare({
+            isViewPortScreenshot: true,
+            isNativeContext: false,
+            options: optionsWithTolerance,
+            testContext: mockTestContext,
+            actualBase64Image: base64Image,
+        });
+        expect(fsPromises.writeFile).not.toHaveBeenCalled();
+    });
+    it('should save base64 actual when diff exceeds saveAboveTolerance', async () => {
+        const base64Image = Buffer.from('base64-image').toString('base64');
+        const optionsWithTolerance = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+            },
+            compareOptions: {
+                ...mockOptions.compareOptions,
+                wic: {
+                    ...mockOptions.compareOptions.wic,
+                    saveAboveTolerance: 0.1,
+                },
+            },
+        };
+        vi.mocked(compareImages.default).mockResolvedValue({
+            rawMisMatchPercentage: 0.2,
+            misMatchPercentage: 0.2,
+            getBuffer: vi.fn().mockResolvedValue(Buffer.from('diff-image-data')),
+            diffBounds: { left: 0, top: 0, right: 0, bottom: 0 },
+            analysisTime: 10,
+            diffPixels: []
+        });
+        await executeImageCompare({
+            isViewPortScreenshot: true,
+            isNativeContext: false,
+            options: optionsWithTolerance,
+            testContext: mockTestContext,
+            actualBase64Image: base64Image,
+        });
+        expect(fsPromises.writeFile).toHaveBeenCalledWith('/mock/actual/test.png', Buffer.from(base64Image, 'base64'));
+    });
     it('should update baseline using base64 when visual baseline is updated', async () => {
         const base64Image = Buffer.from('base64-image').toString('base64');
         vi.mocked(utils.updateVisualBaseline).mockReturnValueOnce(true);
@@ -908,4 +980,74 @@ describe('executeImageCompare', () => {
         expect(images.saveBase64Image).not.toHaveBeenCalled();
         expect(log.warn).not.toHaveBeenCalled();
     });
+    it('should not save actual image when autoSaveBaseline is true, alwaysSaveActualImage is false, baseline exists, and comparison passes', async () => {
+        // This test covers issue #1085: autoSaveBaseline collides with alwaysSaveActualImage
+        // When baseline exists and comparison passes, actual image should NOT be saved
+        const base64Image = Buffer.from('base64-image').toString('base64');
+        const optionsWithAutoSave = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+                autoSaveBaseline: true,
+            }
+        };
+        vi.mocked(fsPromises.access).mockResolvedValue(undefined);
+        vi.mocked(images.checkBaselineImageExists).mockImplementation(async () => {
+            return Promise.resolve();
+        });
+        vi.mocked(compareImages.default).mockResolvedValue({
+            rawMisMatchPercentage: 0,
+            misMatchPercentage: 0,
+            getBuffer: vi.fn().mockResolvedValue(Buffer.from('diff-image-data')),
+            diffBounds: { left: 0, top: 0, right: 0, bottom: 0 },
+            analysisTime: 10,
+            diffPixels: []
+        });
+        await executeImageCompare({
+            isViewPortScreenshot: true,
+            isNativeContext: false,
+            options: optionsWithAutoSave,
+            testContext: mockTestContext,
+            actualBase64Image: base64Image,
+        });
+        expect(images.saveBase64Image).not.toHaveBeenCalled();
+        expect(fsPromises.writeFile).not.toHaveBeenCalledWith('/mock/actual/test.png', expect.anything());
+    });
+    it('should not save actual image when baseline does not exist, alwaysSaveActualImage is false, and autoSaveBaseline is false', async () => {
+        // This test covers issue #1098: When both flags are false, we respect the user's choice
+        // and provide a helpful error message suggesting to adjust the arguments if needed
+        const base64Image = Buffer.from('base64-image').toString('base64');
+        const optionsWithoutAutoSave = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+                autoSaveBaseline: false,
+            }
+        };
+        vi.mocked(fsPromises.access).mockImplementation(async (path) => {
+            if (path === '/mock/baseline/test.png' || path === '/mock/actual/test.png') {
+                throw new Error('File not found');
+            }
+            return undefined;
+        });
+        vi.mocked(images.checkBaselineImageExists).mockImplementation(checkBaselineImageExists);
+        vi.mocked(compareImages.default).mockResolvedValue({
+            rawMisMatchPercentage: 0,
+            misMatchPercentage: 0,
+            getBuffer: vi.fn().mockResolvedValue(Buffer.from('diff-image-data')),
+            diffBounds: { left: 0, top: 0, right: 0, bottom: 0 },
+            analysisTime: 10,
+            diffPixels: []
+        });
+        await expect(executeImageCompare({
+            isViewPortScreenshot: true,
+            isNativeContext: false,
+            options: optionsWithoutAutoSave,
+            testContext: mockTestContext,
+            actualBase64Image: base64Image,
+        })).rejects.toThrow(/If you need the actual image to create a baseline, please set alwaysSaveActualImage to true/);
+        expect(images.saveBase64Image).not.toHaveBeenCalled();
+    });
 });

package/dist/methods/images.js

@@ -77,11 +77,11 @@ export async function checkBaselineImageExists({ actualFilePath, baselineFilePat
             const actualFileExists = await checkIfImageExists(actualFilePath);
             const filePathMessage = actualFileExists
                 ? `The image can be found here:\n${actualFilePath}`
-                : 'The actual image was not saved to disk (alwaysSaveActualImage is false).';
+                : 'The actual image was not saved to disk (alwaysSaveActualImage is false).\nIf you need the actual image to create a baseline, please set alwaysSaveActualImage to true.';
             throw new Error(`
 #####################################################################################
- Baseline image not found, save the actual image manually to the baseline.
- ${filePathMessage}
+Baseline image not found, save the actual image manually to the baseline.
+${filePathMessage}
 #####################################################################################`);
         }
     }
@@ -262,8 +262,8 @@ export async function executeImageCompare({ isViewPortScreenshot, isNativeContex
     if (useBase64Image) {
         // Convert base64 to buffer for comparison
         actualImageBuffer = Buffer.from(actualBase64Image, 'base64');
-        // Only save if autoSaveBaseline is true (needed to copy to baseline)
-        if (autoSaveBaseline) {
+        // Only save actual image if baseline doesn't exist and autoSaveBaseline is true
+        if (autoSaveBaseline && !(await checkIfImageExists(baselineFilePath))) {
             await saveBase64Image(actualBase64Image, actualFilePath);
         }
     }
@@ -316,7 +316,7 @@ export async function executeImageCompare({ isViewPortScreenshot, isNativeContex
     const { diffBoundingBoxes, storeDiffs } = await generateAndSaveDiff(data, imageCompareOptions, ignoredBoxes, diffFilePath, rawMisMatchPercentage);
     // 6a. Save actual image on failure if alwaysSaveActualImage is false
     const saveAboveTolerance = imageCompareOptions.saveAboveTolerance ?? 0;
-    const hasFailure = rawMisMatchPercentage > 0 || rawMisMatchPercentage > saveAboveTolerance;
+    const hasFailure = rawMisMatchPercentage > saveAboveTolerance;
     if (useBase64Image && hasFailure && actualBase64Image) {
         // Save the actual image only when comparison fails
         await saveBase64Image(actualBase64Image, actualFilePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/image-comparison-core",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "author": "Wim Selles - wswebcreation",
   "description": "Image comparison core module for @wdio/visual-service - WebdriverIO visual testing framework",
   "keywords": [
@@ -31,7 +31,7 @@
     "@wdio/types": "^9.20.0"
   },
   "devDependencies": {
-    "webdriverio": "^9.20.1"
+    "webdriverio": "^9.23.0"
   },
   "publishConfig": {
     "access": "public"