DEV Community: Raghwendra Sonu

Using Multiple Browser Contexts in Playwright (With Real-Life Examples 🚀)

Raghwendra Sonu — Tue, 19 Aug 2025 01:47:19 +0000

When I first started using Playwright, one of the features that blew my mind was multiple browser contexts. It sounds fancy, but once you get it, you’ll realize how powerful it is.

Let’s break it down in simple words.

What is a Browser Context? 🤔

Think of a browser context as a fresh user profile inside your browser.

No saved cookies.
No cache.
No logged-in sessions.

Basically, a clean slate.

If you open Chrome in incognito mode, that’s very similar to a new browser context.

Why Do We Need Multiple Contexts?
Imagine you’re testing an e-commerce site.

👉 Scenario:
One user (Alice) adds an item to the cart.
Another user (Bob) logs in and checks out.

If you try to test this in the same browser window, it gets messy because Alice and Bob share cookies and login sessions.

But with multiple browser contexts, Alice and Bob can both use the same browser at the same time — and they’ll never know each other exists.

💡 It’s like giving every user their own private “incognito window,” but all managed in one Playwright script.

Real-Life Analogy 🏠

Think of a browser like a house.

A browser context is a separate apartment inside that house.
Each apartment has its own kitchen, bathroom, and furniture.

Just because you’re cooking in your apartment doesn’t mean your neighbor smells the food. Same for sessions in browser contexts!

Example Code 🧑‍💻
Here’s how you can do it in Playwright (JavaScript/TypeScript):

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch();

  // Create first context (Alice)
  const contextAlice = await browser.newContext();
  const pageAlice = await contextAlice.newPage();
  await pageAlice.goto('https://example.com');
  await pageAlice.fill('#username', 'Alice');
  await pageAlice.fill('#password', 'password123');
  await pageAlice.click('#login');

  // Create second context (Bob)
  const contextBob = await browser.newContext();
  const pageBob = await contextBob.newPage();
  await pageBob.goto('https://example.com');
  await pageBob.fill('#username', 'Bob');
  await pageBob.fill('#password', 'password456');
  await pageBob.click('#login');

  // Both users are logged in — in the SAME browser instance, but separate contexts!
  console.log('Alice and Bob are now logged in separately 🎉');

  await browser.close();
})();

Why This Is Powerful 💪

Parallel user flows → Test multiple users at once.
No interference → Sessions, cookies, and local storage are isolated.
Faster tests → Instead of launching a whole new browser, you just launch new contexts (lightweight and efficient).

Use Cases 📝
Testing chat apps (Alice messages Bob).
Testing multi-role apps (Admin vs. Customer).
Testing different geographies (set geolocation in each context).
Verifying isolated sessions (like different users in incognito).

Wrapping Up 🎬
Multiple browser contexts in Playwright are like having multiple incognito windows under one roof. They’re super handy for testing real-world user scenarios where different people interact with the same app.

So next time you need to test Alice vs. Bob, or Admin vs. User, don’t open two browsers — just open two contexts!

Real-life analogy to explain the concept of Spring.

Raghwendra Sonu — Fri, 19 Jan 2024 04:21:33 +0000

Imagine you are building a kitchen for a restaurant.

Tools (Beans):
In this kitchen, various appliances and tools are needed, such as a refrigerator, an oven, and a blender. Each of these tools is like a "bean" in the Spring framework.

Kitchen (Spring Context):
The entire kitchen, with all the tools arranged and ready to use are like Spring Context.

Cook (Developers):
The cook in the Kitchen are like developers. They are skilled individuals who use the tools (beans) to make food.

Getting the Right Tools for the Job (Dependency Injection):
When a Cook needs a tool e.g. Fridge or Knife (which is Beans), they don't build it from scratch; they take it from the Kitchen rack. Similarly, in Spring, you don't create objects from scratch; the Spring container provides the necessary beans to your application.

Arranging Tools (Configuration Metadata):
Just as you organize your kitchen by placing tools in specific locations for easy access, in Spring, you configure your beans using metadata (XML, annotations, or Java code). This metadata tells the Spring container how to create and manage the beans.

