Getting Started with Testworthy APIs

npx playwright test 

  

module.exports = { 
    tw_Creds: { 
    baseAPIURL : 'www.testworthy.com', 
    suite_id : 'Project Suite Id', 
    run_title: 'Regression Cycle', 
    user_email : 'your_email@example.com', 
    tma_key : 'TestWorthy API key', 
    project_key : 'your_project_key', 
    cookies: 'Your user cookies' 
    }

}  

  

const apiData = require('Your_File_Path/config.js'); 
//This global array will store the Case Titles and Case IDs from "get_run_cases" API response 

let testCaseDataArray = []; 
// Global variable for assigning Test Case IDs to use in the tests 

let case_id; 
// Global variables to dynamically handle the run ids to use in a specific call 

let run_id; 
let run_title; 
class testWorthyAPIs{  
  constructor() { 
    // You can initialize any properties here 

  } 

  //*** Add Test Worthy methods from here ***// 

} 
module.exports = { testWorthyAPIs } 

  

    async get_run_from_suit_id() {
      const apiUrl = apiData.tw_Creds.baseAPIURL + "get_runs/" +
          apiData.tw_Creds.suite_id;
      process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
      const requestOptions = {
          method: 'GET',
          headers: {
              'X-USER-EMAIL': apiData.tw_Creds.user_email,
              'X-TMA-KEY': apiData.tw_Creds.tma_key,
              'X-PROJECT-KEY': apiData.tw_Creds.project_key,
              'Content-Type': 'application/json',
              'Cookie': apiData.tw_Creds.cookies,
          },
      };
      try {
          const response = await fetch(apiUrl, requestOptions);

          if (!response.ok) {
              throw new Error(`API request failed with status: ${response.status}`);
          }
          const data = await response.json();

          if (data.runs && data.runs.length > 0) {
              const runs = data.runs;
              const targetRunName = apiData.tw_Creds.run_title;
              const targetRun = runs.find(run => run.name === targetRunName);
              if (targetRun) {
                  console.log('Target Run Title is:', targetRun.name);
                  console.log('Target Run ID is:', targetRun.id);
                  run_id = targetRun.id;
                  run_title = targetRun.name;
                  console.log('Final Run ID:', run_id);
                  console.log('Final Run Title:', run_title);
                  return targetRun;
              } else {
                  console.log(`No run found with the name: ${targetRunName}`);
                  return null;
              }
          } else {
              console.log('No runs found in the response.');
              return null;
          }
          return data;
      } catch (error) {
          console.error('API Request Error:', error);
          throw error;
      }
  }

  


async get_case_id_api() {
    const apiUrl = apiData.tw_Creds.baseAPIURL + "get_run_cases/" +
        run_id;
    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
    const requestOptions = {
        method: 'GET',
        headers: {
            'X-USER-EMAIL': apiData.tw_Creds.user_email,
            'X-TMA-KEY': apiData.tw_Creds.tma_key,
            'X-PROJECT-KEY': apiData.tw_Creds.project_key,
            'Content-Type': 'application/json',
            'Cookie': apiData.tw_Creds.cookies,
        },
    };
    try {
        const response = await fetch(apiUrl, requestOptions);
        if (!response.ok) {
            throw new Error(`API request failed with status: ${response.status}`);
        }
        const data = await response.json();
        const tests = data.tests;
        for (const test of tests) {
            const caseId = test.case.id;
            const caseTitle = test.case.title;
            testCaseDataArray.push({
                caseId,
                caseTitle
            });
        }
        console.log('Array Data', testCaseDataArray);
        return data;
    } catch (error) {
        console.error('API Request Error:', error);
        throw error;
    }
}

  

