@devassure/tpp-engine 0.0.0-stage → 1.8.0

package/src/api/api-auth.js

@@ -0,0 +1,18 @@
+function  extractAuthHeaders(tppAuth) {
+    if(!tppAuth) return {};
+    switch(tppAuth.authType) {
+      case 'Basic Auth': {
+        if(!tppAuth.userName || tppAuth.password == null) {
+            return {};
+        }
+        const encodedCreds = btoa(`${tppAuth.userName}:${tppAuth.password}`);
+        return {Authorization: `Basic ${encodedCreds}`};
+      }
+      case 'Bearer Token': {
+        return {Authorization: `Bearer ${tppAuth.bearerToken}`}
+      }
+      default : return {};
+    }
+};
+
+exports.extractAuthHeaders = extractAuthHeaders;

package/src/api/api-service.js

@@ -0,0 +1,289 @@
+const { compare } = require("../utils/assert-utils");
+const { extractValue } = require("../utils/json-utils");
+const { extractAuthHeaders } = require("./api-auth");
+const packageJSON = require('../../package.json');
+const fs = require('fs');
+const { FileUtils } = require("../library/file/file-utils");
+
+class ApiService {
+
+  constructor(request) {
+    this.request = request;
+  }
+
+  async makeApiCall(method, apiUrl, options) {
+    let response;
+    switch(method) {
+      case 'GET': {
+        response = await this.request.get(apiUrl, options);
+        break;
+      }
+      case 'POST': {
+        response = await this.request.post(apiUrl, options);
+        break;
+      }
+      case 'PUT': {
+        response = await this.request.put(apiUrl, options);
+        break;
+      }
+      case 'PATCH': {
+        response = await this.request.patch(apiUrl, options);
+        break;
+      }
+      case 'DELETE': {
+        response = await this.request.delete(apiUrl, options);
+        break;
+      }
+    }
+    return this.parseResponse(response)
+  }
+
+  async apiCall(apiRequest) {
+    const apiPath = !apiRequest.path.trim()
+    ? ''
+    : apiRequest.path.startsWith("/") ? apiRequest.path : "/" + apiRequest.path;
+    const fullPath = apiRequest.baseUrl + apiPath.trim();
+    const options = this.getApiOptions(apiRequest);
+    return await this.makeApiCall(apiRequest.method, fullPath, options)
+  }
+
+  getApiFullPath(apiRequest) {
+    const apiPath = !apiRequest.path.trim()
+    ? ''
+    : apiRequest.path.startsWith("/") ? apiRequest.path : "/" + apiRequest.path;
+    return apiRequest.baseUrl + apiPath.trim();
+  }
+
+  async apiCallwithJson(apiRequest,data) {
+    const fullPath = this.getApiFullPath(apiRequest);
+    let options;
+    options = this.getApiOptions(apiRequest);
+    if(data) { // overwrite options
+      options = this.getApiOptionsJSON(options, data);
+    }
+    return await this.makeApiCall(apiRequest.method, fullPath, options)
+  }
+
+  getApiOptionsJSON(options, data) {
+    if (data.body) {
+      options.data = data.body;
+    }
+    if (data.headers || options.headers) {
+      options.headers = {
+        ...options.headers || {},
+        ...data.headers || {},
+      }
+    }
+    if (data.params || options.params) {
+      options.params = {
+        ...options.params || {},
+        ...data.params || {},
+      }
+    }
+    return options
+  }
+  
+  validateStatus(apiResponse, comparator, expectedStatus) {
+    if(!compare(apiResponse.status(), comparator, expectedStatus)) {
+      throw {
+        message: `Response status is not as expected. actual: ${apiResponse.status()} ---- comparator: ${comparator} ---- expected: ${expectedStatus}`,
+      };
+    }
+  }
+
+  async validateText(apiResponse, comparator, expected) {
+    const responseText = await apiResponse.text();
+    if(!compare(responseText, comparator, expected)) {
+      throw {
+        message: `Response text is not as expected. actual: ${responseText} ---- comparator: ${comparator} ---- expected: ${expected}`,
+      };
+    }
+  }
+
+  async validateJson(apiResponse, jsonKey, comparator, expected) {
+    const responseJson = await apiResponse.json();
+    const value = extractValue(responseJson, jsonKey);
+    if(!compare(value, comparator, expected)) {
+      throw {
+        message: `Response text is not as expected. actual: ${value} ---- comparator: ${comparator} ---- expected: ${expected}`,
+      };
+    }
+  }
+
+  getResponseUrl(apiResponse) {
+    return apiResponse.url()
+  }
+
+  getResponseStaus(apiResponse) {
+    return apiResponse.status()
+  }
+
+  async getResponseBodyJson(apiResponse) {
+    return await apiResponse.json();
+  }
+
+  async getResponseBodyText(apiResponse) {
+    return await apiResponse.text();
+  }
+
+  getResponseHeaders(apiResponse) {
+    return apiResponse.headers();
+  }
+
+  getResponseHeaderValue(apiResponse, key) {
+    const headers = apiResponse.headers();
+    return headers[key] || '';
+  }
+
+  getApiOptions(apiRequest) {
+    const queryParams = apiRequest.request?.queryParams;
+    const params = this.extractQueryParams(queryParams);
+    const tppBody = apiRequest.request?.body;
+    const body = this.extractRequestBody(tppBody);
+    const tppHeaders = apiRequest.request?.headers;
+    const tppAuth = apiRequest.request?.auth;
+    const headers = this.extractHeaders(tppHeaders, tppAuth, body, apiRequest.baseUrl);
+    return {
+      ...params,
+      ...headers,
+      ...body,
+    };
+  }
+
+  extractRequestBody(tppBody) {
+    if(!tppBody || tppBody.type === 'none') return {};
+
+    if(tppBody.type === 'text') return {data: tppBody.data || ""};
+
+    if(tppBody.type === 'json') {
+      if(tppBody.data == null) { return {data: {}}};
+      if(typeof tppBody.data === 'string') {
+        if(!tppBody.data.trim()) { return {data: {}}};
+        try {
+          return {data: JSON.parse(tppBody.data || '{}')};
+        } catch (ex) {
+          throw { message: `Request body is not a valid JSON - ${ex}`};
+        }
+      }
+      return {data: tppBody.data || {}}
+    }
+
+    if(tppBody.type === 'form') {
+      if(!tppBody?.data?.length) return {};
+      let hasFiles = false;
+      const params = {};
+      tppBody.data.filter(param => !!param.name?.trim())
+      .forEach(param => {
+        if(param.type !== 'file') {
+          params[param.name] = param.value;
+        } else {
+          hasFiles = true;
+          const filePath = new FileUtils().getFilePath(param.value)
+          if(!fs.existsSync(filePath)) {
+            throw {message: 'File not found - ' + param.value};
+          }
+          params[param.name] = fs.createReadStream(filePath);
+        }
+      });
+      if(Object.keys(params).length <= 0) {
+        return {};
+      }
+
+      return hasFiles ? {multipart: params} : {form: params};
+    }
+
+    if(tppBody.type === 'graphql') {
+      if(tppBody.data == null) { return {data: {query: '', variables: {}}}};
+      const query = tppBody.data.query || '';
+      let variables = {};
+      try {
+        if(tppBody.data.variables) variables = JSON.parse(tppBody.data.variables);
+      } catch (_ex) {};
+      return {data: {query, variables}}
+    }
+
+    return {};
+  }
+
+  extractQueryParams(tppParams) {
+    if(!tppParams || !tppParams.length) return {};
+    const params = {};
+    tppParams.forEach(param => {
+      if(param?.name?.trim()) {
+        params[param.name] = param.value;
+      }
+    });
+    if(Object.keys(params).length <= 0) {
+      return {};
+    }
+    return {params: params};
+  }
+
+  extractHeaders(tppHeaders, tppAuth, body, baseUrl) {
+    const content = typeof body === "object" ? JSON.stringify(body.data) : body.data;
+    const contentLen = !!content ? Buffer.byteLength(content, 'utf-8') : 0;
+    const headers = {
+      'Content-Length': contentLen.toString(),
+      'Host': new URL(baseUrl).hostname || 'localhost',
+      'User-Agent': `DevAssure/${packageJSON?.version || '1.0'}`,
+    };
+    tppHeaders?.forEach(header => {
+      if(!!header?.name?.trim()) {
+        headers[header.name] = header.value;
+      }
+    });
+    const authHeaders = extractAuthHeaders(tppAuth) || {};
+    const data = {...headers, ...authHeaders};
+    if(Object.keys(data).length <= 0) {
+      return {};
+    }
+    return {headers: data};
+  }
+
+  parseResponse(response) {
+    return response;
+  }
+
+  async getResponseLog(response) {
+    return {
+      url: this.getResponseUrl(response),
+      status: this.getResponseStaus(response),
+      headers: this.getResponseHeaders(response),
+      body: await this.getResponseBodyText(response),
+    }
+  }
+
+  getRequestLog(apiRequest) {
+    const apiOptions = this.getApiOptions(apiRequest);
+    const paramData = apiOptions.params && Object.keys(apiOptions.params).length 
+    ? {params: apiOptions.params}
+    : {};
+    const headerData = apiOptions.headers && Object.keys(apiOptions.headers).length 
+    ? {headers: apiOptions.headers}
+    : {};
+    const bodyData = apiOptions.data || apiOptions.form
+    ? {body: apiOptions.data || apiOptions.form}
+    : {};
+
+    return {
+      method: apiRequest.method,
+      url: this.getApiFullPath(apiRequest),
+      ...headerData,
+      ...paramData,
+      ...bodyData,
+    }
+  }
+
+  async getApiDetailsPretty(apiRequest, response) {
+    return `---------------------------------API DETAILS---------------------------------
+----------------REQUEST----------------
+${JSON.stringify(this.getRequestLog(apiRequest), undefined, 4)}
+----------------RESPONSE----------------
+${JSON.stringify(await this.getResponseLog(response), undefined, 4)}
+_______________________________________________________________________________`;
+  }
+
+}
+
+exports.ApiService = ApiService;
+

