DEV Community: Harshit Paul

Tools for Taking Screenshots to Try in 2024

Harshit Paul — Tue, 30 Jul 2024 06:45:08 +0000

However, capturing a screen is one thing, but the ability of highlighting the content is another. There are many third party editing tools available to annotate our snippets each having their own uses in a business workflow. But when we have to take screenshots, we get confused which tool to use.

Some tools are dedicated to taking best possible screenshots of whole desktop screen yet some are browser based capable of taking screenshots of the webpages opened in the browsers. Some have ability to integrate with your development process, where as some are so useful that there integration ability can be easily overlooked.

Confusing, isn’t it? To solve this dilemma we have come up with a curated list of top 18 tools that will help you to take screenshots.

LambdaTest

It is an AI-powered test orchestration and execution platform with an in-built feature of capturing automated screenshots across 3000+ real desktop and mobile environments.

You get a dialog box where you type in the URL of your desired website. You get to select a total of 25 browsers for a single test! Once you choose the desired browsers and their versions, all you need to do is click on Capture. Tada!! You get all the screenshots you need in a single page. Each screenshot is taken in a real machine running the selected OS and browser. Once captured:

Edit or annotate the screenshots with the help of their image editor.
Download all screenshots as zip file in your system with a click of a button.
Schedule screenshots to be taken at regular intervals, helping you monitor any visual regressions that might occur over time.
Capture screenshots of pages that require login by creating login profiles with credentials.
One-click bug logging is provided on every screenshot which helps in labelling the bug and prioritizing it before saving it in your cloud library.
LambdaTest Integrations allows you to integrate with project management, bug tracking, and CI/CD tools.

This helps you to push issues directly to your respective accounts on the associated channels. This feature is very useful in hastening release process.

Awesome Screenshot

It also provides customizable keyboard shortcuts. Supported formats for saving images are .JPG and .PNG. You may also save the image on their cloud storage space for free. All the premium features have now been made free to avail.

Snagit

You get to record image and video, edit text and add comments, shapes, and pointers. Exporting and uploading can be done in a jiffy onto social media platforms, FTP programs. Fun part is you can even create animated GIFs on any short screen recording. They provide a lot more features, know more from their website.

This is another creation of Techsmith group and is referred as a sibling of Snagit. This is a free of cost tool and has a lot of resemblance with SnagIt. You can save images in the computer, you can also upload images and video captures to Screencast. Like SnagIt, you get to share your image or video on a variety of social media services too. Short screen recording is facilitated here as well. However, it is not meant for heavy duty business. You can add text, shapes and other minor edits. In order to use Jing the user needs to create a Screencast account.

Greenshot

A free of cost, light-weighted tool with high compatibility for capturing screens in Windows with download size of around 600 KB. You can capture the entire screen, a particular window or a particular section of your screen with the help of 3 hotkey shortcuts. You can even capture scrolling web pages in full from IE. This tool allows you to save the image on either clipboard or you may specify the exact folder and format in which you would want to save it. One of its key feature allows you to export the screenshots directly to your default image editor or printer.

Picpick

All-in-one design tool for everyone. Featuring a robust capture tool with an easy to use UI with a lot of handy features. This tool is categorized for home users and professional. It’s free of cost tool for home users. For professionals they charge $29.99 USD wherein they provide auto updates, lifetime upgrades, technical support and no advertisement.

Fireshot

It is also a web browser based extension brought up by firefox to capture screens on the go. This tool is available in chrome, mozilla firefox and IE. You can capture full web page, edit and annotate them. You can upload images to social media sites or can save the image inside local storage in the format JPEG / PNG. It is similar to Awesome Screenshot in many ways but it facilitates an additional feature where you canallow Fireshot to open your favourite external image editor automatically when a screen is captured.

Nimbus

Another browser based extension available in chrome, firefox and also as a Windows desktop application. Besides capturing web page and editing them, Nimbus helps to record screencasts. A user friendly alternative for Awesome Screenshot. Premium users can convert video to MP4 and GIF. They are also allowed to publish their screencasts to Youtube and Google Drive.

Screenshot Captor

A freeware with a variety of screen capture options and built-in editing tools. You can capture the entire screen, a particular window or a particular section of your screen. You can even pull images from a scanner and can crop, rotate, blur or annotate after that. Although this is a freeware, you still need to sign up to DonationCoder’s forum for a license key. Interface looks a little old fashioned but it is easy to use.

Snipaste

A multipurpose screen snipping as well as pasting tool which allows you to capture entire windows or selections. Furthermore you can edit, annotate or paste it back onto the desktop as a floating image window. Includes numerous features like magnifier, color picker, image editor and basic annotation tools, shapes, pointers etc.

Monosnap

Became popular as a flexible screen capture application on OS X, with built in annotation editing tools making it a superb desktop productivity aid. Allows you to capture entire windows or selections with a magnifier to aid pixel accuracy. You can edit and save screencaps locally or you can upload images to Monosnap and share them with provided URLs.

Lightshot

A hotkey facility is provided to take a screencap of the entire desktop, or a selection. Built in miniature editor to help with highlights, notes and annotations. Users can upload their screencaps to printscrn.com in order to facilitate an online gallery, link sharing and online backup by creating a free account with them.

Faststone

A screen capturing workhorse with a tiny user interface. This paid tool for windows can capture multiple windows, regions, and multi-level menus. Other than detail editing options, this tool also includes an effective screencast took that supports audio. Has a built in color picker for easy color sampling. To know more visit their website.

Snipping tool

Free built in feature developed by Microsoft which is simply accessible from Start Menu of almost every Windows device albeit Windows 7+, Vistas or tablet edition. Basic functionality allows you to capture the whole screen or an individual window. Provides simple and basic editing functions like highlighting and writing on your snippets. A great choice to have on your system if your screen capture needs are not high demanding.

TinyTake

A versatile software that offers screencapper, video recorder, and image manipulation tool. Allows you to capture entire windows or selections. Furthermore you can edit, annotate the video or image with arrows, shape, text etc. Besides storing in local storage, images can be stored in an online cloud gallery for ease of access. Free version has a limitation of a 5 minute-long video captures, a 2 GB online storage cap.

Skitch

Skitch is basically a screenshot editing and sharing application with various annotating options. It is an extension of Evernote application, along with which it provides users with fast image sharing options across social media platforms. This tool is accessible for both desktop and smartphones, for Windows, Mac, android and iOS.

ShareX

ShareX is an open source software easily downloadable for Windows, also available on Microsoft Store. Along with screenshot and screencasting it has video-capturing features all in a single click. Just like any other basic snipping tool, it can be used to capture full screen or partial screenshots. Captured screenshots can be annotated and edited using the built-in ShareX image editor and further shared across emails and social media websites.

Puush

A tool that helps you share screenshots very conveniently. It screencaps your desktop, active window or a selected area and then “pushes” it online to user’s account, with instant creation of a short URL in user’s clipboard- for easy sharing. A major downside to this tool is that it doesn’t come with annotation tools. But if you are looking to easily share images in an online format then Puush is definitely worth a shot.

These in my opinion are the top 18 tools for taking screenshots. Hope this blog was useful to you. Happy Snipping!

AnnounceKit: Our Secret To Successful Product Announcements

Harshit Paul — Fri, 19 Aug 2022 15:03:48 +0000

AnnounceKit has made it simple for us at LambdaTest to keep our customers informed about new features, bug fixes, and announcements through changelogs and in-app notifications. It has been a pivotal part of our feedback gathering process as well.

Being a product-first company, onboarding new features, browsers, and operating systems is part of our weekly routine. Even amid the global pandemic, we are fully functional and work tirelessly to bring new product updates to our power users.

We launched the first version of LambdaTest out of beta testing in early 2018 with only a handful of features to help the testing community perform live-interactive browser testing. Week after week, we kept adding more features to our platform, and in just one year, we introduced a cloud Selenium Grid to help our users automate their browser testing efforts.

The majority of our features and innovations were based on valuable feedback from our customers. Each feature was solving a unique problem and presented a good marketing opportunity.

Initially, we followed the old-school way of writing product update articles and notifying our customers through emails. It worked well until we expanded our go-to-marketing team by multiple folds.

The bigger go-to-market team implied we could press the accelerator harder over our roadmap as we could now develop and ship new features at a much faster pace.

Last month alone we built 30 new features, and this year we have already introduced more than 80 features. Here are some of the key highlights.

As we scaled our platform at a tremendous pace, we realized a challenge that every product-first SaaS might face.

Exponentially increase your browser coverage by running your Selenium online scripts on a cloud of 3000+ different desktop and mobile environments.

Challenge #1: The Spotlight Issue

When we started writing product updates about our every addition, we observed a dip in terms of visits/views over our product update articles. We learned that jotting down every new feature might not help us gain tractions towards a new feature. On the contrary, it could dim the spotlight over a significant feature.

Challenge #2: The Spam Alert

Sending emails every week around new updates was damaging our relationship with our subscribers. Our campaign’s open rate was declining, and we even received a few complaints from our customers who ended up unsubscribing from our mailing list.

We didn’t want to clutter our customer’s email inboxes. We were looking for a subtle way of informing our customers about LambaTest updates. We realized it was about time we introduced a proper change log in our product and have in-app notifications instead to notify customers about our recent add-ons.

We started looking for product announcements tools that could help us achieve what we wanted. We explored tools which were renowned for product announcements in the tech industry.
Some tools did the job but offered a vanilla experience with no option to incorporate any rich media such as Images, GIF etc. in the announcements. Some tools were offering the exact features we wanted but seemed overpriced. As a startup, you would always want a tool that’s worth your money.

What were the features we were looking for?

*Easy Widget Integration *— We wanted a tool that could easily be integrated with our website and our web-application.
*Support for Images, GIF *— Images and GIFs are crucial to showcase the use case for a new feature announcement.
*Ability to segment audiences *— We wanted to segregate our audience so we could display the right feature announcements to interested audiences.
Post scheduling — We wanted to notify our worldwide audience based on their timezone.
*Custom tags categorization *— Offering various testing, i.e., live-interactive testing, Test automation, Responsive testing, etc., we wanted to have the updates classified based on custom tags.
It has to be a **Whitelabel **software.
Affordable pricing always helps.

This was when AnnounceKit grabbed our attention over the Product Hunt community and we found it reasonably impressive.

Launched in December 2019, AnnounceKit solved all the challenges businesses were facing with the existing solutions.