Tool Usage (Bean Lifecycle):
Just as you use tools in the kitchen when needed, Spring beans have a lifecycle. They are created, configured, and sometimes destroyed by the Spring container. It's like taking tools out when you start cooking and putting them back when you're done.

Special Tools for Specific Purposes (Scopes):
Some tools, like knives or cutting boards, are used throughout the cooking process (singleton scope). Others, like disposable plates, are used for a specific task and then discarded (prototype scope). Similarly, Spring beans can have different scopes based on their usage patterns.

Automatic Kitchen Setup (Annotation-Based Configuration):
Imagine if, as you buy new tools for your kitchen, they automatically find their place without you having to rearrange everything. In Spring, you can use annotations like @Component to automatically register beans without manual configuration.

Just as a well-organized kitchen makes cooking more efficient, Spring's organization of beans simplifies the development of Java applications.

Streams in Java?

Raghwendra Sonu — Thu, 18 Jan 2024 02:56:52 +0000

In Java, streams are a powerful and flexible abstraction introduced in Java 8 as part of the java.util.stream package. Streams provide a new way to process data in a functional and declarative manner. They enable developers to express complex data processing operations concisely and efficiently.

Common Operations on Streams:
Filtering:

List filteredList = myList.stream()
.filter(s -> s.startsWith("A"))
.collect(Collectors.toList());

Mapping:

List lengths = myList.stream()
.map(String::length)
.collect(Collectors.toList());

Sorting:

List sortedList = myList.stream()
.sorted()
.collect(Collectors.toList());

Reducing:

Optional concatenated = myList.stream()
.reduce((s1, s2) -> s1 + s2);

Collecting:

List collectedList = myList.stream()
.collect(Collectors.toList());

Grouping and Partitioning:

Map> groupedByLength = myList.stream()
.collect(Collectors.groupingBy(String::length));

Example of Chaining Stream Operations:

List result = myList.stream()
.filter(s -> s.length() > 2)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());

In this example, the stream is filtered to include only strings with a length greater than 2, then each string is converted to uppercase (so the map is used to do additional operation on the result returned from filter), the resulting strings are sorted, and finally, the result is collected into a new list.

Streams simplify the processing of collections in Java, providing a concise and expressive way to manipulate data. They are particularly useful when dealing with large datasets or performing complex data transformations.

Different ways of iterating an ArrayList ?

Raghwendra Sonu — Thu, 18 Jan 2024 02:41:16 +0000

In Java, there are several ways to iterate over an ArrayList, which is a dynamic array implementation provided by the Java Collections Framework. Here are some common ways to iterate through an ArrayList:

Using a Traditional For Loop:

ArrayList list = new ArrayList<>();
// Add elements to the list
for (int i = 0; i < list.size(); i++) {
String element = list.get(i);
// Process the element
}

Using an Enhanced For Loop (for-each loop):

ArrayList list = new ArrayList<>();
// Add elements to the list
for (String element : list) {
// Process the element
}

Using Iterator:

ArrayList list = new ArrayList<>();
// Add elements to the list
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
// Process the element
}

Using forEach() with Lambda Expression (Java 8 onwards):

ArrayList list = new ArrayList<>();
// Add elements to the list
list.forEach(element -> {
// Process the element
});

Using forEach() with Method Reference (Java 8 onwards):

ArrayList list = new ArrayList<>();
// Add elements to the list
list.forEach(System.out::println); // Example of printing elements

Using Streams (Java 8 onwards):

ArrayList list = new ArrayList<>();
// Add elements to the list
list.stream().forEach(element -> {
// Process the element
});

Using ListIterator (for iterating in both directions):

ArrayList list = new ArrayList<>();
// Add elements to the list
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
String element = listIterator.next();
// Process the element
}

Each of these methods has its advantages and use cases. The enhanced for loop and iterator are common and widely used. The introduction of streams and lambda expressions in Java 8 provides a more concise and expressive way to iterate over collections. Choose the method that best fits your specific requirements and coding style.

