regressify 1.0.0

package/.engine_scripts/puppet/ignoreCSP.js

@@ -0,0 +1,65 @@
+/**
+ * IGNORE CSP HEADERS
+ * Listen to all requests. If a request matches scenario.url
+ * then fetch the request again manually, strip out CSP headers
+ * and respond to the original request without CSP headers.
+ * Allows `ignoreHTTPSErrors: true` BUT... requires `debugWindow: true`
+ *
+ * see https://github.com/GoogleChrome/puppeteer/issues/1229#issuecomment-380133332
+ * this is the workaround until Page.setBypassCSP lands... https://github.com/GoogleChrome/puppeteer/pull/2324
+ *
+ * @param      {REQUEST}  request
+ * @return     {VOID}
+ *
+ * Use this in an onBefore script E.G.
+  ```
+  module.exports = async function(page, scenario) {
+    require('./removeCSP')(page, scenario);
+  }
+  ```
+ *
+ */
+
+const fetch = require('node-fetch');
+const https = require('https');
+const agent = new https.Agent({
+  rejectUnauthorized: false
+});
+
+module.exports = async function (page, scenario) {
+  const intercept = async (request, targetUrl) => {
+    const requestUrl = request.url();
+
+    // FIND TARGET URL REQUEST
+    if (requestUrl === targetUrl) {
+      const cookiesList = await page.cookies(requestUrl);
+      const cookies = cookiesList.map(cookie => `${cookie.name}=${cookie.value}`).join('; ');
+      const headers = Object.assign(request.headers(), { cookie: cookies });
+      const options = {
+        headers,
+        body: request.postData(),
+        method: request.method(),
+        follow: 20,
+        agent
+      };
+
+      const result = await fetch(requestUrl, options);
+
+      const buffer = await result.buffer();
+      const cleanedHeaders = result.headers._headers || {};
+      cleanedHeaders['content-security-policy'] = '';
+      await request.respond({
+        body: buffer,
+        headers: cleanedHeaders,
+        status: result.status
+      });
+    } else {
+      request.continue();
+    }
+  };
+
+  await page.setRequestInterception(true);
+  page.on('request', req => {
+    intercept(req, scenario.url);
+  });
+};

package/.engine_scripts/puppet/interceptImages.js