AnnounceKit offers an intuitive platform with neat UI and flexible experience for product announcements with audience segmentation and tag customization. Plus, it supports images and GIFs into product update announcements. 😀

AnnounceKit has all the features we needed at a super affordable price and that’s why we picked it as our new feature announcement tool. Doing so has helped us in getting more engagements on our product updates announcements and gratitude from our customers.

This Playwright testing tutorial will guide you through the setup of the Playwright framework, which will enable you to write end-to-end tests for your future project.

How LambdaTest Uses AnnounceKit?

As we tried other competitors before switching on to AnnounceKit. We were hesitant if our Changelogs would be lost once we transit to AnnounceKit. Fortunately, they give the option to import posts from other product announcement tools. Allowing us to migrate hassle-free.

At LambdaTest, we leverage AnnounceKit in primarily 2 ways:

Changelogs
In-app notifications

We incorporated LambdaTest Changelog in our website footer allowing our website visitors to go through our recent additions over the platform. A changelog is a great way to let your website visitors know about how quickly you are shipping new features into your products. It helps build a good rapport.

Visitors can see what kind of features have been shipped in past release cycles and how frequently. We leverage custom tags to classify the product announcements depending on whether the feature is around live-interactive testing, Selenium Grid cloud, LT Browser, Tunnel for locally hosted testing, and more.

Not only our developers, but our marketers also leverage Announcekit to let our users know about upcoming Webinars or events.

We integrated a widget in our web application that opens a sidebar when a user clicks on the notification bell inside the LambdaTest application.

Instant Feedbacks

“Amazing things will happen when you listen to the consumer.”
–Jonathan Midenhall, CMO of Airbnb

We are a customer-centric SaaS; many of our product updates are driven based on customer requests and suggestions. Once those features are out, we can analyze the reactions of our users towards them.

AnnounceKit has made it super easy for us to collect customer feedback instantly. The emoji are eye-catching and drive users to share what they feel about our feature announcements in a single click.

A complete cypress testing framework tutorial: Get started with end to end automation testing using Cypress testing framework and LambdaTest test automation cloud.

Custom Tags & Labels

The ability to define custom color codes to label allowed us the flexibility to keep a neat and minimalistic UI while categorizing tags.

We are yet to explore all the features that AnnouceKit has to offer. One particular feature we’re excited about is the multi-lingual support. It would help us deliver a native experience to our customers. We are super excited to try this out. Similarly, we are also waiting for more integrations to be on board.

AnnounceKit has helped LambdaTest be more agile and customer-focused. We have been able to relay our updates on time. The UI is neat and blends well with any SaaS design. The best part is our customers love it too. Kudos to AnnounceKit, our secret to successful product announcements.

How To Generate Code Coverage Report Using JaCoCo-Maven Plugin

Harshit Paul — Wed, 10 Aug 2022 14:41:55 +0000

Code coverage is a software quality metric commonly used during the development process that lets you determine the degree of code that has been tested (or executed). To achieve optimal code coverage, it is essential that the test implementation (or test suites) tests a majority percent of the implemented code.

There are a number of code coverage tools for languages like Java, C#, JavaScript, etc. Using the best-suited code coverage tool is important to understand the percentage of code tested and take appropriate actions to ensure that you achieve the ideal code coverage!

For optimal code testing, many companies use the JaCoCo-Maven plugin that helps generate detailed code coverage reports. JaCoCo-Maven plugin is a free code coverage library for Java projects. It is based on the study of existing integration libraries that were created by the EclEmma team. At a larger extent, code coverage does give a brief overview of the product quality as higher the coverage, lesser are the chances of untested code getting into the release cycle.

In this blog, we will learn more about the JaCoCo-Maven plugin and how this plugin is implemented using Maven. We will also integrate a Maven project and generate detailed code coverage report for the tests by performing Selenium.

What is Code Coverage?

In software development, Code Coverage is a measure used to describe the degree to which the source code of an application is executed when a test suite is executed. A report is generated to view and analyze the code coverage of a software application. This code coverage report could then be used for ensuring code quality.

The JaCoCo-Maven plugin is used to generate code coverage reports. Source code with high code coverage has more of its code executed during testing. For example, if the software you are testing contains 100 lines of code and the number of code lines validated in the software is 90, then the code coverage percentage of that software application will be 90%.

Benefits of Code Coverage

Code coverage is a very useful metric for developers, testers, and QA engineers. Here are some of the salient benefits of code coverage:

Code coverage reports provide useful insights in detection and elimination of dead code. This can be avoided by following implementation best-practices which in turn results in improved code maintainability and better product quality.
Quality assurance can help detect code that has not been covered using the test implementation.
Developers can finish the software development process faster, increasing their productivity, scalability, and efficiency. This results in reduced Time to Market (TTM).

As we know, code coverage is very important for every software product. However, if you are a developer or a tester, you can cure your interest in code coverage via the article: Code Coverage vs. Test Coverage, which one is better?

Now that we have done a quick recap about the integral aspects of code coverage, let’s deep dive into our core topic i.e. generating code coverage reports using Jacoco Maven plugin.

What is JaCoCo-Maven Plugin?

JaCoCo-Maven (abbreviation for Java Code Coverage) plugin is an open-source code coverage tool for Java. It creates code coverage reports and integrates well with IDEs(Integrated development environments) like Eclipse IDE.

It also integrates smoothly with CI/CD tools (e.g. Jenkins, Circle CI, etc.) and project management tools (e.g. SonarQube, etc.). It is a part of the Eclipse Foundation and has replaced the EclEmma code coverage tool in Eclipse.

Did you know? You can run end-to-end tests on a blazing fast test execution for Cypress cloud.

How does JaCoCo-Maven Plugin work?

The JaCoCo-Maven plugin runs the coverage by instrumenting Java code through a runtime agent. In simple terms, you attach this agent to a JVM (Java Virtual Machine) when it starts. This agent is termed as JaCoCo agent. The first execution start-agent starts this JaCoCo Runtime Agent.
Whenever a class is loaded, JaCoCo can instrument the class so that it can view when the class is called and what lines (of code) are called during the testing process. By keeping this track, it builds up the code coverage statistics which is done on the fly during the second execution (i.e. generate-report).
By default, the file is created as soon as the JVM terminates but it is also possible to run the agent in server mode. This triggers a dump of the results and the report is created before the termination. Shown below are the internals of the JaCoCo plugin:

You can define goals and rules in the configuration of the JaCoCo-Maven plugin. This offers you the flexibility to set limits and helps in checking the amount of code coverage.
Maven-surefire plugin is the default Maven plugin. This runs the tests in JVM and provides coverage reports. While the JaCoCo plugin instruments the code already executed by a plugin (e.g. Surefire plugin). Thus, it is a good practice to check for the dependency of the maven-surefire plugin.

Why is Jacoco Maven Plugin good for code coverage?

The JaCoCo-Maven plugin is appropriate for code coverage because of the following reasons:

While working on any project, developers mostly prefer IDEs because it simplifies the coding and testing experience. JaCoCo can be installed on Eclipse IDE in the name of EclEmma, by downloading EclEmma from its marketplace.
It is easy to add the JaCoCo plugin to all types of builds, including ANT, Maven, and Gradle. It can also be integrated with CI/CD tools like Jenkins, Circle CI, etc. This makes it versatile for a lot of use cases.
The code coverage report generated by JaCoCo is a simple and informative HTML file that can be viewed in any browser or IDE.
JaCoCo also provides offline instrumentation (i.e., all the classes are instrumented before running any tests).
Analysis of a report is also quite easy, as it is color-based and provides the exact percentage of code coverage.

How to set up JaCoCo Plugin with Maven?

To get code coverage reports in a Maven project, we first need to set up the JaCoCo Maven plugin for that project. By integrating the JaCoCo plugin, the results of the code coverage analysis can be reviewed as an HTML report. The current version of the JaCoCo-Maven plugin can be downloaded from the MVN Repository.

Here are the steps to integrate JaCoCo Maven plugin with a Maven project:

Every Maven project has a pom.xml file, used to declare all the dependencies and plugins. The JaCoCo-Maven plugin is declared in the same POM.xml file. The XML code for the same is :

org.jacoco
jacoco-maven-plugin
0.8.6

This is the basic XML code added under the build tag for specifying the JaCoCo plugin in a Maven-based project. We can enhance the functionality (like mentioning when a report should be generated, etc.) by specifying goals and rules in the execution tag.

After the version tag, we add the execution tag. This tag prepares the properties or execution to point to the JaCoCo agent and is passed as a VM (in this case, JVM) argument.
For running simple unit tests, two goals set in execution tags will work fine. The bare minimum is to set up a prepare-agent and report goals.

org.jacoco
jacoco-maven-plugin
0.8.6

prepare-agent

prepare-agent

report
test

report

Prepare-agent goal: The prepare-agent goal prepares the JaCoCo runtime agent to record the execution data. It records the number of lines executed, backtraced, etc. By default, the execution data is written to the file target/jacoco-ut.exec.
Report goal: The report goal creates code coverage reports from the execution data recorded by the JaCoCo runtime agent. Since we have specified the phase property, the reports will be created after the compilation of the test phase. By default, the execution data is read from the file target/jacoco-ut.exec, and the code coverage report is written to the directory target/site/jacoco/index.html.

For running simple unit tests, the above configuration works fine. However, we would need constraints to be put on the code coverage reports (e.g. specify the destination directory, etc). This can be done via a configuration tag.

org.jacoco
jacoco-maven-plugin
0.8.6

prepare-agent

prepare-agent

${project.build.directory}/coverage-reports/jacoco-ut.exec
surefireArgLine

report
test

report

${project.build.directory}/coverage-reports/jacoco-ut.exec
${project.reporting.outputDirectory}/jacoco-ut

Configuration of first execution :

As per the above code, you can see some tags like destFile, etc., are specified. Here is a brief description of the tags:

destFile tag: The destFile tag is used for setting the path to the file containing the execution data.
propertyName-surefireArgLine tag: This tag sets the name of the property that contains the settings for the JaCoCo runtime agent. This also sets the VM argument line when the unit tests are run.

Configuration of second execution :

As per the above code, you can see tags like dataFile, etc., are specified. Here is a brief description of the tags:

dataFile tag: The dataFile tag is used to set the path to the file containing execution data.
outputDirectory tag: This tag sets the output directory for the code coverage reports.

We can also add rules to our configuration tag to keep a check on the code coverage percentage. This can be done as shown below:

org.jacoco
jacoco-maven-plugin
0.8.6