How to get data from Postgres DB as Java Map?

Raghwendra Sonu — Tue, 25 Jul 2023 01:19:16 +0000

In this post i will talk about how we get retrieve data from Postgres DB as map of list as well as list of maps in Java.

To fetch data from RDS as List of Map:

public List<Map<String, Object>> readResultSetAsList(String query) throws SQLException {
    System.out.println("query(" + query + ")");
    Statement queryStatement = connection.createStatement();
    ResultSet resultSet = queryStatement.executeQuery(query);
    ResultSetMetaData md = resultSet.getMetaData();
    int columns = md.getColumnCount();
    List<Map<String, Object>> rows = new ArrayList<Map<String, Object>>();
    while (resultSet.next()) {
      Map<String, Object> row = new HashMap<String, Object>(columns);
      for (int i = 1; i <= columns; ++i) {
        row.put(md.getColumnName(i), resultSet.getObject(i));
      }
      rows.add(row);
    }
    System.out.println("rows=====" + rows);
    return rows;
  }

To fetch data from RDS as Map of List:

public Map<String, List<Object>> readResultSet(String query) {
    System.out.println("query(" + query + ")");
    Map<String, List<Object>> resultList = null;
    try {
      Statement queryStatement = connection.createStatement();
      ResultSet resultSet = queryStatement.executeQuery(query);
      ResultSetMetaData md = resultSet.getMetaData();
      int columnCount = resultSet.getMetaData().getColumnCount();

      resultList = new HashMap<>(columnCount);
      for (int i = 1; i <= columnCount; ++i) {
        resultList.put(md.getColumnName(i), new ArrayList<>());
      }
      while (resultSet.next()) {
        for (int i = 1; i <= columnCount; ++i) {
          resultList.get(md.getColumnName(i)).add(resultSet.getObject(i));
        }
      }
      System.out.println("resultList=====" + resultList);

      resultSet.close();
      queryStatement.close();
    } catch (SQLException e) {
      Assert.fail(
          "Failed to execute query("
              + query
              + ")! Reason - "
              + e.getSQLState()
              + " "
              + e.getMessage());
    }
    return resultList;
  }

Let me know in comments if this was helpful.

All about Selenide

Raghwendra Sonu — Wed, 28 Jun 2023 00:47:19 +0000

Selenide is an open-source automation testing library that provides a simplified and user-friendly API for automating web applications. It is built on top of Selenium WebDriver and aims to make test automation with Selenium more efficient and readable by reducing the complexity of code.

Here are some key features and characteristics of Selenide:

Easy Setup: Selenide requires minimal configuration and setup. It automatically handles the WebDriver setup, eliminating the need for boilerplate code.
Concise and Readable Syntax: Selenide offers a fluent and intuitive API, allowing testers to write concise and readable code for their automation scripts. It provides a range of methods for interacting with web elements, such as finding elements by CSS selectors, XPath, or text.
Implicit Waits: Selenide automatically waits for elements to appear on the page, removing the need for explicit waits. It provides intelligent waiting strategies that make tests more stable and reliable.
Built-in Assertions: Selenide includes a rich set of built-in assertions that can be used to validate the state of web elements, such as their visibility, text content, attributes, and more. This simplifies the process of verifying expected behavior in tests.
Automatic Browser Management: Selenide handles the management of browser instances, including opening and closing the browser, switching between windows or frames, and handling pop-up dialogs.
Screenshots and Video Recording: Selenide allows capturing screenshots and recording videos during test execution, which can be helpful for debugging and analyzing test failures.
Integration with Test Frameworks: Selenide integrates smoothly with popular Java-based testing frameworks like JUnit and TestNG, enabling seamless test execution and reporting.
Support for BDD Frameworks: Selenide can be easily integrated with Behavior-Driven Development (BDD) frameworks like Cucumber and JBehave, enabling a more business-readable and collaborative testing approach.