@@ -0,0 +1,37 @@
+/**
+ * INTERCEPT IMAGES
+ * Listen to all requests. If a request matches IMAGE_URL_RE
+ * then stub the image with data from IMAGE_STUB_URL
+ *
+ * Use this in an onBefore script E.G.
+  ```
+  module.exports = async function(page, scenario) {
+    require('./interceptImages')(page, scenario);
+  }
+  ```
+ *
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const IMAGE_URL_RE = /\.gif|\.jpg|\.png/i;
+const IMAGE_STUB_URL = path.resolve(__dirname, '../imageStub.jpg');
+const IMAGE_DATA_BUFFER = fs.readFileSync(IMAGE_STUB_URL);
+const HEADERS_STUB = {};
+
+module.exports = async function (page, scenario) {
+  const intercept = async (request, targetUrl) => {
+    if (IMAGE_URL_RE.test(request.url())) {
+      await request.respond({
+        body: IMAGE_DATA_BUFFER,
+        headers: HEADERS_STUB,
+        status: 200
+      });
+    } else {
+      request.continue();
+    }
+  };
+  await page.setRequestInterception(true);
+  page.on('request', intercept);
+};

package/.engine_scripts/puppet/loadCookies.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const YAML = require('js-yaml');
+
+module.exports = async (page, scenario) => {
+  let cookies = [];
+  const cookiePath = scenario.cookiePath;
+
+  // READ COOKIES FROM FILE IF EXISTS
+  if (!!cookiePath && fs.existsSync(cookiePath)) {
+    let content = fs.readFileSync(cookiePath);
+    if (cookiePath.endsWith('.json')) {
+      cookies = JSON.parse(content);
+    } else if (cookiePath.endsWith('.yaml') || cookiePath.endsWith('.yml')) {
+      cookies = YAML.load(content);
+    }
+  }
+
+  // MUNGE COOKIE DOMAIN
+  cookies = cookies.map((cookie) => {
+    if (cookie.domain.startsWith('http://') || cookie.domain.startsWith('https://')) {
+      cookie.url = cookie.domain;
+    } else {
+      cookie.url = 'https://' + cookie.domain;
+    }
+    delete cookie.domain;
+    return cookie;
+  });
+
+  // SET COOKIES
+  const setCookies = async () => {
+    return Promise.all(
+      cookies.map(async (cookie) => {
+        await page.setCookie(cookie);
+      })
+    );
+  };
+  await setCookies();
+
+  // console.log('Cookie state restored with:', JSON.stringify(cookies, null, 2));
+  console.log('Cookie state restored for: ' + scenario.label);
+};

package/.engine_scripts/puppet/login-user.js

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const YAML = require('js-yaml');
+const { clearInterval } = require('timers');
+const globalData = {
+  domain1: {
+    isSiginingIn: false,
+    cookies: undefined,
+    domain: '',
+  },
+};
+// loginAndSaveCookies.ts
+const getSignInData = async () => {
+  const signInPath = 'visual_tests/_signing-in.yaml';
+  let signInConfig = [];
+  // Read Cookies from File, if exists
+  if (!!signInPath && fs.existsSync(signInPath)) {
+    let content = fs.readFileSync(signInPath);
+    if (signInPath.endsWith('.json')) {
+      signInConfig = JSON.parse(content);
+    } else if (signInPath.endsWith('.yaml') || signInPath.endsWith('.yml')) {
+      signInConfig = YAML.load(content);
+    }
+  }
+
+  return signInConfig;
+};
+const sleep = (time) => {
+  return new Promise((r) => {
+    setTimeout(() => {
+      r(true);
+    }, time);
+  });
+};
+const waitForCondition = (condition = () => true, intervalCheckTime = 1000, maxCheckTime = 30000) => {
+  return new Promise((resolve, reject) => {
+    if (condition()) {
+      resolve(true);
+      return;
+    }
+    let totalCheckedTime = 0;
+    let intervalCheckId = setInterval(() => {
+      totalCheckedTime += intervalCheckTime;
+      if (condition()) {
+        clearInterval(intervalCheckId);
+        resolve(true);
+        return;
+      }
+      if (totalCheckedTime >= maxCheckTime) {
+        clearInterval(intervalCheckId);
+        resolve(false);
+        return;
+      }
+    }, intervalCheckTime);
+  });
+};
+
+const executeSignIn = async (browserContext, domain) => {
+  try {
+    const pageUrl = domain;
+    const signInConfig = await getSignInData();
+    const sigInForPage = signInConfig.find((a) => a.domain.includes(pageUrl.host));
+    if (!sigInForPage) {
+      console.warn('not found signin config for page url', pageUrl);
+      return;
+    }
+
+    console.log('found signin config for page url', pageUrl);
+    const page = await browserContext.newPage();
+
+    console.log('navigate to sigin url', sigInForPage.loginUrl);
+    // Navigate to the login page
+    await page.goto(sigInForPage.loginUrl);
+
+    const inputData = async (selector, value) => {
+      await page.waitForSelector(selector);
+      console.log('found selector', selector);
+      let el = await page.locator(selector);
+      await el.fill(value);
+    };
+    await inputData(sigInForPage.userNameSelector, sigInForPage.userName);
+    await inputData(sigInForPage.passwordSelector, sigInForPage.password);
+
+    await page.waitForSelector(sigInForPage.loginButtonSelector);
+    console.log('found selector login button');
+    await page.click(sigInForPage.loginButtonSelector);
+    await page.waitForNavigation();
+
+    console.log('sign in successfully', page.url());
+    // Save cookies after login
+    cookies = await browserContext.cookies();
+    const loggingCookies = cookies.map((a) => a.name).sort();
+    console.log('cookies', loggingCookies);
+    return cookies;
+  } catch (error) {
+    console.error('sign in error', error, domain);
+    return undefined;
+  }
+};
+const waitForOtherSiginingIn = async (signInData) => {
+  const isSignedIn = await waitForCondition(() => !signInData.isSiginingIn, 1000, 10000);
+  return isSignedIn;
+};
+const getOrSetSignInData = async (browserContext, loginScenario) => {
+  const pageUrl = new URL(loginScenario.url);
+  const signInDomain = pageUrl.host;
+  const signInData = (globalData[signInDomain] = globalData[signInDomain] || {
+    isSiginingIn: false,
+    cookies: undefined,
+    signInDomain: new URL(`${pageUrl.protocol}//${pageUrl.host}`),
+  });
+
+  if (!signInData.isSiginingIn) {
+    console.log('first signin was called');
+    // lock current signin for domain
+    signInData.isSiginingIn = true;
+    signInData.cookies = await executeSignIn(browserContext, signInData.signInDomain);
+    // release lock for domain
+    signInData.isSiginingIn = false;
+  } else {
+    const isSignedInSuccessfully = await waitForOtherSiginingIn(signInData);
+    if (isSignedInSuccessfully) {
+      console.log('cookies is populated by others, reuse it');
+    } else {
+      console.log('cookies is not populated by others, start logging in user');
+      signInData.cookies = await executeSignIn(browserContext, signInData.signInDomain);
+    }
+  }
+
+  return signInData;
+};
+module.exports = async function (browserContext, loginScenario) {
+  if (!loginScenario.requiredLogin) {
+    console.log('testing scenario run as anonymous user ', loginScenario.label);
+    return;
+  }
+  console.log('testing scenario required login cookies ', loginScenario.label);
+  let signInData = await getOrSetSignInData(browserContext, loginScenario);
+  if (signInData?.cookies) {
+    browserContext.addCookies(signInData.cookies);
+    console.log('------login cookies restored for ', loginScenario.label);
+  }
+};

package/.engine_scripts/puppet/onBefore.js

@@ -0,0 +1,4 @@
+module.exports = async (page, scenario, viewport, isReference, browserContext) => {
+  await require('./login-user')(browserContext, scenario);
+  await require('./loadCookies')(browserContext, scenario);
+};

package/.engine_scripts/puppet/onReady.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const autoScroll = require('../auto-scroll');
+
+module.exports = async (page, scenario, vp) => {
+  console.log('SCENARIO > ' + scenario.label);
+  if (scenario.useCssOverride) {
+    await require('./overrideCSS')(page, scenario);
+  }
+  await require('./clickAndHoverHelper')(page, scenario);
+
+  const jsOnReadyPath = scenario.jsOnReadyPath;
+
+  if (!jsOnReadyPath) {
+    return;
+  } else if (!fs.existsSync(jsOnReadyPath)) {
+    console.log('File not exist: ' + jsOnReadyPath);
+    return;
+  }
+
+  const jsOnReadyScript = fs.readFileSync(jsOnReadyPath, 'utf-8');
+  await page
+    .evaluate(jsOnReadyScript)
+    .then(() => "ONREADY script executed for: " + scenario.label);
+
+  // add more ready handlers here...
+  await page.evaluate(autoScroll);
+
+  await page.waitForNetworkIdle({
+    idleTime: 500,
+    timeout: 5000
+  });
+};

package/.engine_scripts/puppet/overrideCSS.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = async (page, scenario) => {
+  const cssOverridePath = scenario.cssOverridePath;
+
+  if (!cssOverridePath) {
+    return;
+  } else if (!fs.existsSync(cssOverridePath)) {
+    console.log('File not exist: ' + cssOverridePath);
+    return;
+  }
+
+  const override = fs.readFileSync(cssOverridePath, 'utf-8');
+
+  // inject arbitrary css to override styles
+  await page.evaluate(`window._styleData = '${override}'`);
+  await page.evaluate(() => {
+    const style = document.createElement('style');
+    style.type = 'text/css';
+    const styleNode = document.createTextNode(window._styleData);
+    style.appendChild(styleNode);
+    document.head.appendChild(style);
+  });
+
+  console.log('BACKSTOP_TEST_CSS_OVERRIDE injected for: ' + scenario.label);
+  // console.log(override);
+};

package/.engine_scripts/replacement-profiles-schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-06/schema#",
+  "$ref": "#/definitions/Root",
+  "definitions": {
+    "Root": {
+      "type": "object",
+      "properties": {
+        "profiles": {
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/Replacement"
+            }
+          }
+        }
+      },
+      "required": ["profiles"]
+    },
+    "Replacement": {
+      "type": "object",
+      "properties": {
+        "ref": {
+          "type": "string"
+        },
+        "test": {
+          "type": "string"
+        }
+      },
+      "required": ["ref", "test"]
+    }
+  }
+}

package/.engine_scripts/scroll-top.js

@@ -0,0 +1,27 @@
+module.exports = async () => {
+  const SCROLL_TOP_MAX = 100;
+
+  await new Promise((resolve) => {
+    const timer = setInterval(() => {
+      if (!window.visualTestScrollingBottom) {
+        clearInterval(timer);
+        resolve();
+        return;
+      }
+    }, 100);
+  });
+
+  await new Promise((resolve) => {
+    let counter = 0;
+    const timer = setInterval(() => {
+      if (window.scrollY === 0 || counter > SCROLL_TOP_MAX) {
+        clearInterval(timer);
+        resolve();
+        return;
+      }
+
+      counter++;
+      window.scrollTo(0, 0);
+    }, 100);
+  });
+};