Updating Test Case Status in Test Plan

Author: BakkappaN

package-lock.json

@@ -21,6 +21,7 @@
   },
   "dependencies": {
     "@faker-js/faker": "^9.4.0",
+    "axios": "^1.7.9",
     "csv-parse": "^5.6.0",
     "dotenv": "^16.4.7",
     "xlsx": "^0.18.5"

package.json

@@ -34,7 +34,7 @@ export default defineConfig({
     ['html'],
     ['list'],
     //['dot'],
-    // ['json', { outputFile: 'json-test-report.json' }],
+    ['json', { outputFile: 'json-test-report.json' }],
     ['junit', { outputFile: 'junit-test-report.xml' }],
     ['allure-playwright'],
   ],

playwright.config.ts

@@ -0,0 +1,24 @@
+export interface TestResult {
+    title: string;
+    status: string;
+}
+
+export interface Suite {
+    title: string;
+    file: string;
+    specs: {
+        title: string;
+        tests: {
+            results: {
+                status: string;
+            }[];
+        }[];
+    }[];
+}
+
+export interface TestReport {
+    config: any; 
+    suites: Suite[];
+    errors: any[]; 
+    stats: any; 
+}

src/interface/TestResults.interface.ts

@@ -0,0 +1,76 @@
+import { request, expect } from '@playwright/test';
+import dotenv from 'dotenv';
+dotenv.config();
+
+import axios from 'axios';
+
+const credentials = Buffer.from(`${process.env.AZURE_DEVOPS_USER}:${process.env.AZURE_DEVOPS_PASS}`).toString('base64');
+
+/**
+ * Testers Talk
+ */
+class AzureDevOps {
+    constructor() { }
+
+    /**
+     * Testers Talk
+     */
+    async updateTestCaseStatus(testCaseId: string, testCaseStatus: string): Promise<void> {
+        try {
+            const testPlanId = process.env.TEST_PLAN_ID as string;
+            const testSuiteId = process.env.TEST_SUITE_ID as string;
+
+            const testPointId = await this.getTestPoint(testPlanId, testSuiteId, testCaseId);
+            await this.updateTestPointStatus(testPlanId, testSuiteId, testPointId, testCaseStatus.charAt(0).toUpperCase() + testCaseStatus.slice(1));
+
+            console.log(`Updated Test Case ID - ${testCaseId} as ${testCaseStatus} in test plan`);
+        } catch (error) {
+            console.error('Error in updating test case status:', error);
+        }
+    }
+
+    /**
+     * Testers Talk
+     */
+    async getTestPoint(testPlanId: string, testSuiteId: string, testCaseId: string): Promise<string> {
+        const values = [testPlanId, testSuiteId, testCaseId];
+        const URL = process.env.TEST_PLAN_GET_API!.replace(/{(\d+)}/g, (match, number) => values[number] || match);
+        const getTestPointResponse = await axios.get(URL, {
+            headers: {
+                "Content-Type": "application/json",
+                'Authorization': `Basic ${credentials}`
+            },
+        });
+
+        const jsonResponse = await getTestPointResponse.data;
+        expect(getTestPointResponse.status).toBe(200);
+        return jsonResponse.value[0].id;
+    }
+
+    /**
+     * Testers Talk
+     */
+    async updateTestPointStatus(testPlanId: string, testSuiteId: string, testPointId: string, testCaseStatus: string): Promise<void> {
+        const values = [testPlanId, testSuiteId, testPointId];
+        const URL = process.env.TEST_PLAN_PATCH_API!.replace(/{(\d+)}/g, (match, number) => values[number] || match);
+
+        const requestBody = {
+            "outcome": testCaseStatus // Passed, Failed, Blocked, etc.
+        };
+
+        try {
+            const patchAPIResponse = await axios.patch(URL, requestBody, {
+                headers: {
+                    "Content-Type": "application/json",
+                    'Authorization': `Basic ${credentials}`
+                }
+            });
+            expect(patchAPIResponse.status).toBe(200);
+        } catch (error: any) {
+            console.error('Error occurred during API request:', error.message);
+            console.error('Stack trace:', error.stack);
+        }
+    }
+}
+
+export default AzureDevOps;

src/utils/AzureDevOpsHelper.ts

@@ -1,4 +1,11 @@
 import { Page } from '@playwright/test';
+import AzureDevOps from '../../src/utils/AzureDevOpsHelper';
+import * as fs from 'fs';
+import { TestReport } from '../../src/interface/TestResults.interface';
+
+import dotenv from 'dotenv';
+dotenv.config();
+
 
 /**
  * Author Testers Talk
@@ -31,4 +38,69 @@ export async function navigateToApps(
     await page.goto(`/main.aspx?appid=${appId.toString()}`);
     await page.getByRole('button', { name: appName }).isVisible();
     console.log('Navigated to ' + appName + ' - Success');
+}
+
+/**
+ * Author Testers Talk
+ */
+async function readJsonReport() {
+    const azureDevOps = new AzureDevOps();
+    const filePath = 'json-test-report.json';
+
+    if (process.env.UPDATE_TEST_PLAN === 'Yes' && process.env.PIPELINE === 'Yes') {
+
+        await waitForFile(filePath);
+
+        try {
+            const data: TestReport = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            data.suites.forEach(suite => {
+                suite.specs.forEach(spec => {
+                    const testCaseTitle = `${spec.title}`;
+                    spec.tests.forEach(test => {
+                        test.results.forEach(async result => {
+                            const testCaseStatus = `${result.status}`;
+
+                            const matches = testCaseTitle.match(/\[(.*?)\]/);
+                            const numbersPart = matches?.[1];
+                            const numbersArray: number[] = numbersPart?.split(',').map(num => parseInt(num.trim(), 10)) ?? [];
+
+                            for (const testCaseId of numbersArray) {
+                                console.log(`Test Case & Status : ${testCaseId} : ${testCaseStatus}`);
+                                await azureDevOps.updateTestCaseStatus(String(testCaseId), testCaseStatus);
+                            }
+                        });
+                    });
+                });
+            });
+        } catch (error) {
+            console.error('Error while readinf JSON report' + error)
+        }
+    } else {
+        console.log('Update test plan or pipeline conditions not met.');
+    }
+}
+
+
+/**
+ * Author Testers Talk
+ */
+async function waitForFile(filePath: string) {
+    const fs = require('fs').promises;
+
+    let fileExists = false;
+    while (!fileExists) {
+        try {
+            await fs.access(filePath);
+            fileExists = true; // If no error is thrown, the file exists
+        } catch (err) {
+            // File does not exist yet, wait and try again
+            console.log('Waiting for the file to be available...');
+            await new Promise(resolve => setTimeout(resolve, 5000)); // Retry every 5 seconds
+        }
+    }
+    console.log(`File ${filePath} is now available!`);
+}
+
+export async function updateTestCaseStatusInTestPlan() {
+    await readJsonReport();
 }

src/utils/Common.ts

@@ -0,0 +1,11 @@
+import { updateTestCaseStatusInTestPlan } from '../../src/utils/Common';
+
+async function run() {
+  try {
+    await updateTestCaseStatusInTestPlan();
+  } catch (error) {
+    console.error('Error executing updateTestCaseStatusInTestPlan:', error);
+  }
+}
+
+run();

src/utils/RunUpdate.ts

@@ -3,7 +3,7 @@ import { test, expect } from '@playwright/test';
 /**
  * Author Testers Talk
  */
-test('test', async ({ page }) => {
+test('[3] Record a test', { tag: ['@PlaywrightWithAzureDevOpsPipeline'] }, async ({ page }) => {
 
   await test.step('Navigating to URL', async () => {
     await page.goto('https://github.com/');
@@ -24,4 +24,12 @@ test('test', async ({ page }) => {
   await test.step('Validate error message', async () => {
     await expect(page.getByRole('alert')).toContainText('Incorrect username or password.');
   });
+});
+
+/**
+ * Author Testers Talk
+ */
+test('[8] Test 2 will fail', { tag: ['@PlaywrightWithAzureDevOpsPipeline'] }, async ({ page }) => {
+  await page.goto('https://www.youtube.com/@testerstalk');
+  expect(true).toBe(false);
 });