DEV Community: Md Moeen Ajaz Khan

A Complete Guide To Playwright Assertions

Md Moeen Ajaz Khan — Thu, 09 Feb 2023 18:39:31 +0000

Assertions play a crucial role in the test automation process, allowing you to verify if the actual results match the expected outcomes.

Playwright's assertions address the issue of test flakiness and feature a built-in retry mechanism, utilizing the expect library from Jest for its test assertions.

Discover the basics of Playwright assertions with this comprehensive tutorial. Learn how to use this tool for efficient and effective testing.

A Complete Guide to PactumJS

Md Moeen Ajaz Khan — Tue, 17 Jan 2023 15:04:57 +0000

Introduction

If you are looking for a JavaScript-based API automation tool that can help in API testing at all the levels in a Test Pyramid then your search will end here, it’s PactumJS an open-source library. Testing backends is made faster and more enjoyable with it. All the necessary ingredients are provided in this library to write better API automation tests easily, and quickly.

PactumJS is a REST API Testing Tool used to automate e2e, integration, contract & component (or service level) tests.

There are many HTTP client, HTTP server, and validation packages available in the Node.js ecosystem, but PactumJS is designed specifically for testing. It is inspired by a frisby and pact. The original versions of this library were compatible with them, but later became a separate test tool.

Getting Started

Step 1) To start with you need to have Node.js installed on your machine. You can download it directly from the Node.js website and install it on your machine if you are not already using it.

Once installed check the version:

node -v

Step 2) Download and Install Visual Studio Code (this will help you write formatted code but you can pick any text editor of your choice)

Step 3) Open Visual Studio Code

Step 4) Open your integrated Terminal and run the following command

mkdir api-testing-pactumjs-mocha-javascript

Step 5) Open the directory

cd api-testing-pactumjs-mocha-javascript

Step 6) Create a new package.json file with default values

npm init -y

Your package.json file should be like this:

{
  "name": "api-testing-pactumjs-mocha-javascript",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Step 7) I will be using Mocha JavaScript test framework for writing the API tests, mochawesome to generate HTML reports and FakerJS, one of the powerful packages to generate dummy data. Install all the required packages

npm install --save-dev pactum mocha @faker-js/faker

Once the installation is complete node_module will be created with all the dependencies installed in it.

Your package.json file should look like this:

{
  "name": "api-testing-pactumjs-mocha-javascript",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@faker-js/faker": "^7.6.0",
    "mocha": "^10.2.0",
    "pactum": "^3.3.2"
  }
}

Step 8) Create a .gitignore file so that unwanted files are not committed to the repository

node_modules
mochawesome-report

Writing Tests

Step 1) Create a folder test-api.

Step 2) Under this folder create a file getUserTest.js.

Step 3) Now we can start writing API tests.

const { spec } = require('pactum');

it('should get a response with status code 200', async () => {
    await spec()
        .get('https://reqres.in/api/users/2')
        .expectStatus(200);
});

Line #1: Import - we are importing the PactumJS library

Line #3: ‘it’ - it’s an individual test case (Read more about the MochaJS library here: Mocha - the fun, simple, flexible JavaScript test framework )

Line #4: spec provides an object to performance request with parameters, headers, cookies, body, files etc. It provides the ability to chain methods.

Line #5: In the example, we are fetching user details by using .get(), it makes an HTTP GET request on the provided endpoint and gives us back the response.

Line #6: expect - is to validate the response code (i.e. 200) after the request is made.

Running Tests

Step 1) Update the test scripts in package.json file

{
  "scripts": {
    "test": "mocha ./test-api/*.js"
  }
}

Step 2) Now open the terminal and run the following command:

npm test

or

npm run test

If a test fails, then this library will print the complete request, response, and gives you the AssertionError in the terminal. This will help you in further debugging the code

E2E API Testing Test Strategy

In this article we will be using Reqres - A hosted REST-API ready to respond to your AJAX requests to write end-to-end API tests. Its a hosted REST API and we will be able to verify the responses in real-time, no need of providing any sample data. For easy understanding I have created simple e2e API testing strategy and I have followed the steps given below:

POST - Create a user by providing data from the JSON file. Also as the real-time approach, I have used the Fakerjs npm package which will give you test data.

Response Validation - Assert the response by either comparing it with JSON data or by matching it with data stored in the variable.

GET - Get the user details by using some of the technique of query param, without query param and path param. And finally assert the response for each.

PUT - Update user attributes for an existing resource and assert the response.

PATCH - Partially update an existing resource (not all attributes required) and assert the response.

DELETE - Finally we will delete the user and assert the response code.

Base Setup

We will store the environment details separately and use dotenv npm package to store base URI. Lets install the dependency and save it:

