DEV Community: Anirban Majumdar

Setting Up a Java Project in VS Code - TestNG

Anirban Majumdar — Sat, 14 Mar 2026 15:55:21 +0000

Setting Up a Java Project in VS Code: A Step-by-Step Guide

Introduction

In this guide, I’ll walk you through setting up a modern Java project using Maven and TestNG in Visual Studio Code (VS Code). We’ll cover everything from project creation to running your first test, leveraging the VS Code Java Extension Pack for a seamless experience.

1. Installing the VS Code Java Extension Pack

To get started, install the Java Extension Pack by Microsoft in VS Code. This pack includes essential tools for Java development, such as language support, debugging, and Maven integration.

2. Creating a Maven Project

Open VS Code and launch the integrated terminal. Run the following command to generate a Maven project using the quickstart archetype:

mvn org.apache.maven.plugins:maven-archetype-plugin:3.1.2:generate \
  -DarchetypeArtifactId="maven-archetype-quickstart" \
  -DarchetypeGroupId="org.apache.maven.archetypes" \
  -DarchetypeVersion="1.4" \
  -DgroupId="com.example" \
  -DartifactId="tutorial"

This creates a project structure with src/main/java and src/test/java folders, and a pom.xml for dependency management.

3. Setting Up TestNG

To use TestNG for testing, add the TestNG dependency to your pom.xml:

<dependency>
    <groupId>org.testng</groupId>
    <artifactId>testng</artifactId>
    <version>7.8.0</version>
    <scope>test</scope>
</dependency>

4. Creating a SimpleTest Class

Inside src/test/java/com/example/, create a file named simpleTest.java:

package com.example;

import org.testng.annotations.Test;

public class simpleTest {
    @Test
    public void testMethod() {
        System.out.println("TestNG is running!");
    }
}

5. Configuring testng.xml

Create a testng.xml file in your project root to specify which tests to run:

<?xml version="1.0" encoding="UTF-8"?>
<suite name="Tutorial Suite">
    <test name="SimpleTest">
        <classes>
            <class name="com.example.simpleTest"/>
        </classes>
    </test>
</suite>

6. Updating pom.xml for TestNG

Ensure your pom.xml includes the TestNG dependency and is set up for Java 21 (LTS):

<properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
</properties>

7. Running Your Tests

Build and run your tests using Maven:

mvn test

You should see output from your simpleTest class, confirming TestNG is working.

Conclusion

With VS Code, Maven, and TestNG, you have a powerful setup for Java development. The Java Extension Pack streamlines your workflow, and TestNG makes testing easy. Happy coding!

Demystifying Promises, Async, and Await in JavaScript/TypeScript with Playwright and Cypress

Anirban Majumdar — Fri, 29 Aug 2025 09:54:41 +0000

One of the most common challenges for automation engineers using JavaScript/TypeScript is handling asynchronous code. Whether you’re writing tests in Playwright or Cypress, you’ll often deal with actions that don’t resolve instantly — such as page navigation, element interactions, or API calls.

That’s where Promises, async, and await come in. Let’s break them down with automation-specific examples.

What is a Promise?

A Promise represents the eventual completion (or failure) of an asynchronous operation. Think of it like a “contract” — “I’ll give you the data when it’s ready.”

Example: Fetching Data

const dataPromise = fetch('https://api.github.com/users');
dataPromise.then(response => response.json())
           .then(data => console.log(data));

In test automation, every browser action is often a Promise.

Async & Await Simplified

async marks a function as asynchronous.

await pauses the function until the Promise is resolved.

This makes code look synchronous and much easier to read.

Using Async/Await in Playwright

Playwright heavily relies on async/await. Almost every browser interaction returns a Promise.

Example: Playwright Test with Async/Await

import { test, expect } from '@playwright/test';

test('Search on Amazon', async ({ page }) => {
  await page.goto('https://www.amazon.com');
  await page.fill('#twotabsearchtextbox', 'Laptop');
  await page.click('input[type="submit"]');

  const results = page.locator('span.a-size-medium');
  await expect(results.first()).toBeVisible();
});

Notice how await makes each step sequential and readable.
Without it, you’d be chaining .then() everywhere, making tests messy.

Using Async/Await in Cypress

Cypress is slightly different — it uses built-in command chaining instead of raw async/await. Cypress commands like cy.get() and cy.click() are asynchronous but auto-managed.

Example: Cypress Test with Implicit Async Handling

describe('Search on Amazon', () => {
  it('should search for Laptop', () => {
    cy.visit('https://www.amazon.com');
    cy.get('#twotabsearchtextbox').type('Laptop');
    cy.get('input[type="submit"]').click();
    cy.get('span.a-size-medium').first().should('be.visible');
  });
});

Here, Cypress internally queues commands and resolves them without you writing await.

Mixing Promises with Playwright

Sometimes you need to handle multiple promises, e.g., waiting for API + UI events together.

Example: Waiting for Navigation and Click (Playwright)

await Promise.all([
  page.waitForNavigation(),
  page.click('text=Login')
]);

This ensures the test doesn’t miss the navigation event.

Mixing Promises with Cypress

Cypress doesn’t expose Promises directly, but you can wrap them:

cy.wrap(Promise.resolve(42)).then(value => {
  cy.log('Resolved value:', value);  // 42
});

Common Pitfalls & Tips

Forgetting await in Playwright