prepare-agent

prepare-agent

${project.build.directory}/coverage-reports/jacoco-ut.exec
surefireArgLine

report
test

report

${project.build.directory}/coverage-reports/jacoco-ut.exec
${project.reporting.outputDirectory}/jacoco-ut

jacoco-check

check

PACKAGE

LINE
COVEREDRATIO
0.50

Configuration of third execution :

Here, a new goal check is defined. The jacoco:check goal is bound to verify the rule specified. Rule is given in the rule tag. You have the flexibility to specify more than one rule.

Element tag: This tag specifies the element on which the rule has to be applied.
Limit tag: Tags like counter, value, minimum, etc., are used to limit the code coverage percentage. A command like mvn clean verify can be used for ensuring whether the rule is followed or not.

There are multiple goals and rules which can be defined in the JaCoCo-Maven plugin configuration.

Check out this Playwright testing tutorial and explore the setup of the Playwright automation framework, which will enable you to write end-to-end tests for your future projects.

Code Coverage Reports Using Maven and JaCoCo Plugin

In this section, we would demonstrate the steps to generate code coverage report using the JaCoCo Maven plugin. The demonstration is done by taking a very simple test scenario. So, let’s get started.

Pre-requisites:

Maven 3.0 or higher: Maven is a project development management and comprehension tool. You can install the latest version from the official Apache Maven website.
Java 1.5 or higher: You need to ensure that Java is installed on your machine. In case you do not have Java installed, please download the latest version of Java from the official Java website.
Eclipse IDE for Java Developers: Though you can use the IDE of your choice, for this demo we have used the Eclipse IDE.

Steps to create a simple Maven Project:

In Eclipse IDE, Go to File>New>Maven Project.

A new dialog box appears. Make sure that the ‘Use default Workspace location’ checkbox is ticked. Click Next.

For selecting Archetype in the project, type org.apache.maven in the textbox that is located next to the Filter. Select maven-archetype-quickstart and click Next.

Now, specify the Group Id as com.example and Artifact Id as jacoco-example. The artifact Id is our project name. Finally, click on the Finish button.

You can see the project file and folder hierarchy in Project Explorer.

How to specify JaCoCo Maven plugin in POM.xml

Open POM.xml, scroll to tag. We will specify the JaCoCo-Maven plugin in the section that lists the Maven plugins. Just copy the below code and paste it above the tag.

org.jacoco
jacoco-maven-plugin
0.8.6



prepare-agent

prepare-agent



report
test

report
1. Since we are demonstrating report generation for automated web testing with JUnit, we will also declare the JUnit dependency in POM.xml.

Here is the entire content of POM.xml:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0)" xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance](http://www.w3.org/2001/XMLSchema-instance)"
  xsi:schemaLocation="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0) [http://maven.apache.org/xsd/maven-4.0.0.xsd](http://maven.apache.org/xsd/maven-4.0.0.xsd)">
  <modelVersion>4.0.0</modelVersion>

<groupId>com.example</groupId>
  <artifactId>jacoco-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>

<name>jacoco-example</name>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

<!-- JUnit dependencies added to run test cases -->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

<build>
      <plugins>
        <!-- Maven plugin for Project Management -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see [http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging](http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging) -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.19.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.6</version>

                <executions>
                    <execution>
                        <id>prepare-agent</id>
                        <goals><goal>prepare-agent</goal></goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals><goal>report</goal></goals>
                    </execution>
                </executions>
            </plugin>
      </plugins>
  </build> 
</project>

From the project directory, traverse to com.example.jacoco_lambdatest package existing in src/main/java. Create a new Java class named LambdaTest.java. We will write a simple setUp() function in it that provides the desired capabilities of Selenium Grid.

package com.example.Jacoco_lambdatest;

import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;

public class LambdaTest {
public static String username = "";
public static String accessKey = "";

public static DesiredCapabilities setUp() throws Exception {
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("platform", "Windows 10");
capabilities.setCapability("browserName", "Chrome");
capabilities.setCapability("version", "87.0"); // If this cap isn't specified, it will just get the any available one
capabilities.setCapability("resolution","1024x768");
capabilities.setCapability("build", "First Test");
capabilities.setCapability("name", "Sample Test");
capabilities.setCapability("network", true); // To enable network logs
capabilities.setCapability("visual", true); // To enable step by step screenshot
capabilities.setCapability("video", true); // To enable video recording
capabilities.setCapability("console", true); // To capture console logs
return capabilities;
}
}

Adding JUnit test Cases in the project:

We will create a simple JUnit test case in AppTest.java. This is provided by default, in the src/test/java under the package name com.example.jacoco_lambdatest.

package com.example.Jacoco_lambdatest;

import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import com.example.Jacoco_lambdatest.*;

public class AppTest {
public static RemoteWebDriver driver;

@Test
public void testScript1() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username =LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click(); driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
driver.quit();

} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}

Generating code coverage reports:

Just click on the Run As button and set the configuration as Maven Test.

Instead, you can open cmd(Command Line), traverse to the project folder, and run the maven command, “mvn test.”

Running the JUnit tests will automatically set the JaCoCo agent in motion. It will create a report in binary format in the target directory, with path target/jacoco.exec. The output of jacoco.exec cannot be interpreted single-handedly but other tools like SonarQube and plugins can interpret it. As we have earlier specified the jacoco:report goal, it will generate readable code coverage reports in popular formats like HTML, CSV, and XML.
As the build is successful, go to the target folder, then to the site>jacoco folder. The code coverage report (i.e. index.html) is located in target/site/jacoco/index.html. The report looks like this:

You can drill down at a micro level by clicking on com.example.jacoco_lambdatest>LambdaTest in the report.

By clicking on specific functions, you will have a more detailed view in LambdaTest.java.

Here, you would see a lot of diamonds of different colors like green, yellow and red. These are the specifications used in the report to symbolize which line of code was executed and when it was executed. We will learn more about it in the next section of the report analysis. With this, you have successfully generated a code coverage report via the Jacoco Maven plugin.

Analysis of the Code Coverage Report

Our code coverage report shows 94% instruction coverage, 100% branch coverage, which is a great code coverage score. Later, we will try to achieve a 100% code coverage score by adding more test cases.

The 38 instructions shown by JaCoCo in the report refer to the bytecode instructions instead of Java code instructions. The JaCoCo reports help you visually analyze
code coverage by using diamonds with colors for branches and background highlight colors for lines. A brief explanation of the diamonds seen in the code coverage report is below:

Red diamond indicates that no branches have been exercised during the testing phase
Yellow diamond indicates that the code is partially covered (i.e. some branches are not exercised)
Green diamond indicates that all branches are exercised during the test

The same color code applies to the background highlight color for the line coverage.
The report mainly provides three crucial metrics :

Line coverage: This reflects the amount of code exercised based on the number of Java byte code instructions called by the tests.
Branch coverage: This shows the percentage of exercised branches in the source code. These are typical if/else or switch statements.
Cyclomatic complexity: This reflects code complexity via the number of paths needed to cover all possible paths in a code. It also refers to the number of test cases needed to implement to cover the entire code. As there is no switch or statement in the code, the cyclomatic complexity will be 1; only one execution path is sufficient to cover the entire code.

Introducing more test cases for improving code coverage

To achieve better code coverage, more tests need to be introduced that test the code that was not covered earlier via the test implementation.
Go to AppTest.java in src/test/java to add more test cases.
The new test cases added to AppTest.java will look as follows:

@Test
public void testScript2() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username = LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/"); driver.findElement(By.name("li2")).click();
driver.findElement(By.name("li3")).click();
driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it to list"); driver.findElement(By.id("addbutton")).click();
driver.quit();

} catch (Exception e) {
System.out.println(e.getMessage());
}
}

@Test
public void testScript3() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username = LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/"); driver.findElement(By.name("li4")).click();
driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it!");
driver.findElement(By.id("addbutton")).click();
driver.quit();

} catch (Exception e) {
System.out.println(e.getMessage());
}
}
1. Let’s run the maven jacoco:report to publish a new coverage report.

JaCoCo offers a simple and easy way to track code coverage score by declaring minimum requirements. Build fails if these requirements are not met else the build is successful.
These requirements can be specified as rules in POM.xml. Just specify the new execution specifying ‘check’ goal in POM.xml. Add the below code after the second tag in POM.xml.

jacoco-check

check

PACKAGE

LINE
COVEREDRATIO
0.50
With this, we are limiting our coverage ratio to 50%. This signifies a minimum of 50% of the code should be covered during the test phase.
You can run maven clean verify to check whether the rules set in jacoco:check goal are met or not.

The log shows “All coverage checks have been met.” as our code coverage score is 94% which is greater than our minimum 50%.

Automation Testing On LambdaTest Selenium Grid using Maven Project with Jacoco Plugin

Selenium testing on the cloud helps you attain better browser coverage, increased test coverage, and accelerated time to market. Parallel testing in Selenium helps you achieve the above mentioned requirements.

LambdaTest Cloud Selenium Grid is a cloud-based scalable Selenium testing platform that enables you to run your automation scripts on 2000+ different browsers and operating systems.

Pre-requisites:

To run the test script using JUnit with Selenium, first, we need to set up an environment. You would first need to create an account on LambdaTest. Do make a note of the username and access-key that is available in LambdaTest profile section.

We will use this sample project for Java Selenium testing.

Did you know? Exponentially increase your browser coverage by running your Selenium automation testing scripts on a cloud of 3000+ different desktop and mobile environments.

Importing project to Eclipse IDE:

After downloading a zip file of the project: junit-selenium-sample from GitHub, we import it to Eclipse IDE by following the below mentioned steps:

Go to your Eclipse IDE, click on the File menu and select Import. A new dialog box appears.
Type Maven in the textbox below and select Existing Maven Projects, and then click Next.

In the next dialog box, click on Browse and traverse to the project folder. Also, tick the checkbox giving the path to the POM.xml file, and click Finish.

Your project will be loaded in Eclipse IDE successfully.

Adding dependencies in the POM.xml file:

Open the POM.xml, now add the dependencies of JUnit, Selenium, and JaCoCo Maven Plugin. After adding the dependencies to the code of POM.xml should look like this:

<?xml version="1.0" encoding="UTF-8"?>
xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance](http://www.w3.org/2001/XMLSchema-instance)"
xsi:schemaLocation="[http://maven.apache.org/POM/4.0.0](http://maven.apache.org/POM/4.0.0) [http://maven.apache.org/xsd/maven-4.0.0.xsd](http://maven.apache.org/xsd/maven-4.0.0.xsd)">
4.0.0

com.lambdatest
lambdatest-junit-sample
1.0-SNAPSHOT
UTF-8
2.19.1
default



junit
junit
4.12
test

commons-io
commons-io
1.3.2
test



org.seleniumhq.selenium
selenium-java
2.52.0
test

com.googlecode.json-simple
json-simple
1.1.1
test



maven-compiler-plugin
3.0

1.8
1.8

maven-surefire-plugin
2.19.1



org.jacoco
jacoco-maven-plugin
0.8.6

prepare-agent
prepare-agent

report
test
report

Github

Configuring the Desired Capabilities for JUnit Automation Testing:

To connect to LambdaTest Selenium Automation Grid, the first thing done is invoking a remote webdriver. This remote driver requires some capabilities like browser, browser versions, operating system, etc., to build an environment. The code to it looks as follows:

WebDriver driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + "@hub.lambdatest.com/wd/hub"),
DesiredCapabilities.firefox()); //A class named DesiredCapabilities is used to create an environment as a Firefox browser.
1. In the JUnit automation testing code, the capabilities like browser, browser versions, operating system information, etc., can be customized and are passed via Capabilities Object.
2. LambdaTest has made this process very easy by providing an inbuilt Capabilities Generator. The Capabilities Generator will automatically generate the code for desired capabilities based on your input. Such as, our configurations are:

Selecting the above-specified configuration in the Capabilities generator and paste it to LambdaTestBseTest.java.

Specifying LambdaTest Username and Access Key in required Java Class:

In the Project Explorer, you would see 3 Java classes: LambdaTestBaseTest.java (contains the setup required for Java Selenium testing), Parallelized.java (contains Junit tests for parallel testing on LambdaTest Selenium grid), and SimpleTest.java (contains simple unit tests).

LambdaTestBaseTest.java fetches the required data like desired capabilities, username, and access key from a config file. This is provided in src/test/resources as config.json.
Specify the desired capabilities, Username, and Access key in config.json. This JSON file is used as you can provide multiple configurations in it for realizing parallel testing with Selenium. to specify multiple configurations in config.json and then fetch them later.

[ { "tunnelName":"LambdaTest tunnel",
"buildName":"running Java Selenium Tests",
"testName":"Jacoco JUnit Test",
"username": "user-name",
"access_key":"access-key",
"operatingSystem" : "win10",
"browserName" : "chrome",

"browserVersion" : "62.0",
"resolution" : "1024x768" }]

Unit Testing using JUnit with Selenium:

SimpleTest.java is the Java class for specifying a single unit test case for testing and performing code coverage using the JaCoCo Maven plugin.

package com.lambdatest;

import com.lambdatest.LambdaTestBaseTest;
import org.junit.Test;
import org.openqa.selenium.By;
import static org.junit.Assert.assertEquals;

public class SimpleTest extends LambdaTestBaseTest {
/**
* Simple Test case annotation for JUnit Test
* @throws Exception
*/

@Test
public void validateUser() throws Exception {
driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click();
driver.findElement(By.id("sampletodotext")).clear();
driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
}

}
1. This is a simple Selenium WebDriver test that will open a sample to-do application that will do the following task:

Mark the first two items as mark done.
Add a new item to the list.
Return the added item.

Trigger the command mvn test on the terminal to build and run the test case.

Now, login to your LambdaTest Account and go to Automation. You will find the tests you ran under the build name “JUnit JaCoCo Tests.”

Click on “JUnit JaCoCo Tests” and review them in detail. LambdaTest has recorded the video. So you can see the visuals too.

Generating Code Coverage Report via JaCoCo Maven Plugin:

Now, as we have run the JUnit test cases on LambdaTest Selenium Grid, the code coverage report should be generated via the JaCoCo Maven plugin.
Just go to the target folder, you will find the binary format of the report as jacoco.exec.
You can view the HTML, CSV, and XML form of the code coverage report in the target/site/jacoco folder as index.html, jacoco.csv, and jacoco.xml, respectively.
Great! Now you can also try to improve the code coverage score and analyze the code coverage report generated.

Conclusion

In this article, we have seen how to use the JaCoCo-Maven plugin to generate code coverage reports for Java projects. We have also leveraged the agility and scalability of LambdaTest Selenium Grid cloud to automate the test processes. Remember, though, 100% code coverage is not responsible for reflecting effective testing, as it only shows the amount of code exercised during tests.

Yet, it helps to reduce the number of bugs and improves the software release quality. Also, it adds minimal overhead to the build process and allows it to keep a certain threshold as the development team adds edge cases or implements defensive programming.

Code coverage is a really good practice, especially when you have conditional statements in your source code. Hopefully, this article will help you learn how to achieve code coverage with JaCoCo for a Maven project. That’s all for the day. However, we have some very useful content coming up on the LambdaTest blog, so stay tuned and happy testing!

LambdaTest and CloudBeat Collaborates For Faster Selenium Testing

Harshit Paul — Tue, 09 Aug 2022 14:52:14 +0000

Are you planning strategies to help simplify the execution of your automation scripts for Selenium testing?

Selenium is considered as one of the favourites, in test automation frameworks, especially if we refer to the open-source ones. Selenium was brought to help facilitate automation testing for web-applications, all so it could ease the life of web testers.And it has been doing a pretty good job! However, Selenium is no magic wand. It will help you automate your web application testing but you would require thorough planning to implement Selenium testing across your organization.

You may have to consider different metrics to calculate your ROI for test automation such as the infrastructure cost, maintenance of Selenium scripts and Selenium Grid, test reporting process, and most important the right selection for Selenium testing tool.

Now, most of you may wonder as to what would you need a Selenium testing tool if Selenium is an open-source test automation framework? Well, there are many reasons behind that but the most primary ones are:

You don’t have to worry about building or maintaining your in-house Selenium testing infrastructure.
You get integrations to third-party tools to help you ship your product faster than your deadlines.

So If the above questions are not being a part of your pre-discussion for Selenium testing then chances are, that you may struggle while scaling your Selenium test suites in the near future as your product grows.

Many enterprizes fail to reap the maximum output with minimal throughput as they perform Selenium testing. If you are working under a similar organization where your test department is struggling in implementing Selenium testing then don’t worry, we got your back!

LambdaTest is conducting a webinar with CloudBeat to help address all your concerns related to Selenium testing. The webinar will demonstrate how you can fast-track your Selenium testing process using LambdaTest and CloudBeat simultaneously. Here is what you can expect to learn from the webinar:

A quick intro to LambdaTest platform.
Brief about CloudBeat Oxygen OS.
How LambdaTest & CloudBeat can help with faster product delivery.
Q&A session.

Did you know? You can run end-to-end tests on a blazing fast test execution for Cypress cloud.

When Is The Webinar And How Do I Register?

Now that we have your interest, make sure you to set a reminder for the below date and time.

Date: 07 OCT 2019

Time: 10 AM PST

Registrations are open and seats are limited. So hurry and book your slot now by visiting our Webinar registration page or by simply filling the below form.

Check out this Playwright testing tutorial and explore the setup of the Playwright automation framework, which will enable you to write end-to-end tests for your future projects.

What Is LambdaTest?

LambdaTest is a browser compatibility testing tool which offers both manual and automated cross browser testing with Selenium Grid of 2000+ real browsers running on real operating systems. LambdaTest also helps to perform cross browser testing of your locally hosted web applications using an SSH(Secure Shell) connection. With LambdaTest integrations, you can integrate with numerous third-party tools for CI/CD and project management. Fetch detail test reports of your Selenium test execution over the LambdaTest platform, along with video recording of test script, command-by-command screenshot, various types of logs, metadata, and more.

Did you know? Exponentially increase your browser coverage by running your Selenium automation testing scripts on a cloud of 3000+ different desktop and mobile environments.

What Is CloudBeat?

CloudBeat aims to simplify automation testing by its open-source test automation framework known as Oxygen. Oxygen is a wrapper for Selenium and Appium. With Oxygen, you can perform API testing, Integration testing, UI testing, and Browser testing.

Since Oxygen is based on Selenium, it also offers the record and playback functionality to help you easily debug the issue in your Selenium scripts. You can even perform assertions against a database, invoke RESTful APIs, web services, and more. Oxygen framework provides you with detailed insight over the execution of your test automation scripts such as error-details, screenshots, and HAR files.

CloudBeat allows you to perform cross browser testing with every browser that is compatible with Selenium and from 10 locations over the world. It offers you with detailed test reports and also helps you to keep a track on performance measurements from the server-side. You also get notifications and test results in your mailbox so you don’t miss out on anything.

LambdaTest Collaborates With CloudBeat To Help You Expand Cross Browser Testing

Using LambdaTest and CloudBeat you can perform end to end testing of your web-application while expanding your browser and devices test coverage, so you ensure a seamless user experience for all your website visitors. Perform Selenium cloud testing on a Selenium Grid of 2000+ real browser to help you expand your test coverage on a wide variety of devices and browsers. The best part?

You could do it all without any in-house Selenium Grid infrastructure as LambdaTest will host all the browsers and devices as per your test script on its cloud servers. You can even perform parallel testing with Selenium scripts and get detailed test reports about the execution of your automation scripts from Oxygen on LambdaTest Selenium automation. You can make use of REST API for Selenium automation offered by LambdaTest to extract test details directly from LambdaTest clouds to your preferred store, without logging into LambdaTest.

In case you missed the webinar, then here is the full recording:

Let us know in case you have any questions, drop us an email to support@lambdatest.com or simply give us a shout. We are here to help you speed your test suites 24/7. Happy testing!

18 Tools You Must Try For Taking Screenshots

Harshit Paul — Mon, 08 Aug 2022 13:33:00 +0000

Screenshots! These handy snippets have become indispensable to our daily business as well as personal life. Considering how mandatory they are for everyone in these modern times, every OS and a well-designed game, make sure to deliver a built-in feature where screenshots are facilitated. However, capturing a screen is one thing, but the ability to highlight the content is another. There are many third-party editing tools available to annotate our snippets each having its own uses in a business workflow. But when we have to take screenshots, we get confused about which tool to use. Some tools are dedicated to taking the best possible screenshots of the whole desktop screen yet some are browser based capable of taking screenshots of the webpages opened in the browsers. Some have the ability to integrate with your development process, whereas some are so useful that their integration ability can be easily overlooked.

