Added Utility and steps to compare and validate PDF files

VinayKumarBM · VinayKumarBM · commit 0b570ae57c35 · 2025-09-29T12:09:11.000+05:30
diff --git a/src/advantage/constants/CommonConstants.ts b/src/advantage/constants/CommonConstants.ts
@@ -4,4 +4,5 @@ export default class CommonConstants {
     static readonly TEN = 10;
     static readonly TWO = 2;
     static readonly DOWNLOADS_PATH = "./test-results/downloads/";
+    static readonly PDF_RESOURCE_PATH = './src/resources/pdf';
 }
diff --git a/src/advantage/steps/ConfigurationSteps.ts b/src/advantage/steps/ConfigurationSteps.ts
@@ -22,17 +22,29 @@ export default class ConfigurationSteps {
         return fileName;
     }
 
-    public async verifyPDFFilePageCount(fileName: string, pages: number) {
+    public async verifyPDFDetails(fileName: string, pages: number, content: string) {
+        const pdf = await PDFUtil.getPdfTextDetails(CommonConstants.DOWNLOADS_PATH, fileName);
+        await this.verifyPDFFilePageCount(fileName, pages, pdf.pageCount);
+        await this.verifyPDFFileText(fileName, content, pdf.content);
+    }
+
+    private async verifyPDFFilePageCount(fileName: string, pages: number , actual: number) {
         await test.step(`Verify that ${fileName} file has ${pages} pages`, async () => {
-            await Assert.assertEquals(await PDFUtil.getNumberOfPages(CommonConstants.DOWNLOADS_PATH + fileName),
-                pages, fileName);
+            await Assert.assertEquals(actual, pages, fileName);
         });
     }
 
-    public async verifyPDFFileText(fileName: string, content: string) {
+    private async verifyPDFFileText(fileName: string, content: string, actual: string) {
         await test.step(`Verify that ${fileName} has content ${content}`, async () => {
-            await Assert.assertContains(await PDFUtil.getText(CommonConstants.DOWNLOADS_PATH + fileName),
-                content, fileName);
+            await Assert.assertContains(actual, content, fileName);
+        });
+    }
+
+    public async verifyPdfByComparing(actualFileName: string, baselineFileName: string, pages: string , maskText: string) {
+        await test.step(`Verify that ${actualFileName} matches with baseline file ${baselineFileName}`, async () => {
+            const isMatched = await PDFUtil.maskAndComparePdf(CommonConstants.PDF_RESOURCE_PATH, baselineFileName,
+                CommonConstants.DOWNLOADS_PATH, actualFileName, pages, maskText);
+            await Assert.assertTrue(isMatched, `${actualFileName} matches with baseline file ${baselineFileName}`);
         });
     }
 }
diff --git a/src/framework/reporter/Allure.ts b/src/framework/reporter/Allure.ts
@@ -1,4 +1,5 @@
-import { allure } from "allure-playwright";
+import * as allure from "allure-js-commons";
+import { ContentType } from "allure-js-commons";
 import os from "os";
 
 export default class Allure {
@@ -9,4 +10,18 @@ export default class Allure {
             allure.link(`${process.env.LINK}${issue}`, `ISSUE-${issue}`);
         }
     }
+
+    public static async attachPNG(name: string, path: string) {
+        await allure.attachmentPath(name, path, {
+            contentType: ContentType.PNG,
+            fileExtension: "png"
+        });
+    }
+
+    public static async attachPDF(name: string, path: string) {
+        await allure.attachmentPath(name, path, {
+            contentType: 'application/pdf',
+            fileExtension: "pdf"
+        });
+    }
 }
