test: add missing tests

Author: wswebcreation

packages/image-comparison-core/src/helpers/__snapshots__/afterScreenshot.test.ts.snap

@@ -87,6 +87,16 @@ exports[`afterScreenshot > should handle only removeElements with length > 0 1`]
 }
 `;
 
+exports[`afterScreenshot > should return base64 when alwaysSaveActualImage is false 1`] = `
+{
+  "base64Image": "string",
+  "devicePixelRatio": 2,
+  "fileName": "mocked-file-name.png",
+  "isLandscape": false,
+  "path": "/mocked/path",
+}
+`;
+
 exports[`afterScreenshot > should skip hide/remove elements when both are empty arrays 1`] = `
 {
   "devicePixelRatio": 2,

packages/image-comparison-core/src/helpers/afterScreenshot.test.ts

@@ -102,6 +102,19 @@ describe('afterScreenshot', () => {
         expect(result).toMatchSnapshot()
     })
 
+    it('should return base64 when alwaysSaveActualImage is false', async () => {
+        const mockBrowserInstance = createMockBrowserInstance()
+        const options = createBaseOptions({
+            alwaysSaveActualImage: false,
+        })
+
+        const result = await afterScreenshot(mockBrowserInstance, options)
+
+        expect(vi.mocked(saveBase64Image)).not.toHaveBeenCalled()
+        expect(result.base64Image).toBe(options.base64Image)
+        expect(result).toMatchSnapshot()
+    })
+
     it('should handle native context and skip browser operations', async () => {
         const mockBrowserInstance = createMockBrowserInstance()
         const options = createBaseOptions({

packages/image-comparison-core/src/methods/__snapshots__/images.test.ts.snap

@@ -28,6 +28,20 @@ exports[`checkBaselineImageExists > should update baseline when updateBaseline i
 ]
 `;
 
+exports[`checkBaselineImageExists > should use provided base64 when auto-saving baseline 1`] = `
+[
+  [
+    "%s",
+    "
+#####################################################################################
+ INFO:
+ Autosaved the image to
+ /path/to/baseline.png
+#####################################################################################",
+  ],
+]
+`;
+
 exports[`checkIfImageExists > should return false when file does not exist 1`] = `false`;
 
 exports[`checkIfImageExists > should return true when file exists 1`] = `true`;

packages/image-comparison-core/src/methods/images.executeImageCompare.test.ts

@@ -588,6 +588,162 @@ describe('executeImageCompare', () => {
         expect(result).toMatchSnapshot()
     })
 
+    it('should compare from base64 when not saving actuals', async () => {
+        const base64Image = Buffer.from('base64-image').toString('base64')
+        const optionsWithBase64 = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+                autoSaveBaseline: false,
+            }
+        }
+        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: optionsWithBase64,
+            testContext: mockTestContext,
+            actualBase64Image: base64Image,
+        })
+
+        expect(images.saveBase64Image).not.toHaveBeenCalled()
+        expect(compareImages.default).toHaveBeenCalledWith(
+            expect.any(Buffer),
+            Buffer.from(base64Image, 'base64'),
+            expect.any(Object),
+        )
+        expect(fsPromises.writeFile).not.toHaveBeenCalled()
+    })
+
+    it('should disable JSON reports when actuals are not saved', async () => {
+        const optionsWithJsonButNoSave = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+            },
+            compareOptions: {
+                ...mockOptions.compareOptions,
+                wic: {
+                    ...mockOptions.compareOptions.wic,
+                    createJsonReportFiles: true,
+                    saveAboveTolerance: 0.1,
+                },
+            },
+        }
+
+        await executeImageCompare({
+            isViewPortScreenshot: true,
+            isNativeContext: false,
+            options: optionsWithJsonButNoSave,
+            testContext: mockTestContext,
+            actualBase64Image: Buffer.from('base64-image').toString('base64'),
+        })
+
+        expect(logWarnSpy).toHaveBeenCalled()
+        expect(createCompareReport.createJsonReportIfNeeded).toHaveBeenCalledWith(expect.objectContaining({
+            imageCompareOptions: expect.objectContaining({ createJsonReportFiles: false }),
+        }))
+    })
+
+    it('should save base64 actual for auto-saved baseline', async () => {
+        const base64Image = Buffer.from('base64-image').toString('base64')
+        const optionsWithAutoSave = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+                autoSaveBaseline: true,
+            }
+        }
+        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(fsPromises.writeFile).toHaveBeenCalledWith('/mock/actual/test.png', Buffer.from(base64Image, 'base64'))
+    })
+
+    it('should save base64 actual on diff when not always saving', async () => {
+        const base64Image = Buffer.from('base64-image').toString('base64')
+        const optionsWithDiff = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+            }
+        }
+        vi.mocked(compareImages.default).mockResolvedValue({
+            rawMisMatchPercentage: 0.5,
+            misMatchPercentage: 0.5,
+            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: optionsWithDiff,
+            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)
+        const optionsWithUpdate = {
+            ...mockOptions,
+            folderOptions: {
+                ...mockOptions.folderOptions,
+                alwaysSaveActualImage: false,
+            }
+        }
+        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: optionsWithUpdate,
+            testContext: mockTestContext,
+            actualBase64Image: base64Image,
+        })
+
+        expect(writeFileSync).toHaveBeenCalledWith('/mock/baseline/test.png', Buffer.from(base64Image, 'base64'))
+    })
+
     it('should handle Android device pixel ratio correctly', async () => {
         const androidOptions = {
             ...mockOptions,

packages/image-comparison-core/src/methods/images.test.ts

@@ -222,6 +222,23 @@ describe('checkBaselineImageExists', () => {
         expect(logInfoSpy.mock.calls).toMatchSnapshot()
     })
 
+    it('should use provided base64 when auto-saving baseline', async () => {
+        accessSpy.mockRejectedValue(new Error('File not found'))
+        const base64Actual = Buffer.from('image data').toString('base64')
+        vi.mocked(writeFileSync).mockImplementation(() => {})
+
+        await checkBaselineImageExists({
+            actualFilePath: '/path/to/actual.png',
+            baselineFilePath: '/path/to/baseline.png',
+            autoSaveBaseline: true,
+            actualBase64Image: base64Actual,
+        })
+
+        expect(vi.mocked(readFileSync)).not.toHaveBeenCalled()
+        expect(vi.mocked(writeFileSync)).toHaveBeenCalledWith('/path/to/baseline.png', Buffer.from(base64Actual, 'base64'))
+        expect(logInfoSpy.mock.calls).toMatchSnapshot()
+    })
+
     it('should throw error when file does not exist and autoSaveBaseline is false', async () => {
         accessSpy.mockRejectedValue(new Error('File not found'))
 
@@ -253,6 +270,20 @@ describe('checkBaselineImageExists', () => {
         expect(vi.mocked(writeFileSync)).not.toHaveBeenCalled()
         expect(logInfoSpy).not.toHaveBeenCalled()
     })
+
+    it('should mention missing actual file in error when not saved to disk', async () => {
+        accessSpy.mockRejectedValue(new Error('File not found'))
+        vi.mocked(fsPromises.access).mockRejectedValue(new Error('File not found'))
+
+        await expect(checkBaselineImageExists({
+            actualFilePath: '/path/to/actual.png',
+            baselineFilePath: '/path/to/baseline.png',
+            autoSaveBaseline: false
+        })).rejects.toThrow(/actual image was not saved to disk/)
+
+        expect(vi.mocked(readFileSync)).not.toHaveBeenCalled()
+        expect(vi.mocked(writeFileSync)).not.toHaveBeenCalled()
+    })
 })
 
 describe('rotateBase64Image', () => {