package/src/app-config.json

@@ -0,0 +1,7 @@
+{
+    "development": false,
+    "webAppUrl": "https://app.devassure.io",
+    "webAppSocketUrl": "wss://app.devassure.io",
+    "s3Url": "https://devassures3bucket.s3.amazonaws.com",
+    "aiCoreUrl": "wss://aicore.devassure.io"
+}

package/src/autoheal-actions.js

@@ -0,0 +1,309 @@
+const { FileUtils } = require("./library/file/file-utils");
+const path = require("path");
+
+class AutohealActions {
+
+  constructor(actions) {
+      this.actions = actions;
+      this.page = actions.page;
+      this.fromAi = actions.fromAi;
+      this.customConfig = actions.customConfig;
+      this.autohealLog = actions.autohealLog;
+  }
+
+  async initPreferences() {
+    if (this.locatorPreferences) return this.locatorPreferences;
+    const projPath = this.customConfig?.projPath || "";
+    const locatorPreferenceFile = path.join(projPath, "project-preferences", "locator.preference.tspp");
+    this.locatorPreferences = await new FileUtils().readJSONContent(locatorPreferenceFile);
+    return this.locatorPreferences;
+  }
+
+  async click_on_element(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Clicking at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.click(x, y);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while clicking: ${e}`, element);
+    }
+  }
+
+  printLog(stepName, log, element) {
+    let nestedStep = stepName + ` :: ${this.autohealLog(element)}`;
+    this.actions.log(nestedStep, log);
+  }
+
+  async double_click_on_element(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Double clicking at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.move(x, y);
+      await page.mouse.dblclick(x, y);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while double clicking: ${e}`, element);
+    }
+  }
+
+  async right_click_on_element(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Right clicking at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.move(x, y);
+      await page.mouse.click(x, y, { button: 'right' });
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName,`[Auto-heal] Exception while right clicking: ${e}`, element);
+    }
+  }
+
+  async input_value(value, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Typing "${value}" at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      const targetSelector = `${Date.now()}`;
+    // find the elements at x,y and check if any one of them is of type input/textarea or has roles combobox/textbox or has contentEditableSetto true
+    const inputElement = await this.page.evaluate(([x, y, targetSelector]) => {
+      const inputElement = document.elementsFromPoint(x, y);
+      for(let i=0; i<inputElement.length; i++) {
+        const tagName = inputElement[i].tagName.toLowerCase();
+        const type = inputElement[i].getAttribute('type');
+        const role = inputElement[i].getAttribute('role');
+        const nonTextTypes = ['checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'image', 'color', 'range'];
+        const contentEditable = inputElement[i].getAttribute('contentEditable');
+        if((tagName === 'input' && !nonTextTypes.includes(type)) || tagName === 'textarea' || (role && role.toLowerCase() === 'combobox') || (role && role.toLowerCase() === 'textbox') || (contentEditable && contentEditable.toLowerCase() === 'true')) {
+          inputElement[i].setAttribute('tpp-data-target', targetSelector);
+          return inputElement[i];
+        }
+      }
+    }, [x, y, targetSelector]);
+    if(!inputElement) {
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.click(x, y);
+      await this.page.waitForTimeout(100);
+      const fallbackElement = await this.page.evaluate(([x, y, targetSelector]) => {
+        const inputElement = document.activeElement;
+        const tagName = inputElement.tagName.toLowerCase();
+        const type = inputElement.getAttribute('type');
+        const role = inputElement.getAttribute('role');
+        const nonTextTypes = ['checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'image', 'color', 'range'];
+        const contentEditable = inputElement.getAttribute('contentEditable');
+        if((tagName === 'input' && !nonTextTypes.includes(type)) || tagName === 'textarea' || (role && role.toLowerCase() === 'combobox') || (role && role.toLowerCase() === 'textbox') || (contentEditable && contentEditable.toLowerCase() === 'true')) {
+          inputElement.setAttribute('tpp-data-target', targetSelector);
+          return inputElement;
+        }
+      }
+      , [x, y, targetSelector]);
+      if (!fallbackElement) {
+        this.printLog(stepName, `[Auto-heal] No suitable element found to type into.`, element);
+        return;
+      }
+    }
+    const locator = await this.page.locator(`[tpp-data-target="${targetSelector}"]`);
+    await locator.fill(value);
+    await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName,`[Auto-heal] Exception while typing: ${e}`, element);
+    }
+  }
+
+  async clear_text(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Clearing text at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+        let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+        await page.mouse.click(x, y);
+        const selectAllKey = process.platform === 'darwin' ? 'Meta' : 'Control';
+        await page.keyboard.down(selectAllKey);
+        await page.keyboard.press('A');
+        await page.keyboard.up(selectAllKey);
+        await page.keyboard.press('Delete');
+        await page.keyboard.press('Backspace');
+        await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while clearing text: ${e}`, element);
+    }
+  }
+
+  async press_keys_on_element(keys, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Pressing keys "${keys}" at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.click(x, y);
+      await page.keyboard.press(keys);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while pressing keys: ${e}`, element);
+    }
+  }
+
+  async select_value(value, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Selecting value "${value}" at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      const options = this.fromAi ? {delay: 50} : {};
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.move(x, y);
+      await page.selectOption({x, y}, `${value}`, {...options});
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while selecting value: ${e}`, element);
+    }
+  }
+
+  async set_element_attribute(key, value, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Setting attribute "${key}" to "${value}" at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      await this.page.evaluate(([key, value, x, y]) => {
+        const element = document.elementFromPoint(x, y);
+        if (element) {
+          element.setAttribute(key, value);
+        }
+      }, [key, value, x, y]);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while setting attribute: ${e}`, element);
+    }
+  }
+
+  async get_element_attribute(key, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Getting attribute "${key}" at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    let val = null;
+    try {
+      val = await this.page.evaluate(([key, x, y]) => {
+        const element = document.elementFromPoint(x, y);
+        return element ? element.getAttribute(key) : null;
+      }, [key, x, y]);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while getting attribute: ${e}`, element);
+    }
+    return val;
+  }
+
+  async is_element_attribute_present(key, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Checking if attribute "${key}" is present at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    let present = false;
+    try {
+      present = await this.page.evaluate(([key, x, y]) => {
+        const element = document.elementFromPoint(x, y);
+        return element ? element.hasAttribute(key) : false;
+      }, [key, x, y]);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while checking attribute: ${e}`, element);
+    }
+    return present;
+  }
+
+  async set_input_files(files, x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Setting input files at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    try {
+      const fileUtils = new FileUtils();
+      const filePaths = files.map(file => fileUtils.getFilePath(file));
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.move(x, y);
+      await this.page.setInputFiles({x, y}, filePaths);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while setting input files: ${e}`, element);
+    }
+  }
+
+  async hover_on_element(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Hovering at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.mouse.move(x, y);
+    await this.printFallbackLocator(x, y, stepName, element);
+  }
+
+  async get_input_element_value(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Getting input value at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    let value = null;
+    try {
+      value = await this.page.evaluate(([x, y]) => {
+        const element = document.elementFromPoint(x, y);
+        return element ? element.value : null;
+      }, [x, y]);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while getting input value: ${e}`, element);
+    }
+    return value;
+  }
+
+  async get_element_text(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Getting text at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    let text = null;
+    try {
+      text = await this.page.evaluate(([x, y]) => {
+        const element = document.elementFromPoint(x, y);
+        return element ? element.innerText : null;
+      }, [x, y]);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while getting text: ${e}`, element);
+    }
+    return text;
+  }
+
+  async get_element_dimensions(x, y, stepName, element) {
+    const logLabel = `[Auto-heal] Getting dimensions at (${x}, ${y}).`;
+    this.actions.action_log(logLabel);
+    let dimensions = null;
+    try {
+      dimensions = await this.page.evaluate(([x, y]) => {
+        const element = document.elementFromPoint(x, y);
+        if (element) {
+          const rect = element.getBoundingClientRect();
+          return {
+            width: rect.width,
+            height: rect.height,
+            x: rect.x,
+            y: rect.y,
+          };
+        }
+        return null;
+      }, [x, y]);
+      await this.printFallbackLocator(x, y, stepName, element);
+    } catch (e) {
+      this.printLog(stepName, `[Auto-heal] Exception while getting dimensions: ${e}`, element);
+    }
+    return dimensions;
+  }
+
+  async printFallbackLocator(x, y, stepName, element) {
+    let pref = await this.initPreferences();
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    let ele = await page.evaluate(([x, y, pref]) => {
+      const element = document.elementFromPoint(x, y);
+      const eventElement = window.getTppEventElement ? window.getTppEventElement(element, 'click', { locatorPreference: pref }) : null;
+      return eventElement;
+    }, [x, y, pref]); 
+    if (ele && ele.target && ele.target !== element.locator) {
+      ele.locator = ele.target
+      await this.actions.setFallbackLocators(element, ele);
+      ele.elementLabel = element.label;
+      let fallbackLog = {
+        element: element.label,
+        fallback: ele,
+      }
+      this.printLog(stepName, `[autoheal-locator-used] ${JSON.stringify(fallbackLog)}`, element);
+    }
+  }
+}
+
+exports.AutohealActions = AutohealActions;

package/src/console-log/console-log-manager.js

@@ -0,0 +1,39 @@
+class ConsoleLogManager {
+
+    constructor(consoleConfig, page) {
+        this.enabled = !!consoleConfig?.enabled;
+        if(!consoleConfig?.enabled || !page) {
+            return;
+        }
+        
+        this.consoleLogs = [];
+        this.allowedTypes = consoleConfig.allowedTypes;
+        this.startLogTracing(page);
+    }
+
+    startLogTracing(page) {
+        if(!this.enabled) {
+            return;
+        }
+
+        const handleLog = (msg) => {
+            if(this.allowedTypes && !this.allowedTypes.includes(msg.type()?.toLowerCase())) {
+                return;
+            }
+            this.consoleLogs.push({
+                type: msg.type(),
+                text: msg.text(),
+                sourceUrl: msg.location()?.url,
+            });
+        };
+
+        page.on('console', handleLog);
+
+        page.context().on('page', async (newPage) => {
+            newPage.on('console', handleLog);
+        });
+    }
+
+};
+
+exports.ConsoleLogManager = ConsoleLogManager;