Selenide focuses on providing a developer-friendly experience for test automation, making it easier to write and maintain automated tests using Selenium. Its intuitive API, built-in waiting strategies, and streamlined setup process contribute to its popularity among automation testers.

To get started with Selenide, you can explore the official documentation and resources available on the project's website: http://selenide.org/

Generate Allure reports in Cypress Framework

Raghwendra Sonu — Tue, 20 Jun 2023 02:55:17 +0000

To generate an HTML Allure report in the Cypress framework, you can follow these steps:

Install the Allure Command Line tool:

The Allure Command Line tool is required to generate the HTML report. Install it globally using the following command:

npm install -g allure-commandline

Add the Cypress Allure Plugin:

Install the Cypress Allure Plugin by running the following command:

npm install --save-dev @shelex/cypress-allure-plugin

Configure the Cypress plugin:

Open the cypress/plugins/index.js file and add the following code:

const allureWriter = require('@shelex/cypress-allure-plugin/writer');

module.exports = (on, config) => {
  allureWriter(on, config);
  return config;
};

Run your Cypress tests:

Run your Cypress tests using the Cypress command:

npx cypress run

Generate the Allure report:

After running the tests, the Allure report data will be stored in the allure-results directory.

To generate the HTML report, use the following command:

allure generate allure-results --clean && allure open

This command will generate the HTML report based on the data in the allure-results directory and open it in your default browser.

That's it! You have generated an HTML Allure report for your Cypress tests. The report will provide detailed information about the test execution, including test cases, steps, attachments, and more.

How to update environment variable on Mac

Raghwendra Sonu — Tue, 25 May 2021 06:25:17 +0000

Goto terminal
Run : VIM ~/.BASH_PROFILE
Enter I
TO INSERT NEW ENVIRONEMNT PATH
export M2_HOME=/Users/1138872/Documents/Automation/Software/apache-maven-3.6.3
export PATH=$PATH:$M2_HOME/bin:$JAVA_HOME/bin:$GRAILS_HOME/bin

You can add multiple paths in PATH variable by using : also remember to use /bin in the end of path variable
Once edited this file, tap esc button
Enter :wq to edit this file and quit
To execute this file close all terminal and rerun again else Type source .bash_profile to execute the .bash_profile file.

To verify successful installation enter: echo $PATH. It should display your newly added path. Also, You can type echo $M2_HOME

How to use Junit Annotation in Android UI Framework- Kotlin & Espresso based

Raghwendra Sonu — Sat, 22 May 2021 05:16:02 +0000

Problem Statement:
We need to add a capability in the framework, where they can Create and use JUnit tags to filter/group and run tests. e.g.

@Sanity
@Regression
@MyAnnotation

So, basically we will Run specific Android Espresso tests by creating custom annotations.

Solution:
Step 1) Create a custom annotation

import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy

//Create Annotation Class- Step3
@Target(
    AnnotationTarget.FUNCTION,
    AnnotationTarget.PROPERTY_GETTER,
    AnnotationTarget.PROPERTY_SETTER,
    AnnotationTarget.ANNOTATION_CLASS,
    AnnotationTarget.CLASS
)
@Retention(
    RetentionPolicy.RUNTIME
)
annotation class MyAnnotation\

@Target specifies the possible kinds of elements which can be annotated with the annotation (classes, functions, properties, expressions etc.)

We used it for annotate some functions, so we use AnnotationTarget.FUNCTION

@Retention specifies whether the annotation is stored in the compiled class files and whether it’s visible through reflection at runtime (by default, both are true).

AnnotationRetention.RUNTIME makes sure that the Rat annotation is visible to the test runner during the runtime.

Step 2) Annotate @MyAnnotation on the tests you want to run

@Test @MyAnnotation
fun AddTaskToDoListTestAndMarkDone() {
   ......
   ......
}

Step 3) Use gradlew to run only MyAnnotation tests

./gradlew connectedAndroidTest -P android.testInstrumentationRunnerArguments.annotation=com.example.todolist.app.MyAnnotation

Windows Desktop Automation with pyWinAuto

Raghwendra Sonu — Thu, 06 Feb 2020 01:50:45 +0000