Confusing, isn’t it? To solve this dilemma we have come up with a curated list of the top 18 tools that will help you to take screenshots.

Awesome Screenshot:

The name says it all! With over 2 million users this browser based extension is available on chrome and firefox allowing you to capture any or every part of a website. Besides capturing, it helps to add notations, share with single click uploads, and blur sensitive information. It also provides customizable keyboard shortcuts. Supported formats for saving images are. JPG and . PNG. You may also save the image on their cloud storage space for free. All the premium features have now been made free to avail.

Snagit:

TechSmith Snagit is one of the paid service providers but they do provide you a one month free trial to be addictive, after that you ought to pay. They follow a volume discount business pricing. This tool is a one stop shop for a business with extensive needs and is definitely worth the price if the number of users in your firm are high in volume. It delivers numerous inbuilt photo editing and annotation tools. You get to record image and video, edit text and add comments, shapes, and pointers. Exporting and uploading can be done in a jiffy onto social media platforms, FTP programs. Fun part is you can even create animated GIFs on any short screen recording. They provide a lot more features, know more from their website.

LambdaTest:

It is cross browser testing platform with an in-built feature of screenshot.

You can edit or annotate the screenshots with the help of their image editor.
Download all(Zip) button will download all the screenshots in your system in a single click.
One-click Bug logging — A button Mark as Bug is provided on every screenshot which helps in labelling the bug and prioritizing it before saving it in your cloud library.
Integrations — LambdaTest allows you to integrate with

ASANA
SLACK
JIRA
TRELLO
GITHUB
VSTS
GITLAB
BITBUCKET
PAYMO
TEAMWORK
BUGMANTIS
BUGHERD
CLUBHOUSE

This helps you to push issues directly to your respective accounts on the associated channels. This feature is very useful in hastening release process.

Did you know? You can run end-to-end tests on a blazing fast test execution for Cypress cloud.

LambdaTest have also released their Chrome Extension and WordPress Plugin for capturing full-page screenshots. If you want to know how to use them. Just follow our concise YouTube videos for the same:

Chrome Extension

LambdaTest Chrome Extension For Automated Screenshots

WordPress Plugin

Automated Screenshots Using LambdaTest WordPress Plugin🔌| LambdaTest Integrations

Jing:

This is another creation of Techsmith group and is referred as a sibling of Snagit. This is a free of cost tool and has a lot of resemblance with SnagIt. You can save images in the computer, you can also upload images and video captures to Screencast.com. Like SnagIt, you get to share your image or video on a variety of social media services too. Short screen recording is facilitated here as well. However, it is not meant for heavy duty business. You can add text, shapes and other minor edits. In order to use Jing the user needs to create a Screencast account.

Greenshot:

Check out this Playwright testing tutorial and explore the setup of the Playwright automation framework, which will enable you to write end-to-end tests for your future projects.

Picpick:

Fireshot:

Nimbus:

Screenshot Captor:

Snipaste:

Monosnap:

Lightshot:

Faststone:

Snipping tool:

TinyTake:

Skitch:

ShareX:

Puush:

Did you know? Exponentially increase your browser coverage by running your Selenium automation testing scripts on a cloud of 3000+ different desktop and mobile environments.

These in my opinion are the top 17 tools for screenshots. Hope this blog was useful to you. Happy Snipping!

5 Reasons Why You Need To Care About API Performance Monitoring

Harshit Paul — Fri, 05 Aug 2022 13:50:46 +0000

Connectivity is so daunting. By far, we are all used to instant connectivity that puts the world at our fingertips. We can purchase, post & pick anything, anywhere with the aid of desktops & devices.

But how does it happen? How do different applications in different devices connect with each other? Allowing us to place an order, plan a vacation, make a reservation, etc. with just a few clicks.

API — Application Programming Interface — the unsung hero of the modern world which is often underrated.

What is an API?

APIs are building blocks of online connectivity. They are a medium for multiple applications, data and devices to interact with each other. Simply put, an API is the messenger that takes request and tells the system what you want to do and then returns the response back to user. A documentation is drafted for every API, including specifications regarding the manner in which the information gets transferred between two systems.

Did you know? Exponentially increase your browser coverage by running your Selenium automation scripts on a cloud of 3000+ different desktop and mobile environments.

Why is API important?

APIs can interact with third-party application publicly. Ultimately, upscaling the reach of an organization’s business. So when we book a ticket via Bookmyshow.com, we fill in details regarding the movie we plan to watch.

Movie Name
Locality
3D/2D
Language

These details are fetched by API and are then taken to servers associated different movie theatres to bring back the collected response from multiple third-party servers. Providing user the convenience of choosing which theatre fits best? This is how different applications interact with each other.

Instead of making a large application and then adding more functionalities via code in it. The present times demand for Micro Service Architecture wherein we create multiple individually focused modules with well defined interfaces and then combine them together to make a scalable, testable product. The product or software which might have taken an year to deliver can now be delivered in weeks with the help of Micro Service Architecture.

API serves as a necessity for Micro Service Architecture. Consider an application which delivers music, shopping & bill payments service to end users under a single hood. The user needs to login to the app and select the service for consumption. API is needed for collaborating different services for such application, contributing to overall enhanced UX.
API also enables an extra layer of security to the data. Neither the user’s data is overexposed to server nor the server data is overexposed to user. Say in case of movies, API tells the server, what user would like to watch and then tells the user what they have to give, in order to redeem the service. Ultimately, you get to watch your movie and the service provider is credited accordingly.

Did you know? Execute Playwright automated testing directly on the cloud, over powerful hardware, in an environment that scales effortlessly.

Difference between API Performance Monitoring and Application Performance Monitoring

As similar as these two terms sound, they perform distinctive check on the overall application connectivity.

Application Performance monitoring is compulsory for a high level analytics regarding how well the app is executing on integral front.
It facilitates a internal check on the internal connectivity of a software.
Following are the key data factors that must be monitored:
Server Loads
User Adoption
Market Share
Downloads
Latency
Error logging
API Performance monitoring is required to check if there exists any bottleneck outside the server, it could be in the cloud or load balancing service. These bottlenecks are not dependent on your application performance monitoring but are still considered to be catastrophic as they may abrupt the service for end users.
It facilitates a check on the external connectivity of the software, aiding its core functionalities:
Back-end business operations
Alert operations
Web services

Why API Performance Monitoring is a necessity?

1. Functionality

With the emergence of modern Agile practices, organizations are adapting a virtuous cycle of developing, testing, delivering and maintaining by monitoring the response. It is integral to involve API monitoring as part of the practice. A script must be maintained in relevance to appropriate and latest versions of the functional tests for ensuring flawless experience of services to the end user. Simply put, if your API goes south then your app goes with it. For Instance, In Jan, 2016, a worldwide outage was met by the Twitter API. This outage lasted more than an hour and within that time span, it impacted thousands of websites and applications.

2. Performance

Organizations are open to performance reckoning if they neglect to thoroughly understand the process involved, behind every API call. Also, API monitoring helps to acknowledge which APIs are performing better and how to improvise on the APIs with weaker performance display.

3. Speed/ Responsiveness

Users can specify the critical API calls in the performance monitoring tool. Set their threshold(acceptable response time), to make sure that they get alerted if the expected response time deteriorates.

4. Availability

With the help of monitoring we can realize whether all the services hosted by our applications are accessible 24×7.

5. Why monitor API when we can test it?

Well, an API test can be highly composite considering the large number of multisteps that gets involved. This creates a problem in terms of frequency required for the test to take place. This is where Monitoring steps in! Allowing every hourband check regarding the indispensable aspects. Helping us to focus on what’s most vital to our organization.

Did you know? In this Cypress tutorial, learn more about the Cypress test automation framework that is fundamentally and architecturally different from the Selenium test automation.

How to Monitor API Performance?

Identify your dependable APIs — Recognize your employed APIs whether they are third-party, partner APIs? Internally connecting or Externally?
Comprehend the functional and transactional use cases for facilitating transparency towards the services being hosted — improves performance and MTTR(Mean Time to Repair).
Realize whether you already are in possession of test cases required to monitor. Whether you have existing test cases that needs to be altered or is there an urgency of new ones to be developed?
Know the right tool — API performance monitoring is highly dependent on the tool being used. You need an intuitive, user friendly, result optimizing tool with everything packed in.

Some commonly well-known platforms to perform API performance testing are:

One more factor to keep a note of is API browser compatibility to realize how well can your API aid to different browsers. To know more about this topic follow our blog about API and Browser Compatibility.

Conclusion

API Performance monitoring is a need of modern times that gives you a check regarding the internal as well as the external impact of the services hosted by a product. Not everyone cares to bother about APIs but we are glad you did! Hoping this blog will help expand your understanding on the topic. Cheers!

Testing Challenges related to Microservice Architecture

Harshit Paul — Thu, 04 Aug 2022 11:31:49 +0000

If you are living in the same world as I am, you must have heard the latest coding buzzer termed MICROSERVICES — A lifeline for developers and enterprise scale businesses. Over the last few years, Microservice Architecture emerged out to be on top of conventional SOA(Service Oriented Architecture). This much more precise and smaller architecture brought in many benefits along with it. Enough to make the business more scalable in a fly by paralleling development, testing and maintenance across various independent teams. Considering how different this approach is from the conventional monolithic process, the testing strategies that apply are also different. With different testing strategies emerge different testing challenges.

If you are not already aware of what a microservice architecture is or how it could be tested? Then refer to our blog regarding How to test a Microservice Architecture Application.

By far everyone in the tech world is aware that Microservice Architecture is useful in delivering a more responsive and agile application. Some major organizations such as Netflix, Nike, Facebook, etc. have backed their performance on the basis of this architecture.

You can check out this Cypress test automation tutorial to learn the benefits of Cypress automation, and how to install Cypress and execute Cypress automation testing over scores of browsers and OS online.

Key challenges for Testing Microservices:

Integration Testing and Debugging

To write effective integration test cases, a quality assurance engineer should have thorough knowledge regarding each of the various services that software is delivering. Analyzing logs across multiple microservices can be very twitchy and mentally taxing.

Struggling Coordination

With so many independent teams working simultaneously on improving different functionalities, it becomes very challenging to coordinate the overall development of the software. For instance, it is tough to spot an idle time window for extensive testing of the entire software.

Decoupling of Databases

Each microservice helps to establish a single business capability and should have its own separate database. However, if that isn’t feasible then you may also know that in some applications, there may not exist a necessity for decoupling database. So a sound evaluation is required to judge which microservice needs decoupling and which doesn’t?