async matchAndAssignCaseId(currentTestTitle) {
    const matchingTest = testCaseDataArray.find(test => test.caseTitle === currentTestTitle);
    if (matchingTest) {
        case_id = matchingTest.caseId;
        console.log('Match found. Assigned caseId:', case_id);
    } else {
        console.error('No match found for the test title:', currentTestTitle);
    }
    console.log('Case ID: ', case_id);
    console.log('Case Title: ', matchingTest.caseTitle);
}

  

  async add_results_for_cases(testStatus) {
     if (testStatus === 'PASSED') {
         testStatus = 1;
         console.log('Test Status = ' + testStatus);
     } else {
         testStatus = 5
         console.log('Test Status = ' + testStatus);
     }
     const apiUrl = apiData.tw_Creds.baseAPIURL +
         "add_results_for_cases/" + run_id;
     process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
     console.log('Case ID in Map Status Function', case_id);
     const requestData = {
         "Results": [{
             "case_id": case_id,
             "status_id": testStatus,
             "Comment": "test from postman",
         }]
     }
     const requestOptions = {
         method: 'POST',
         headers: {
             'X-USER-EMAIL': apiData.tw_Creds.user_email,
             'X-TMA-KEY': apiData.tw_Creds.tma_key,
             'X-PROJECT-KEY': apiData.tw_Creds.project_key,
             'Content-Type': 'application/json',
             'Cookie': apiData.tw_Creds.cookies,
         },
         body: JSON.stringify(requestData),
     };

     try {
         const response = await fetch(apiUrl, requestOptions);
         if (!response.ok) {
             throw new Error(`API request failed with status: ${response.status}`);
         }
         const data = await response.json();
         console.log('API Response Data:', data);
         return data;
     } catch (error) {
         console.error('API Request Error:', error);
         throw error;
     }
 }

  

import { test, expect, request } from '@playwright/test';
const { signUp } = require('../page/signupPageClass.js');
const { purchaseItem } = require('../page/samplePageClass.js');
const { testWorthyAPIs } = require('../TestWorthy-JS-Integration/testworthy-api-functions.js');

test.describe('Demo - TestWorthy Integration with Playwright/JavaScript', () => {
  let page;

  // Initialize the test status as 'FAILED'. Mandatory to have this as PlayWright doesn't have its own Test Status variable
  let testStatus = 'FAILED';

  // Object of Testworthy API Class
  const testWorthyAPIs_Obj = new testWorthyAPIs();

  // This is for random username and password generation, you can use your own mechanism for this
  const randomUsername = Math.random().toString(36).substring(2, 7);
  console.log(randomUsername);
  const randomPassword = Math.random().toString(36).substring(2, 7);
  console.log(randomPassword);

  test.beforeAll(async ({ browser }) => {
    // API - GET Runs via Suite ID
    // This API will fetch all the test runs using a specific suite id
    await testWorthyAPIs_Obj.get_run_from_suit_id();

    // API - Get Test Cases IDs
    // Call this method here in beforeAll to get all the Test Cases IDs and Titles present in the Test Run on TestWorthy before starting the execution of automated Test Cases. It will help in matching and assigning Test Case IDs to the relevant Automated Test Case
    await testWorthyAPIs_Obj.get_case_id_api();

    page = await browser.newPage();

    const userSignUp = new signUp(page);
    await userSignUp.gotoSite();
  });

  test.afterEach(async () => {
    // Call "add_results_for_cases" API function
    // Call this method in afterEach, so it will map the Automated Case status to the relevant test case in the TestWorthy. It has an argument "testStatus" globally initialized
    await testWorthyAPIs_Obj.add_results_for_cases(testStatus);
  });

  test('Case - 1: Verify use can sign up a new account', async () => {
    // Mandatory to have variable "currentTestTitle" in every test case and in the value copy and paste the same test case title you are going to Automate from the Test Run on the TestWorthy
    const currentTestTitle = 'Verify use can sign up a new account';

    // Call this method in every Test Case. It will match and assign the relevant test title from the Test Run on the TestWorthy. It has the argument "currentTestTitle" declared above
    await testWorthyAPIs_Obj.matchAndAssignCaseId(currentTestTitle);

    // Recommended to write Tests in Try Catch blocks so that it would be easy to assign the correct Test Status to the variable "testStatus" globally initialized and less chance to map the incorrect test statues on TestWorthy
    try {
      const userSignUp = new signUp(page);

      await userSignUp.signUpNewUser(randomUsername, randomPassword);
      await userSignUp.login(randomUsername, randomPassword);
      await expect(page.locator('#nameofuser')).toHaveText('Welcome ' + randomUsername);

      const welcomeName = await userSignUp.welcomeText.textContent();
      console.log('Welcome Name = ' + welcomeName);
      await expect(userSignUp.welcomeText).toHaveText(welcomeName);

      // If a failure condition is met, update the test status to 'FAILED'
      if (await welcomeName != 'Welcome ' + randomUsername) {
        console.log('welcomeName =' + welcomeName);
        testStatus = 'FAILED';
      } else {
        console.log('welcomeName =' + welcomeName);
        testStatus = 'PASSED';
      }
    } catch (error) {
      // Handle test failure (e.g., an unhandled exception) and update the status
      testStatus = 'FAILED';
      console.error('Test Error:', error);
    } finally {
      console.log('Test Status = ' + testStatus);
    }
  });