DEV Community: Khairun Nahar Nowrin

Move the Minimize, Maximize and Close buttons to the left in Ubuntu

Khairun Nahar Nowrin — Sun, 12 May 2024 08:17:38 +0000

Open a terminal by pressing Ctrl + Alt + T.
Open a terminal by pressing Ctrl + Alt + T.

gsettings set org.gnome.desktop.wm.preferences button-layout 'close,minimize,maximize:'

If you want to revert the changes and move the buttons back to the right, you can use the following command:

gsettings set org.gnome.desktop.wm.preferences button-layout 'appmenu:minimize,maximize,close'

Generating a new SSH key and adding it to the ssh-agent in Mac

Khairun Nahar Nowrin — Wed, 08 May 2024 10:03:57 +0000

Go to github profile
Go to Profile settings

Then click on SSH and GPG keys

Open you mac terminal and Paste the text below, replacing the email used in the example with your GitHub email address

ssh-keygen -t ed25519 -C "your_email@example.com"

After Run the command it show

Put your laptop password

After that it generate SHA256

7.Start the ssh-agent in the background.

$ eval "$(ssh-agent -s)"
> Agent pid 59566

open ~/.ssh/config

If the file doesn't exist, create the file.

touch ~/.ssh/config

Open ~/.ssh/config file, then modify the file to contain the following lines. If your SSH key file has a different name or path than the example code, modify the filename or path to match your current setup.

Text

Host github.com
AddKeysToAgent yes
UseKeychain yes
IdentityFile ~/.ssh/id_ed25519

ssh-add --apple-use-keychain ~/.ssh/id_ed25519

If it show error like

Then run

ssh-keygen -t ed25519 -C Your_github_emailr@gmail.com

Then run

Go to your git hub account and click on "New SSH key"

Provide title and key.

For "key" open .ssh > id_ed25519.pub

Now clone a project from your github repository

git clone git@github.com:KhairunNaharNowrin/End-to-End-Testing-With-Cypress.git

Setup the project environment
Run

git add .

git commit -m "set up environment"

It will show error like "Author identity unknown"

Run

git config --global user.email "you@example.com"

  git config --global user.name "Your Name"

to set your account's default identity.
Omit --global to set the identity only in this repository.

git push

reference -

End-to-End Testing With Cypress

Khairun Nahar Nowrin — Tue, 07 May 2024 09:52:23 +0000

Initial steps

Download vs code- https://code.visualstudio.com/download
Clone repository from github- git clone git@github.com:KhairunNaharNowrin/End-to-End-Testing-With-Cypress.git
Now open the project folder in VS Code.

Set the environment

Initialize a New Node.js Project: Open a terminal, navigate to your project directory, and run the following command to initialize a new Node.js project:

npm init -y

Install Cypress: Install Cypress as a development dependency in your project using npm:

npm install cypress --save-dev

3.Opening Cypress: After the installation is complete, you can open Cypress with the following command:

npx cypress open

After run this command it will open cypress modal
After click on Continue button it will open testing type modal. Select E2E Testing.
After select the E2E testing it will oprn Configuration files modal. Click on "Continue" button.
Select preferable browser and Start E2E Testing.
After that select first spec

Opening Cypress: After the installation is complete, you can open Cypress with the following command:

npx cypress open

This command will open the Cypress Test Runner, where you can write and run your tests.

Project Setup

Disabling watchForFileChanges: false , in cypress.confiq.js improves performance and control by preventing automatic reloading of application files during test runs.

module.exports = {
  e2e: {
    watchForFileChanges: false,
    setupNodeEvents(on, config) {
      // implement node event listeners here

    },
  },
};

Page Object Model (POM) pattern:

└── cypress
    ├── fixtures
    │   └── (static data files)
    ├── integration
    │   └── (test files)
    ├── plugins
    │   └── (Cypress plugins)
    ├── support
    │   ├── commands.js
    │   ├── index.js
    │   └── (other support files)
    ├── page objects
    │   ├── LoginPage.js
    │   ├── HomePage.js
    │   └── (other page object files)
    ├── utilities
    │   └── (utility functions)
    └── (other Cypress configuration files)

