Added_winston_logger

Author: akshayp7

CustomReporterConfig.ts

@@ -1,22 +1,36 @@
 import { Reporter, TestCase, TestError, TestResult, TestStep } from "@playwright/test/reporter";
+const winston = require(`winston`);
+
+const console = new winston.transports.Console();
+const logger = winston.createLogger({
+    level: 'info',
+    format: winston.format.json(),
+    transports: [
+      // - Write all logs with importance level of `info` or less than it
+      new winston.transports.File({ filename: 'logs/info.log', level: 'info' }),
+    ],
+  });
+
+  // Writes logs to console
+  logger.add(console);
 
 export default class CustomReporterConfig implements Reporter {
 
     onTestBegin(test: TestCase): void {
-        console.log(`Test Case Started : ${test.title}`);
+        logger.info(`Test Case Started : ${test.title}`);
     }
 
     onTestEnd(test: TestCase, result: TestResult): void {
-        console.log(`Test Case Completed : ${test.title} Status : ${result.status}`);
+        logger.info(`Test Case Completed : ${test.title} Status : ${result.status}`);
     }
 
     onStepBegin(test: TestCase, result: TestResult, step: TestStep): void {
         if (step.category === `test.step`) {
-            console.log(`Executing Step : ${step.title}`);
+            logger.info(`Executing Step : ${step.title}`);
         }
     }
 
     onError(error: TestError): void {
-        console.log(error.message);
+        logger.error(error.message);
     }
 }

README.md

@@ -200,6 +200,20 @@ await page.routeFromHAR('har/personalInfo.har',{update:false});
 ```
 where `update:false` means to use the existing HAR from from the path given in first paraeter `har/personalInfo.har`, to see this in action you can turn off your internet and run the script, complete webpage is mocked up along with assertions on the browser of your choice this is done using the Network Replay feature and by using our recorded HAR file.
 We can use this feature when webpage is down for some reason and we want to test some scenarios. 
+22. Logging is implemented in `CustomReporterConfig.ts` using winston logger.
+
+First we have to create a logger object using winston.createLogger and then provid the configuration you need.
+First argument is "level" for which i have provided value as "info", in winston logger every logging level is provided with a numeric value, for info the numeric value is 2, so if we provide level as info then all the logs which are equal to or less than info level will be displayed. In our case logs with error(0) and warn(1) wil also be logged. For more info on logging refer below link
+`https://github.com/winstonjs/winston#logging`
+
+Second we have to provide format for the log file generate I have provided format as json using ` winston.format.json()` because JSON is widely used. There are various levels like printf, simple, colorize which you can refer in below link
+`https://github.com/winstonjs/logform#formats` 
+
+Third part is transports which defines where the log file will be written. I have provided the location as `logs/info.log` in my case
+
+Once logger object is created I have provided `logger.add(console);` which instructs logger to write the log files in console as well.
+
+Once logger object is created you can use this instead of console.log in your framework and these logs will be written both in your console and log file.
 
 ## Reports
 

lib/WebActions.ts

@@ -26,10 +26,6 @@ export class WebActions {
         return CryptoJS.AES.decrypt(testConfig.password, key).toString(CryptoJS.enc.Utf8);
     }
 
-    async waitForElementAttached(locator: string): Promise<void> {
-        await this.page.waitForSelector(locator);
-    }
-
     async waitForPageNavigation(event: string): Promise<void> {
         switch (event.toLowerCase()) {
             case `networkidle`:
@@ -50,12 +46,10 @@ export class WebActions {
     }
 
     async clickElement(locator: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         await this.page.click(locator);
     }
 
     async clickElementJS(locator: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         await this.page.$eval(locator, (element: HTMLElement) => element.click());
     }
 
@@ -67,24 +61,19 @@ export class WebActions {
     }
 
     async enterElementText(locator: string, text: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         await this.page.fill(locator, text);
     }
 
     async dragAndDrop(dragElementLocator: string, dropElementLocator: string): Promise<void> {
-        await this.waitForElementAttached(dragElementLocator);
-        await this.waitForElementAttached(dropElementLocator);
         await this.page.dragAndDrop(dragElementLocator, dropElementLocator);
     }
 
     async selectOptionFromDropdown(locator: string, option: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         const selectDropDownLocator = await this.page.$(locator);
         selectDropDownLocator.type(option);
     }
 
     async getTextFromWebElements(locator: string): Promise<string[]> {
-        await this.waitForElementAttached(locator);
         return this.page.$$eval(locator, elements => elements.map(item => item.textContent.trim()));
     }
 
@@ -121,7 +110,6 @@ export class WebActions {
     }
 
     async verifyElementText(locator: string, text: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         const textValue = await this.page.textContent(locator);
         expect(textValue.trim()).toBe(text);
     }
@@ -139,18 +127,15 @@ export class WebActions {
     }
 
     async verifyElementContainsText(locator: string, text: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         await expect(this.page.locator(locator)).toContainText(text);
     }
 
     async verifyJSElementValue(locator: string, text: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         const textValue = await this.page.$eval(locator, (element: HTMLInputElement) => element.value);
         expect(textValue.trim()).toBe(text);
     }
 
     async verifyElementAttribute(locator: string, attribute: string, value: string): Promise<void> {
-        await this.waitForElementAttached(locator);
         const textValue = await this.page.getAttribute(locator, attribute);
         expect(textValue.trim()).toBe(value);
     }