npm install dotenv --save-dev

Create a .env file in root folder and add below line:

PACTUM_REQUEST_BASE_URL=https://reqres.in
We will generate the test result in html by using mochawesome to better analyze the test results:

npm install mochawesome --save-dev
POST Request using test data from JSON file
We are going to send a POST request by providing test data from json file. Create a folder at root level named test-data and then create a JSON file named user-data.json.

Since the POST request endpoint https://reqres.in/api/users will accept name and job, we will provide same in JSON.

{
    "name": "Mike Tyson",
    "job": "Boxer"
}

Under test-api folder create a test file named postJsonTest.js. Now, lets write the post request:

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;
const userData = require('../test-data/user-data.json');

describe('POST API tests using PactumJS', () => {

    it('should successfully pass the test for post API when test data from JSON file is used', async () => {
        await spec()
            .post(baseUrl + '/api/users')
            .withJson(userData)
            .expectStatus(201)
            .expectJsonMatch('name', 'Mike Tyson')
            .expectJsonMatch('job', 'Boxer');
    });
});

Line #1: Import - we are importing the PactumJS library

Line #2 & 3: We have specified our URI in config file, we need to require it.

Line #4: We need JSON test date so we need to require it.

Line #6: ‘describe’ function is used to group tests. It accepts a string to describe the group of tests and a callback function which contains it() tests.

Line #8: ‘it’ - it’s an individual test case. Note that one describe block can contain multiple it blocks, which means multiple tests.

Line #9: spec provides an object to performance request with parameters, headers, cookies, body, files etc. It provides the ability to chain methods.

Line #10: In the example, we are fetching user details by using .get(), it makes an HTTP GET request on the provided endpoint and gives us back the response.

Line #12: expect - is to validate the response code (i.e. 200) after the request is made.

POST Request by using FakerJS package to generate test data

Under test-api folder create a test file named postFakerJsTest.js. We are going to send a post request by calling test data generated by fakerjs.

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;
const { faker } = require('@faker-js/faker');

const randomName = faker.name.firstName();
const randomJob = faker.name.jobTitle();

describe('POST API tests using PactumJS', () => {

    it('should successfully pass the test for post API when test data generated using fakerjs', async () => {
        await spec()
            .post(baseUrl + '/api/users')
            .withJson({
                "name": randomName,
                "job": randomJob
            })
            .expectStatus(201)
            .expectJsonMatch('name', randomName)
            .expectJsonMatch('job', randomJob);
    });
});

Line #4: Import - we are importing the FakerJS library

Line #6 & 7: We are generating firstName and jobTitle using FakerJS and storing them into a const.

Line #14: withJson we are passing the const name and job.

Line #19 & 20: We are verifying name and job in response with const generated by FakerJS library.

GET Request

Under test-api folder create a test file named getSingleUserTest.js. We are going to send a GET request:

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;

describe('GET API tests using PactumJS', () => {

    it('should successfully pass the test for single user GET API', async () => {
        await spec()
            .get(baseUrl + '/api/users/2')
            .expectStatus(200)
            .expectJsonMatch('data.id', 2)
            .expectJsonMatch('data.first_name', 'Janet');
    });
});

GET Request using query param

Under test-api folder create a test file named getSingleUserQueryParamTest.js.

We are going to send a GET request with query parameters:

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;

describe('GET API tests using PactumJS', () => {

    it('should successfully pass the test for single user GET API using query param', async () => {
        await spec()
            .get(baseUrl + '/api/users')
            .withQueryParams({ page: '2' })
            .expectStatus(200)
            .expectJsonMatch('page', 2)
            .expectJsonMatch('data[0].id', 7)
            .expectJsonMatch('data[0].first_name', 'Michael');
    });
});

In the above example we are passing query params and it used as withQueryParam(key, value). This will help us to pass query params with the request.

PUT Request

Create a file named putTest.js and write the following code:

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;
const updatedUserData = require('../test-data/updated-user-data.json');

describe('PUT API tests using PactumJS', () => {

    it('should successfully pass the test for PUT API', async () => {
        await spec()
            .put(baseUrl + '/api/users/2')
            .withJson(updatedUserData)
            .expectStatus(200)
            .expectJsonMatch('name', 'Floyd Joy Mayweather Jr.')
            .expectJsonMatch('job', 'Boxer Two');
    });
});

PATCH Request

Create a file named patchTest.js and write the following code:

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;
const minorUpdatedUserData = require('../test-data/minor-updated-user-data.json');

describe('PATCH API tests using PactumJS', () => {

    it('should successfully pass the test for PATCH API', async () => {
        await spec()
            .put(baseUrl + '/api/users/2')
            .withJson(minorUpdatedUserData)
            .expectStatus(200)
            .expectJsonMatch('job', 'Boxer');
    });
});