Re-Architecturing a software product

It can be very tiresome for a software architect to redesign the working of an application in accordance to microservices, especially if we are talking about an enterprise with gigantic and compound systems.

Complexity

Complexity of a software is directly proportional to the number of microservices that the product is either delivering or adding.

Performance tracing

If you are transitioning from monolithic to microservice architecture then large number of tiny components are bound to be generated. These components should communicate consistently. Performance tracing for business transactions could turn out to humongous.

Difficult to visualize after effects

Involving numerous distinctively functioning teams, requires a top notch interface for communication. If all interfaces aren’t properly updated in a software then it may doom the collaboration. It becomes very strenuous to consider the after effects of bringing any enhancement in the existing communication platform.

Increases Flexibility?

It is true that microservices provide developers the freedom to not be dependent on a specific programming language, increasing their flexibility. However, you would have to face the hassle of maintaining multiple libraries and database versions.

Cleaning up software libraries

As quoted by Fowler-Rigetti, “You have some script running on a box somewhere doing God knows what and nobody wants to go clean that up, They all want to build the next new thing.” With variety of developers from different microservice teams, there are numerous ways for performing a single action. Deploying custom scripts from different languages it happens very often that we forget about a certain piece of code. This results in recreating that feature by some other custom script belonging to some other language. Effective maintenance and management is needed to overcome this.

Prioritization

Having great number of microservices at your disposal it becomes vital to prioritize these services in terms of resource allocation. You cannot afford to launch unnecessary number of resources in a microservice team that is responsible for a relatively small functionality.

Did you know? Run your Playwright automated testing scripts instantly and execute testing in parallel and cut down your test execution time by multiple folds.

How to overcome such challenges?

Specific API endpoints- API endpoint must be provided by every microservice in order to communicate either synchronously or asynchronously with other microservices. These endpoints work on http verbs say get request, post request and delete request etc. Each Microservice has to let the other services know exactly what pattern should be followed, for appropriate routing of the request? Usually it is a REST endpoint for facilitating synchronous communication but it could also be a WSDL endpoint for facilitating asynchronous communication. The formats of these APIs have to published to other microservice teams so that they know how to connect to your microservice.
Once the routing is published and passed on to every microservice team, then a standardized communication takes place among the system. Boosting the efficiency of the integrated software.
Every microservice is responsible for its own data model. Ideally, each database model should be 100% decoupled from another. The idea behind this is to know what persistence model is needed for the team working on facilitating a single microservice?
Autonomous selection of technically sound staff for every microservice. Hiring effective developers, testers, quality analysts, business analysts and project managers will definitely bring you the key to success.
Not all microservices are bound to provide some form of UI. Some are there to support the integrated interaction such as middleware team.
Standardized development practices along teams calls for a bigger investment on platform basis. This is where cloud based providers come into the picture like AWS(Amazon Web Services), Heroku, Google cloud etc. Therefore, if you are planning a small scale organization and not envisioned to go for scalability anytime soon then you are better off microservice Architecture.
Make it a necessity to correlate calls with the help of various methods like IDs, tokens or headers. Also, when logging to locate a bug we need to make sure about correlating events across all platforms to avoid ambiguity in this stateless, independently distributed architecture.
DevOps need to be more integrated than they ever were. Security needs to be more robust and unbiased as the diversified structure provides hackers the opportunity to hit the soft target of your system.
Fault tolerance should be optimized and consistent monitoring must be performed. Effective use of caching would also help to speed up response time by reducing the number of requests that the software will aim to meet.
Also, if you are planning on developing a feature to aid your respective microservice. You need to make sure that it doesn’t affect the functionality that is being delivered by some other microservice team. Your enhancement must support the entire pre-existing functionality of the application.

Did you know? A reliable, scalable, secure, and high-performing Selenium online test execution cloud that empowers development and testing teams to accelerate their release cycles.

You need to have excellent monitoring tools to display the working of your software. Effective logging and documentation may seem exhausting but are indispensable for software maintenance and enhancement. We don’t intend to criticize microservice architecture, however, we want you to be aware of them in detail before it gets deployed into your organization. The microservice architecture will definitely boost the scalability of your business development, bringing a top-notch product to the market. All you need is a little precaution regarding the pros and cons of its implementation. Remember, prevention is better than cure!

What is a WebView And How To Test It?

Harshit Paul — Wed, 03 Aug 2022 14:00:47 +0000

Convenience is something that we can never be fully satisfied with. This is why software developers are always made to push their limits for bringing a better user experience, without compromising the functionality. All for the sake of saving the churn in today’s competitive business. People are greedy for convenience and this is why Hybrid applications have been so congenial in the cyber world.

What is so unique about Hybrid applications? Yeah, that’s right. WebViews!

*Hybrid Applications *— As the name suggests they are a mixture of Native and Web Applications. They are available in application store for download and require set of access from device like native apps, but they also have a browser embedded in the application(WebView) for rendering HTML.
Instagram is a good example of a hybrid application.

Remember the time, when we wished to access any third party link; it used to open in a new browser on the device. Resulting in, moving us out from the application where we were intended to work on. A disaster to User Experience which was resolved by facilitating an in-app browser window for facilitating third-party web pages as part of activity layout. Kudos to WebViews!

Did you know? Execute your Playwright Automated Testing directly on the cloud, over powerful hardware, in an environment that scales effortlessly.

Why do you need WebViews?

It provides a better control over your application’s UI.
You don’t have to make an update on the entire application, if you wish to bring an update over your app content. Say, you wish to publicise about an upcoming sale on your application or some other exciting offer.
You don’t get pushed onto another 3rd party application, rather an in-app browser pulls the content from the web for you. With the convenience of staying in the intended application. Take Instagram for an instance, where you need to swipe up in some stories and you are redirected to a webpage through a in-app browser, rather than opening the content in chrome, safari, firefox or any other browser. You can navigate the content freely on the redirected webpage by scrolling up/down, zooming in/out or searching for a text.
Webviews allow cross-platform development resulting in reduced development cost, along with flexibility to a developer.
Note: We cannot make a single build of an application to work on multiple OS though.
We can only ease the development of another build with the help of web extension through HTML, CSS, Javascript etc
Companies often aim to build a wrapper application of an existing webapp. By doing so companies aim for creating a presence in the application stores with comparatively less endeavour. Also, frameworks like Ionic allows you to transit an application on the app store, and deploy to the mobile web as a PWA

For generating a WebView, a developer you need to:

Develop an instance of a webview class
Embed a browser in your application
Add browser functionalities with the help of WebView Library
Add internet permission in the Android Manifest file
Add the code for WebView to open in-app browser.

WebView Testing- Refers to creating and executing test cases for checking the effective working mechanism of WebViews.

Did you know? Test Selenium online in parallel and cut down test execution by more than 10x.

Keep a note of the following while testing Webviews:

Verify if the application is responding according to its intended behavior by interrupting the webpage from loading.
If your content is including hyperlinked email addresses in the Webview then make those hyperlinks are opening mail application in your device when tapped.
Test similarly for a hyperlinked phone number, whether it is routing user to dialer app or not? Also, how is that hyperlink responding if a SIM is not inserted in the device.
Test the response of WebView in different network modes — 2G, 3G, WiFi, LTE .
Special characters should be also be tested. Along with zooming in/out , navigating the web content by scrolling up/down or navigating the screen left/right.
Test the tolerance of WebView against external factors like SMS, signal drop, notifications, call etc.
Test the behaviour of your application when an external application is launched by a hyperlink from your web content.
Vary orientation of your device and test your web content is able to support them.
Test if the graphic display is satisfactory.
Compress the browser window and see if the text is being compressed appropriately.
A cross browser platform will be very helpful in testing the above-mentioned tips to test. It will also provide an idea as to how your WebView is being portrayed to the targeted audience.
Learn how to perform cross browser testing with LambdaTest.

Did you know? Analyze detailed Selenium testing tools to help you debug on the go.

How to perform WebView Testing?

Espresso-Web for Android WebView — **This tool helps in examining and controlling the behavior of WebView UI components by reusing **Atoms from the WebDriver API. It is one of the most common tools used for testing hybrid applications.
It is required to check the Integration of an application’s native UI components and its WebView UI components.

Before using Espresso-web, you need to thoroughly analyze the source code of your website for determining hooks for its methods. This is why it could become very complex for compound websites.

Alternative approach

A different approach would involve forgetting the third-party code and focusing only on the Android. Basically, a WebView maps elements of a website; allowing users to interact with them through Android View objects and their extensions. These views don’t have an ID making them inaccessible with findViewById(int id). You can neither access these IDs in your application package.

That doesn’t mean that you can’t track them. You can with the help of Android Device Monitor — A standalone tool for providing a UI to aid multiple Android application analysis and debugging tools.

You need to take a snapshot of every screen on an emulator with Android Device Monitor.
Acknowledge how the WebViews are internally structured.
Perform actions on them with the help of UiAutomator.

This approach won’t require you to analyze the source code. Acknowledge the screens and adjust accordingly. This way requires less effort in establishing and maintaining. Well, now you know an alternative to Espresso-web.

So now if somebody starts a conversation on WebViews and throws the ball is in your court — I hope you will be able to smash it. Cheers!

How to Test a Mobile Website Using LambdaTest

Harshit Paul — Tue, 02 Aug 2022 11:10:00 +0000

By far, I am sure we have all witnessed an increase in the usage of mobile web browsers. According to StatCounter, there has been a noticeable incline in mobile and tablet users. By April 2014, 30% of web traffic was incoming through mobile users, and the percentage has been elevating ever since.

In today’s competitive world, where digital discovery is more mobile-centric, responsiveness comes as a requisite.

InVision quoted in one of their blogs:

”Responsive design is no longer a luxury, but a necessity.”

With great audience comes great responsibility, this is true when we talk about quality assurance. Although mobile website testing is not a new topic, and you will find it as a staple of all QA checklists.

Wondering why?

The bounce back rate of users is so elevated, you need an extra edge to your website for attracting more publicity and traffic towards it. RWD (Responsive Web Design) plays an indispensable role in it.
RWD — Responsive Web Design
A method of allowing your web pages to render through multiple devices or screen sizes without compromising the overall functionality. Devices could be a tablet, desktop, notebook or a smartphone. LambdaTest as a cross browser testing tool provides you an effective way of testing responsiveness of any website through various screen sizes.
With inclining numbers of users on mobile users, one should be certain about delivering a positive UX experience through their mobile website. By delivering a mobile-friendly website you are aiming for:

Exceeding search visibility
1. Enhancing your brand value
2. Enhancing User Experience as well as User Interface
3. Elevation in lead nurturing
4. On April 21, 2015, Google revolutionized SEO, by releasing a new mobile-friendly ranking algorithm. This algorithm gave preferences to mobile-optimized websites and came to be known by many names such as Mobilegeddon, mobocalypse, mobilepocalyse. So if your website is not providing a quality mobile UX, then brace yourself for the fall in SERPs.
5. On November 04, 2016, Google Webmaster posted came out with the concept of Mobile-first Indexing. Here, they stated: > Although our search index will continue to be a single index of websites and apps, our algorithms will eventually primarily use the mobile version of a site’s content to rank pages from that site, to understand structured data, and to show snippets from those pages in our results.

Did you know? Run end-to-end tests on a blazing fast Cypress automation test execution cloud. A reliable, scalable, secure, and high-performing test execution platform built for scale.

Getting started with Mobile Website Testing

Here is what you need to consider:

Whether the website is looking impressive on every device.
Ofcourse you need to check if there are any bugs existing in it.
Is the website loading pages at an efficient speed.

Remember, speed is the key! If users won’t get that from your website then it won’t take them long to rush to your competitors

Validate your HTML and CSS issues with the help of Chrome Developer tools.

*Cross Browser Compatibility *— Flex, JavaScript, Applets, AJAX requests, Flash and many more client side components may behave differently on different web browsers with respect to their rendering engines. The process of testing whether website works consistently without any dependencies in feature delivery on various browsers through different OS is termed as Cross Browser Testing. Follow our blog on performing cross browser testing through LambdaTest.

*Device Testing Labs/Clouds *— These labs are a collection of real mobile devices, providing you a diverse mobile device testing experience. Once you test on real devices then you know for certain that your product is working as intended. However, maintaining such a library of mobile devices requires a heavy investment. For Instance, AWS Device Farm is offering 3 levels of pricing:

Start your real device farm testing today.

$0.17 per device minute, with first 1,000 minutes free.
Unlimited testing, starting from $250/month.
Private devices (test on dedicated devices deployed exclusively for your account), starting from $200/month.

You may refer to this blog to know more about Device Testing Clouds.

What if you are not interested in paid options? Well, then it is time for you to turn from Device Testing Labs to Emulators and Simulators.

*Android Emulator and iOS Simulator *— They include default web browsers for figuring a valuable approximation regarding your website’s performance and appearance. You can’t have exact statistics related to page loading time or performance under real network scenarios. Other than that, they are pretty viable for mobile testing. You can perform both Mobile Emulator Testing and Mobile Simulator Testing for free at LambdaTest without being hassled by the thought of setting up VMs or worrying about licenses. You can also go for a responsive design checker such as LT Browser to check the mobile view of website.

Did you know? Exponentially increase your browser coverage by running your scripts for Selenium online.

In the end, it is all about SPEED!

On July 09, 2018, Google Webmaster updated the mobile search ranking using page loading speed. They stated:

The “Speed Update,” as we’re calling it, will only affect pages that deliver the slowest experience to users and will only affect a small percentage of queries. It applies the same standard to all pages, regardless of the technology used to build the page. The intent of the search query is still a very strong signal, so a slow page may still rank highly if it has great, relevant content.

Well if you aim to increase the responsive of your website, the page loading time is bound to increase as well. Because of the multiplication of assets included to facilitate a better UI and UX. How to cope up with them?

RESS — Responsive Web Design + Server Side Components

merges Server Side Components with the Responsive web layouts. This method is not intended to focus on a full page optimization, it dynamically loads the content in accordance to the specific device on which the website is being rendered upon. So if you are using a mobile phone with smaller screen resolution, then you don’t need a full size desktop image where you have to scroll your way to the desired content.

Prioritize on eradicating known issues to ease user convenience. Also, make sure to do a Regression test after every deployment. Follow our blog on Regression Testing strategies of mobile web pages.

Finding issues and bug logging is tedious but crucial. LambdaTest being cloud-driven product, provides you integrations with multiple platforms for hastening the release process:

ASANA
SLACK
JIRA
TRELLO
GITHUB
VSTS
GITLAB
BITBUCKET
LambdaTest WordPress Plugin: This plugin allows users to take screenshots of web pages. Users can then post those screenshots directly from the WordPress platform with a single click

Did you know? Analyze and dive into the detailed Selenium tests logs and Selenium testing tools to help you debug on the go.

That is all!

That just about sums up the basics of mobile website testing. Now you know why we should test mobile websites and how? What you also know is that LambdaTest is an all-in-one stop for it. Become an insider and test for yourself. Happy Testing!

Common Challenges Faced During Website Automated Testing

Harshit Paul — Mon, 01 Aug 2022 11:47:03 +0000

Automation is the need of the hour and is probably going to help you in the long run! Considering the huge number of competitors for every product, widespread adoption of Agile development is demanding automation everywhere in the IT world — in order to reach the pinnacle stage. With everyone planning on deploying automation into their organization, I thought of addressing the challenges faced while Automated Website Testing!

What is Website Automated Testing?

It is a process involving automated tools to perform testing on a website to evaluate the website’s efficiency. These automation tools are there to make sure that every element of a website is tested with fewer resources and time. They do so with the help of a customizable as well as a reusable test suite. Website testing automation helps in delivering your product with consistency to the end-user by well organizing the workflow.

Did you know? Start testing your native mobile apps using our capable mobile app emulators online.

Why should we perform Automated Website Testing?

By far, we are all aware of the popularity of Agile Methodology for software development. Automated Website Testing brings true relevance to the term ‘agile’ by hastening your iterations or sprints.
Cloud Computing Software is vastly dependent on automated testing tools. The reason is that the resources shared on the cloud are supposed to be accessible by anytime, anywhere, and by anybody with an internet facility. So testing whether your software is working as intended all day & everywhere could not only be very tedious and faulty if done manually. But it could also be highly time-consuming.
Regression testing is made considerably effortless with the help of automated scripts.
The tools used for automation ensure 100% code coverage. This makes sure that the website stays robust in terms of functionality.

**Did you know? Accelerate your release velocity with blazing fast test automation on the cloud. **

Myths related to Automation

*You can deploy 100% fully automated testing! *— These scripts are written by a human; there is only a limit to how far-sighted one can be! Doesn’t matter how tremendous testers are working under your firm. They can’t predict all the possible test cases required to call a software 100% bug-free.
*Just Record and Playback. That is all there is to it! *— Many automation tool vendors advertise, mentioning us to just record and playback for automating the testing process through their tool. But that isn’t true! The real automation starts after the playback once you have the idea regarding the test script being generated by the tool.
*Automation Testing is going to substitute Manual Testing! *— Since 100% automation is an impossibility, manual testing will always be irreplaceable. The point of automation testing is to allow testers the time to look for loopholes in the system manually and think of better test cases. Manual testing can never be trivialized, and here are some reasons for which manual testing is still prevailing.

In this article, take a look at what is Regression testing, its importance and types, and how to perform it. Read more!

Challenges faced during Website Test Automation.

*Which tool to go for? *— Website Test Automation is highly tool-dependent. There are plenty of options available to choose from in the market. It is relevant to evaluate and find a tool that fits your budget and business needs.
*How much to automate? *— You cannot automate everything! So you need to plan thoroughly regarding which process to automate and up to what level. This needs to be coordinated with DevOps.
*Parallel Execution *— of multiple test cases is usually not viable. Even when viable, then bug logging and debugging become a strenuous task.
False Positives and False Negatives- A false positive is a scenario where the system is fundamentally working fine, but the automation scripts show otherwise. This could cost a tester a huge amount of his time and money to find something which doesn’t even exist. Vice-versa, a false negative is a scenario where the automation script declares the system to be working fine when in reality, it isn’t! This happens if the initial stage of a database is inaccurate or if test environment settings are abrupt due to network issues.
*Web elements with undefined IDs *— Web Developers often miss out on providing an ID to every web element. If IDs aren’t declared properly to web elements, then it takes time for an automated script to find these web elements. If they are not found in a significant amount of time, then it leads to failure. So, ID allocations are a must for better script synchronization. Although a no-brainer still needs mentioning, there shall be no duplicating IDs on DOM.
*Quality manual test cases are the fuel for quality automation testing *— Out-of-the-box thinking is required from a tester who is writing these scripts. You need to think from the perspective of every end-user that will be utilizing your product. Make use of appropriate validation checks at the right places!
*Staff selection *— You need technically sound resources with a thorough understanding of the business process. A vast understanding of the respective development language is a prerequisite for every resource working on automation testing.
*Maintenance *— Automation does allow reusability of test scripts but considering the lightning changes that are consistent with Agile methodology. Maintaining the test tools along with test scripts can be very exhausting.
**Cross-browser Compatibility Testing **— If you are having a compound website, then there will always remain some test cases that won’t get proper rendering in all web browsers. A manual approach is best suited for cross-browser testing to realize which Browser/Version/OS/Device your website is unable to deliver its intended functionality. At LambdaTest, you can check for cross browser compatibility from 2000+ browsers and their versions.
*Dynamic GUI content *— As it is ever-changing in accordance with the demands of time and business. Frequent changes may lead some scripts to fail.
*Anxiety! *— Although automation is believed to be time effective, that also depends upon the number of test cases. In the humongous website, it can even take a day or more for an automation test script to declare whether everything is working as intended!

I understand how eager we all are to bring automation to most of our business-related processes. Being the latest buzzword, everyone seems to be rushing towards its implementation to improve their business efficiency. Will Automation help improve business efficiency? Yes. Is Automation the only way to improve business efficiency? No! There are many other ways of going around it. Consider automation as one of the tools available in your garage. You need to be aware of how to use that tool to tune your car up to shape. Just keep in mind the above-mentioned challenges and consider yourself well equipped for website automation testing.

Testing your Website using Apache Test Environment

Harshit Paul — Fri, 29 Jul 2022 13:53:34 +0000

Launched in 1995, Apache Web Server has been the subject of discussion regarding the most popular web server on the internet. The name in itself is said to have rewritten history. Apache was derived from a very well-known Native American Indian Tribe who were feared and respected for their superior skills related to warfare strategy and everlasting durability.

What is Apache Web Server?

