Getting Started with MongoDB Testing Using Selenium WebDriver

How to set up MongoDB with Selenium?

MongoDB’s NoSQL architecture pairs seamlessly with Selenium’s web automation capabilities, offering a dynamic approach to managing test data. In this section of the MongoDB testing tutorial, I will walk you through the steps to set up MongoDB with Selenium, including installing MongoDB and MongoDB Compass and creating a sample MongoDB database using Compass.

Installing MongoDB

When writing this blog on MongoDB testing, MongoDB version 6.0.6 is available. However, the Klov server we will use in this blog is incompatible with that MongoDB version. Hence, we will install MongoDB version 5.0.17 on Windows for this exercise.

• Go to this link: https://www.mongodb.com/download-center/community/releases/archive.
• Locate the entry, mongodb-windows-x86_64-5.0.17.zip. Download and copy the zip file to C:\MongoDB. Extract it.
• Let’s create a data folder for MongoDB to store data. Create folder structure as C:\MongoDB\data.
• We are ready to start MongoDB. Go to the extracted folder. Go inside the bin folder. Start CMD from this path.
• Run the below command. mongod –bind_ip_all –port 27017 –dbpath C:\MongoDB\data

Note: –bind_ip_all flag is required if MongoDB installed is on Windows to avoid connectivity issues. The default port is 27017. So even if it is not passed explicitly, that’s fine.

Command output would look something like this.:

Installing MongoDB Compass

MongoDB Compass is the UI client for MongoDB, where we visualize our data. We can interact with data using full CRUD functionality. We can run ad-hoc queries. We can also view and optimize the query performance. It is available on Linux, Mac, or Windows. Compass empowers us to make smarter decisions about indexing, document validation, and more. For this exercise, we will use Windows Server 2016; the steps might differ if you are using any other OS.

• Let’s now install ‘MongoDB Compass’. For this exercise, try to install it on the same machine where MongoDB is installed.
• Open Windows Powershell.
• Go to the location where MongoDB was extracted. Go to the bin folder. Locate Install-Compass.psl. Run Install-Compass.psl script from Windows Powershell. Sometimes, while running the script on Windows, it gives an error such as ‘PowerShell script is not digitally signed.’. To avoid this, first run the below command from powershell cmd. Set-ExecutionPolicy -ExecutionPolicy unrestricted
• Run Install-Compass.psl. This will install a MongoDB client.

Creating a sample MongoDB database using Compass

• Open the MongoDB Compass. It will launch the connect page, as shown below.

• Click on Connect. It will connect to the MongoDB server.
• Click on ‘+’ to create a new database. Give DB details to the database named ‘Demo’ as below and say ‘Create Database’.

• MongoDB Compass would create DB & would show a blank DB page as below.

Our MongoDB is set up!

Austin Siewert

CEO, Vercel

Discovered @TestMu AI yesterday. Best browser testing tool I've found for my use case. Great pricing model for the limited testing I do 👏

2M+ Devs and QAs rely on TestMu AI

Deliver immersive digital experiences with Next-Generation Mobile Apps and Cross Browser Testing Cloud

Sign up with googleSign up with Email

How to write a Selenium script to connect to MongoDB?

Let’s dive in and learn how to create Selenium scripts that establish a robust connection to MongoDB, unlocking possibilities for your MongoDB testing endeavors.

Code Setup

• Download the code from GitHub.
• Open the project in IntelliJ.
• In IntelliJ, use Java 11.0.2 as SDK and Maven 3.3.9.
• Project structure would look like this.

Code Walkthrough

<dependency>
    	<groupId>org.seleniumhq.selenium</groupId>
    	<artifactId>selenium-java</artifactId>
    	<version>4.8.3</version>
 </dependency>
 <dependency>
    	<groupId>org.seleniumhq.selenium</groupId>
    	<artifactId>selenium-api</artifactId>
    	<version>4.8.3</version>
 </dependency>
 <dependency>
    	<groupId>org.seleniumhq.selenium</groupId>
    	<artifactId>selenium-support</artifactId>
    	<version>4.8.3</version>
 </dependency>
 <dependency>
    	<groupId>org.testng</groupId>
    	<artifactId>testng</artifactId>
    	<version>7.7.1</version>
 </dependency>
 <dependency>
    	<groupId>io.github.bonigarcia</groupId>
    	<artifactId>webdrivermanager</artifactId>
    	<version>5.4.0</version>
 </dependency>