pywinauto is a set of python modules to automate the Microsoft Windows GUI. At its simplest it allows you to send mouse and keyboard actions to windows dialogs and controls.

Installation- > pip install pywinauto

To use this tool, you need to get attributes of your application. For this purpose you can use PyInspect tool. Clone the below repository:
https://github.com/dm-vodopyanov/py_inspect

and run python py_inspect.py from command prompt.

You can inspect the properties of all the elements using this tool.

Later, you need to use these attributes for automation using pyWinAuto.

I will write a python file that will do following stuffs:

launch Notepad
type 99999 in the notepad
Click on Edit -> replace
Click on Cancel button on the Replace Dialog box.
Again it will enter "Hi from Python...." text in the notepad
It will navigate to File-> Save menu
Save the file with name "Test"

Here is the pyWinAuto code for this use case:

from pywinauto import application
app=application.Application(backend="uia")
try:
app.start("Notepad.exe")
app.window().wait('visible')
app.window(best_match='Untitled - Notepad').type_keys('99999')
app.UntitledNotepad.menu_select("Edit -> Replace")
app.Dialog.CancelButton.click()
app.UntitledNotepad.Edit.type_keys("Hi from Python.....")
app.Dialog.menu_select("File->Save")
app.Dialog.Pane.ComboBox0.Edit5.type_keys("Test")
app.Dialog.Save.click()
app.window(title='Test - Notepad').wait('ready', timeout=10)
except TimeoutError as e:
print(e)
raise e

Here is the execution video.
https://vimeo.com/389630552

Hope this was helpful. For more details go through pyWinAuto documentation: https://pywinauto.readthedocs.io/en/latest/

What is Cloud Native?

Raghwendra Sonu — Thu, 19 Dec 2019 09:24:01 +0000

Cloud Native is an approach to design, build and run applications using Continuous Integration, Container Engines and Cloud Orchestrators, to reduce the cost and risk and increase quality, scalability and speed of application.

Why we need Cloud Native?

1> Modularity- To create modular products. This helps in reducing delivery and maintanence costs. This is achieved by Micro services.

2> Observability- This helps in easy tracking of the applications and services. So, if something goes wrong with the account services module, only that will get impacted.

3> Deployability- Quick and easy to deploy in small chunks.

4> Testability- Easy to test an application and services.

5> Disposability- Easy to kill part of application, as it does not depend much on other modules or environments.

6> Replaceability- Can often create and move to other deployments.

What is the difference between Cloud Native and Traditional Approaches?

1> Abstraction- Cloud native provides abstraction whereas, traditional approach is Operating System dependent.

2> Predictable- Time taken to deploy an application in Cloud Native is predictable. Whereas, in traditional approach is unpredictable.

3> Right Size Capacity- Easily scalable application depending on need, traditional approach is most of the time over sized.

4> Continuous Delivery- Cloud native enforces Continuous Delivery.

5> Automated Scaling in Cloud Native, whereas Manual scaling in Traditional approach.

6> Recovery- In case of any failures cloud native is rapidly recoverable than traditional.

How to design Cloud Native Application?

There are certain design principles that should be followed to have a Cloud native Application, some of them are:
1> Micro-services- Develop application in chunks.

2> API Based design- So that it will be easy to deploy and test the services.

3> Safe Service Infrastructure- Infrastructure should be auto healing and auto load balancing.

4> Anti fragile- Robust exception handling in application.

Hope this post was able to give some basic idea of Cloud Native. Thanks for reading.

Automate anything you see, with Sikuli

Raghwendra Sonu — Tue, 19 Nov 2019 02:36:37 +0000

Sikuli is an open source GUI based automation tool. It uses the technique of 'Image Recognition' to interact with elements of the web page and windows popups. Sikuli is preferred when UI elements are stable and are not constantly changing.

What we did?

Add the Sikuli dependency in pom.xml

Store all of the images inside project Image folder:

How it works?

Perform action on the images:

Read more about Sikuli commands and available methods from http://doc.sikuli.org/