fixtures: Contains static data files used by tests.
integration: Contains test files.
plugins: Contains Cypress plugins.
support: Contains helper functions, custom commands, and global configuration.
page objects: Contains page object classes representing different pages of the application.
utilities: Contains utility functions shared across tests.

Generating Detailed Reports with Plugins

Install the Plugin:

npm install --save-dev cypress-mochawesome-reporter

Update Cypress Configuration: Update cypress.config.js to include the reporter configuration.

const { defineConfig } = require('cypress');

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on, config) {
      require('cypress-mochawesome-reporter/plugin')(on);
    },
    reporter: 'cypress-mochawesome-reporter',
    reporterOptions: {
      reportDir: 'cypress/reports',
      overwrite: false,
      html: true,
      json: true,
    },
  },
});

Create a Report After Running Tests:

npx cypress run

View the Report:

The report will be saved in the cypress/reports directory.
Open the generated HTML file in a browser to view the detailed report.

Install Java in macbook M1/M2/M3

Khairun Nahar Nowrin — Fri, 03 May 2024 14:58:00 +0000

Install Homebrew: If you haven't already installed Homebrew, you can do so by opening Terminal and running the following command:
bash

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

==> Next steps:

Run these two commands in your terminal to add Homebrew to your PATH:

(echo; echo 'eval "$(/opt/homebrew/bin/brew shellenv)"') >> /Users/user_name/.zprofile
    eval "$(/opt/homebrew/bin/brew shellenv)"

Run brew help to get started
Further documentation: https://docs.brew.sh

Install JDK using Homebrew: Once Homebrew is installed, you can install the JDK for ARM-based Macs by running the following command:
bash

brew install --cask temurin

This will install the Temurin JDK, which is compatible with ARM-based Macs.
Verify Installation: After installation, you can verify that Java is installed by running:
bash

java -version

This command should display the version of Java installed on your system.

Install Home brew in Mac M1/M2/M3

Khairun Nahar Nowrin — Fri, 03 May 2024 13:40:15 +0000

1st run



/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

The Homebrew installation script will ask you to enter your Mac user password. This is the password you use to sign into your Mac.

After that run



eval "$(/opt/homebrew/bin/brew shellenv)"

Run



$ brew doctor

To check the brew install successfully in your system RUN



$ brew doctor

General process for writing unit test cases

Khairun Nahar Nowrin — Tue, 13 Jun 2023 05:03:53 +0000

Writing unit test cases involves creating test cases that verify the behavior and correctness of individual units of code, such as functions or methods. Here's a general process for writing unit test cases:

Understand the Unit: Before writing test cases, it's important to have a clear understanding of the unit you're testing. Identify the purpose, inputs, expected outputs, and any edge cases or special conditions that need to be considered.
Choose a Testing Framework: Select a testing framework that suits your programming language and environment. Common choices include JUnit for Java, NUnit for .NET, pytest for Python, and Mocha for JavaScript.
Create a Test File: Set up a separate file for your test cases. This file should typically have a naming convention that indicates it's a test file, such as "test_..." or "unit_test_...".
Import Dependencies: If your unit relies on external dependencies or modules, import them into your test file.
Write Test Functions: Each test case should be written as a separate function within your test file. The function name should reflect the behavior being tested. Consider using descriptive names that clearly indicate the purpose of the test case.
Set Up Test Data: Prepare the necessary input data for the unit under test. This may involve creating objects, initializing variables, or mocking external resources.
Invoke the Unit: Call the unit being tested with the provided test data or inputs. Pass in any necessary parameters.
Compare the Result: Verify that the output or behavior of the unit matches the expected result. Use assertions or comparison methods provided by your testing framework to check for equality, exceptions, or other specific conditions.
Handle Exceptions: If the unit is expected to raise an exception under certain conditions, use try-catch blocks or assertion methods to ensure the correct exception is thrown.
Repeat for Multiple Scenarios: Create additional test functions to cover different scenarios, edge cases, or boundary conditions. Test both valid and invalid inputs to ensure the unit handles them correctly.
Run the Tests: Execute the test suite using your chosen testing framework. The framework will provide feedback on the success or failure of each test case.
Analyze the Results: Review the test results and identify any failing test cases. Debug and fix any issues in the code being tested until all test cases pass successfully.
Maintain and Update: As your code evolves, update your test cases accordingly to ensure they remain relevant and accurate. Regularly run the test suite to catch regressions or unintended changes in behavior.