For Selenium and TestNG libraries, we have added below the entries into pom.xml.

For MongoDB Java drivers, the below library is added.

<dependency>
    	<groupId>org.mongodb</groupId>
    	<artifactId>mongo-java-driver</artifactId>
    	<version>3.12.13</version>
 </dependency>

Besides the above libraries in pom.xml, we have added Maven plugins to build the project.

<plugins>
  	<plugin>
    	<groupId>org.apache.maven.plugins</groupId>
    	<artifactId>maven-compiler-plugin</artifactId>
    	<version>3.8.0</version>
    	<configuration>
          	<source>${javac.version}</source>
          	<target>${javac.version}</target>
    	</configuration>
  	</plugin>
    </plugins>

Finally, Java version 11 has been set to be used for compiling.

<properties>
    	<maven.compiler.release>11</maven.compiler.release>
 </properties>

import com.mongodb.BasicDBObject;
 import com.mongodb.MongoClient;
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.MongoDatabase;
 import com.mongodb.client.model.Filters;
 import org.bson.Document;
 import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import org.openqa.selenium.By;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.chrome.ChromeDriver;
 import org.openqa.selenium.chrome.ChromeOptions;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;

Import statements: We need to import several libraries to accomplish our exercise.

connectToMongoDB(): Function to initialize and connect to MongoDB.

@BeforeClass
 public void connectToMongoDB(){
 	// Connect to MongoDB by giving {MongoDBHost}
 	mongoClient = new MongoClient("{MongoDBHost}", 27017);
 	// Get Database handle by replacing {MongoDBName} with DB name
 	database = mongoClient.getDatabase("{MongoDBName}");
 	// Get collection handle by giving collection name created in MongoDB.
 	test_execution_info = database.getCollection("test_execution_details");
 }

This function will initialize MongoClient and establish a DB connection with the MongoDB database and collection.

Provide the connection parameters to it.

{MongoDBHost}: IP Address of the machine where MongoDB is hosted.

Sometimes, we face issues binding to localhost on Windows. To avoid this, on the MongoDB host, open cmd and run ipconfig. Use the ‘ipv4 address’ as IP for connecting to MongoDB via script.

{MongoDBName}: Database ‘Demo’ created in earlier steps.

{MongoDBPort}: 27017

browserSetup(): Function to initialize browser setup.

private void browserSetup(){
 	WebDriverManager.chromedriver().setup();
 	ChromeOptions options = new ChromeOptions();
 	options.addArguments("--headless");
 	options.setBrowserVersion("109");
 	driver = new ChromeDriver(options);
 	driver.manage().window().maximize();
 	driver.manage().timeouts().implicitlyWait(120, TimeUnit.MILLISECONDS);
 }

We use WebDriver Manager to instantiate Chrome WebDriver instances. We will launch the browser in a headless manner.

Test1() and Test2(): Test methods

Let’s look at the two test methods, Test1 and Test2. These will perform simple checks on the LambadaTest application. It would also append test cases and test execution info into MongoDB.

@Test
 public void Test1(){

 	browserSetup();
  
 	// Create one MongoDB document to store test results of this test, Test1
 	doc = new Document("testname", "MongoDBTest 1");

 	// Lets append, some fields and value pairs into MongoDB document as below
 	doc.append("testname", "MongoDBTest 1");
 	doc.append("description", "Detailed description of a positive test, test 1");
 	doc.append("author","Guru");

 	//Login to Lambdatest demo url
 	driver.get(baseURL);
 	driver.findElement(By.xpath(enterMessage)).sendKeys("MongoDBTest MongoDB");
 	driver.findElement(By.xpath((getCheckedValue))).click();

 	// Lets set the test result accordingly into MongoDB document
 	if (driver.findElement(By.xpath(yourMessage)).isDisplayed()){
     	doc.append("status","PASS");
     } else{
     	doc.append("status","FAIL");
 	}
  
 	// Finally, Lets now insert document into collection
 	test_execution_info.insertOne(doc);
 }

In Test1(), we first create a document by passing the document and test names. We can then append details in key-value pairs. Once a pair of values is appended, we insert that document into the MongoDB collection at the end.