The most widely used open-source, cross-platform web server is meant for hosting one or more HTTP-based websites. It is free to download and is considered to be a reliable platform by the majority of internet consumers on a global scale. By Nov 2013, it was responsible for running 67% of all web servers around the globe. Though right now, that popularity is steadily decreasing.

Apache is developed and maintained by an open community of developers under the auspices of the Apache Software Foundation. Its official website→ httpd.apache.org

The software is available for the below-mentioned OS:

Unix
FreeBSD
Linux
Solaris
Novell Netware
OS X
Microsoft Windows
OS/2
TPF
OpenVMS
eComStation

Key Features:

Supports numerous programming languages.
Provides an authentication mechanism for user log in.
Facilitates Database Support.
Supports Server Side Scripting.

With the gradual passage of time the popularity of Apache has been slowly fading. The major reason behind that is Nginx.

According to the above statistics presented by W3Techs.com it is notable that Nginx has developed an eminent place in the WWW.
Some popular sites using Nginx are:

WordPress.com
Pinterest.com
360.cn
Twitch.tv
Mail.ru
Csdn.net

Did you know? Online Test Automation Platform accelerates your release velocity with blazing fast test automation on the cloud.

Wondering about which web server are you using?

The answer to that lies on your website’s HTTP header. Although, it is not always visible.

You may view the website’s HTTP header by using the Network tab inside the Chrome Dev Tools or you can also go for tools like a Pingdom, GTmetrix, etc.

This method is not feasible if you are using Cloudflare or any other similar service provider.

Start testing your native mobile apps using our capable mobile app emulators online.

Fixated on using Apache? Then first setup local apache environment.

Service providers like XAMPP, LAMP, WAMP have made it all too easy to deploy an Apache web server for hosting your locally stored website.

Step 1 → Download XAMPP → https://www.apachefriends.org/download.html

Step 2 → Start the installation and provide a directory for the same.

Installation may take up a couple minutes. This is how it would look like once the setup is complete. Click Finish.

Step 3 → You will get a window for selecting a language. Hit Save on your preferred one.

Step 4 → After selecting a language, XAMPP would open up. You need to hit Start on Apache and that’s it! You will have Apache running.

Step 5 → Go to your browser and type http://127.0.0.1 or http://localhost:80 to verify Apache web server hosting by XAMPP by visiting dashboard.

Local Hosting a Website through XAMPP

I will be demonstrating this with the help of Roadside template.

Step 1 → Head to the Roadside template’s link and download it.

Step 2 → Extract the download folder into XAMPP(root directory) → htdocs

Step 3 → Run Apache on XAMPP.

Step 4 → Go to your browser and enter in the URL → localhost/roadtrip.

Note the reason I am mentioning roadtrip after localhost is because that is how I named the template’s folder in my htdocs. If you have come up with some other name say “roadtrip-template” then your URL would be → localhost/roadtrip-template.

Now that your website is hosted you can go on ahead and make changes into its source code using any text editor. Notepad++ and Sublime Text are my personal favourite.

To check the back-end functionality of your website then, you will have to start MySQL along with Apache under XAMPP Control Panel.

If you are not willing to use XAMPP then you can **download and install Apache from **Apache Lounge.

Step 1 — Once you are on the website, then download either 32-bit or 64-bit, depending upon your windows server setting.

I will be using a Apache 2.4.34 Win64 for this tutorial.

Step 2 — Extract the downloaded zip file. Extract it in the location of your server.

Step 3 — Configuring Apache

Locate the “httpd.conf” file and open it in any standard text editor.
If you extracted Apache at any other directory than the default C:\Apache24 then you ought to update the configuration file accordingly.
ServerRoot C:/Apache24 → ServerRoot D:/Apache
DocumentRoot C:/Apache24/htdocs →DocumentRoot D:/Apache/htdocs
Directory C:/Apache24/htdocs> →Directory D:/Apache/htdocs
ScriptAlias /cgi-bin/ C:/Apache24/cgi-bin/ → ScriptAlias /cgi-bin/ D:/Apache/cgi-bin/
You would also need make the following modification in the configuration file.
Options Indexes FollowSymLinks →Options Indexes FollowSymLinks ExecCGI
Remove the # symbol at the start of this line to uncomment: AddHandler cgi-script .cgi
Also add the line, AddHandler cgi-script .pl
At the End of File you must add this line ScriptInterpreterSource Registry

Step 4 — Launch Apache by going into the extracted directory. → Apache → Bin → Open Powershell here or Open Command Prompt here(Shift + Right click)

Step 5 — Test if your Apache is running by typing http://127.0.0.1. You should get the below mentioned response:

In this article, take a look at what is Regression testing, its importance and types, and how to perform it. Read more!

Test Your Locally Hosted Websites and Webapps using LambdaTest

If you are looking for something simpler than XAMPP to serve your purpose of testing on an Apache test environment, then let me inform you about LambdaTest.

LambdaTest provides you a feature to test your local page testing using the tunnel hosted through LambdaTest cloud servers. You can perform testing on simple and plain HTML, CSS, Python, PHP, etc., and similar web files that are stored on your local system.

Performing real-time interactive cross-browser testing is not only easy but is also helpful in figuring out whether the new feature is supported through multiple browsers prior to launching it into your Production environment.

If you notice, I was able to set up this template in Lambda Tunnel under 50 seconds/minute. I could also check how the template would appear on a different browser on a different OS.

Become an Insider and try Lambda Tunnel for free by registering on our website.

What Is Holding A Software Tester From Finding Bugs?

Harshit Paul — Thu, 28 Jul 2022 13:52:00 +0000

Every major product on the internet is trying to expand its reach to its full potential by accomplishing the goal of Web Interoperability. Which various Web technologies on the World Wide Web should be compatible with one another. Also, the technologies should be accessible through any hardware and software. Facilitating Web Interoperability has been a major impediment for Software testers as they play a key role in ensuring the quality of a web app. Although, recently, automation and machine learning are dawning upon the IT world and are overshadowing the role of testers. Especially if we refer to manual testing. We often underestimate the scope of manual testing, assuming that automation is going to take over everything. This is a big misconception. The point of automation is to save testers the time to write better and more efficient test scripts. Manual testing is going to prevail in the industry.

Automation Testing and machine learning are bringing along a lot of promising opportunities to a tester who is open-minded and attentive towards it. However, the implementation of AI has also imposed one to think about how efficient have humanly been so far in testing software.
What exactly were we doing wrong as humans while testing? Why were we not able to deliver a better quality assurance in spite of being more experienced and knowledgeable than a machine?

Deep down we all know the answer to these questions but i am still going to be a little blunt about them.

Unable to come up with enough User Stories Scenario

User Stories — A term that is made popular with the adoption of agile scrum. User Story is basically putting yourself in the shoes of the customer and think why he would use your product and to what purpose?
An example would be, I am a software developer and I want a tool for cross browser testing. To ensure that my device stays compatible when summoned through different browsers, devices with different screen sizes.
Back to the point, Agile software development demands for pace and somewhere while coping up with that pace we fail to consider important User Stories as we rush in deploying our software in the market asap.

Did you know? Here’s a free online character count tool that allows programmers to calculate the length of any given string of text or numbers in order to check the total number of characters (including spaces) there are in the string.

Distinguish between Checking and Testing

Testers focus on checking the app’s basic functionality but often neglect real time appearance of the application to an end user might.

This is where the relevancy of different types of modern testing steps into play.

*Accessibility Testing *— To make sure your software is accessible to all, including people with special disabilities.
*Usability Testing *— Testing of a website for its usability concerning user satisfaction.
*Exploratory Testing *— A testing approach that includes simultaneous learning, test designing, and test execution.
*Regression Testing *— Testing the whole application after any new change has been made. The idea here is to check that the new change is not disrupting any of the pre-existing functionality.
With digital discovery being more mobile-centric, it is crucial that you be ready for mobile web pages with regression testing.
*Cross Browser Testing *— Testing to ensure that your web app is operable through different browsers across various devices with different screen sizes.

It is vital that you stick to different contemporary testing strategies.

Here’s an article to help you get started with what is Regression testing, its importance and types, and how to perform it.

Assuming Test Cases are all you need!

Software testing is dependent upon test cases. With successful test cases, we assume that our product is maintaining a good quality, but that’s not always true. Just because test cases provide a count doesn’t mean that they guarantee quality. Don’t go by numbers.
Ever heard of a parent using parenting cases or a pilot who opts from pilot cases?

Test cases are there to maintain a tally, but you can’t blindly rely on them. Testing is a process that involves continuous learning and adaptation. So you need to explore the product outside your test cases too.

Did you know? This CRC32 hash generator lets you quickly generate the CRC32 checksum hash from a given string. In addition, you can generate CRC32 hashes via your web browser.

Orthodox thinking

Probably the biggest flaw that has been in testing conducted by human is presuming a path according to what others tell them to. Walking on the same method in the same way as our ancestors have been doing. We fail to consider the pace at which the technology has been evolving, within a decade we have seen a trending transformation from a floppy disk storage being the only method to everyone moving to cloud. Advises regarding application of archaic methodologies won’t always going to work out. Rather, obsolete wisdom is only going to make you turn a blind eye towards a galvanizing and much more effective approach of conducting. Think out of the box on how you can engage into testing more efficiently.
Worried about commiting mistakes? Don’t be!

There is nothing wrong in commiting a mistake, it comes as a package of being human. However, to commit mistakes and fail to learn from them, makes it all futile. Success favours the bold so perform testing according to how you feel is correct and not how others tell you to. Learning from your failures is only going to make you more wiser.

In the end, i would like to comment on AI involvement in the testing industry. If you are worried that Automation testing is going to eliminate the need for manual testing, then don’t be! Innovativeness is a quality that is gifted to humans and probably isn’t something that machines are going to be capable of on their own. Nobody is certain as to how much automation can be brought into the testing domain. AI may boost your testing efficiency. However, the thought of a machine testing everything as well as a human could doesn’t quite comfort the thought process. How effective is it going to be? Card to that question will be revealed only by the hands of time.

For now, we need to note the following for bringing out the human potential to its full extent.

Be empathetic towards the end user, and organize your testing around it.
Simply checking if the application is working functionality isn’t enough.
Don’t just count on Test cases.
Think exceptional and let archaic thinking be in archives.
Perform contemporary ways of testing thoroughly.

Testing is not as easy as it looks to other people. We realize how humongous and faulty it can be as a process. However, the right amount of perseverance and extensiveness will definitely help in delivering it with brilliance.