DELETE Request

Create a file named deleteTest.js and write the following code:

const { spec } = require('pactum');
require('dotenv').config()
const baseUrl = process.env.PACTUM_REQUEST_BASE_URL;

describe('DELETE API tests using PactumJS', () => {

    it('should successfully pass the test for DELETE API', async () => {
        await spec()
            .delete(baseUrl + '/api/users/2')
            .expectStatus(204);
    });
});

Test Report

We are going use mochawesome package to generate html report and it will be placed under root directory with name mochawesome-report

Step 1) Update the test scripts in package.json file

{
  "scripts": {
    "test": "mocha ./test-api/*.js --reporter spec --reporter mochawesome --timeout 5000"
  }
}

Step 2) Now open the terminal and run the following command:

npm test

or

npm run test

Conclusion

While writing this article I have tried to use all the basic operations done from scratch to set up an API automation framework, project initiation, set common components, explained requests: POST, GET, PUT, PATCH and DELETE requests, and finally how we can generate mochawesome report (Checkout my example code to generate Allure report).

However, there are several advanced features which can be found in PactumJS Guide, that you may want to try.

Code Repository

All the code written above can be found on GitHub.

If you have any suggestions or found a bug? Fork this project to help make this even better.

Star the repo and follow me to get the latest updates

What Do You Think?

Did this work for you?

Could I have done something better?

Have I missed something?

Please share your thoughts and let me know if there are particular things that you would enjoy reading further.

Cheers!

UI Automation Testing Demo Site

Md Moeen Ajaz Khan — Fri, 30 Dec 2022 18:19:59 +0000

While learning Web UI testing we are always searching for Demo sites that try to mimic real-world scenarios. Over time, several people in the community have developed these sites with different features and provided good resources and documentation about each usage.

In this article I will be listing out all the good resources which you can make use of, and if you find I have missed anything then please comment and I will update the list:

Automation Book Store: https://automationbookstore.dev/
Automation Test Store: https://automationteststore.com/
DemoBlaze: https://www.demoblaze.com/
DemoQA: https://demoqa.com/
ParaBank: https://parabank.parasoft.com/parabank/index.htm
LetCode: https://letcode.in/test
SelectorHub: https://selectorshub.com/xpath-practice-page/
Selenium Test Pages: https://testpages.herokuapp.com/styled/index.html
Swag Labs: https://www.saucedemo.com/
The Internet: https://the-internet.herokuapp.com/
UI Test Automation Playground: http://uitestingplayground.com/
XYZ Bank: https://www.globalsqa.com/angularJs-protractor/BankingProject/#/login

What Do You Think?

Did this work for you?
Could I have done something better?
Have I missed something?
Please share your thoughts and let me know if there are particular things that you would enjoy reading further.

Cheers!

API Testing Demo Site

Md Moeen Ajaz Khan — Sun, 25 Dec 2022 15:00:00 +0000

Introduction

While learning API testing we are always searching for API Testing Demo sites that try to mimic real-world scenarios. Over time, several people in the community have developed these APIs and provided good resources and documentation about each end-point usage.
In this article I will be listing out all the good resources which you can make use of, and if you find I have missed anything then please comment and I will update the list:

restful-booker: https://restful-booker.herokuapp.com/apidoc/index.html
ReqRes: https://reqres.in/
httpbin: http://httpbin.org/
{JSON} Placeholder: https://jsonplaceholder.typicode.com/
FakeRESTApi.Web V1: https://fakerestapi.azurewebsites.net/index.html
Swagger Petstore: https://petstore.swagger.io/
This site list many other Free API: https://apipheny.io/free-api/

What Do You Think?

Did this work for you?
Could I have done something better?
Have I missed something?
Please share your thoughts and let me know if there are particular things that you would enjoy reading further.
Cheers!

API Automation using SuperTest Mocha ChaiJS and FakerJS

Md Moeen Ajaz Khan — Sun, 11 Dec 2022 14:30:32 +0000

I have been using JavaScript for UI automation and am in love with it for many reasons, but one of the reasons that always helps me is when I Google any library/package with just npm word, there are many solutions available, which makes life so much easier. The other benefit is saving time as well.

It is possible to automate API tests using several tools available on the market. It is up to you to choose which tool is most appropriate for your needs.

The first thing I did was to explore and try to find some library/package on npm which I could use to test APIs. In the end, I found SuperTest to be the answer to my search. Using this tool may be the best solution for scaling your automation framework with additional capabilities. It’s easy to use and allows you to easily integrate it into existing automation frameworks.

In this article, we will be using SuperTest, Mocha, and Chai. We will use FakerJS to generate the test data and JavaScript for scripting. Let’s look into them one by one.