@Test
 public void Test2(){

 	browserSetup();
  
 	// Create one MongoDB document to store test results of this test, Test2
 	doc = new Document("testname", "MongoDBTest 2");

 	// Lets append, some fields and value pairs into MongoDB document as below
 	doc.append("testname", "MongoDBTest 2");
 	doc.append("description", "Detailed description of a negative test, MongoDBTest 2");
 	doc.append("author","Geeta");

 	// Login to Lambdatest demo url
 	driver.get(baseURL);
 	driver.findElement(By.xpath(enterMessage)).sendKeys("MongoDBTest MongoDB");
 	driver.findElement(By.xpath((getCheckedValue))).click();

 	// Lets set the test result accordingly into MongoDB document
 	if (!driver.findElement(By.xpath(yourMessage)).isDisplayed()){
     	doc.append("status","FAIL");
 	} else{
     	doc.append("status","PASS");
 	}

 	// Finally, Lets now insert document into collection
 	test_execution_info.insertOne(doc);

 }

otherCRUDOperations(): This method showcases how different CRUD operations can be performed on MongoDB.

@Test
 public void otherCRUDOperations(){

 	// Create one simple test & append its result into MongoDB
 	doc = new Document("testname", "MongoDB update test");
 	doc.append("testname", "MongoDB test");
 	doc.append("description", "Some description");
 	doc.append("author","Gopal");

 	//Some test steps here
 	//Some test steps here
 	//Some test steps here

 	doc.append("status","PASS");

 	test_execution_info.insertOne(doc);

 	//Now Lets update the record of same document

 	//Retrieve the id of that particular document
 	ObjectId docId  = doc.getObjectId("_id");

 	//Construct a MongoDB query where id is equals to particular id. Using Filters we can construct desired query
 	Bson query = Filters.eq("_id", docId);

 	//Create a set of values to be updated,
 	BasicDBObject set = new BasicDBObject("$set", new BasicDBObject("testname", "MongoDB test Updated"));

 	//This method will first execute the query. It would then update first record (of search results) with below set of values
 	test_execution_info.updateOne(query,set);

 	//We can also delete the document
 	test_execution_info.deleteOne(query);
 }

After updating connection details, execute the script via IDE.

Once the test is executed, go back to MongoDB to check the test execution data.

As we can see below, data has been populated into MongoDB.

Let’s rerun the same test class to see how new execution data is getting appended into MongoDB.

We can see below MongoDB has inserted data for the next run. Since MongoDB assigned an object id for every record, it becomes easier to track historical data. We can use this historic execution data to build new reports or apply analytics.

So, this is how we can interact with MongoDB via Selenium scripts. MongoDB can help testers build test scripts that are resilient to any change. We can even build reports from scratch by leveraging MongoDB documents and collections.

Let’s now take an example of one third-party test automation reporting tool leveraging MongoDB to build sophisticated test automation reports.

Note: Automate your test scripts with Selenium on the cloud. Try TestMu AI Today!

Third-Party Reporting Tools with MongoDB

As some might be familiar, Extent Report is one open-source reporting library useful for test automation. It can be easily integrated with major test automation frameworks like JUnit, TestNG, JGiven, etc. These reports have pie chart representation, test stepwise report generation, screenshots for failing test cases, etc. Due to a good, presentable user interface, these reports can be shared with all stakeholders.

Extent reports have gone one step ahead and leveraged MongoDB to build a real-time analytic report server called ‘Klov’.

What is Klov?

Klov is a reporting server for extent reports. It provides a detailed analysis of our most recent builds. It enables us to leverage historical data to analyze how tests have performed against AUT (Application under test). It works with the Extent Report Library to push data into a MongoDB instance. And then, these reports are published on the Klov server.

To use the Klov server, we should use extent reports in our tests. Let’s see how we can rewrite the earlier test using Klov for MongoDB.

How to set up Klov?

Installation of Klov is very simple. As the community version is Docker-based, we must deploy the container image to Docker.

Installing the Docker Engine on a CentOS machine

• Uninstall any older versions of Docker before attempting to install a new version. sudo yum remove docker \

• Set up the rpm repository. sudo yum install -y yum-utils

• Install the Docker Engine. sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

• Start Docker. sudo systemctl start docker Verify that the Docker Engine installation is successful by running the hello-world image. sudo docker run hello-world

Installing Klov image

• Download the Docker-compose.yml file to install the Klov image. Run the below command. curl https://raw.githubusercontent.com/extent-framework/klov-server/master/docker-compose.yml -o docker-compose.yml

