Setup pipeline (#1)

* Create main.yml

* Update main.yml

* Update package.json

* updated headless config in the hook

* added headless variable

* added procces exit

* added firefox and webkit to the matrix

.github/workflows/main.yml

@@ -0,0 +1,35 @@
+name: Playwright and Cucumber Tests
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        browser: [chromium, firefox, webkit]
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+      - name: Install dependencies
+        run: npm ci
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
+      - name: Run Cucumber tests
+        env:
+          HEADLESS: 'true'  
+        run: npm run test:${{ matrix.browser }}
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: cucumber-reports
+          path: test-results/
+          retention-days: 30

package.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "BROWSER_TYPE=chromium cucumber-js -t @prod",
+    "test:chromium": "BROWSER_TYPE=chromium cucumber-js -t @prod",
     "test:firefox": "BROWSER_TYPE=firefox cucumber-js -t @prod",
     "test:webkit": "BROWSER_TYPE=webkit cucumber-js -t @prod",
     "debug": "cucumber-js -t @debug",
@@ -34,4 +34,4 @@
     "puppeteer": "^21.3.8",
     "v8-to-istanbul": "^9.1.3"
   }
-}
+}

src/core/hooks.ts

@@ -1,34 +1,40 @@
 import { After, AfterAll, AfterStep, Before, Status } from "@cucumber/cucumber";
-import { Browser, chromium, firefox, webkit } from "@playwright/test";
+import { Browser, BrowserContext, chromium, firefox, webkit } from "@playwright/test";
 import { finalizeCoverage, saveV8Coverage } from "./coverageHelper";
 import { pageFixture } from "./pageFixture";
 
 let browser : Browser;
-let worldContext: any;
+let context: BrowserContext;
+let page;
 
 Before(async function(scenario) {
     try {
         console.log(`Starting scenario: ${scenario.pickle.name}`);
-        worldContext = this;
 
         // Determine which browser to use
         const browserType = process.env.BROWSER_TYPE || 'chromium'; // Default to chromium if no env variable is set
+        const isHeadless = process.env.HEADLESS === 'true'; // Check the HEADLESS environment variable
+
+        let launchOptions = {
+            headless: isHeadless,
+            args: ['--start-maximized'] // Maximized window is only relevant in non-headless mode
+        };
 
         let browser;
         switch (browserType.toLowerCase()) {
             case 'firefox':
-                browser = await firefox.launch({ headless: false, args: ['--start-maximized'] });
+                browser = await firefox.launch(launchOptions);
                 break;
             case 'webkit':
-                browser = await webkit.launch({ headless: false, args: ['--start-maximized'] });
+                browser = await webkit.launch(launchOptions);
                 break;
             default:
-                browser = await chromium.launch({ headless: false, args: ['--start-maximized'] });
+                browser = await chromium.launch(launchOptions);
                 break;
         }
 
-        const context = await browser.newContext();
-        const page = await context.newPage();
+        context = await browser.newContext();
+        page = await context.newPage();
         pageFixture.page = page;
         //await pageFixture.page.coverage.startJSCoverage();
     } catch (error) {
@@ -44,16 +50,25 @@ AfterStep(async function({pickle, result}) {
     }
 });
 
-After({timeout:5000},async (scenario) => {
-    // Close the page and browser if they are open
-    if (pageFixture.page && !pageFixture.page.isClosed()) {
-        await pageFixture.page.close();
-    }
-    if (browser && browser.isConnected()) {
-        await browser.close();
+After(async function () {
+    try {
+        if (pageFixture.page && !pageFixture.page.isClosed()) {
+            console.log('Closing page...');
+            await pageFixture.page.close();
+        }
+        if (context) {
+            console.log('Closing context...');
+            await context.close();
+        }
+    } finally {
+        if (browser && browser.isConnected()) {
+            console.log('Closing browser...');
+            await browser.close();
+        }
     }
 });
 
 AfterAll(async () => {
+    process.exit(0);
     //await finalizeCoverage();
 });