SuperTest

SuperTest module is to provide a high-level abstraction for testing HTTP, while still allowing you to drop down to the lower-level API provided by superagent.

Mocha

Mocha is a feature-rich JavaScript test framework running on Node.js and in the browser, making asynchronous testing simple and fun. Mocha tests run serially, allowing for flexible and accurate reporting, while mapping uncaught exceptions to the correct test cases.

Chai

Chai is a BDD / TDD assertion library for node and the browser that can be delightfully paired with any javascript testing framework.

Faker

Generate massive amounts of fake (but realistic) data for testing and development.

Getting Started
Step 1) To start with you need to have Node.js installed on your machine. You can download it directly from the Node.js website and install it on your machine if you are not already using it.
Once installed check the version
node -v

Step 2) Install Visual Studio Code (this will help you write formatted code but you can pick any text editor of your choice)

Step 3) Open Visual Studio Code

Step 4) Open your integrated Terminal and run the following command
mkdir supertest-mocha-chai-javascript

Step 5) Open the directory
cd supertest-mocha-chai-javascript

Step 6) Create a new package.json file
npm init -y

Your package.json file should be like this:

{
  "name": "supertest-mocha-chai-javascript",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Step 7) I will be using Mocha JavaScript test framework for writing the API tests, ChaiJS for assertions, and mochawesome to generate HTML reports. Also, I will use Faker, one of the powerful packages to generate test dummy data. Install all the required packages
npm install --save-dev supertest mocha chai mochawesome @faker-js/faker

Once the installation is complete node_module will be created with all the dependencies installed in it.

Your package.json file should look like this:

{
  "name": "supertest-mocha-chai-javascript",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "supertest",
    "mocha",
    "chai",
    "mochawesome"
  ],
  "author": "Code with MMAK",
  "license": "ISC",
  "devDependencies": {
    "@faker-js/faker": "^7.6.0",
    "chai": "^4.3.7",
    "mocha": "^10.1.0",
    "mochawesome": "^7.1.3",
    "supertest": "^6.3.1"
  }
}

Step 8) Create a .gitignore file so that unwanted files are not committed to the repository