• Open the yml file. Update the MongoDB connection details and the port where Klov will be hosted. version: '2' services: klov: image: anshooarora/klov:1.0.1 container_name: klov environment: - SPRING_DATA_MONGODB_URI=mongodb://{MongoDBHost}:{port}ports: - 80:80 In place of {MongoDBHost}, give the IP (ipv4) address of the Windows host machine where MongoDB is hosted (used earlier in the Selenium script). {port} would be the default MongoDB port, 27017.
• Start Klov. docker-compose up It should show a message such as “org.springframework.boot.StartupInfoLogger: Started KlovApplication in 9.266 seconds (JVM running for 10.14).”

• Open Klov at the $PORT you specified in docker-compose.yml or default:80. Give url as: http:///projects It would look something like this.

Changes required on the test project side for Klov

<dependency>
      	<groupId>com.aventstack</groupId>
      	<artifactId>klov-reporter</artifactId>
      	<version>5.0.2</version>
  	</dependency>

  	<dependency>
   	   <groupId>com.aventstack</groupId>
   	   <artifactId>extentreports</artifactId>
   	   <version>5.0.8</version>
  	</dependency>

import com.aventstack.extentreports.ExtentReports;
 import com.aventstack.extentreports.ExtentTest;
 import com.aventstack.extentreports.reporter.ExtentKlovReporter;
 import org.openqa.selenium.By;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.chrome.ChromeDriver;
 import org.openqa.selenium.chrome.ChromeOptions;
 import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import java.util.concurrent.TimeUnit;

@BeforeClass
 private void klovSetup(){
 	ExtentKlovReporter klov = new ExtentKlovReporter("LambdaTest");
 	klov.initMongoDbConnection("{MongoDBHost}",27017);
 	klov.initKlovServerConnection("http://{KlovHost}:{KlovPort}");
 	//Create an instance of ExtentReports.
 	extent = new ExtentReports();
 	// Attach Extent Reports to Klov Server. This will publish the Extent reports of all the tests of this class to Klov server
 	extent.attachReporter(klov);
 }

• {MongoDBHost}: IP Address of the machine where MongoDB is hosted. Same as earlier.
• {KlovHost}: CentOS machine hostname where Klov Docker image is hosted.
• {KlovPort}: Port where Klov Server listens as mentioned in the Docker-compose.yml file. By default, it is 80.

private void browserSetup(){
 	WebDriverManager.chromedriver().setup();
 	ChromeOptions options = new ChromeOptions();
 	options.addArguments("--headless");
 	driver = new ChromeDriver(options);
 	driver.manage().window().maximize();
 	driver.manage().timeouts().implicitlyWait(120, TimeUnit.MILLISECONDS);
 }

@Test
 public void Test1(){

 	browserSetup();

 	// Create entry for this test into extent report. By giving key details, such as Test name, description, author etc.
 	extentTest = extent.createTest("MongoDBTest 1", "Detailed description of test 1");
 	extentTest.assignAuthor("Guru");

 	// Log information about your test into the extent report
 	extentTest.info("Started with MongoDBTest 1");
     driver.get(baseURL);
 	driver.findElement(By.xpath(enterMessage)).sendKeys("MongoDBTest MongoDB");
 	driver.findElement(By.xpath((getCheckedValue))).click();

 	// Based on testcase checkpoints, append final execution status into extent Report
 	try {
     	Assert.assertEquals(driver.findElement(By.xpath(yourMessage)).isDisplayed(), true, "Message is not matched.");
     	extentTest.pass("PASS");
 	}catch(AssertionError e){
     	extentTest.fail("FAIL: "+e.getMessage());
 	}

 }

 @Test
 public void Test2(){
 	browserSetup();

 	// Create entry for this test into extent report. By giving key details, such as Test name, description, author etc
 	extentTest = extent.createTest("MongoDBTest 2", "Detailed description of test 2");
 	extentTest.assignAuthor("Geeta");

 	// Log information about your test into the extent report
 	extentTest.info("Started with MongoDBTest 2");
 	driver.get(baseURL);
 	driver.findElement(By.xpath(enterMessage)).sendKeys("MongoDBTest MongoDB");
 	driver.findElement(By.xpath((getCheckedValue))).click();

 	// Based on testcase checkpoints, append final execution status into extent Report
 	try {
     	Assert.assertEquals(driver.findElement(By.xpath(yourMessage)).isDisplayed(), false, "Message is matched.");
     	extentTest.pass("PASS");
 	}catch(AssertionError e){
     	extentTest.fail("FAIL: "+e.getMessage());
 	}

 }