Remember, unit tests should be focused, independent, and isolated from other units of code. Each test should cover a specific aspect or behavior of the unit, making it easier to locate and fix issues when they arise.

Let's say we have a simple class called Calculator with a method add that adds two numbers together:

java

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

To test this class, we can create a test class named CalculatorTest and write the following test case:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();

        // Test case 1: Add two positive numbers
        int result = calculator.add(5, 3);
        Assertions.assertEquals(8, result);

        // Test case 2: Add a positive and a negative number
        result = calculator.add(7, -2);
        Assertions.assertEquals(5, result);

        // Test case 3: Add zero to a number
        result = calculator.add(10, 0);
        Assertions.assertEquals(10, result);
    }
}

In this example, we have a single test method named testAdd annotated with @test. Within this method, we create an instance of the Calculator class and call its add method with different inputs. We then use the Assertions.assertEquals method to verify that the actual result matches the expected result for each test case.

To run the test case, you can use your IDE's built-in test runner or use a build tool like Maven or Gradle. When using Maven, you can execute the following command in your terminal:

mvn test

JUnit will automatically discover and execute the test methods in your test class. The test results will be displayed in the console, indicating whether each test case passed or failed.

You can add more test methods to cover additional scenarios or edge cases. It's also possible to use other assertion methods provided by JUnit, such as assertTrue, assertFalse, or assertThrows, depending on the nature of the expected behavior you want to test.

Cucumber automation code structure

Khairun Nahar Nowrin — Thu, 23 Mar 2023 05:27:08 +0000

The structure of a cucumber automation code usually follows the following steps:

Feature file: This file contains the description of the feature to be tested. It should be written in the Gherkin language which is a business-readable, domain-specific language that describes scenarios using a set of predefined keywords like Given, When, Then, And, and But.

Feature: Login
  As a user
  I want to log in to the system
  So that I can access my account

  Scenario: Successful login
    Given I am on the login page
    When I enter my valid credentials
    And I click the login button
    Then I should be logged in successfully

Step Definitions: These are the implementation of the steps defined in the feature file. They are written in programming language, and their main purpose is to interact with the system under test, and perform actions or validations. Each step definition should correspond to a step in the feature file.

import io.cucumber.java.en.*;

public class LoginSteps {

    @Given("I am on the login page")
    public void navigateToLoginPage() {
        // code to navigate to login page
    }

    @When("I enter my valid credentials")
    public void enterCredentials() {
        // code to enter valid credentials
    }

    @When("I click the login button")
    public void clickLoginButton() {
        // code to click the login button
    }

    @Then("I should be logged in successfully")
    public void verifySuccessfulLogin() {
        // code to verify successful login
    }
}

Hooks: Hooks are code snippets that execute before or after each scenario or feature. They can be used for setup and teardown tasks such as launching the browser, closing the browser, or creating test data. Hooks can be global or specific to a feature or scenario.

Test Runner: A test runner is a program that runs the feature files and executes the step definitions. There are different test runners available for Cucumber, including JUnit, TestNG, and Cucumber-JVM. The test runner usually handles the configuration, setup, and execution of the tests.

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(features = "src/test/resources/myFeature.feature",
                 glue = {"com.example.stepdefinitions"})
public class TestRunner {
    // empty
}

Supporting files: These are files that contain additional information or configuration for the tests, such as test data, configuration files, or utility classes. They can be organized in folders for better structure and maintainability.

Here's an example of how a typical Cucumber project structure could look like:

- src
  - test
    - java
      - com
        - example
          - features
            - feature_file.feature
          - step_definitions
            - step_definition.java
          - runners
            - TestRunner.java
          - support
            - hooks.java
            - utils.java
          - resources
            - test_data.csv
    - resources
      - chromedriver.exe
  - main
    - java
    - resources

Appium automation code structure

Khairun Nahar Nowrin — Sun, 19 Mar 2023 10:34:43 +0000

Desired Capabilities: Desired capabilities are a set of key-value pairs that specify the characteristics of the device or emulator to be used for testing. This includes details such as device name, platform version, app package name, and app activity name. These capabilities are used to initialize the driver object.

    @BeforeTest
    public void setup() throws Exception {
        DesiredCapabilities caps = new DesiredCapabilities();
        caps.setCapability("deviceName", "Android Emulator");
        caps.setCapability("platformVersion", "11");
        caps.setCapability("appPackage", "com.example.myapp");
        caps.setCapability("appActivity", "com.example.myapp.MainActivity");
        caps.setCapability("automationName", "UiAutomator2");
        caps.setCapability("noReset", true);

        driver = new AndroidDriver<AndroidElement>(new URL("http://127.0.0.1:4723/wd/hub"), caps);
    }

Page Objects: Page objects are classes that encapsulate the behavior and properties of the user interface elements of an app. They provide a layer of abstraction between the test code and the app's user interface. Each screen or page of the app can have a corresponding page object class.

Test Code: The test code is written to interact with the user interface elements of the app through the page objects. It typically includes the steps that the user takes to navigate through the app, interact with the elements, and perform validations.

    @Test
    public void loginTest() {
        LoginPage loginPage = new LoginPage(driver);
        loginPage.enterUsername("myusername");
        loginPage.enterPassword("mypassword");
        loginPage.clickLoginButton();

        HomePage homePage = new HomePage(driver);
        Assert.assertTrue(homePage.isUserLoggedIn());
    }

Test Runner: The test runner is a program that runs the test code and communicates with the Appium server to automate the app. There are different test runners available for Appium, including TestNG, JUnit, and Appium Studio. The test runner usually handles the configuration, setup, and execution of the tests.

Supporting files: These are files that contain additional information or configuration for the tests, such as test data, configuration files, or utility classes. They can be organized in folders for better structure and maintainability.

- src
  - main
    - java
      - com
        - example
          - pages
            - LoginPage.java
            - HomePage.java
          - tests
            - LoginTest.java
          - utils
            - AppiumUtils.java
    - resources
      - app
        - MyApp.apk
  - test
    - java
      - com
        - example
          - runners
            - TestRunner.java

Connect iOS device Connected to Appium Studio

Khairun Nahar Nowrin — Thu, 09 Feb 2023 06:38:26 +0000

Installation
Install ios-deploy via Homebrew by running:

brew install ios-deploy

List ids and names of connected devices

ios-deploy -c

Link - https://www.npmjs.com/package/ios-deploy

How To Setup ZSH on Mac Terminal

Khairun Nahar Nowrin — Sun, 05 Feb 2023 07:21:48 +0000

Install Homebrew

Open up a terminal window and install homebrew with the following command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Add Homebrew To Path

After installing, add it to the path (replace "[username]" with your actual username):

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> /Users/[username]/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

Install iTerm2

To install, run:

brew install --cask iterm2

Switch to iTerm2 for the remainder of this walkthrough.

Install Git

If you don't have it installed, install git as well:

brew install git

Install Oh My Zsh

Run this to install Oh My Zsh:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Install PowerLevel10K Theme for Oh My Zsh

Run this to install PowerLevel10K:

git clone https://github.com/romkatv/powerlevel10k.git $ZSH_CUSTOM/themes/powerlevel10k

Now that it's installed, open the zshrc run this command

nano ~/.zshrc

file with your preferred editor and change the value of "ZSH_THEME" as shown below:

ZSH_THEME="powerlevel10k/powerlevel10k"

To reflect this change on your terminal, restart it or run this command:

source ~/.zshrc

Install Meslo Nerd Font

Install the font by pressing "y" and then quit iTerm2.

Update VSCode Terminal Font (Optional)

The settings.json file in Visual Studio Code can be found in the following location:

macOS: $HOME/Library/Application Support/Code/User/settings.json
You can also access the settings.json file directly in Visual Studio Code by going to File > Preferences > Settings, and then clicking on the {} icon in the top right corner to open the settings.json file.

Open settings.json and add this line:

"terminal.integrated.fontFamily": "MesloLGS NF"
Configure PowerLevel10K

Restart iTerm2. You should now be seeing the PowerLevel10K configuration process. If you don't, run the following:

p10k configure

Follow the instructions for the PowerLevel10K configuration to make your terminal look as desired.

Increase Terminal Font Size

Open iTerm2 preferences
Go to Profiles > Text
I increase my font size to about 20px

Change iTerm2 Colors to My Custom Theme

Open iTerm2
Download my color profile by running the following command (will be added to Downloads folder):

curl https://raw.githubusercontent.com/josean-dev/dev-environment-files/main/coolnight.itermcolors --output ~/Downloads/coolnight.itermcolors

Open iTerm2 preferences
Go to Profiles > Colors
Import the downloaded color profile (coolnight)
Select the color profile (coolnight)

You can find other themes here: Iterm2 Color Schemes

Install ZSH Plugins

Install zsh-autosuggestions:

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

Install zsh-syntax-highlighting:

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

Open the "~/.zshrc" file in your desired editor and modify the plugins line to what you see below.

plugins=(git zsh-autosuggestions zsh-syntax-highlighting web-search)

Load these new plugins by running:

source ~/.zshrc

You're Done!

Youtube video reference - https://www.youtube.com/watch?v=CF1tMjvHDRA&t=284s

Java RestAssure Maven Dockerfile

Khairun Nahar Nowrin — Mon, 23 Jan 2023 11:36:19 +0000

Dockerfile

FROM maven:3.6.3-openjdk-11

# Set the working directory to the project root
WORKDIR /app

# Copy the pom.xml file to the image
COPY pom.xml .

# Build the project dependencies
RUN mvn dependency:go-offline

# Copy the rest of the project source code
COPY . /JAVA_AUTOMATION

# Build the project
RUN mvn package

# Set the default command to run when the container starts
CMD ["java", "-jar", "target/JAVA_AUTOMATION.jar"]

Docker Image build, Container run and Run Testcase

# Fetch the latest of running container
docker ps -l

# The docker rm command is used to remove the container. The $(...) syntax is used to execute the docker ps -l -q command and pass the output (which is the container ID of the latest container) as an argument to the docker rm command.
#This approach will delete the latest running container
docker rm $(docker ps -l -q)

#To remove a Docker image forcefully
docker rmi -f hn-automation
# Build the Docker image
docker build -t hn-automation .

# Run a new container based on the image, and Run test case command in container
docker run -it hn-automation  mvn clean test -DsuiteXmlFile=testng.xml

API Automation using JAVA, Dockerize and Write data from google sheets using Java for Generate API Test-case automation report

Khairun Nahar Nowrin — Tue, 10 Jan 2023 06:13:37 +0000

Environment Setup for JAVA API Project

To install the Java Development Kit (JDK) on a Mac, you can follow these steps:

Go to the Oracle website and download the latest version of the JDK for Mac.
Open the downloaded .dmg file and run the installer package.
https://www.oracle.com/java/technologies/downloads/#jdk19-mac
Follow the prompts to install the JDK on your computer.

Alternatively, you can also install JDK using Homebrew package manager by running the command

 brew cask install java

Once the installation is complete, you can verify that the JDK is installed by opening a terminal window and running the command

java --version

This should display the version of the JDK that is currently installed on your system.

java --version                                              ✔  
javac 17.0.5
Which java

After that set the Java path in .zshrc file, To follow these steps:

Open the .zshrc file by running the command This will open

nano ~/.zshrc