page.click('button#submit'); // ❌ Won’t wait  
await page.click('button#submit'); // ✅ Correct

Using async/await incorrectly in Cypress
Cypress commands don’t return raw Promises, so don’t do:

const text = await cy.get('h1').text(); // ❌ Not supported

Instead, use

.then():

cy.get('h1').then($el => {
  cy.log($el.text());
});

Parallelization with Promises
For Playwright, prefer Promise.all when waiting for multiple things.

Conclusion

Understanding Promises, async, and await is essential for writing clean, reliable automation in JavaScript/TypeScript.

In Playwright, always use async/await to control flow.

In Cypress, commands are asynchronous but automatically queued.

For advanced scenarios, leverage Promise.all (Playwright) or cy.wrap (Cypress).

Mastering these concepts makes your automation more readable, stable, and maintainable.

Using MCP Server to Supercharge Playwright Automation

Anirban Majumdar — Fri, 29 Aug 2025 09:32:45 +0000

Automation at scale often struggles with two pain points:

Slow test development (boilerplate code, selectors, retries).

Flaky tests due to fragile locators.

With Model Context Protocol (MCP), we can connect Playwright to an AI server that assists in writing, fixing, and maintaining automation tests. In this blog, we’ll set up MCP with Playwright to automate real-world scenarios on Amazon.com.

🔹 1. Prerequisites

Make sure you have the following installed:

Node.js (>=18)

Playwright

MCP server implementation (e.g., mcp-server
or custom server)

OpenAI/GitHub Copilot or another LLM provider

Install Playwright

npm init playwright@latest

Add TypeScript config if needed:

npm install -D typescript ts-node @types/node

🔹 2. Folder Structure

playwright-amazon/
 ┣ tests/
 ┃ ┣ amazon-search.spec.ts
 ┃ ┣ amazon-cart.spec.ts
 ┣ mcp/
 ┃ ┣ server.ts
 ┃ ┣ config.json
 ┣ playwright.config.ts
 ┗ package.json

🔹 3. MCP Server Setup

Your MCP server is the middleware between Playwright and the LLM. It provides structured prompts like “Suggest resilient Playwright locator for Add to Cart button”.

Example MCP Config (mcp/config.json)

{
  "name": "playwright-mcp",
  "description": "MCP server for Playwright automation",
  "capabilities": {
    "selectors": true,
    "code-gen": true
  },
  "llmProvider": "openai",
  "llmModel": "gpt-4o-mini"
}

Example MCP Server (mcp/server.ts)

import express from 'express';
import bodyParser from 'body-parser';
import { generateLocator } from './utils/locator-generator';

const app = express();
app.use(bodyParser.json());

app.post('/locator', async (req, res) => {
  const { request, context } = req.body;
  const locator = await generateLocator(request, context);
  res.json({ locator });
});

app.listen(4000, () => console.log('MCP server running on port 4000'));

🔹 4. Playwright + MCP Integration

We’ll call MCP server from within our Playwright tests whenever we need AI-assisted selectors or snippets.

Utility to Call MCP (tests/utils/mcp-client.ts)

import axios from 'axios';

export async function getLocator(request: string, context: string): Promise<string> {
  const response = await axios.post('http://localhost:4000/locator', { request, context });
  return response.data.locator;
}

🔹 5. Example Test – Amazon Search

tests/amazon-search.spec.ts

import { test, expect } from '@playwright/test';
import { getLocator } from './utils/mcp-client';

test('Amazon Search for Laptop', async ({ page }) => {
  await page.goto('https://www.amazon.com');

  // Get locator dynamically from MCP
  const searchBox = await getLocator("Search input field", "amazon-homepage");
  await page.fill(searchBox, 'Laptop');

  const searchButton = await getLocator("Search button", "amazon-homepage");
  await page.click(searchButton);

  // Validate results
  const results = page.locator('span.a-size-medium');
  await expect(results.first()).toBeVisible();
});

Here MCP generates resilient locators, so even if Amazon updates their DOM slightly, the AI can adapt.

🔹 6. Example Test – Add to Cart

tests/amazon-cart.spec.ts


import { test, expect } from '@playwright/test';
import { getLocator } from './utils/mcp-client';

test('Add product to Amazon Cart', async ({ page }) => {
  await page.goto('https://www.amazon.com');

  // Search product
  const searchBox = await getLocator("Search input field", "amazon-homepage");
  await page.fill(searchBox, 'iPhone 15');
  const searchButton = await getLocator("Search button", "amazon-homepage");
  await page.click(searchButton);

  // Click first result
  const firstResult = await getLocator("First product link", "amazon-search-results");
  await page.click(firstResult);

  // Add to cart
  const addToCart = await getLocator("Add to Cart button", "amazon-product-page");
  await page.click(addToCart);

  // Validate cart
  const cartCount = page.locator('#nav-cart-count');
  await expect(cartCount).toHaveText('1');
});

🔹 7. Benefits

✅ Resilient selectors – MCP auto-generates robust locators.
✅ Reduced flaky tests – Fewer selector breakages on UI changes.
✅ Faster automation – Engineers describe tests; AI scaffolds code.
✅ Scalable – Can plug into CI/CD for continuous improvement.

🔹 Conclusion

Using MCP with Playwright transforms how we build automation. Instead of spending hours debugging fragile selectors, engineers can focus on test strategy, while MCP + AI handles the scaffolding.