node_modules/
mochawesome-report/
test-results/
downloads/*
log/*

Now you can start writing your API tests.

Following is the list of APIs on the Reqres – A hosted REST-API ready to respond to your AJAX requests website which I have used to write end-to-end tests.

Create a user
Get the user details
Updated user details
Update the user with partial details
Delete user

For the end-to-end automation testing strategy, I have followed the steps given below:

Create a user with when the date is supplied from the JSON file. Also as the real-time approach, I have used the Fakerjs npm package which will give you dummy test data, which looks real.
Assert the response by either comparing it with JSON data or by matching it with data stored in the variable.
Get the user details by query param, without query param and path param. And assert the response for each.
Updated user full details and assert the response
Update user practical details and assert the response.
Finally, delete the user and assert the response. It’s time to code !!

Base Setup

To being with we will start implementing the base so that it can be reused and we are not going to write unnecessary repeated code.

Create a folder and name it config inside this folder create a JSON file named reqres.config.json file. here we will keep our base URL, which is the test URL

{
"baseUrl": "https://reqres.in"
}

POST Request

To being with create a folder and name it test-reqres-api and then create a test file named postTest.js.

We are going to create a post request by using data stored in JSON, with this we will be able to create a user.

Create a folder named test-data and then create a JSON file named user-data.json

{
    "name": "Code with MMAK",
    "job": "Testing"
}

Now start writing a line of code to import the supertest library and expect the library from chai.

const request = require('supertest');
const expect = require('chai').expect;
const reqres = require('../config/reqres.config.json');
const userData = require('../test-data/user-data.json');

describe('POST API tests using SuperTest', () => {

    it('should successfully pass the test for POST api when test data from json file is used', (done) => {
        request(reqres.baseUrl)
            .post('/api/users')
            .send(userData)
            .set('Accept', 'application/json')
            .set('Content-Type', 'application/json')
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(201);
                expect(res.body.name).to.be.equal('Code with MMAK');
                expect(res.body.job).to.be.equal('Testing');
                expect(res.body.id).not.to.be.null;
                expect(res.body.createdAt).not.to.be.null;
                done();
            });
    });
});

Here ‘describe’ means test scenario and ‘it’ means individual test cases

post – is the request type

send – is to send the data with the post request

set – is to set the header of the request

end – is to say the request is ended and we will perform the assertion

expect – is to validate the response

done – is to say our request is completed and the test is done.

Let’s run the test:

mocha ./test-reqres-api --reporter spec --reporter mochawesome --timeout 5000

Dummy data using fakerjs

const request = require('supertest');
const expect = require('chai').expect;
const { faker } = require('@faker-js/faker');
const reqres = require('../config/reqres.config.json');

const randomName = faker.name.findName();
const randomJob = faker.name.jobTitle();

describe('POST API tests using SuperTest', () => {

    it('should successfully pass the test for POST api when fakerjs dummy data is used', (done) => {
        request(reqres.baseUrl)
            .post('/api/users')
            .send({
                "name": randomName,
                "job": randomJob
            })
            .set('Accept', 'application/json')
            .set('Content-Type', 'application/json')
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(201);
                expect(res.body.name).to.be.equal(randomName);
                expect(res.body.job).to.be.equal(randomJob);
                expect(res.body.id).not.to.be.null;
                expect(res.body.createdAt).not.to.be.null;
                done();
            });
    });
});

GET Request

Create a file named getTest.js and write the following code:

const request = require('supertest');
const expect = require('chai').expect;
const reqres = require('../config/reqres.config.json');

describe('GET API tests using SuperTest', () => {

    it('should successfully pass the test for get api without query param', (done) => {
        request(reqres.baseUrl)
            .get('/api/users/2')
            // .set('Accept', 'application/json')
            // .set('Content-Type', 'application/json')
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(200);
                expect(res.body.data.id).to.be.equal(2);
                expect(res.body.data.first_name).to.be.equal('Janet');
                done();
            });
    });
    it('should successfully pass the test for get api with query param', (done) => {
        request(reqres.baseUrl)
            .get('/api/users')
            .query({ page: '2' })
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(200);
                expect(res.body.page).to.be.equal(2);
                expect(res.body.data[0].id).to.be.equal(7);
                expect(res.body.data[0].first_name).to.be.equal('Michael');
                done();
            });
    });

});

PUT Request

Create a file named putTest.js and write the following code:

const request = require('supertest');
const expect = require('chai').expect;
const reqres = require('../config/reqres.config.json');

describe('PUT API tests using SuperTest', () => {

    it('should successfully pass the test for post api', (done) => {
        request(reqres.baseUrl)
            .put('/api/users/2')
            .send({ name: 'Andy', job: 'Admin' })
            .set('Accept', 'application/json')
            .set('Content-Type', 'application/json')
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(200);
                expect(res.body.name).to.be.equal('Andy');
                expect(res.body.job).to.be.equal('Admin');
                expect(res.body.updatedAt).not.to.be.null;
                done();
            });
    });
});

PATCH Request

Create a file named patchTest.js and write the following code:

const request = require('supertest');
const expect = require('chai').expect;
const reqres = require('../config/reqres.config.json');

describe('PATCH API tests using SuperTest', () => {

    it('should successfully pass the test for patch request', (done) => {
        request(reqres.baseUrl)
            .patch('/api/users/2')
            .send({ name: 'Mike', job: 'Test Lead' })
            .set('Accept', 'application/json')
            .set('Content-Type', 'application/json')
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(200);
                expect(res.body.name).to.be.equal('Mike');
                expect(res.body.job).to.be.equal('Test Lead');
                expect(res.body.updatedAt).not.to.be.null;
                done();
            });
    });
});

DELETE Request

Create a file named deleteTest.js and write the following code:

const request = require('supertest');
const expect = require('chai').expect;
const reqres = require('../config/reqres.config.json');

describe('DELETE API tests using SuperTest', () => {

    it('should successfully pass the test for delete request', (done) => {
        request(reqres.baseUrl)
            .delete('/api/users/2')
            .set('Accept', 'application/json')
            .set('Content-Type', 'application/json')
            .end(function (err, res) {
                expect(res.statusCode).to.be.equal(204);
                done();
            });
    });
});

Some Tips

If you want to run a single test then use ‘it.only’. Similarly, if you want to run a single test scenario then use ‘describe.only’.
If you want to skip any test in a test suite then use ‘it.skip’. Similarly, if you want to skip the test scenario then use ‘describe.skip.

Code Repository

The sample framework is hosted on GitHub.

Have a suggestion or found a bug? Fork this project to help make this even better.

Star the repo and follow me to get the latest updates

What Do You Think?

Did this work for you?
Could I have done something better?
Have I missed something?
Please share your thoughts and let me know if there are particular things that you would enjoy reading further.

Cheers!

Data Masking

Md Moeen Ajaz Khan — Thu, 24 Nov 2022 14:04:27 +0000

What is Data Masking?

Data Masking is a process that is used to hide data.
In Data Masking, real data is masked or hidden by replacing them with random characters.
It protects confidential information from those who don’t have the authorization to see it.

Why Data Masking Is Required?

Data Masking shields PII data and other confidential information of the organization.
It secures the file transferring process from one location to another.
It also helps to secure application development, testing, or CRM applications.
It allows users to access dummy data for testing or training purposes. Image Source: Wallarm

Data Masking Process

Data Masking Tools

K2View Data Masking
Delphix
Oracle Data Masking and Subsetting
Accutive Data Discovery & Masking

WHY IS COMPATIBILITY TESTING MUCH NEEDED FOR CUSTOMER-FOCUSED TESTING?

Md Moeen Ajaz Khan — Sun, 20 Nov 2022 11:23:23 +0000

WHAT IS COMPATIBILITY?
Compatibility is the ability to check if two entities can work together without actually modifying or altering them.

Let’s see some of the real-life examples to better understand:

if my feet size is 10 UK, can I wear 9 UK size shoes?
if Windows 11 requires a minimum of 4 GB RAM, can I still install it on a lower RAM configuration?
can I install a Mac installer on a Windows machine?

WHAT IS COMPATIBILITY TESTING?
Compatibility testing is a type of Non-functional testing.

It majorly focuses on the support or compatibility of applications to ensure there is no difference in behaviour, look and feel etc. It gives great flexibility to my customer to use the application in different modes.

There are several analytics tools which can give you a clear idea of how the application is used and where your target audience is located and how they are accessing your application etc. It helps in serving customer needs.

TYPE OF COMPATIBILITY TESTING
The following are the type of compatibility testing types:

Browsers: It checks the compatibility of test applications on different browser combinations such as Google Chrome, Mozilla Firefox, Safari, Internet Explorer, Microsoft Edge, Opera etc.
Devices: It checks the compatibility of your software with different devices like different ports like USB, Printers, Scanners, Other media, and Bluetooth.
Operating systems: It checks your software to be compatible with different Operating Systems like Windows, Mac OS, Linux/Unix etc.
Network: It checks your software to be compatible with different network speeds and bandwidth.
Mobile: It checks your software is compatible with different mobile platforms like Android, iOS, Trizon OS etc.
Version: It checks your software is compatible with a different version of the software or even a hardware combination.
Software: It checks your software is compatible with other software and doesn’t cause hindrances for each other.

TOOLS FOR COMPATIBILITY TESTING
Earlier when there was no cloud solution at that time compatibility testing used to be done by setting up devices, and platform with different OS and browser combination, and later point of time some of the cost of the setting of physical machines were taken care of by Virtual Machines. Thanks to the cloud solution which takes care of setting up an environment for you. You just need to select the different combinations of OS and browser combinations and you are good to start testing just like tossing a coin in the air.

Some of the most commonly used compatibility testing tools are as follows:

COMPATIBILITY TESTING MATRIX
While doing customer-focus testing, it is required to have a list of browsers and devices which is being anticipated to be most used by the customer and compatibility of developed applications should be maintained across the different combinations.

The table below represents a sample browser compatibility testing matrix.

COMPATIBILITY TESTING APPROACH

Gathering Functional & Non-Functional Requirement
Ask for a compatibility testing matrix with this you will understand customer focus. In some cases, it can work the other way round and you can propose the compatibility testing matrix with all the combinations you can think of.
Ask for a test bed if it’s available or else you can suggest a cloud solution like LambdaTest.
Analyse the requirement and prepare the test scenarios.
Perform functional testing and make sure the application is stable and the majority of bugs are resolved.
Perform non-functional testing which is compatibility testing on the configuration which is agreed upon with the client.
Prepare a Compatibility testing report which clearly states the bugs which occurred on a different configuration.
Once all the bugs found in compatibility testing once fixed and verified, make sure to run another round of compatibility testing to ensure there are no regression bugs.
Finally, make sure to sign off and produce the test closure report.

COMMON COMPATIBILITY TESTING DEFECTS
Even though modern development frameworks these days claim to be completely responsive on all devices but still many times bugs slip through the cracks.

The compatibility testing bugs are generally user interface issues, which are as follows:

Web elements alignment issues.
Web elements overlapping issues.
Font size issues.
Broken frames or rendering issues.
Look and feel issues.

E-COMMERCE GROWTH AND HEADLESS COMMERCE OVERVIEW

Md Moeen Ajaz Khan — Sat, 19 Nov 2022 13:24:06 +0000

WHY E-COMMERCE GROWTH CAN STAY STRONGER FOR LONGER
An article “Global E-Commerce Growth Forecast 2022” by Morgan Stanley says:

In the initial days of COVID-19 e-commerce business surged and very soon it was picked up as all the shopping was done Online as retail locations were closed due to the virus spread.
Overall retail sales in 2019 were 19% and it was picked up to 21% in the year 2021. It is roughly estimated that 22% of sales would be in 2022.
It further states that even after COVID e-commerce market will grow in long term and could see a spike from $3.3 trillion today to $5.4 trillion in 2026.
User purchase behaviour has changed over this period and it’s contributing to the growth and marketplace expansion.

E-commerce as a percentage of retail sales continues to grow across regions.

Source: Euromonitor, National Data Sources, Morgan Stanley Research estimates

WHAT IS HEADLESS COMMERCE?
Now that we know how the e-Commerce market is going to grow over a period of time, it’s time to discuss Headless Commerce.

Headless commerce is an e-commerce architecture which decouples the front end from the backend. In other words, it decouples the customer-facing front-end application of eCommerce from the backend system’s commerce functions and business logic.

Source: ElasticPath

WHAT ARE THE BENEFITS OF HEADLESS COMMERCE?

It is less error-prone since the front-end and back-end are decoupled.
It will eventually help in causing less impact on each other and changes can be deployed smoothly.
It helps in updating or editing front-end and back-end systems.

COUPLED E-COMMERCE VS HEADLESS E-COMMERCE

HEADLESS COMMERCE PROVIDERS

Adobe Commerce (formerly Magento Commerce)
Shopify Plus
BigCommerce Enterprise
CommerceTools
Elastic Path
Salesforce Commerce Cloud
SAP
OroCommerce Enterprise
Spryker
Swell
SpreeCommerce
Saleor

HEADLESS COMMERCE NEEDS EXTENSIVE LEVELS OF TESTING FOR A BETTER CUSTOMER EXPERIENCE
Headless Commerce communicate or interact with many systems at various level of technology and it requires extensive levels of testing which can cover all aspect.

Some of these layers include:

Component Level Testing
Application Programming Interfaces (APIs) Testing
Integration Testing
Database Testing
User interfaces (UI) or presentation layer.

Typically testing can start from the Component level and APIs can be tested for each of these components. Reflect of data can be tested on UI, for example, if a payload value is changed how it reflects on the front-end if the content is changed from CMS then how it reflects on the front-end.

Covering all the aspects of the application can be challenging and requires an extensive amount of planning and execution to incorporate the rapid changes throughout the software life cycle.

Visual Studio Code For Absolute Beginner

Md Moeen Ajaz Khan — Sun, 10 Jul 2022 18:34:22 +0000

In this course, I’ll walk you step-by-step about Visual Studio Code and some of its extensions.

The complete playlist of Visual Studio Code For Absolute Beginner gives you basic setup knowledge to advance usage of the tool.

youtube.com

We will be covering the following topics:

Introduction to Visual Studio Code and Installation - https://youtu.be/h6NGKBX7rFM
Format On Save in Visual Studio Code - https://youtu.be/R7Uw8BHL2RQ
Git Integration in Visual Studio Code - https://youtu.be/fP2fFG2Ck2o
GitLens Extension for Visual Studio Code - https://youtu.be/uQB7eGncFEA
Code Icons Extension for Visual Studio Code - https://youtu.be/23cU2wq87vw

👍 You can follow my content here as well -

Website
GitHub
LinkedIn
Twitter
Facebook
Instagram

...

I love coffees! And, if this post helped you out and you would like to support my work, you can do that by clicking on the button below and buying me a cup of coffee -

Buy me a coffee

You can also support me by liking and sharing this content.

Thanks for reading!

Git & GitHub Tutorial For Beginners

Md Moeen Ajaz Khan — Sat, 09 Jul 2022 19:17:47 +0000

In this course, I’ll walk you step-by-step about Git and GitHub.

The complete playlist of Git & GitHub Tutorial For Beginners gives you basic setup knowledge to advance usage of the tool.

#1 What is Git | How to download Git | How to install Git - https://www.youtube.com/watch?v=xSsqGDjj9uM #2 How to check Git Version | How to set Git Username...

youtube.com

We will be covering the following topics:

What is Git | How to download Git | How to install Git - https://www.youtube.com/watch?v=xSsqGDjj9uM
How to check Git Version | How to set Git Username and Email - https://youtu.be/8Y8bzAdq9zk
How to initialize Git repository - https://youtu.be/gyMUvcZyUUQ
How to checkout code - https://youtu.be/SgTcNle4uBs
How to check git log - https://youtu.be/d5NV41qOeCU
How to check git diff - https://youtu.be/GSIPNtUlkdU
How to remove the file from Git - https://youtu.be/ctppTTN_o-U
How to add .gitignore file - https://youtu.be/bywxx6eqz8g
How to create git branch and merge code - https://youtu.be/CkiWWz-2NQg
How to delete a git branch - https://youtu.be/u3yuQyH1m5U
Introduction to GitHub - https://youtu.be/dcutaVfIWCc
Push an existing repository from the command line to GitHub - https://youtu.be/w1eKbfvAu0I
Git Fetch and Git Pull Command - https://youtu.be/i78nYE9NAyk
How to clone Git Repository - https://youtu.be/hq1CNUioSA8

👍 You can follow my content here as well -

Website
GitHub
LinkedIn
Twitter
Facebook
Instagram

...

I love coffees! And, if this post helped you out and you would like to support my work, you can do that by clicking on the button below and buying me a cup of coffee -

Buy me a coffee

You can also support me by liking and sharing this content.

Thanks for reading!

How to do Test Automation using Playwright and JavaScript?

Md Moeen Ajaz Khan — Thu, 07 Jul 2022 16:50:13 +0000

How to do UI Automation using Playwright and JavaScript? In this course, I’ll walk you step-by-step to build your UI Automation framework.

Playwright a test automation tool which is used for end-to-end testing for any of the modern web applications like react.js or AngularJS. It currently supports the Chromium, WebKit and Firefox family where you have Chrome, Microsoft Edge, Firefox, Opera and Safari browsers. It also supports all the major platforms of Windows, Linux and Mac OS and you have very good support of all the programming languages like Typescript, JavaScript, Python, .net and Java. So which means that you can write your automation test in any of the programming language. It also supports mobile automation or it supports the mobile emulators which means you can fire up the Chrome browser on Android or the Safari on iPhone/iPAD and do your test. You can also run all your tests on any of the cloud environments as well like LambdaTest, SauceLabs, BrowserStack.

The complete playlist of Playwright test automation tool which gives you basic setup knowledge to advance usage of the tool.

Playwright - Test Automation Tool - YouTube

Playwright - Test Automation Tool #1 Playwright - Test Automation Tool | Overview - https://www.youtube.com/watch?v=l8PQ7rIZPp4 #2 Playwright Installation - ...

youtube.com

We will be covering the following topics:

Playwright - Test Automation Tool | Overview - https://www.youtube.com/watch?v=l8PQ7rIZPp4
Playwright Installation - https://www.youtube.com/watch?v=I59Vban8lAo
What is Next.js - https://www.youtube.com/watch?v=u6xMGPZnsXk
Playwright First Test Script - https://www.youtube.com/watch?v=CPlYyCLjPqo
Playwright Configuration File - https://www.youtube.com/watch?v=r7YGrF3s5kw
Playwright Test Hooks - https://youtu.be/739dMoKNcYY
Playwright VS Code Extension - Run test with a single click - https://youtu.be/54BlaEFQjTg
Playwright VS Code Extension - Record new tests - https://youtu.be/ykF3Pff6Zo8
Playwright Command Line - https://www.youtube.com/watch?v=aqRQ1XhbWG8
Configure NPM scripts in Playwright - https://www.youtube.com/watch?v=wwlNcfOAqCs
Playwright Test Generator - https://www.youtube.com/watch?v=WNUmJjIrs2o
Playwright Test Annotations - https://www.youtube.com/watch?v=g91durt7HUY
Playwright Test Video Recording - https://www.youtube.com/watch?v=SvW_aZCmlE4
Playwright Workers | Parallel Test Execution - https://youtu.be/WgKXdzOfHQU
Playwright Custom Reporters - https://youtu.be/iGcqv7vmzq8
Allure Report For Playwright - https://youtu.be/M3jw47nKHpw
Retries In Playwright - https://youtu.be/wY2hrvFAmTI
Integration of Jenkins with Playwright - https://youtu.be/BHgfOYL6q5A

👍 You can follow my content here as well -

Website
GitHub
LinkedIn
Twitter
Facebook
Instagram

...

I love coffees! And, if this post helped you out and you would like to support my work, you can do that by clicking on the button below and buying me a cup of coffee -

Buy me a coffee

You can also support me by liking and sharing this content.

Thanks for reading!

How to do API Automation using Axios, Mocha, Chai and JavaScript

Md Moeen Ajaz Khan — Wed, 29 Jun 2022 19:30:47 +0000

How to do API Automation Testing using Axios, Mocha, Chai and JavaScript? In this course, I’ll walk you step-by-step to build your API Automation framework.

API Automation using Axios, Mocha, Chai and JavaScript | Code with MMAK Tutorial 1 - Introduction - https://www.youtube.com/watch?v=q7uOGtmd11g Tutorial 2 - ...

youtube.com

👍 You can follow my content here as well -

Website
GitHub
LinkedIn
Twitter
Facebook
Instagram

...

I love coffees! And, if this post helped you out and you would like to support my work, you can do that by clicking on the button below and buying me a cup of coffee -

Buy me a coffee

You can also support me by liking and sharing this content.

Thanks for reading!