the nano text editor with your .zshrc file.

Add the following lines to the file, replacing the path with the path to your JDK installation. To find Java path run

Which java

export JAVA_HOME=path-to-jdk
export PATH=$JAVA_HOME/bin:$PATH

Save and close the .zshrc file by pressing "CTRL+X", then "Y", and then "Enter".
Reload the .zshrc file by running the command

source .zshrc

Verify the changes by running the command

echo $JAVA_HOME

and "echo $PATH" it should display the path you have set in the above step.

Create API Project

To create a new Gradle project in IntelliJ IDEA, you can follow these steps:

Open IntelliJ IDEA and navigate to the "Welcome to IntelliJ IDEA" window.
Click on the "Create New Project" button or choose "File" > "New" > "Project" from the main menu.
In the "New Project" window, select the "Gradle" option from the list of available project types.
Select the "Java" or "Kotlin" option as the project's SDK. I select Java.
In the "Project name" field, enter a name for your project.
In the "Project location" field, choose a location on your computer where you want to save your project.
Click on the "Next" button to proceed.
In the "Project Structure" window, you can configure the settings for your project such as the project SDK, language level, and project format.
Click on the "Finish" button to create your new Gradle project.

Setup Project

API automation using Java involves writing code to test the functionality and performance of Application Programming Interfaces (APIs). There are several libraries and frameworks available in Java for API automation, including:

Rest-Assured: A Java library specifically designed for testing RESTful web services. It provides a simple and clean syntax for sending HTTP requests and asserting the responses.

JUnit: A popular unit testing framework for Java, JUnit can be used to write automated tests for APIs.

TestNG: Another testing framework for Java, TestNG is similar to JUnit but provides additional features such as support for data-driven testing and parallel test execution.

Apache HttpClient: A library for sending and receiving HTTP requests and responses. It can be used to send requests to an API and assert the response.

WireMock: A library for creating HTTP-based API mocks. It can be used to simulate API responses for testing purposes.

JSON: The JSON object library, such as Gson, provides a way to work with JSON data in Java by providing a set of classes and methods for parsing and generating JSON. Using a JSON library allows you to easily convert between JSON data and Java objects, making it more convenient to work with JSON data in a Java application.

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'

    //RestAssured
    testImplementation 'io.rest-assured:rest-assured:4.3.1'

    //TestNG Library
    testImplementation 'org.testng:testng:7.3.0'

    //HttpClient
    implementation 'org.apache.httpcomponents:httpclient:4.5.13'

    //WireMock
    testImplementation 'com.github.tomakehurst:wiremock-jre8:2.27.2'
    testImplementation 'com.github.tomakehurst:wiremock-standalone:2.27.2'

    //JsonObject
    implementation 'com.google.code.gson:gson:2.8.6'
}

Code-base
Repository link - https://github.com/DevSK1207/API_Automation_and_App_Integratio_Testing_Using_Java
Run Test-case
I'm facing this issue while im run test case from Intellij.

To resolve this issue -> Intellij > settings > Build, execution >
To run a JUnit test case in Java, you can use the following command:

./gradlew test --tests <TestClassName>

Can also specify the package name and class name to run the test case

./gradlew test --tests packageName.TestClassName

Can also run all the test cases for a project by using

./gradlew test

Dockerize the Project

FROM gradle:5.0-jdk11-alpine AS build


# Set the working directory to the project root
WORKDIR /app

# Copy the gradle
COPY --chown=gradle:gradle . /home/gradle/src

#Run gradle
RUN gradle build --no-daemon


FROM openjdk:11-jre-slim

EXPOSE 8080

# Copy the rest of the project source code
COPY . /JavaRestAssure

# Set the default command to run when the container starts

CMD ["java", "-jar", "build/libs/JavaRestAssure.jar"]

For build docker Image

docker build -t java-automation .

Run Docker container,

docker run -it java-automation /bin/bash

Google Spreadsheet Setup for g-Sheet
Read and Write g-Sheet function
Write data from google sheets
Generate API Test-case automation report