diff --git a/src/framework/utils/PDFUtil.ts b/src/framework/utils/PDFUtil.ts
@@ -1,49 +1,207 @@
-import fs from "fs";
-import pdfParse from "pdf-parse";
+import fs from 'fs';
+import { PDFExtract } from 'pdf.js-extract';
+import { PDFDocument, rgb } from 'pdf-lib';
+import { ComparePdf } from "compare-pdf-plus";
+import Allure from '@allure';
 
 export default class PDFUtil {
+    private static readonly MASKED_PDF_DIR_BASELINE = './test-results/pdf/masked/baseline';
+    private static readonly MASKED_PDF_DIR_ACTUAL = './test-results/pdf/masked/actual';
+    private static readonly PNG_DIR_BASELINE = './test-results/pdf/png/baseline';
+    private static readonly PNG_DIR_ACTUAL = './test-results/pdf/png/actual';
+    private static readonly PNG_DIR_DIFF = './test-results/pdf/png/diff';
     /**
-     * Gets the text content of the pdf file
-     * @param filePath File path
-     * @returns PDF as text
+     * Gets the text, number of pages and info from a PDF file
+     * @param pathToFileDirectory path to file directory
+     * @param fileName name of the PDF file
+     * @returns 
      */
-    public static async getText(filePath: string): Promise<string> {
-        const buffer = fs.readFileSync(filePath);
-        try {
-            const data = await pdfParse(buffer);
-            return data.text;
-        } catch (err) {
-            throw new Error(err);
+    public static async getPdfTextDetails(pathToFileDirectory: string, fileName: string) {
+        const filePath = `${pathToFileDirectory}/${fileName}`;
+        const pdfExtract = new PDFExtract();
+        const data = await pdfExtract.extract(filePath, {});
+        const fullText = data.pages.map(page => page.content.map(item => item.str).join(' ')).join('\n');
+        return {
+            pageCount: data.pages.length,
+            content: fullText,
+            info: data.meta.info
+        };
+    }
+    /**
+     * Extracts text positions from a specific page in a PDF file
+     * @param pdfPath path to the PDF file
+     * @param page page number (0-indexed)
+     * @returns 
+     */
+    private static async extractTextPositions(pdfPath: string, page: number): Promise<any[]> {
+        const pdfExtract = new PDFExtract();
+        const data = await pdfExtract.extract(pdfPath, {});
+        return data.pages[page].content.map(item => ({ text: item.str, x: item.x, y: item.y, width: item.width, height: item.height }));
+    }
+    /**
+     * Finds text items that match any of the dynamic texts to be masked
+     * @param textItems 
+     * @param dynamicTexts 
+     * @returns 
+     */
+    private static findDynamicMatches(textItems: any[], dynamicTexts: string[]) {
+        const matches = [];
+        for (const dynamicText of dynamicTexts) {
+            for (const item of textItems) {
+                if (item.text.includes(dynamicText)) {
+                    matches.push(item);
+                }
+            }
         }
+        return matches;
     }
-
     /**
-     * Gets number of pages in pdf file
-     * @param filePath File path
-     * @returns Number of pages
+     * Adjusts coordinates based on page rotation
+     * @param x masked rectangle x coordinate
+     * @param y masked rectangle y coordinate
+     * @param w masked rectangle width
+     * @param h masked rectangle height
+     * @param pageWidth width of the PDF file 
+     * @param pageHeight height of the PDF file
+     * @param rotation PDF page rotation
+     * @returns 
      */
-    public static async getNumberOfPages(filePath: string): Promise<number> {
-        const buffer = fs.readFileSync(filePath);
-        try {
-            const data = await pdfParse(buffer);
-            return data.numpages;
-        } catch (err) {
-            throw new Error(err);
+    private static transformCoordinates(x: number, y: number, w: number, h: number, pageWidth: number, pageHeight: number, rotation: number) {
+        switch (rotation) {
+            case 0:
+                return { x, y: pageHeight - y, width: w, height: h };
+            case 90:
+                return { x: y, y: x - h, width: h, height: w };
+            case 180:
+                return { x: pageWidth - x - w, y: y - h, width: w, height: h };
+            case 270:
+                return { x: pageHeight - y - h, y: pageWidth - x - w, width: h, height: w };
+            default:
+                return { x, y, width: w, height: h };
         }
     }
-
     /**
-     * Gets the information about the pdf file
-     * @param filePath File path
-     * @returns PDF document info
+     * Masks the dynamic text in the specified pages of the baseline and actual PDF files, saves the masked files, and compares them
+     * @param baselineDirPath path to the baseline PDF file directory
+     * @param baselineFileName baseline PDF file name
+     * @param actualDirPath path to the actual PDF file directory
+     * @param actualFileName actual PDF file name
+     * @param pageNumbers array of pages to be compared (0-indexed)
+     * @param dynamicTexts array of text from baseline PDF file to be masked
      */
-    public static async getInfo(filePath: string): Promise<any> {
-        const buffer = fs.readFileSync(filePath);
-        try {
-            const data = await pdfParse(buffer);
-            return data.info;
-        } catch (err) {
-            throw new Error(err);
+    private static async maskPdf(baselineDirPath: string, baselineFileName: string, actualDirPath: string, actualFileName: string, pageNumbers: number[], dynamicTexts: string[]) {
+        const baselinePath = `${baselineDirPath}/${baselineFileName}`;
+        const actualPath = `${actualDirPath}/${actualFileName}`;
+        const baselinePdfDoc = await PDFDocument.load(fs.readFileSync(baselinePath));
+        const actualPdfDoc = await PDFDocument.load(fs.readFileSync(actualPath));
+        for (const pageNum of pageNumbers) {
+            const textItems = await this.extractTextPositions(baselinePath, pageNum);
+            const matchedItems = this.findDynamicMatches(textItems, dynamicTexts);
+            const baselinePage = baselinePdfDoc.getPage(pageNum);
+            const actualPage = actualPdfDoc.getPage(pageNum);
+            const { width, height } = baselinePage.getSize();
+            const rotation = baselinePage.getRotation().angle;
+            for (const item of matchedItems) {
+                const rect = this.transformCoordinates(item.x, item.y, item.width, item.height, width, height, rotation);
+                const pdfRectOptions = {
+                    x: rect.x,
+                    y: rect.y,
+                    width: rect.width,
+                    height: rect.height,
+                    color: rgb(0, 0, 0),
+                    borderColor: rgb(0, 0, 0),
+                    borderWidth: 8,
+                    opacity: 1,
+                }
+                baselinePage.drawRectangle(pdfRectOptions);
+                actualPage.drawRectangle(pdfRectOptions);
+            }
         }
+        const outputDirPathBaseline = this.MASKED_PDF_DIR_BASELINE;
+        if (!fs.existsSync(outputDirPathBaseline)) {
+            fs.mkdirSync(outputDirPathBaseline, { recursive: true });
+        }
+        const outputDirPathActual = this.MASKED_PDF_DIR_ACTUAL;
+        if (!fs.existsSync(outputDirPathActual)) {
+            fs.mkdirSync(outputDirPathActual, { recursive: true });
+        }
+        const timeStamp = new Date().valueOf();
+        const outputBytesBaseline = await baselinePdfDoc.save();
+        const maskedBaselineFileName = baselineFileName.replace('.pdf', `_${timeStamp}.pdf`);
+        const maskedActualFileName = actualFileName.replace('.pdf', `_${timeStamp}.pdf`);
+        fs.writeFileSync(`${outputDirPathBaseline}/${maskedBaselineFileName}`, outputBytesBaseline);
+        const outputBytesActual = await actualPdfDoc.save();
+        fs.writeFileSync(`${outputDirPathActual}/${maskedActualFileName}`, outputBytesActual);
+        return { maskedBaselineDir: outputDirPathBaseline, maskedBaselineFileName, maskedActualDir: outputDirPathActual, maskedActualFileName };
+    }
+    /**
+     * Compares the specified pages of the actual and baseline PDF files and returns the comparison results
+     * @param actualPdfDir Path to the actual PDF file directory 
+     * @param actualPdfFileName Actual PDF file name 
+     * @param baselinePdfDir Path to the baseline PDF file directory
+     * @param baselinePdfFileName Baseline PDF file name     
+     * @param pages Array of pages to be compared (0-indexed)
+     * @param tolerance Pixel difference tolerance 
+     * @param threshold Similarity threshold (range is 0.00 to 1.00) 
+     * @returns 
+     */
+    private static async comparePdf(actualPdfDir: string, actualPdfFileName: string, baselinePdfDir: string, baselinePdfFileName: string, pages: number[], tolerance: number, threshold: number) {
+        const comparer = new ComparePdf({
+            paths: {
+                actualPdfRootFolder: actualPdfDir,
+                actualPngRootFolder: this.PNG_DIR_ACTUAL,
+                baselinePdfRootFolder: baselinePdfDir,
+                baselinePngRootFolder: this.PNG_DIR_BASELINE,
+                diffPngRootFolder: this.PNG_DIR_DIFF,
+            },
+            settings: {
+                imageEngine: 'native',
+                density: 150,
+                quality: 80,
+                tolerance: tolerance,
+                threshold: threshold,
+                cleanPngPaths: false,
+                matchPageCount: true,
+                disableFontFace: true,
+            },
+        });
+        const results = await comparer
+            .actualPdfFile(actualPdfFileName)
+            .baselinePdfFile(baselinePdfFileName)
+            .onlyPageIndexes(pages)
+            .compare();
+        return results;
+    }
+    /**
+     * Masks the dynamic text in the specified pages of the baseline and actual PDF files and compares them. If differences are found, attaches the actual, baseline, and diff files to the test report.
+     * @param baselineDirPath Path to the baseline PDF file directory
+     * @param baselineFileName Baseline PDF file name
+     * @param actualDirPath Path to the actual PDF file directory 
+     * @param actualFileName Actual PDF file name
+     * @param pageNumber Pages to be compared (1-indexed, comma-separated. E.g., "1,2,3")
+     * @param maskTexts text from baseline PDF file to be masked (pipe-separated. E.g., "text1|text2")
+     * @param tolerance Pixel difference tolerance (default is 0). Use 0 for strict comparison and higher values for more lenient comparison 
+     * @param threshold Similarity threshold (default is 0.00, range is 0.00 to 1.00). Use 0.00 for strict comparison and higher values for more lenient comparison
+     */
+    public static async maskAndComparePdf(baselineDirPath: string, baselineFileName: string, actualDirPath: string, actualFileName: string, pageNumber: string, maskTexts: string, tolerance: number = 0, threshold: number = 0.00) {
+            const pageNumbers = pageNumber.split(',').map(num => parseInt(num.trim(), 10) - 1);
+            const dynamicText = maskTexts ? maskTexts.split('|').map(text => text.trim()) : []
+            if (dynamicText.length > 0) {
+                const maskDetails = await this.maskPdf(baselineDirPath, baselineFileName, actualDirPath, actualFileName, pageNumbers, dynamicText);
+                baselineDirPath = maskDetails.maskedBaselineDir;
+                baselineFileName = maskDetails.maskedBaselineFileName;
+                actualDirPath = maskDetails.maskedActualDir;
+                actualFileName = maskDetails.maskedActualFileName;
+            }
+            const result = await this.comparePdf(actualDirPath, actualFileName, baselineDirPath, baselineFileName, pageNumbers, tolerance, threshold);
+            if (result.status !== 'passed') {
+                await Allure.attachPDF('Actual PDF', `${actualDirPath}/${actualFileName}`);
+                await Allure.attachPDF('Baseline PDF', `${baselineDirPath}/${baselineFileName}`);
+                for (let i = 0; i < result.details.length; i++) {
+                    await Allure.attachPNG(`PDF Diff${i + 1}`, result.details[i].diffPng);
+                }
+                console.log(`PDF comparison failed.\n ${JSON.stringify(result.details, null, 2)}`);                
+            }
+            return result.status === 'passed';            
     }
 }
diff --git a/src/resources/pdf/baseline.pdf b/src/resources/pdf/baseline.pdf
diff --git a/src/tests/DownloadTest.spec.ts b/src/tests/DownloadTest.spec.ts
@@ -2,15 +2,17 @@ import ConfigurationSteps from "@uiSteps/ConfigurationSteps";
 import HomeSteps from "@uiSteps/HomeSteps";
 import { test } from "@base-test";
 import Allure from "@allure";
+import PDFUtil from "@utils/PDFUtil";
 
-test(`DownloadTest - To download pdf file from application`, async ({ page }) => {
-    Allure.attachDetails("To download pdf file from application", null);
+test(`DownloadTest - To download pdf file from application and verify the PDF details`, async ({ page }) => {
+    Allure.attachDetails("To download pdf file from application and verify the PDF details", null);
     const home = new HomeSteps(page);
     await home.launchApplication();
     const newPage = await home.navigateToManagementConsole();
     await page.close();
     const configStep = new ConfigurationSteps(newPage);
     const fileName = await configStep.downloadAOSBackendPDF();
-    await configStep.verifyPDFFilePageCount(fileName, 4);
-    await configStep.verifyPDFFileText(fileName, "Advantage Online Shopping (AOS)");
+    await configStep.verifyPDFDetails(fileName, 4, "Advantage Online Shopping (AOS)");
+    const maskText = '5134647|The Lawn, 22-30 Old Bath Road, Berkshire, RG14 1Q| Java 11';
+    await configStep.verifyPdfByComparing(fileName, 'baseline.pdf', '1,2,3,4', maskText);
 });

Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,5 @@ export default class CommonConstants {`
`4`	`4`	`static readonly TEN = 10;`
`5`	`5`	`static readonly TWO = 2;`
`6`	`6`	`static readonly DOWNLOADS_PATH = "./test-results/downloads/";`
	`7`	`+ static readonly PDF_RESOURCE_PATH = './src/resources/pdf';`
`7`	`8`	`}`