Forem: TestMu AI

Recapping Conversations From Selenium Conf and Appium Conf 2025 | LambdaTest

TestMu AI Team — Fri, 04 Jul 2025 10:29:18 +0000

At this year’s Selenium Conf and Appium Conf, we had the pleasure of hosting booths where industry experts like Angie Jones, Christian Bromann, and Jonathan Lipps stopped by for engaging Q&A sessions.

From thoughtful discussions to spontaneous insights, these moments captured the pulse of where testing is headed-AI, automation strategies, and ethical considerations were all on the table.

Here’s a quick look at what went down.

Angie Jones on AI, Ethics, Adaptation, and MCP

In a recent fireside chat at Selenium Conf and Appium Conf, test automation leader Angie Jones shares valuable insights on the evolving role of AI in testing, the ethical considerations it brings, and the growing importance of frameworks like the Model Context Protocol (MCP).

What AI Can’t Do (Alone)

Angie begins by addressing a common misconception: that AI can operate entirely independently. She stresses that AI, while powerful, can’t go from zero to 100 without human involvement. “ Trying to get it to solve everything on its own is a futile effort,” she explains. Humans must continue to guide and structure the problems AI solves, remaining the architects of their solutions.

Ethics in AI Implementation

When asked about ethical concerns, Angie emphasizes the importance of data responsibility. In industries like healthcare and finance, testers must be cautious about how AI interacts with sensitive information. It’s not just about what AI can do but what it should do. She also points out the risk of AI being exploited by bad actors and stresses the need for strong safeguards.

The Power of Model Context Protocol (MCP)

A self-described “huge Model Context Protocol (MCP) advocate,” Angie speaks passionately about the benefits of MCP. She describes it as both “simple and elegant” while enabling complex integrations across teams and systems.

Her company uses MCP organization-wide, including for CI/CD workflows and test automation. By adopting MCP, testers can expand beyond basic scripting and begin exploring how customer data and system interactions can enhance test coverage.

A Message to Testers

Angie closes with a powerful reminder: adapt or be left behind. She acknowledges fear about AI replacing jobs but points out that those who embrace AI are already working smarter. “ There’s a guy at my job who uses AI, finishes early and has time for more,” she said. “ That’s the person who’s getting the promotion.”

Christian Bromann on Agentic Workflows and Web Standards

At Selenium Conf and Appium Conf, we had the opportunity to sit down with Christian Bromann for a thoughtful discussion on how AI is shaping browser automation, the evolution of web standards, and what lies ahead for the testing ecosystem. He is well-known for his contributions to the open-source testing community.

Rethinking Agentic Workflows

When asked how AI might reshape browser interactions in the coming years, Christian had a grounded perspective. While agentic workflows-where browsers are controlled via prompts-are getting a lot of attention, he believes their long-term value might be overstated. “ If I have to prompt an AI to click a button, I could’ve clicked it myself,” he noted, suggesting that efficiency shouldn’t be compromised for novelty.

Instead, Christian sees real promise in AI’s ability to validate system states by leveraging the browser’s knowledge of application context. He emphasizes that the community is moving toward integrating this intelligence into tools, allowing testers to validate broader aspects of a system with far less effort.

Beyond BiDi: The Road Ahead for Browser Standards

Christian also reflects on the progress of WebDriver BiDi (Bi-directional Protocol)-a web standard that’s been evolving since 2018. While some of its capabilities have already landed in browsers (e.g., for accessibility and authentication), he believes it’s just the beginning. The future, according to Christian, lies in extending BiDi protocols to support more interactions, effectively turning common browser functionalities into standardized APIs.

He envisions a world where nearly every action in a browser can be programmatically represented via such standards, enhancing interoperability and reliability across testing tools.

Model Context Protocol (MCP): The Next Frontier?

On the topic of AI integration, Christian highlights the potential of the Model Context Protocol (MCP). Particularly in the context of web components, MCP could allow individual elements-like a login form-to expose an MCP server. This would enable intelligent agents to understand both the presence and semantics of components on a page.

“ When agents can identify the components, know what they do, and how to interact with them, we’ll be closer to a truly semantic agentic workflow,” he further explains. The result? AI agents that understand the structure and behavior of web applications in a meaningful way.

A Message to the Community

Wrapping up the chat, Christian reflects on the value of community engagement. “ We’re here at Selenium Conf, not just with the people who build the tools, but also those who use them,” he says; conferences like this are a chance to collaborate, contribute, and inspire each other. His message to the community was clear: everyone is welcome, and everyone can be part of the journey.

Jonathan Lipps on the Realities of Mobile Testing, AI Hype, and Developer Experience

At Selenium Conf and Appium Conf, industry pioneer Jonathan Lipps shares candid insights on the evolution of mobile testing, the current state of AI in test automation, and the ongoing challenges developers face. Known for his deep involvement in the Appium project, Jonathan reflects not just on tools-but the philosophical and practical implications of the tech we use.

The Evolution of Mobile Testing

Mobile testing has undergone a dramatic shift over the years. What was once considered a niche practice has become a non-negotiable part of modern app development. As Jonathan states, “ If you’re building an app, automate it. “ But despite this growth, the mobile automation space hasn’t seen the same explosion of frameworks and experimentation that the web world has.

While web testing has long thrived on diversity-with tools like Selenium, Cypress, and Playwright pushing boundaries-mobile testing remained constrained for a significant time. According to Jonathan, this was largely due to closed ecosystems and the limited tooling provided by mobile OS vendors. “ We’re more subject to the tools given to us by the platforms,” he explains, highlighting an ongoing challenge even today.

Tooling Limitations and Vendor Lock-In

When asked about the biggest pain in mobile testing, Jonathan didn’t hesitate: restrictive tooling. “Much of the flakiness testers face isn’t about automation itself,” he said, “but the lack of accessible, reliable, full-featured tools-especially from Apple.” He emphasizes how difficult it remains to even set up testing on an iOS device, a pain compounded by security constraints and a lack of open collaboration from vendors.

While acknowledging the efforts of platform teams to keep up with OS versions, he underscores that the testing experience is often compromised by decisions made outside the testing community-a tension that continues to slow innovation.

AI in Mobile Testing: Promise vs. Reality

Despite the buzz, Jonathan remains skeptical of AI’s current impact on mobile automation. “ There’s been a lot of marketing, but not much that’s truly transformational,” he adds. He’s yet to hear a compelling case study where AI has revolutionized how an enterprise handles mobile testing. Most use cases today feel experimental, not operational.

Tools that suggest locators or assist with test authoring have been around for years, and while useful, they don’t reflect the promise of AI in its modern, ML/LLM-powered form. “ People are trying it based on hype, but I haven’t seen the results yet,” he adds.

The Value of Purpose-Built Protocols

While Large Language Models (LLMs) get much attention, Jonathan believes that structured protocols-like Model Context Protocol (MCP)-might offer more practical value. Instead of relying on generalized AI systems that “hallucinate,” MCP enables components to define known actions and properties, making automation more predictable and less error-prone.

“ I like that it adds structure and takes some of the magic out of AI, “ he explains. When paired with trusted systems like Appium servers or APIs, these protocols offer real reliability-something LLMs can’t guarantee.

AI in Life: Use it Where It Helps, Not Where It Hurts

Jonathan concludes with a thoughtful message on the philosophy of AI adoption. While it’s useful for automation, he warns against overextending it into personal or emotional spaces. “ Don’t turn to AI for things that make life full-like music, creativity, or relationships, “ he shares. As a musician, he values creating art for personal expression, not outsourcing it to machines.

His parting words: “Let AI into your automation. But not into everything else. Keep the human in the loop.”

Conclusion

The chats at Selenium Conf and Appium Conf remind us that while the testing world is changing fast, some things still need a human touch. Whether it is Angie Jones urging us to be mindful of how we use AI, Christian Bromann calling for smarter, standards-driven tools, or Jonathan Lipps highlighting the ongoing struggles of mobile automation-each voice brings clarity to the hype.

Yes, AI is exciting. But it’s not a silver bullet. The tools that truly make a difference are the ones that bring structure, reliability, and real-world value-like MCP. And behind every good tool, there’s a community of testers asking hard questions, experimenting, and pushing things forward.

So, as we explore what’s next, let’s stay curious, stay grounded, and above all-stay human.

LambdaTest Collaborates With Selenium to Drive Innovation in Test Automation

TestMu AI Team — Thu, 03 Jul 2025 11:57:03 +0000

We’re over the moon to share some big news: LambdaTest is now an official Development Partner of the Selenium Project.

In many ways, it’s a story of building what once built us — Selenium’s open-source framework fueled LambdaTest’s inception and success, and now LambdaTest is giving back by contributing to the Selenium project.

From Sponsor to Partner: A Milestone Achieved

Our relationship with Selenium has evolved naturally over the years. Selenium has been foundational to our growth from day one — with its robust support and integration, it has formed the core of LambdaTest’s widespread adoption by users.

As we scaled, we became active sponsors of the project, supporting Selenium conferences, community events, and nurturing the testing community with resources. Now, we’re taking the next step by dedicating engineering resources to contribute directly to Selenium’s core codebase.

“Selenium has been integral to LambdaTest’s journey from day one. It’s like we’re building what once built us — giving back to the foundation that supported our growth. We’re honored and incredibly excited to work even more closely with Selenium and make a lasting positive impact for testers worldwide. Together, we will make test automation more powerful and accessible for everyone.”

- Asad Khan, CEO and Co-Founder of LambdaTest

Open Source in Our DNA

Open source is the engine that drives us every day here at LambdaTest. From our earliest days, we’ve seen how community‑led projects spark innovation and solve real‑world challenges faster than anything built behind closed doors. That conviction inspired us to create our Open Source Program Office (OSPO)-a dedicated team whose sole mission is to nurture and uplift the testing tools that matter most.

Through the LambdaTest Open Source program, we provide LambdaTest’s testing infrastructure to community projects, so maintainers can run comprehensive test suites without worrying about servers or setup.

We assign seasoned engineers to mentor contributors, review code, and share best practices to support contributors at every step. And we back it all with sponsorship support, helping open‑source teams cover hosting costs, event expenses, or even their own development time.

The LambdaTest Grants for Open Source program takes this one step further. It’s our way of celebrating the unsung heroes, the maintainers who keep critical libraries alive and the contributors who squash bugs that affect thousands.

Every grant shines a spotlight on their work and provides financial backing to fuel their next breakthrough.

With this Selenium Development partnership, we’re doubling down on the commitment we’ve made to Open Source.

Expect to see us contributing to Selenium’s core codebase, working side-by-side with maintainers, enhancing documentation, and putting LambdaTest’s full support behind the community.

What Does This Partnership Mean to Us?

Being officially added as a Selenium Development Partner is a milestone for us and a shared commitment to building a stronger Selenium and a more resilient testing ecosystem for everyone.

Here’s what this partnership means for each part of our community:

For the community: More hands on deck! Our engineers will work directly with Selenium maintainers to fix issues, develop new features, architect new capabilities, and streamline releases. We are helping carry out the load of maintaining this vital project.
For LambdaTest users: Expect tighter integration and early access to improvements. Since Selenium is at the heart of our platform, our contribution allows us to incorporate updates and new capabilities into LambdaTest much faster than ever.

This partnership sets an example of how commercial platforms and open-source projects can join forces to uplift the entire tech community.

In short, as Selenium evolves, testers, developers, and vendors all benefit from it. By channeling our engineering resources back into the project, we’re co‑investing in the future of test automation together.

“I am thrilled about this official partnership. It marks a new chapter in test automation innovation. This isn’t just a one-time collaboration but a long-term commitment to open-source excellence. By joining forces, we’re set to build robust, scalable solutions that empower developers and enhance quality assurance across the board. I’ve seen firsthand how much we can achieve when the community and companies grow together. With LambdaTest and Selenium in tandem, our collective future looks brighter than ever.”

- Sri Harsha, Engineering Manager OSPO, LambdaTest & Selenium TLC Member

Coming Full Circle: Building the Future Together

In many ways, this partnership brings our story full circle.

LambdaTest has been built on the strengths of Selenium and other open-source technologies, and now, two decades into Selenium, we are their official development partner to help shape the future of test automation.

Ultimately, this is about building together -uniting industry knowledge, user insights, and a passion for open collaboration. We can’t wait to see what the future holds, and we’re grateful you’re with us on this exciting path. Now it’s time to build the future together. 🚀

Happy Testing!

Want to learn more about how this partnership will benefit your testing practice?

Or have feedback on Selenium features, want to report issues, or explore how you can get involved?

Whether you’re curious about the partnership, interested in shaping the future of open-source testing, or want to be part of our Open Source Program or Grants initiative, we’d love to hear from you. Reach out to our Open Source Program Office anytime at opensource@lambdatest.com.

HyperExecute MCP Server: The Future of AI-Native Test Automation

TestMu AI Team — Sat, 28 Jun 2025 13:46:51 +0000

In today’s fast-paced development landscape, testing at scale can be a daunting challenge. The complexity of configuring test runners, managing executions, and troubleshooting errors often leads to significant delays. To tackle these obstacles, LambdaTest introduced the HyperExecute MCP Server, which integrates the Model Context Protocol (MCP). This server empowers AI models to seamlessly interact with testing tools, automating complex tasks such as code analysis, test command generation, and configuration file creation-all within minutes.

Building upon the success of HyperExecute, our AI-native test orchestration platform, the MCP Suite further enhances its capabilities. HyperExecute now accelerates testing by up to 70% faster than traditional grids. The integration of MCP improves scalability, allowing teams to handle larger test suites with ease. With real-time insights and automated documentation access, the entire testing process becomes more efficient. By incorporating MCP, HyperExecute now offers faster, more intelligent testing, enabling teams to deliver software with greater speed and precision.

Understanding MCP: Model Context Protocol

The Model Context Protocol (MCP) is an open standard that creates a universal language between AI models and applications. MCP essentially works like a “USB-C for AI integrations” allowing AI assistants to seamlessly connect with diverse software tools through a standardized interface. This eliminates the fragmentation problem of building custom implementations for each new integration, making it significantly easier to expand an AI assistant’s capabilities across the digital ecosystem.

Leveraging MCP, the HyperExecute MCP Server enables AI to analyze code, generate precise test commands, automatically create configuration files, and retrieve necessary documentation directly within the testing workflow. This integration significantly reduces manual configuration and debugging time, allowing teams to dedicate their efforts to higher-value activities.

HyperExecute MCP Server: AI-Native Testing Simplified

Historically, setting up HyperExecute could take anywhere from several hours to weeks, depending on project complexity. With the introduction of the MCP Server, this process has been dramatically streamlined, reducing setup time to mere minutes.

Key Capabilities of HyperExecute MCP Server:

With the MCP Server, users can manage HyperExecute directly from their Integrated Development Environment (IDE), enjoying capabilities such as:

Automated Codebase Analysis: MCP Server intelligently identifies project types, frameworks, and test structures without manual intervention.
Dynamic Test Command Generation: Automatically produces precise command-line instructions tailored to the analyzed tests.
Automatic Configuration File Creation: Eliminates manual setup by generating accurate YAML configuration files customized for each project.
Real-Time Test Monitoring: The integrated Job Info Tool delivers immediate updates regarding test executions, simplifying progress tracking.
Efficient Debugging: The Sessions Tool facilitates detailed inspection of test results, easily identifying failures through comprehensive recordings.
Instant Documentation Retrieval: Integrated AI agents utilizing Agentic RAG technology quickly deliver relevant insights from HyperExecute’s documentation, providing immediate assistance when needed.

Enhancing Developer and Tester Experiences

The core advantage of the MCP Server is its capability to manage complex testing tasks autonomously, utilizing natural interactions and commands. By significantly reducing setup times from hours to seconds, the MCP Server makes advanced test automation widely accessible and practical.

Hours of Setup, Reduced to Seconds: Reduces previously time-consuming configurations to near-instantaneous execution.
Fully Automated Operations: Eliminates the need for repetitive manual tasks, ensuring a truly continuous integration and continuous delivery (CI/CD) pipeline.
Seamless Scalability: Effectively handles projects of varying sizes, effortlessly adapting to the specific testing demands of each team.

Curious how the MCP Server and AI agents are reshaping infrastructure and automation workflows? Hear it directly from the experts — watch the video below to see their impact in action.

Revolutionizing Test Automation with AI

HyperExecute previously set a benchmark by executing tests considerably faster than traditional grids. The MCP Server enhances this further by delivering substantial improvements in developer experience and test efficiency.

Automated testing should be intelligent, streamlined, and outcome-driven, minimizing the complexity involved in test configurations and management. Experience the next level of AI-native test automation with HyperExecute MCP Server.

Happy Testing!

How to Use Selenium for Record and Playback

Tahera Alam — Fri, 27 Jun 2025 13:21:11 +0000

Selenium is a popular test automation framework that comes with a robust suite of tools, simplifying everything from writing test scripts to executing them.

You can also use Selenium for record and playback tests with one of its components, the Selenium IDE. With Selenium IDE, you can create automated tests without writing a single line of code.

What Is Selenium IDE?

Selenium IDE is a browser extension that simplifies the process of creating automated tests for web applications. It allows you to record your actions on a website in the browser and playback those actions to verify the expected functionality.

It provides a user-friendly interface that allows you to quickly create and run test cases directly within your browser without requiring any technical expertise.

What Is Record and Playback in Selenium?

When it comes to codeless test automation, the record and playback feature in Selenium allows you to record your interactions with a website, and then you play them back to see if everything works as expected.

The record and playback feature is available within its ecosystem through the Selenium IDE. When you enable recording, the IDE captures every action you perform in the browser and translates it into a sequence of commands.

These commands are then saved as a test script, which can be executed later to replicate the same interactions. It also eliminates the need for repetitive manual testing and ensures consistency in test execution.

How to Record and Playback With Selenium?

Now, let’s look at how to use Selenium for record and playback tests.

Install the Selenium IDE

Important: When writing this blog, the Selenium IDE extension is no longer available for the Chrome browser on the Chrome Web Store as it didn’t align with Chrome extension best practices.

You can still access the Selenium IDE extension on other browsers, such as Brave.

To demonstrate how to use Selenium for record and playback, we’ll use the Brave browser to run our tests.

Install the Selenium IDE Chrome extension.
Open the Selenium IDE and click on Create a new project.

3. Give it a name and click OK.

Create a New Test

Now that we have a project ready, let’s create our first test in this project. For this purpose, we will use the LambdaTest eCommerce Playground website.

Currently, this is how our workspace looks like:

Click on the Add new test button in the top left side and give the test a name:

2. Click ADD and now we are ready to actually record the test and play it back.

Record the Test

Before you can start recording, you need to enter the URL of the website you want to test. To demonstrate this, we’ll use the LambdaTest eCommerce Playground. So, go ahead and paste this URL https://ecommerce-playground.lambdatest.io/ in the playback base URL field.

Once you enter the URL, click the recording button (at the top right in red). Selenium will open the website in a new tab and start recording all your interactions.

As you navigate through the website, Selenium records every action. This includes clicking buttons, filling out forms, selecting dropdown options, and navigating between web pages.

Now that recording is active, let’s follow the below steps will help you understand how Selenium IDE captures user interactions.

Search for an iMac, check the results, and open a product page — Selenium IDE records each step.
Click on the search bar, type “iMac,” and press Enter or click the search button.

The Search results page appears, and Selenium IDE captures the navigation.

3. Click on any iMac product to open its details page — this click is also recorded.

4. Once you have completed the actions, return to Selenium IDE and stop the recording.

Now, let’s move on to the next step — playing back the test to see if it works as expected.

Playback the Test

Playing back a test in Selenium IDE allows you to automatically re-run the recorded steps and check whether the interactions you recorded work as intended.

Now, let’s see how we can playback the test we just recorded in the previous step.

Here, at the top of the Selenium IDE window, you can see a Run current test button. Click it, and Selenium IDE will automatically execute each recorded action step by step.

You can also run multiple tests in a sequence by clicking the right arrow next to each test. This will execute every test in your project one after another.

It becomes useful when verifying multiple workflows or features in a web application. Since our project has a single test, both buttons will have the same effect.

As the test runs, you’ll see the browser automatically repeat the recorded steps- navigating to the website, searching imac, viewing the results, and opening the product page just as you did while recording.

When this playback takes place, Selenium IDE offers feedback in real-time. If the test passes, all steps will run without errors. Selenium identifies a failed step and highlights it (for instance, if an element is not found or there are changes in the structure of the page). This makes it possible to quickly debug the test.

At the bottom of Selenium IDE’s window, you’ll see the test log showing the steps executed along with their timestamps and a message saying everything was executed successfully.

Now that we know how to record and playback a test, let’s explore how to export your test so it can be used in Selenium or other test automation frameworks.

Export a Test

Selenium IDE supports exporting tests in various programming languages and frameworks.

Let’s see how you can export your test:

Click on the three dots menu located in the top left corner of the Selenium IDE window:

2. Choose your preferred language/framework and other optional configurations, and click Export.

After selecting the format, simply save the file on your local machine and you are done.

The exported file will contain the test script in your chosen programming language. This script includes the commands and steps that Selenium IDE recorded.

You can now import this file into your development environment (e.g., Eclipse, IntelliJ IDEA, VS Code) and integrate it with your Selenium WebDriver project.

How to Run Selenium IDE Tests on the Cloud?

Up until now, we have learned how to record, playback, and export tests using the Selenium IDE. However, there are limitations to running tests on only your local browser. For instance, if you need to test on several browsers and operating systems to check how your website functions?

This is where cloud testing platforms like LambdaTest come into play. It is an AI-native test execution platform that enables you to execute Selenium IDE tests on a cloud-based grid.

LambdaTest provides you with access to various combinations of browsers and operating systems (Chrome, Firefox, Edge, Safari on Windows/macOS, etc.), which can help you run your tests in parallel, enabling faster software release cycles.

Now, let’s see how we can run the Selenium IDE tests on LambdaTest with just a few simple steps.

Install Node.js.
Connect Selenium IDE with LambdaTest. For that, you’ll need your Username and Access Key. To get the access, head over to your Account Settings > Password & Security.
Install the Selenium IDE Runner (or the SIDE Runner) using the below given command:

npm install -g selenium-side-runner

This will help you run the tests outside the browser.

4. Open Selenium IDE and click on the save project icon to save it to your local machine.

This file contains your recorded test case, which will be used to run tests on LambdaTest. You can also access the exported Selenium IDE project in this GitHub repository.

5. To direct your tests to the platform, you’ll need the LambdaTest Username and Access Key in the LambdaTest grid URL. In this URL, replace user-name and access-key with your actual LambdaTest credentials.

https://user-name:access-key@hub.lambdatest.com/wd/hub

6. Desired capabilities are a set of key-value pairs that let you define the specific environment for test execution.

So, in this step, specify the browsers and operating systems you want to test against. You can also use LambdaTest Automation Capabilities Generator to simplify this process.

For instance, to test on Chrome with Windows 11, we will use the following configuration for Selenium 4:

options = ChromeOptions()
options.browser\_version = "latest"
options.platform\_name = "Windows 11"

7. Open your terminal, navigate to the directory containing your .side file, and run the following command, replacing the user-name and access-key with your actual values:

selenium-side-runner "your-test-file.side" --server
https://user-name:access-key@hub.lambdatest.com/wd/hub -c " options =
ChromeOptions() options.browser\_version = "latest" options.platform\_name = "Windows 11""

Ensure to replace your-test-file.side with the accurate file name of your Selenium IDE project.

With these steps, your Selenium IDE test is now running on the LambdaTest online Selenium Grid.

You can now check the test execution results directly from the LambdaTest Web Automation dashboard.

Best Practices to Use Selenium for Record and Playback

Record and playback is an easy way to automate tests without writing test scripts, but to make the most of this functionality, you’ll need to follow below best practices.

Avoid using XPath whenever possible. It tends to break when a webpage’s structure changes. Instead, choose more reliable options like IDs, class names, or data attributes.
Split your tests into smaller, reusable chunks. Instead of cramming multiple actions into a single test, create separate test cases for common tasks like logging in or form submissions.
Web applications aren’t always static, so use control flow commands like if, while, and times to handle changing conditions. This helps make your tests more adaptable.
Testing isn’t just about running actions — it’s about verifying results. Add assertions to check that the application behaves as expected at key points in your test.
Automated tests often fail because they move too fast. Adding wait commands ensures the script pauses until elements are ready, preventing unnecessary failures.
Recorded scripts aren’t perfect. Instead of relying on them as-is, take the time to refine them, adding logic to handle dynamic content and edge cases.

Conclusion

If you are just getting started with test automation, then there is nothing better than using Selenium IDE to record and playback tests. It lets you record and replay tests, which makes it ideal for accelerating repetitive tasks.

That said, the record and playback feature is not without its limitations. It is good for simple tests and relatively static websites but not ideal for complex workflows or dynamic elements that update often.

You’ve just learned the fundamentals; now let’s get into Selenium IDE and automate some web tests!

Happy testing!

19 Best Practices for Automation Testing with Node.js

Harish Rajora — Wed, 25 Jun 2025 02:38:50 +0000

Node.js has become one of the most popular frameworks for web development, powering millions of applications. As projects grow in complexity, automation testing with Node.js is essential to ensure seamless performance. This article explores the best practices for Node.js automation testing in 2025, helping you build reliable, high-quality applications.

While testing a weather forecast app in Node.js could be highly complex due to multiple data sources, APIs, and location tracking, this guide simplifies the process. Instead of diving into such a large-scale application, we’ll walk through a step-by-step approach to automation testing with Node.js, ensuring you understand the fundamentals and best practices for automation testing.

Initializing A Simple Test In Node JS

If you are new to node.js then here I will initialize a simple test in node.js for you to understand the procedure of testing in node.js. Let us create a basic function of multiplying two numbers:

function mul(x,y)
{
return x\*y;
}

This is a basic function for multiplication. But, this function is not valid for every case and can stand invalid for various other numbers. We cannot perform testing in such a situation. We will extend this function to validate the equality feature.

function mul(x,y)
{
return x\*y;
}
function testMul()
{
var x = 4;
var y = 5;
val mul = x\*y;
var mul2 = mul(4,5);
if(mul == mul2)
console.log(‘Equality Test Passed’);
else
console.log(‘Equality Test Failed’);
}
testMul();

After writing the basic tests, we will initialise the new node project by hooking it up to the npm.

npm init

Now you need to install the modules. As we discuss further in this article you will learn more about the importance of Mocha and Chai in the node js testing. Mocha gives you a good platform to define your test case suites, hooks and use assertion of whatever library you want to use. Chai on the other hand is used for writing the assertions only. These assertions are the human readable test codes which has advantages of its own.

npm install --save-dev mocha chai

After this, I have created two js files. One being test.js and other mull.js . Save the test.js in the test folder and mull.js in the root directory.

Now paste the function mul written above with an extra line.

function mul(x,y)
{
return x\*y;
}
module.exports = mul;

Exporting it will help us in adding it to the require line as we perform testing with node.js.

Open your test.js file in the tests folder and write the following test code given below to go-ahead testing with node.js. This test code will test the equality of the two functions. The expect variable is the object code from chai library to write the “expect” part of the assertion and multiply will be the variable that contains the exported module of the code given just above it (module.exports = mul).

var expect = require(‘chai’).expect;
var multiply = require(‘../mul’);
describe(‘mul()’, function(){
    it(‘should multiply two number’, function(){
var x = 4;
var y = 5;
val mul = x\*y;
var mul2 = mul(4,5);
expect(mul2).to.be.equal(mul)
});
});

Just run your tests now through npm test in the console window and you are good to go.

Best Practices For Testing Node JS

Testing tells the stability of your application and if not, makes it more stable which in turn save you from a sudden wrong commit which can take the whole software down with it.

Testing is required before you push your code to your users so that no one is bugged by any of the unwanted behaviour of the application. Being this important, we will see some of the best practices for testing Node JS in 2025.

1. Isolated and Atomic

Test should be atomic and isolated. Every test should run independently and without being dependant on each other. If neither test is dependent on any other test then if one test fails, other tests are not affected. Also, the tests should follow the atomicity property. It should not fail in between suddenly. A test should be entered and exited with the pass or fail result smoothly.

You should also keep in mind that the data you are testing upon should be separate for every test. More than one tests working on the same global data harms the overall motive of using the tests upon the application. Your time will absolutely increase leading to good performance but it is of no point. Keep your data specific to the tests.

2. Naming Of Your Test

This is one of the most basic and important feature for writing effective test cases. A test should be named meaningful and easily understood by other departments who are not related to testing such as development team. A name should not be any random name such as foo() being used popularly. After seeing that your test is no random word, you should focus on what you should name your test. A test name should constitutes of

What is being tested?
What are the different scenarios under which you are testing?
What should be the expected result of the test?

Here is an example of a meaningful naming convention for testing node.js.

function CheckCountryLanguage()
{
//code to check if the application is showing data in the country’s official language
}

The above test name makes sense because we can easily get what that function would be doing. What if I had written the function name as foo? Then I would have to read the complete code to understand the working of the function.

3. Using Assertions

An assertion in the programming language is a statement for which we declare at the time of coding. This declaration may or may not be true and hence provides the boolean output with true or false. The declaration itself contains the meaning of the test code such as expect(‘age’).to.be.equal(23).

This is self-explanatory and cuts the code lines’ logic to a great extent. If the variable ‘age’ is equal to 23 then True is printed or else False.

Assertions are more beneficial than normal tests because they already provide a statement in the test case. Also, when an assertion is run, you don’t need to know what was the response and why you got it. It would just provide you whether the test failed or passed.

A test will use logic in test cases while assertions are the human readable forms where you write tests in human readable forms. This helps when analyzing the tests after they are run.

expect(‘currentweather’).to.be(‘string’);

Such assertions are human readable and are self-explanatory about the test they are performing. This expect shows that the currentWeather has to be a string such as Hazy, Clear or Rainy etc.

4. Use Test Runner

A test runner is a library or a tool that takes a source code directory which contains the unit tests and runs tests on it. After executing the tests, it writes the results back on the console or the log files. It is always recommended to use a good test runner and some of the testers use their own test runners too.

While having a test runner can be advantageous with the databases as it can take the database values (dummy or real) and execute different tests on it. It can load fixtures too.

Mocha is a test runner. Mocha can provide you a programmatic way to run the tests via command line tools on ES6 codebase.

5. Focus On Test Coverage

A test coverage while writing the tests is the amount of source code you are covering in your test. In simple words it can also be said the amount of application as a whole you are covering for your test. While writing the tests, it is considered the most important thing to work upon. So how can you increase your test coverage?

First of all, you should always keep in mind that test coverage percentage is totally depended upon the nature of your application. If it is some application say Music Player then it need not have 100% test coverage because as we increase the test coverage it becomes more and more expensive for the company.

But if you have an important application like any real time application receiving data from satellite or an application for the manufacturer of Airplanes then you need to have 100% coverage because it will affect the application to a great extent.

We will focus on test coverage for the upcoming points. For this you can use Mocha along with Istanbul and run your Mocha tests over Istanbul.

6. Use Plugins For Test Coverage

Plugins are available which tests all the test coverage. Plugins will not help you in writing the tests that covers maximum code but it will definitely help you analyze your test and tell you if a test is skipped or not. It will also show if all the test cases are covered or not.

This way you might be thinking that you have written the tests that covers some percentage of the code but in reality some tests are skipped bringing down the overall percentage.

7. Analyse The Test Coverage Report

A test coverage report can be generated with the help of Istanbul and Mocha. Once you have generated the test coverage report, try to analyze the report. A report with say 90% test coverage that you might think will not be covering the complete 90% code with its test cases.

While using Istanbul it is quite easy and straightforward to analyse the test coverage report. Also, you should take the failed test seriously and analyse them as to why did they fail and check if there is an issue or not.

8. Use Mutation Testing

Mutation testing is the type of testing in which the test cases’ logical condition are tweaked (mutated) to deliberately fail the tests or if it failed then to pass it. The logics can also be changed for the same reasons. It is also popularly called as planting a bug. There are various libraries that you can get on the internet but one of them and most popular being Stryker can be used for the same purpose.

9. Check Plagiarism On Tests

While testing node.js on the source code, you should always check for plagiarism on the code. It is not so uncommon to copy and paste the code from the internet to make the software work. You might never know the source code can be licensed and your organisation can fall into serious trouble for the same.

These things violate the copyright issues also. So always remember to check the code for plagiarism in order to tweak the code a little but for the advantage of your organisation.

In order to use the plagiarism checker, you can install the node js npm plagiarism-checker package.

To install it just type the following code:

npm i plagiarism-checker

After that, in order to use that SDK, type the following code:

var a = require('plagiarism-checker');
var b = new a();
var config = b.getConfig();

Download the code from this repository and add it to your project. Keep in mind the following dependencies are installed

$ npm install lodash
$ npm install request
$ npm install request-promise
$ npm install mime-types

10. Use Realistic Inputs

Many times it so happens that the testers use the inputs that are not realistic or according to the real life scenarios. For example an input demanding phone numbers should be tested on numbers which resemble the real phone numbers. So you should always use realistic inputs while testing your application.

The best library available for this purpose is Faker library. According to GitHub, Faker library is a php library that generates fake data for the input you are willing to test upon.

You should also keep in mind to use more and more inputs for a single input parameter so as to test heavily. As in real life, many inputs will be processed on the same function, you should use as many as possible to test them.

A simple portrayal of the situation can be the same weather application that we discussed in the beginning of this chapter.

function CountryName(string country)
{
//code
}

Now, this function should be tested with realistic inputs such as

function CountryName(India)
{
//code
}
function CountryName(Netherlands)
{
//code
}

Instead of :

function CountryName(abc)
{
//code
}
function CountryName(foo)
{
//code
}

11. Use Linters

According to Wikipedia, linter is a tool that analyzes the source code to flag programming errors, bugs, stylistic errors and suspicious constructs. Linters are great at finding certain classes of bugs including assignment to undeclared variable and use of undefined variables. Using linters can help you a lot in determining the bugs in the structural way of the code. For Node JS, you can use ESLint for the same purpose.

12. Property Based Testing

Property based testing depends on different properties of the function. It is used to check the property of the entity (function, program etc) in particular. A property is a characteristic of the entity. For example, if you have a function that takes the input arguments as a,b and holds the property that b is always even then by property based checking, we check whether b is always even or not.

for all(a,b)

b is always an even number

Property based testing helps us as it

Contains the scope of all inputs and that can generate a huge number of test cases
Can take us to the failure in a very short time as it has something specific to put as the input like even numbers in the above case. It can keep on inserting even numbers until a point that it fails and we can get the threshold value of the function quite easily.

You can use FastCheck, QuickCheck or Mocha Test Check for property based testing.

13. Use Chai Library

Error catching should be done with specific libraries such as Chai library. It expects the assertions and hence give you what the error was about. This might not be the case with try-catch-finally statement. A Try-Catch-Finally statement will throw some generic error statement because it takes the exceptions as a whole class of exceptions and errors and does not give the specific result about the same. It then takes lot of time to decode what the error was actually about.

For example,

expect(‘a’).to.not.have.property(‘b’);

this way few lines of code is summarised to a single line of chai assertion.

14. Check For Exceptional Scenarios

While the test cases and scenarios that you design might cover everything on the source code but there are few exceptions that are very important while testing the application behaviour/response/outcome. Let say there is a feature in your application that sends email when a new user is added.

The email is sent to both admin and the user. This becomes an exceptional scenario as the method must be passing correctly but you might not be getting any email.

These things should be tested. The testing should also include forcefully sending different response code from the server side so that we can know how the application behaves in such a way and what values are returned.

If you go to the normal approach of checking the JS conditions and test cases internally then you will be able to check the internal conditioning but will never get if your application behaves in the same way practically or not.

Many firms develop their own methods to achieve these things. A good example is Netflix which has developed something they call Chaos Engineering which tests their functions and method by killing off their servers one by one.

This way they are also assured that even if one server fails, the application works correctly.

15. Follow The Testing Pyramid

While testing with node.js, you should try to follow the test automation pyramid. As seen from the following image the unit test should be taken as the base of all the testing.

We do so because unit test will cover the basic units of functionality independently of one another. After the unit tests are done then move ahead to the integration testing. Integration testing will let you test the different modules combined with one another as a group. After that we move on to the next part of the pyramid and test the front-end or User-Interface testing using Selenium or similar tools.

As you can see, the cost incurred keeps on increasing as we move on to the pyramid but the speed keeps on decreasing. Unit test takes most of the time to execute while the front end is tested fastest because of the less complexities and modules.

16. Use Component Testing

Component testing tests the functionality of the modules which are separately testable. The input/output behaviour of the test object is verified by the component testing.

As seen in the image, each component has a test plan and every test plan has various different tests under it and then they are tested to check the functionality of the component. It is recommended to use the component testing after the unit testing in the pyramid. Component testing is a very good approach and has a great coverage and speed greater than unit testing.

17. Keep Infrastructure Issues In Mind

More often, testers think that the testing of source code with the above practices kept in mind is the all they have to do for the proper functioning of the application. But, they are wrong. Testers tend to forget the infrastructure issues and testing them which have a great percentage of happening in the real life practical scenarios.

These infrastructure issues include memory overloading and how the application behaves when it happens. Other infrastructure issues may include the sudden shutdown of the server or API becoming 50% slower which is used in the application. Infrastructure testing include testing of these issues and providing a feedback report on it so that they can efficiently managed.

18. Going Parallel

Parallel testing means running multiple test cases, simultaneously. Running different tests in parallel has its own advantages. If you are not following parallelism then you will run one test and provide the feedback about it then you will run another tests and provide feedback about it and so on.

These feedbacks are then analysed and are worked upon. Then the team will check the feedback of the second test you did and then resolve them. While following parallelism, you can drastically reduce the feedback loop and provide feedback of many tests altogether which can be resolved in a lesser time as before. This way you can save a lot of time and resources of the company.

Many libraries are available for achieving parallel testing, most popular of them being Mocha and Jest.

19. Automate The Updation Of Your Dependencies

Running the tests and following different rules require lot of libraries and different tools to work altogether in order to achieve the perfect testing. But it sometimes happen that the dependencies become out of date and other dependency require the latest version to run with each other.

This creates disturbance in the smooth running of the tests and can be resolved by automating the updation of your dependencies. Once you automate the updation, every dependency will update by itself and will not require to manual intervention after raising the flag for the same.

Use An Online Selenium Grid For Cross Browser Testing

Talking about automation, everyone favors Selenium as an open-source for performing cross browser testing. However, there are a limitation on the number of browser and machines you get access to as you go ahead setting up your Selenium grid. Performing a thorough round of automated cross browser testing calls for a cloud-based provider such as LambdaTest.

LambdaTest is an AI-native test orchestration and execution platform that lets you run manual and automated tests at scale on over 5000 real devices , browsers, and OS combinations.

You can automate your testing process and can even perform testing with node.js in parallel. You can even perform test using any other test automation framework with respect to different languages such as Python, PHP, C#, Java and more.

Well, that was all from my end. Testing with node.js may look a little scary at first. However, you can get rid of hesitation and perform it like a professional by keeping the above best practices for testing Node JS in mind. Let me know if there is a special practice that I have missed, and you feel is indispensable for the article. Happy testing! 🙂

Conclusion

Testing is a crucial part of ensuring the stability and reliability of your Node.js application. By following these best practices, you can ensure that your tests are efficient, effective, and maintainable. Isolated and atomic tests, proper naming conventions, assertions, and the use of test runners like Mocha can help create a solid testing foundation.

Additionally, focusing on test coverage, using plugins, and practicing mutation testing will help you spot potential issues early on. The inclusion of realistic inputs, linters, and property-based testing further strengthens the quality of your tests. By continuously analyzing reports, checking for exceptional scenarios, and automating dependency updates, you can stay ahead of any issues.

Implementing parallel testing and component testing ensures efficiency and scalability, while keeping infrastructure issues in mind adds an extra layer of reliability. With these best practices, you’ll be able to take your Node.js testing to the next level in 2025.

Best Mobile App Testing Frameworks for Android and iOS

Harish Rajora — Mon, 23 Jun 2025 08:10:57 +0000

Mobile app testing framework helps automate the testing of your native apps. It reduces test execution time and identifies bugs before the app goes live. Once a mobile application is developed, it is moved ahead to the testing phase, where it is decided whether the application is fit to be delivered to the people or needs more work.

In this blog we will learn the best mobile app testing frameworks for 2025, the list of frameworks mentioned in this blog will help mobile app developers take better decision to build mobile apps in more effect way.

Different mobile app testing frameworks offer different features and may confuse the app tester in choosing the best one according to the situation. To resolve this, we have crafted this post that brings out all the mobile app testing frameworks, popular features, and other relevant information.

Types of Mobile App Testing Frameworks

Mobile app testing frameworks come in three strict divisions:

Strictly Android testing framework.
Strictly iOS testing Automation framework.
Cross platform testing framework (for both Android latest version and latest iOS version).

We have divided this post into three sections and arranged all the mobile app testing frameworks accordingly.

Android Test Automation Frameworks

The following section highlights the most popular mobile app testing frameworks available only for Android applications.

In this blog, we will discuss some of the best Android test automation frameworks, such as Espresso, Selendroid, and MonkeyRunner.

Espresso

“Use Espresso to write concise, beautiful and reliable Android UI tests” — Google.

Espresso is a Google-made Android testing framework and has been a popular choice due to its high performance. Espresso believes in creating very simple and straightforward tests without worrying about the application’s infrastructure. Furthermore, it is open-source, which gives the developers the power to customize the framework.

Key Features of Espresso

Google promotes Espresso as a quick-to-learn Android testing framework.
Espresso is comparatively faster in test execution.
Espresso is a highly stable Android test automation framework as it can detect when the main thread is idle and run the UI tests at an appropriate time to prevent load on the system.
If you are using Android Studio to develop Android applications, Espresso could be the best choice for you as it is easy and quick to integrate.
Espresso is based on JUnit, a very popular testing language. Therefore, app testers can quickly pick the APIs when opting for this framework.

Selendroid

“Test automation for native or hybrid Android apps and the mobile web with Selendroid.” — Selendroid

Selendroid is an Android test automation framework based on Selenium. Selendroid uses Selenium 2.0 for writing test scripts for Android apps. Currently, Selendroid is only an Android test automation framework, although they plan to extend it to iOS applications soon. Selendroid recommends using the iOS driver with the Webdriver for testing the iOS applications, which is just a workaround.

Key Features of Selendroid

Selendroid can be used with Android emulator online, real devices, and Selenium Grid for selenium android testing and selenium for iOS testing.
Selendroid uses Selenium which is hugely popular among app testers, and they can start right away with the Android test automation framework without investing time in learning.
Selendroid comes with advanced user interaction support APIs for faster testing. These may include human interaction such as swipe and drag and drop.
The Android testing framework comes with the support of the JSON Wire protocol.
Selendroid comes with an advanced inspector that can detect the UI elements quickly.

MonkeyRunner

“The MonkeyRunner tool is not related to the UI/Application Exerciser Monkey, also known as the monkey tool.” — Google.

The MonkeyRunner mobile app testing framework is an Android test automation framework designed to control the Android applications outside the Android code. Monekyrunner uses the Jython language, which implements the Python programming language using Java language. These popular languages make it extremely easy for the app testers to develop the tests. The tool is designed to test the Android based applications at the functional or framework level or for running the unit tests. Although, the developers of the framework define the tool to be used in any way the app testers or the developers want.

Key Features of MonkeyRunner

MonkeyRunner can be attached to more than one Android emulator or real device simultaneously. Through this single connection, you can run multiple test cases (or test suites) on all of them per your program/sequence, etc.
MonkeyRunner can provide you with a complete start-to-end test script for an Android application. The app tester can take multiple output screenshots whenever he feels through the test scripts.
The most popular feature of MonkeyRunner is its ability to compare multiple screenshots for correctness. The app tester can compare the present screenshot (the one taken from the current test run) and the screenshot, which is correct.
MonkeyRunner mobile app testing is a set of API toolkits, and hence it can be customized up to any level as the developer wants. Now test with free APK emulator online!!!

iOS Testing Frameworks

The following mobile app testing frameworks are available exclusively for iOS mobile applications.

XCTest

XCTest is considered the primary and most popular iOS automation testing framework when you have to test an iOS mobile application. The iOS testing framework uses instance methods and creates a friendly environment for the iOS app developers. XCTest uses Objective-C and Swift programming languages for testing and is compatible with XCode 5.0+.

Key features of XCTest

The XCTest is a powerful iOS testing framework and can be used for unit testing, mobile performance testing, and UI testing.
The languages used for writing the test cases are similar to development, and therefore the developers and app testers can start testing right away.
XCTest gives good control over continuous integration facilities.
XCTest also allows the user interface recording and enhancement.

OCMock

OCMock has a rich feature set for many different use cases. — OCMock

Another open-source mobile app testing framework designed for iOS applications is the OCMock. As the name suggests, OCMock focuses on the testing done through mock objects. OC here refers to the Objective-C language. OCMock provides three types of mocks — partial, dynamic, and stubs. The details of using each of them can be found on the official page of OCMock.

Key Features of OCMock

OCMock is an iOS test automation framework that provides deep and detailed documentation with many examples for the testers.
The framework uses Objective-C language, which is used in iOS development also. Therefore, it becomes very easy to learn and create suites in OCMock.
OCMock is open-source and, therefore, is free to use, is actively developed, and has established a very active community.
The latest version of OCMock (OCMock 3.0) has included modern syntax that uses macros. This benefits from separating method calls and mock setup and provides a better error reporting mechanism.

KIF

“The magic of KIF is that it allows you to drive your UI from your unit tests and reap all the advantages of testing in-process.” — KIF.

KIF is an iOS test automation framework used for testing iOS mobile applications. The framework builds the tests using the XCTest targets, and therefore it becomes easier for people already familiar with XCTest to create instant tests. Since KIF is used for UI testing, app testers and developers often add it to the user interface testing target. However, the official documentation advises developers and app testers not to do that as KIF works from the unit test target and should be added to it only.

Key Features of KIF

KIF uses Objective-C language just like OCMock, and the ease of learning is well appreciated.
KIF mobile app testing framework can be integrated directly in XCode, and there is no need to install any additional libraries, etc.
The framework uses tap events for testing, similar to a user’s action giving this framework an additional benefit over others.

Detox

“We believe the only way to tackle flakiness head-on is by moving from black-box testing to gray box testing. That’s where Detox comes into play.” — Detox.

Detox is an iOS test automation framework for end-to-end testing. They focus on eliminating flakiness, a major issue in mobile app testing frameworks.

Key Features of Detox

Detox writes test cases in Javascript, which is an extremely popular language among developers all around the globe.
Detox tests the mobile application after running it on the simulator/emulator, which resembles a real user-like testing behavior.
The framework brings advanced monitoring techniques into the environment.
Detox can run end-to-end tests integrating with CI tools such as Travis very smoothly.
Detox is open-source, and hence the community is very active.
The framework is test runner independent until you are using Javascript test runners.

Frameworks for iOS And Android

Appium

“Appium is built on the idea that testing native apps shouldn’t require including an SDK or recompiling your app.” — Appium

If you are in the testing field, there is a high chance you have already heard of Appium. Appium has been in test automation for the last 8.5 years, and its popularity has only increased since.

This mobile app testing framework is highly versatile and officially states that it aims to automate any mobile app in any language in any framework. Therefore, it is one of the most recommended frameworks by app testers.

Key Features of Appium

Appium supports almost every programming language and every framework. So the app tester need not learn a new framework or language and can start testing right away.
Appium mobile app testing framework facilitates reusability of the code by using the same APIs for multiple platforms.
The framework has an extremely large and active community that can help you with every problem in no time.
Appium works with real devices, emulators and simulators as well.
Appium does not let you compile the application in the Appium environment because of the issues it creates later on after shipping in a different environment. Hence, Appium runs its test on the same development framework and language to give confidence around the application development.
The framework can be integrated with CI/CD tools very easily.

LambdaTest is a cloud based mobile app testing platform. LambdaTest offers a reliable, scalable, secure Appium test execution cloud that helps app testers accelerate their release cycles. You can test using emulators, simulators, and real device cloud. In addition, you can access any device you need directly from your desktop browser. Up your game with free Android automation testing via Appium.

LambdaTest

“A Boatload of Capabilities with Surprisingly Few Obstacles” — LambdaTest user

Key Features of LambdaTest

LambdaTest is an AI-native test orchestration and execution platform that lets you run manual and automated tests at scale with over 3000+ real devices cloud, browsers and OS combinations.
The platform provides unique features such as geolocation testing, localization testing, app test automation etc., that are not available on many other platforms.
LambdaTest provides a lot of integrations for the app testers to enhance the platform’s functionality and provide a one-stop solution to app testers.
The platform is easy to learn and is faster to launch the applications on their virtual testing platform and real device cloud.
Run tests in parallel on Appium mobile device cloud at scale. Run tests at scale across multiple devices at a time and reduce your overall test execution time by more than 10X.

What’s your favorite tool?

Mobile app testing frameworks are on the rise today due to their software development and delivery needs. While there are many more mobile app testing frameworks, we focused on the top four in each category and gave insights about them. But a framework is good as long as people like us prefer it in our day-to-day testing scenarios. Let us know your personal favorite mobile app testing framework and the reason you prefer them above all else. Please mention your answers and suggestions in the comment section below.

I hope this post helps you decide your mobile app testing framework if you are new in testing or helps you recalibrate your existing choices. Till then, happy mobile testing!

What Is AI Unit Test Generation: Key Strategies and Tools

Harish Rajora — Fri, 20 Jun 2025 07:28:35 +0000

Writing test scripts for all unit test cases can be time-consuming and prone to human error. To mitigate this challenge, you can use intelligent techniques such as AI unit test generation.

With AI unit test generation, you can streamline the process of writing unit test scripts by automating test creation, reducing manual effort, and enhancing your overall testing process.

What Is AI Unit Test Generation?

AI unit test generation is the process of using artificial intelligence to automatically create unit test scripts for software applications.

Instead of manually writing test cases for unit testing, AI tools analyze the the logic, structure, and behavior of the code to identify key functions, edge cases, and potential failure points. Based on this analysis, they generate unit tests that include inputs, expected outputs, and assertions.

Importance of AI Unit Test Generation

When unit tests are generated through artificial intelligence, the team reaps the following benefits, impacting the method and quality of software development process.

Test cases generated through AI cover a wider range, as the goal of the software is to cover all aspects of the functionality. This includes edge cases as well that testers often overlook.
AI unit test generation targets each line of code, even if the tests may become more complex. This results in better test coverage and, therefore, a better unit test suite.
AI-based unit testing can automatically modify the unit test scripts when the codebase is changed or updated, so you do not need to maintain these tests.
When AI is deployed to generate unit tests, you have more time to invest in code enhancement or work on other functionalities.
Since you invest time in other development tasks, this can be directly associated with costs that have a visible ROI. AI unit test generation, therefore, becomes a great way for the team to save costs in unit testing.

Framework for AI-Based Unit Test Generation

Generating unit tests using AI requires integration between machine learning models and software testing processes. At a higher level, a framework is designed whose high-level components look as follows:

Large Language Model Configuration and Integration: To work on AI technology, an LLM model is required. This model is tuned and fed according to the tasks it will perform. The team and the organization decide which model to choose. The model automates the generation of unit test scripts in the desired programming language. It can also have additional functionalities, such as prioritizing functions and providing options to regenerate tests if required. However, these are considered enhancements rather than core requirements.
Test Generation: The integrated LLM model generates test scripts and saves them in a separate file with extensions that match the targeted programming language.
Test Execution: In this stage, the tests generated in the previous stage are executed. This stage also connects with the reporting module, where the test results are documented automatically.
Analysis and Regeneration: The final results are presented to the tester, and if regeneration is required, the model has to be run again. Here, there can be multiple modifications according to the tester’s requirements. For instance, the tester can run a different model to see if it generates better output. If the framework is designed autonomously, all these options can also be chosen automatically.

This is a generic framework design for AI unit test generation. You can also add other modules to make it more productive and efficient, depending on their requirements. However, the stated modules have to be present as a foundation.

Key Strategies for Using AI in Unit Test Generation

To make effective use of AI for unit testing, there are some strategies that you can follow:

Use AI to generate realistic synthetic test data. This type of data covers a variety of test cases and may be used to assess how a software application will behave across a variety of conditions.
Define specific goals for your AI unit testing efforts. Also, defined objectives to ensure a focused and structured testing approach, targeting key areas effectively.
Test individual components in isolation to unearth issues within specific units. It will make your debugging simpler and efficient.
Adopt a Test-Driven Development (TDD) approach, where you first write automated tests, then develop the code required to pass those tests. By doing so, you can have a good understanding of the expected behavior of all the components of the software application, and at the same time, your test scripts will cover all functionality from the beginning. It also makes it easier to find and fix issues quickly during the development process.
Besides leveraging AI, integrate your test suites with CI/CD tools. This way, the tests will execute on each code commit, keeping high code quality and ensuring faster bug detection.

Top AI Tools for Unit Test Generation

Unit tests can be generated automatically through AI using the following tools.

1. KaneAI

KaneAI is a GenAI native end-to-end test assistant for high-speed quality engineering teams. It is built on modern LLMs, where you can write test steps in natural language command instructions.

It can be used to generate unit tests using high-level objectives or tags through third-party software such as Jira, Slack, and GitHub, and debug errors automatically. The unit tests generated here can be integrated with the CI/CD pipeline for enhanced testing.

Once tests are generated, they need to be run and managed regularly. You can look for tools that do more than just basic input-output tasks, and that’s where LambdaTest’s AI-native Test Manager comes in.

With LambdaTest Test Manager, you get everything in one place — test case creation, management, execution, and reporting. You can create test cases manually or use AI to speed things up.

2. ChatGPT

ChatGPT is one of the most popular GenAI tools. It takes English-based prompts (test steps) and generate unit tests.

It helps you with code explanation, refactoring, debugging, and optimization. It supports multiple programming paradigms, such as object-oriented and functional programming, tailoring responses based on user requirements.

3. Claude

Claude is an AI assistant built by Anthropic, working on Generative AI technology similar to ChatGPT. It takes input from the user and presents the output after analysis. For AI unit test generation, the input can be the instructions to generate unit tests.

Similar to ChatGPT, it comes in free and paid versions. The free version has limited features and a reduced model performance compared to the paid version. The tool is more inclined towards code generation, which makes it a good choice for automatically generating unit tests.

4. GitHub Copilot

GitHub Copilot is an AI unit test generation tool that seamlessly integrates into Visual Studio Code and provides multiple model options for interaction.

It can take multiple programming files as input and update all of them based on the input provided. Therefore, when unit test generation is required, you need not worry about finding the context of multiple files to edit, which ultimately saves a lot of time.

5. Diffblue Cover

Diffblue Cover helps you generate unit tests, specifically in Java. It can be integrated into IntelliJ and CI pipelines, generating automatic unit tests by understanding the code in the files and covering all the edge cases.

It monitors the code files for which the unit tests were generated, and when any change is found, the unit test cases are automatically adjusted accordingly. In addition, this AI unit test generation tool can provide test coverage details in a visual format.

6. Workik

Workik is an AI-powered platform that simplifies the software development process by automating various tasks, including unit test generation. It has an AI-driven unit test case generator that generates test cases for multiple programming languages.

It provides a VS Code extension that enables effortless test case generation and debugging assistance within the code editor.

7. Functionize

Functionize is an AI-powered testing platform that leverages machine learning to automate test creation and reduce the need for manual test creation.

It can detect and fix issues on its own, so you don’t have to spend time troubleshooting. With Generative AI, Functionize also generates a variety of test cases, making regression testing more thorough and keeping software stable.

8. Bito

Bito is an AI-driven coding assistant that streamlines your development process by automating test generation and code reviews. It integrates seamlessly into your development lifecycle, automatically generating and updating unit tests to achieve 100% code coverage.

Its capabilities extend to generating function/method tests, including boundary and edge cases. This enhances code reliability and reduces the time developers spend writing tests.

9. UnitTestBot

UnitTestBot is an IntelliJ plugin that generates tests and human-readable test descriptions. The test cases generated through UTBot do not require manual intervention. They are “ready to use” with valid inputs, method bodies, assertions, and comments.

The rest of everything is taken care of by the tool. UTBot also claims to find hidden bugs in the source code with a 0 rate of false positives. It means all the hidden bugs it finds are indeed real and would have impacted the application at some time. This is a great feature to increase the test coverage and enhance the application’s quality.

10. Windsurf

Windsurf is an AI-powered extension available for popular IDEs such as JetBrains, VS Code, Eclipse, Visual Studio, and Xcode.

It can be used to interact with the code editor and generate unit tests in simple English. However, instead of automatically generating the tests, the tester has to specify the method name using “@,” and the tool can only generate 60–70% of the tests.

Challenges With AI Unit Test Generation

Though AI unit test generation can help optimize your testing process but it comes with a few challenges:

AI models heavily rely on large volumes of high-quality data for training and decision-making. However, gathering and curating such data is often more difficult than it seems. If the data is insufficient or of low quality, it can result in incorrect predictions and reduce the effectiveness of the AI model.
Some AI models — especially those based on deep learning can make it hard to understand how they reach their conclusions. So, this lack of transparency can lead to mistrust, especially when the model makes predictions that turn out to be wrong or unexpected.
AI models may sometimes report defects that don’t exist (false positives) or miss real ones (false negatives). These issues can lead to wasted effort or overlooked bugs, reducing the overall testing efficiency.
You also need to frequently maintain and update AI models to retain their effectiveness when scaling software applications. Without proper efforts towards updates and maintenance, such models can quickly lose their respective relevance and turn out to be outdated.

Conclusion

Unit tests play an important role in reducing bugs, maintenance time, and all the costs associated with these processes. They can point out bugs at specific locations at the start of the cycle and perfect each module as the code base increases.

However, with strict deadlines and shorter timelines, unit testing does get sidelined, often completing the test cases for formalities and writing them according to the methods so that they do not fail and consume more time.

While we cannot shorten the time it takes to write test scripts for the feature, we can leverage AI to generate unit tests automatically, and need not worry about maintaining them in the long run.

What Is Machine Learning Automation (AutoML)

Harish Rajora — Fri, 20 Jun 2025 06:05:04 +0000

Machine learning automation, or AutoML, is a technique used to automate the process of design, training, optimization, and deployment of machine learning models.

AutoML techniques help stakeholders create ML models and deploy them efficiently, even for those without deep expertise. Various tools streamline the machine learning pipeline to implement automation. Some tools focus on specific tasks, such as model selection, while others automate the entire workflow.

In this blog, let’s look at how to use machine learning automation to automate the process of creating ML models.

What Is Machine Learning in Automation?

Automated machine learning, or machine learning automation, involves automating the process of developing a machine learning model. A machine learning model is the final result of a long chain of sequential processes, where the output from one process goes to another.

For instance, a machine learning model first preprocesses the data, prepares the data for training, trains on the data, tests on the testing data, uses an algorithm based on the goal of the product (such as a classifier), and then repeats all these steps on different models to check highest compatibility.

All these steps have to be performed each time a model needs to be developed, and they consume a lot of time. AutoML or machine learning automation automates all these processes and provides a final model ready to be incorporated into the software backend.

Why Is Automated Machine Learning Important?

Automated machine learning provides a lot of benefits to the team working on it:

Since AutoML automates all the manual work to develop the models, non-experts in machine learning can also use AutoML to achieve the same outputs.
Big tech giants use AutoML tools with a dedicated team that works only on machine learning. They constantly tune their machine learning automation process and include high-quality algorithms with greater accuracy.
When it comes to time savings, AutoML saves a lot of time, as almost all the work is done by AutoML tools. Moreover, since human resources are not involved in the machine learning model development process, the time saved can be utilized in other processes, such as model integration, enhancing the team’s productivity. Hence, the software can be built in less time, which means the cost involved will also be less.

How Does AutoML Work?

AutoML works in various steps, the end of which generates a model for implementation in the software application.

Collect Data: The first step in AutoML is data collection. This step is manual and testers are expected to either search for a dataset or create their own (not recommended as it takes a lot of time). It is an extremely crucial step as all the AutoML steps are performed after it considers data for their execution. If the data quality is inappropriate, the model will also show anomalies. The collected data is then fed to the AutoML system as input.
Define the Problem: In this step, a problem is defined within the AutoML tool, enabling it to understand the context, relate it to the data, and generate the most suitable model. Examples of this are classification and forecasting.
Preprocess Data: The next step is the preprocessing of data which is done by the AutoML tool automatically. In this step, the data is cleaned and transformed according to the requirements of machine learning automation. While this process is done by AutoML tools, it is highly recommended to manually preprocess the data as well for higher quality.
Configure Parameters: The AutoML tool provides various parameters to tweak during the model development process. Developers can provide the values and alter the default values based on their requirements.
Train the Model: In the next step, the AutoML tool trains a model on the submitted data, determining its performance and accuracy based on various parameters.
Identify the Correct Model: The data is then trained using various models. This step determines the best model according to the data and the problem defined.
Review the Model: The model leaderboard is then generated and presented to the user with results that include parameters like accuracy. The team can review the model, test it using different data, and if satisfied, start using it in their software application.

Except for the data collection and defining the problem, everything is taken care of by the AutoML tool.

AutoML for Different Data Types

Machine learning models are created for different purposes and each of those purposes is satisfied by only a certain type of input data.

For instance, if you want to create a model that can detect fraudulent transactions in a banking system, you have to train that model using financial transaction data where each transaction is labeled as “Fraud” or “Legitimate.”

Users leveraging AutoML tools can work with various data types, including:

Image Data

Computer vision is a discipline of machine learning in which the model can recognize and classify an object according to pre-defined labels based on the training data.

When machine learning automation is brought into the picture, it takes over the identification tasks of certain features that will guide the model in classifying that particular object without manual intervention.

The quality of data, however, plays a key role in the training of the model. The images used should be diverse, including the object requiring classification.

Video Data

Image-based categorization can be extended to video data, incorporating additional factors for analysis. AutoML tools working on video data can generate models that can identify objects in a video, analyze their actions, and understand voice commands.

However, it is worth noting that AutoML tools with video support are not currently commonly available due to their higher complexities and low accuracy.

Tabular Data

Tabular data provides information in the tabular form, where the identifier is the class to which each data point belongs. The main goal behind training with the tabular data using AutoML is categorizing the new data into pre-defined classes.

For instance, the team can provide the data based on identifiers that result in declaring an email as spam or not spam. These identifiers can be words used, emails used, etc.
When the same process is done on numerical values, it is called regression. In this data, the final classes are not categories but numerical values.

Another branch of tabular data is time-series forecasting. In this process, the goal is to forecast a certain value in the future based on current trends and past values.

Time-series forecasting is kept as a separate discipline because of its dynamicity and involvement of a high number of variables, such as seasonality and changing trends with time.

Due to such variables, a large number of quality models often fail to work on time-series, and AutoML is often the recommended path to follow.

Textual Data

Textual data is used to train machine learning models primarily for natural language processing. In this discipline, AutoML tools aim to understand the text and make sense of it.

It is done by training the model with appropriate text with pre-defined categorization of information. AutoML tools are expected to include high-quality Bidirectional Encoder Representations from Transformers (BERT)-based models that are finely tuned and work with very high efficiency when it comes to natural language processing.

The type of data to use depends on the problem the team is trying to solve. The team should take its time collecting data, as the quality and type of this data, will determine the quality and type of subsequent phases, resulting in a better model.

Role of Machine Learning in Automation Testing

The inclusion of machine learning in automation testing has played a critical role in revolutionizing how a tester used to perform tasks earlier. It has seeped into almost every task associated with testing, bringing immense benefits to the team.

Machine learning in test automation includes:

Supervised Learning: It uses labeled datasets to assess risks.
Unsupervised Learning: It detects errors and patterns in data.
Reinforcement Learning: In this, neural networks improve through a reward-and-punishment system to minimize flaws.

Here are the use cases of using machine learning in test automation:

Test Case Generation

Machine learning can also generate test cases automatically when a context is given to it.

For instance, providing input such as “test login functionality on www.abcwebsite.com/login" can generate all the steps automatically in the English language without any manual interruption.

Let’s take an example of an AI-native unified Test Manager platform by LambdaTest. It comes with integrated test case authoring and execution capabilities that centralize all test case-related information.

Test Data Generation

Many domains of automation testing require extensive, diverse, and boundary-scenario-covering high-quality data. Defining, collecting, and arranging such data takes a lot of time, as the table can sometimes expand to hundreds of rows. However, machine learning can perform all these steps within a few seconds.

Depending on the model on which the tool is developed using AutoML, generating high-quality data is often just a simple query away as “generate data for login functionality where the password needs to be alphanumeric and contain one special character”.

It is also essential to know that the better your prompts are structured, the better the model will understand the context. You can learn more about the best AI/ChatGPT prompts for software testing.

Test Generation

Authoring and maintaining tests (especially complex ones) has been one of the most time-consuming tasks of automation testing. They require specific programming skills and tools to conduct testing.

Machine learning has been a savior and most widely implemented technology when it comes to test authoring or when you have to generate tests. The NLP branch of machine learning can eliminate the use of programming language, take the script input in the English language, and understand the context (or intent) behind it.

For instance, GenAI native test agents like KaneAI by LambdaTest leverage natural language processing to generate tests effortlessly through natural language command instructions.

To get started, refer to this getting started guide on KaneAI.

With the rise of AI in testing, its crucial to stay competitive by upskilling or polishing your skillsets. The KaneAI Certification proves your hands-on AI testing skills and positions you as a future-ready, high-value QA professional.

Visual Testing

Identifying visual anomalies manually on a web page is difficult. The testers have to go through each pixel and match it to the base image to verify the page’s correctness.

When manual inspection is completed, the pixels are often matched through scripted programming for each web page on the website. This takes a lot of time and if a bug is found, the whole process has to repeat.

Machine learning automation can identify pixel differences (down to single pixel differences) within a few seconds. They are the most efficient solution to this problem and can also be included in regression test suites and run hundreds of times daily.

For example, AI-native platforms like SmartUI offer smart visual UI testing to check websites and mobile apps for visual deviations.

Defect Prediction

Machine learning automation lets you predict future failures in the current code or infrastructure. This helps identify potential bugs (and defects) in code that have passed regression and functional tests but will raise issues in the future.

Such bugs have the highest probability of breaking the production and spoiling the user experience. That’s why having models that can predict failures is a valuable asset to the team.

What ML Tasks Should You Automate?

Machine learning automation can be used in different domains to accomplish a variety of tasks. Some of the tasks where the users can opt for AutoML are as follows:

Text-based content is all over the Internet and serves as a great medium to communicate with the reader. However, when automated tools like chatbots interact with such content, they may not understand the intent and emotion of the text. This results in straightforward, machine-like responses that can be frustrating for the end-user. Automating intent detection with ML models can improve user interactions. For example, in a custom support tool or system, these models can automatically recognize the intent of the messages (positive, negative, or urgent) and prioritize tickets accordingly for faster resolution.
Analyzing images is one of the most common use cases of machine learning. When there is a task where images are to be analyzed, and certain objects are to be identified in them, it is best to automate these tasks with finely tuned models available.
Prediction and forecasting help in getting future value based on past data, current trends, and other variables. Such predictions and forecasting are extremely valuable in strategizing before the time and getting a glimpse of the future to evaluate it.
Classification is one of the most focused areas of machine learning due to its wide usage across different domains. No matter what field the team is working on, they can easily spot an area where classification can fit perfectly.

Machine Learning Automation Tools

To take advantage of machine learning automation, you need to adapt to the right tool built for building models.

The most commonly used tools for AutoML are as follows:

Google Cloud AutoML: It offers tailored machine learning models for different needs such as AutoML Image for image-based tasks, AutoML Translation for language translation, and more. It follows the same process Google uses, making it a reliable and scalable choice for projects of any size.
Amazon SageMaker Autopilot: SageMaker Autopilot builds ML models with full transparency, handling tasks like classification, regression, and prediction. It can process incomplete datasets, fill in missing values, and rank models based on key metrics like accuracy.
Azure Machine Learning: Azure’s AutoML supports classification, regression, vision, and NLP while integrating with Spark Cluster for scalable cloud-based processing. It also lets users deploy pre-trained models from OpenAI, Hugging Face, Meta, and Cohere.
IBM AutoAI: It extends AutoML by adding features like model testing, scoring, code generation, and risk management. It streamlines AI lifecycle management, embeds ModelOps into workflows and cuts costs by automating the entire process.
H2O AutoML: It supports hyperparameter tuning, iterative modeling, and feature engineering. It works with R, Python, and a no-code GUI and integrates seamlessly with Hadoop, Spark, and Kubernetes for scalable model developon, and a no-code GUI and integrates seamlessly with Hadoop, Spark, and Kubernetes for scalable model development.

Conclusion

Artificial intelligence has become a mandatory technology in our software today. It not only brings a lot of benefits, such as cutting down time and costs for each task but also helps in being competitive and ahead of competitors.

However, the road to this integration is not an easy one. It requires multiple time-consuming steps ranging from data collection, pre-processing, running data on multiple models, feature generation, and many more. Moreover, all this can only be done by an expert in AI who themselves costs a lot of money to the company.

AutoML is the answer to all these problems, bringing machine learning model development into the automation world where each of the above processes can be completed without any manual intervention or monitoring. These software are designed to compare multiple models and provide the best possible solution to the users.

February’25 Updates: Accessibility Test Scheduling, Latest Features in SmartUI, Insights, and More! | LambdaTest

Salmankhan2389 — Tue, 17 Jun 2025 08:59:24 +0000

February might be the shortest month, but we made every day count with new features and improvements tailored just for you.

Check out the below updates that will make your experience smoother, faster, and better than ever.

Schedule Scans With Accessibility Scheduling Feature

Ensuring accessibility is an ongoing activity. However, keeping up with regular accessibility testing can be challenging, and you may miss running checks that can lead to compliance risks, and manual testing takes time, as well. That’s where scheduling comes in.

It helps schedule accessibility scans, allowing you to stay proactive, catch issues early, and maintain compliance without additional manual effort.

To streamline this process, we have released the Accessibility Scheduling feature. This feature allows you to schedule (or automate) recurring or one-time accessibility scans, reducing your manual effort while ensuring your websites and web applications comply with the Web Content Accessibility Guidelines (WCAG).

Other than rolling out this feature, we have also added the following support:

You can schedule accessibility scans for locally or internally hosted web pages with Tunnel.
While running accessibility tests, you can send bug reports straight to bug-tracking tools like Jira without leaving your accessibility testing workflow.

Test Websites in Real Time With Self-Signed Certificates

Some web features work only in a secure environment (HTTPS). When testing HTTPS-only features in an internal or staging environment, teams often rely on self-signed certificates instead of certificates issued by trusted authorities.

To make your testing even more secure, we have added self-signed certificate support in real-time testing to test your locally hosted websites and web applications.

With this update, you can test locally hosted websites and web applications that are in internal, pre-production, or secure environments without interruptions.

Debug Flutter Tests on iOS With Console Logs

Debugging Flutter tests on iOS is now more efficient. You can now view console logs directly for debugging. Earlier, you had to go through lengthy instrumentation logs to troubleshoot issues, which made the process time-consuming.

However, this update makes real Flutter logs available, allowing testers to quickly spot errors and debug without extra hassle.

Looking to test your Flutter apps on iOS? Check this guide on Flutter Dart testing with iOS.

Important Update: Starting February 26th, the support for iOS 12 devices is no longer available on our real device cloud. We will also deprecate the support for iOS 13 devices soon, with at least two months’ notice before removal.

Latest Features Roll-Out in SmartUI

In our continuous effort to enhance your visual testing experience, we’ve rolled out several features in SmartUI.

Improved UX for Drawing Regions on Screenshots: We’ve enhanced our screenshot comparison tool to ignore or select annotated regions. You can now draw directly while zooming, panning, and pinching for seamless navigation. An enhanced draw cursor improves speed and accuracy and makes it faster and easier for you to highlight differences.

Bulk Review of Screenshot Variants: The new bulk review feature lets you do a bulk review of screenshot variants. You can accept, reject, or move multiple screenshots variants in a single action. This will reduce your repetitive work and make the review process more efficient.

SmartIgnore Now Works With SmartUI Public APIs and Integrations: SmartIgnore now integrates with SmartUI public APIs, giving you more flexibility in visual testing. You can easily use SmartIgnore with SmartUI fetch APIs to speed up and refine your visual comparison process. It also supports email and Slack, so you get instant updates right where you work.
Move PDFs and Their Individual Pages to the Baseline: You can now move entire PDFs or select their individual pages to the baseline. It provides you a better control over approval workflows and simplifies your document-level and page-level verification.
Execute JavaScript Code on Target URLs With SmartUI CLI: The SmartUI CLI now supports executing JavaScript before capturing snapshots. You can interact with dynamic elements, modify content, and manage loading states. Refer to the documentation to execute custom JavaScript code with SmartUI.

Enhancements and Features in HyperExecute

We continue our effort to enhance HyperExecute, bringing new capabilities. Here are some of the newly added features:

Artifact Extraction on Job Abortion: Artifacts will now be extracted even if a test job is aborted midway. Therefore, you can access partial test results and logs to analyze failures, debug more effectively, and review critical test data even if the execution is interrupted.
afterEachScenario Flag for Test Cleanup: The afterEachScenario flag in HyperExecute lets you automate post-test scenario tasks, helping maintain test isolation and consistency. This flag executes cleanup activities such as clearing cookies, resetting databases, or capturing logs after each test scenario.
Role-Based Access Control (RBAC) for Projects: We have implemented Role-Based Access Control to improve project security and access management. You can now assign specific roles with predefined permissions so that only authorized individuals can access or modify project settings and resources.
UI/UX Enhancements for Performance Testing Jobs: We’ve improved the UI/UX for managing and analyzing performance testing jobs, making navigation smoother and more intuitive. A new group-wise error view categorizes errors for better readability and faster troubleshooting.

Additionally, we’ve introduced a toggle feature that lets you switch performance metrics between Milliseconds and Seconds, providing more flexibility in analyzing test execution times.

Test on New Browser Versions: You can now test on new browser versions for Microsoft Edge — 133.0.3065.31 and 133.0.3065.39.

New Features in Insights

To provide deeper visibility into your test execution, we have added some new features in Insights:

Filter Custom Data for Builds: We have added the customData capability for Build Comparison that allows you to filter and compare web automation builds. You can also analyze specific test scenarios based on the tags or metadata you’ve defined.

New Widget for App Automation: We have introduced a new widget for App Automation that provides visibility into your test execution metrics.

This widget helps you track the total number of unique applications under test and provides valuable insights into test coverage and application performance.

Export Usage Reports in Excel Format: You can now export Insights Usage Reports directly to Excel, making it easier to analyze, share, and integrate data into existing workflows.

Since all data formatting and structure are preserved, you can seamlessly integrate these reports into your existing Excel-based workflows.

New “Created by” Column for Dashboards: The Dashboard list now includes a “Created by” column that indicates who created a dashboard.

Sort Insights Data Based on Column: The Insights drill-down experience has been improved with column sorting functionality.

Admin Controls for Accessing and Managing Dashboards: Admins can now access and manage all Insights dashboards within their organization, irrespective of who created them.

Filter Deleted/Disabled Test Builds: You can now exclude disabled tests from your dashboards for clearer insights. Removing disabled and deleted tests from your data can help you provide a more accurate view of your current testing workflow.

All in All!

February brought a range of enhancements to make testing more efficient and seamless. With features like accessibility test scheduling, SmartUI improvements, and better debugging for Flutter tests on iOS, these updates will simplify your workflow.

Make the most of these new capabilities, and keep your feedback coming!

March’25 Updates: iOS VoiceOver Support, New KaneAI Features, and More! | LambdaTest

Salmankhan2389 — Tue, 17 Jun 2025 07:05:55 +0000

What’s new since our last round of updates?

A whole lot, actually 😀

Here’s a quick look at some of the latest features we’ve rolled out to elevate your testing experience.

VoiceOver Support on Real iOS Devices

You can now use VoiceOver on real iOS devices to manually test the accessibility of your mobile apps.

This helps you understand how your mobile app works for users who rely on screen readers-especially those with visual impairments. It lets you check if the content is readable, navigation makes sense, and interactive elements are announced correctly.

New Feature Releases in KaneAI

We’ve added a bunch of new features to KaneAI to give you more control, flexibility, and ease during test creation and execution.

Change Your App While Editing Mobile Test Cases

Now, you can change or update the mobile app you’re testing right in the middle of editing a mobile test case in KaneAI. So, there is no need to start over from scratch for every new mobile app.

Let’s say you need to switch to a different version or configuration of your mobile app while working on a test case-you can do that without losing your progress. Your test steps will stay put and adjust to the new mobile app. Therefore, you don’t have to redo everything.

“Auto login through Google” Feature for Android Native App Automation”

KaneAI now lets you log into a Google account on Android devices while creating native app test cases.

Using the Play Store login flow, you can sign in with your credentials-no Multi-Factor Authentication (MFA) is needed. This makes it easier to access and test Google-integrated apps during test creation while keeping things secure and efficient.

Debug Web Automated Tests With Network and Console Logs

You can now capture network and console logs in KaneAI while running web automation tests.

You’ll get detailed info like network requests, responses, browser errors, and JavaScript logs for debugging, checking API calls, and spotting what went wrong in your test.

These logs are saved and ready for you after the test run, giving you better visibility into performance and failures.

Run Web Tests With Chrome Options Support

You can now set Chrome browser options before starting a web test in KaneAI. This lets you set things like headless mode, disable extensions, or block pop-ups.

This is useful if you’re testing features that rely on specific browser settings or want to make tests run faster by disabling unnecessary features.

Replace URL for Test Runs Across Different Environments

You can now run the same test case across staging or production without editing your script. Just set up dynamic URL replacement in KaneAI, and it will update the environment link automatically during test runs.

This helps avoid mistakes from manual edits and saves time when testing across multiple environments. It’s especially useful when you’re validating the same flow in different builds or need to quickly switch between environments without duplicating or rewriting test cases.

Use Smart Implicit Waits for Managing Network Requests

KaneAI now supports smart implicit waits that automatically pause the test for network activity to complete. You don’t need to manually add waits or guess the right delay anymore.

The test will continue only when the network response is ready. This reduces flakiness and improves overall test speed. It’s helpful when dealing with web pages that load content asynchronously or when network delays are common.

Run KaneAI Tests With LambdaTest Tunnel

You can now run tests on local or private environments using LambdaTest Tunnel in KaneAI. Just select a tunnel during test execution-whether through the UI or API-and KaneAI will connect to your local setup.

This means you can test websites or mobile apps that aren’t publicly available without exposing them online. It’s useful for testing development builds, staging servers, or behind a firewall.

Test Firebase Mobile Apps on Real Devices

You can now integrate your Firebase App Distribution account directly to LambdaTest and instantly push apps to real Android and iOS devices in the cloud.

No more downloading and re-uploading builds-just link your Firebase project, and your mobile app is ready to test. It’s a faster way to test beta builds, bug fixes, or new features on actual devices without the back-and-forth.

Also, you can easily share your Firebase apps with teammates so everyone’s testing from the same source.

Refer to this documentation on how to test apps installed via Firebase.

Latest Releases in SmartUI

SmartUI just got a lot more powerful-now supporting DOM-level controls, XCUITest for iOS, and much more.

Draw Regions and Use DOM-Based Ignore/Select in SmartIgnore

You now have greater control over what parts of your web application get checked during visual testing. With the new region drawing tool in SmartIgnore, you can manually define specific areas to test. It is helpful when only certain sections of the UI are relevant to your test case.

You can also ignore or select annotated regions by targeting DOM elements. For example, if any specific component, like dynamic banners or rotating ads, is constantly changing, you can exclude them from the comparison. This reduces false positives and helps focus your visual testing on the actual UI changes that matter.

SmartUI Capabilities Support for Selenium SDKs

If you run Selenium tests using Java or JavaScript, the SmartUI SDK now supports defining capabilities directly within the SDK itself. You can set browser versions, OS configurations, resolution settings, and more-all from your test script.

The SmartUI SDK capabilities remove the need to maintain separate configuration files or override them externally. It streamlines how you set up your Selenium tests and ensures that the visual regression suite runs exactly how you expect in different test environments.

Draw Regions and Use DOM-Based Ignore/Select in SmartIgnore

The SmartUI CLI Exec commands allow you to manage the SmartUI snapshot server more easily. You can now start, stop, and check the status of the snapshot server directly from the command line-no need to manually open a separate process or check logs elsewhere.

This is useful when you need to control when and how the snapshot server runs in your automation pipeline or during local debugging. It gives you more operational control and helps reduce test flakiness caused by mismanaged server states.

Test Native Apps With Appium Using SmartUI App SDK

The SmartUI App SDK now supports running visual regression tests with Appium Java on real devices. You don’t need to rely on screenshots captured manually-this SDK automates the entire process.

You can also integrate SmartUI App SDK into your CI/CD workflows and test directly on any supported cloud platform, including LambdaTest.

Run Mobile Visual Tests With XCUITest Framework

You can perform mobile visual testing with XCUITest with SmartUI. It lets you automate visual regression tests for iOS apps using the native iOS test framework. You can capture snapshots during test runs and compare them against baselines to catch unwanted UI changes, all while continuing to work in the XCUITest ecosystem.

Run Visual Tests Using SmartUI SDK With Tunnel

You can use SmartUI SDK with Tunnel to test apps running in local, private, or staging environments. This is particularly useful when your application isn’t exposed to the public internet but still needs visual validation.

Just start a secure tunnel from your local machine or test environment and run your visual regression tests like you normally would. You’ll be able to catch layout issues or broken styles in isolated environments before deploying to production-without compromising security.

Latest Enhancements in HyperExecute

We’ve also made some key enhancements to HyperExecute. Here’s a quick look at what’s new:

Parameterize Appium Flag for iOS Simulation on Desktop Browsers: You can now control iOS simulation behavior on desktop browsers by setting a parameterized appium flag. This lets you toggle simulation based on test requirements without altering the script. It brings more flexibility to cross-platform testing setups.
Use the reporterConfigFile Option in cypressOps for Custom Reporter Setup: Cypress users can now specify a custom reporter configuration file using the reporterConfigFile option in cypressOps. This allows you to plug in advanced reporting tools with minimal setup.
Run .NET Tests Using the runtime Flag With Versions 4.7 and 4.8: You can now run .NET tests by specifying the runtime flag for versions 4.7 and 4.8.
Define Project Name and Auto Create Project With projectName Capability: The projectName capability lets you define and auto-create projects directly from your test configuration. No need for manual project setup each time.
Generate Consolidated Native Robot Test Reports: HyperExecute now supports consolidated reporting for native Robot Framework test runs. Instead of navigating through multiple logs, you get a single, unified report. This makes analysis faster and simplifies reporting for large test suites.

Get Deeper Visibility With Private Desktop Insights

You can now access detailed analytics for your desktop testing with the new Private Desktop insights -now live in beta.

With this feature, you can track exactly how your test devices are being used: how many tests were run, how long devices were active, and which environments were used most.

You also get usage breakdowns by user, group, or sub-org-so you can easily spot trends, boost adoption, and plan smarter. Use filters like date, browser, OS, hostname, and more to slice the data however you need.

View, Schedule, and Download Reports in the Test Manager

We’ve introduced a new Reports feature in Test Manager to help you stay on top of your testing efforts with ease. You can now view, schedule, and download reports-all from one place.

The Reports feature lets you generate two types of reports: Execution and Traceability.

Execution Report

With this report, you can track your test execution history in detail and see how your test runs are performing over time with data like:

Number of passed/failed tests
Test durations
Execution trends across cycles

Traceability Report

With this report, you can gain end-to-end visibility by connecting test cases to their related:

Requirements
User stories
Bugs and defects

Summing Up!

Last month, we brought the heat with a fresh batch of features in KaneAI, SmartUI, and HyperExecute to level up your testing game.

April’ 25 Updates: HyperExecute MCP Server, Schedule Tests With Test Manager, and More!

Salmankhan2389 — Tue, 17 Jun 2025 06:31:23 +0000

Hey there — we’ve rolled out new features across our different product lines to help you test smarter and faster.

HyperExecute now comes with an MCP Server to boost performance and control. We’ve added test scheduling feature in KaneAI, and there are more awesome updates.

Let’s uncover them one by one!

Live With HyperExecute MCP Server

When you want to scale your testing, setting up test runners, managing test execution, and dealing with errors can slow things down. That’s why we built the HyperExecute MCP Server. It helps you with test configurations that used to take weeks and gets it done in minutes.

HyperExecute MCP Server is an AI-native platform that understands your codebase to generate test commands and create YAML config files right inside your IDE.

It provides real-time insights from Agentic RAG and helps you speed up your test execution by up to 70% faster than with regular cloud grids.

Other than launching the HyperExecute MCP Server, we have also made some other enhancements in HyperExecute:

Validate HyperExecute YAML File With validate Flag: You can now ensure your YAML file is correctly formatted with the -validate flag. This you can do without running any tests. The -validate flag allows you to verify the correctness of your YAML configuration before test execution.
Use the failFast Flag at Scenario Level: The failFast flag is now supported for the scenario level. Therefore, instead of stopping the entire test suite, you can now stop specific scenarios after a defined number of failures.

Schedule Test Runs With KaneAI

With KaneAI, you can now schedule test runs for specific times. This way, you don’t have to start them manually every time.

You can set parameters like network logs, console logs, and some other advanced options, too. This will help you manage test runs better, but without needing to check in constantly.

Check out this video for a complete summary of what’s new in LambdaTest , all the latest product updates in one place.

Test Flutter Apps With Appium on Virtual Devices

You can now test Flutter apps on Android emulators with Appium. This means you can easily test your app on different screen sizes and OS versions without needing to set up your emulators.

Also, you can plug these Flutter web app tests into your CI/CD pipeline with our APIs, so your tests run automatically. You’ll get detailed logs, screenshots, and videos to help troubleshoot issues.

To get started, check out this guide on testing Flutter apps on Android with LambdaTest.

Note: In addition, we have also integrated with Flutter Integration Driver, which allows you to test Flutter apps on Android emulators and iOS simulators.

Latest Features in App Automation

We’ve added new capabilities for App Automation. Now you can interact with devices in real time, control Bluetooth, and simulate GPS locations during your test runs.

Interact With Android and iOS Devices in Real-Time: You can now interact with real Android and iOS devices in real-time while running web automated tests.
Control Bluetooth Settings During Test Sessions: Bluetooth control is now available for real Android and iOS devices.
Set Custom GPS Coordinates: You now have the ability to set custom GPS coordinates during your tests.
Manage iOS Keychain Cleanup and Access Groups: Keychain services by Apple provide a secure mechanism for mobile apps to store sensitive info like passwords, certificates, and authentication tokens.

Run Real-Time App Tests With Bluetooth Support

In addition to App Automation, we have also added support for Bluetooth control in real-time mobile app testing.

During live-interactive test sessions, you can now switch Bluetooth on or off directly from the console and test your app features that rely on Bluetooth connectivity.

New Features in Insights

We have rolled out three major features in Insights to help you optimize app performance, speed up debugging, and get deeper insights from your test data.

Monitor Performance in Real-Time With App Profiling Dashboard: The new App Profiling dashboard gives you a clear view of how your app behaves during tests on real devices.

It tracks eight key performance metrics:

CPU usage
Frame rate
Memory usage
Battery consumption
Network activity
Device temperature
Cold start time
Hot start time

With this dashboard, you can easily identify bottlenecks, correlate different metrics, set performance benchmarks, and optimize app behavior across real devices. It also provides practical tips to improve each metric.

Categorize Test Failures With AI: Manually identifying test failures is time-consuming.

Therefore, we have released the feature, AI-native test failure categorization in Insights, that helps you speed things up by automatically grouping failures based on environment, browser, OS, and error patterns.

Create Your Own Custom Dashboard Widgets: You can now build your own custom dashboard widgets in Insights. This feature gives you the flexibility to create the exact visualizations you need.

Benefits:

Select any supported values for both X and Y axes.
Organize data using your preferred group-by fields.
Apply multiple filter conditions to zero in on the right data.

Fresh Set of Features in SmartUI

Test Locally Hosted Websites Automatically With SmartUI SDK and Tunnel: The SmartUI SDKs now come with automatic tunneling support to test websites and web applications hosted in local or private environments. Instead of manually setting up tunnels every time, with SmartUI SDK and LambdaTest Tunnel, you can now configure everything directly within your SmartUI configuration file. You get the flexibility to choose how you want to manage the tunnels. In automatic mode, SmartUI sets up the tunnel for you.

Just add a simple tunnel object in your config file with type: “auto“, and it will pick up your LambdaTest credentials from environment variables to create a secure connection.

If you prefer more control, you can go with manual mode by specifying the tunnel name using type: “manual“. You can also fine-tune the setup by configuring ports, proxy settings, or local directories.

Compare Layouts With SmartUI SDK: You can test layouts with SmartUI SDK to check if the structure of your UI stays consistent, regardless of device, browser, or environment. Layouts often break when content changes or when the same page is viewed in a different language. This feature helps catch those issues early by focusing only on how elements are arranged, not on how they look.

It intentionally ignores changes in text, colors, font sizes, margins, and images. Instead, it checks whether UI components maintain their intended positions and relationships.

This is helpful for localization testing or when maintaining layout reliability across viewports.

View Coded Regions Directly on SmartUI Dashboard: You can now view coded regions areas you’ve defined in your test scripts to be included or ignored directly on the SmartUI dashboard.

With this feature, these regions appear as overlays alongside any manually drawn ones. So, this helps you ensure consistency between coded and drawn regions and reduce misconfigurations.

Log Bugs With Assembla Integration

Assembla is a cloud-based platform that provides robust version control capabilities, supporting industry-standard systems like Git and even enterprise-focused options..

We have now integrated with Assembla to enhance your bug tracking process. With Assembla integration with LambdaTest, you can log issues directly from the LambdaTest platform to the Assembla instance, assign them to team members, and include screenshots during test sessions.

Wrapping Up!

That’s all for this round of updates. You can now schedule test runs with Test Manager, test Flutter apps using Appium on virtual devices, and do much more.

Real-time app testing now comes with Bluetooth support, and we’ve packed in new features across Insights and SmartUI. You can also log bugs straight into your workflow with the new Assembla integration.

Go try out these features, see what works for you, and let us know how it goes. We’re not done yet more’s on the way!

How to Handle Dropdowns Using the Cypress .select() Command

Alex Anie — Tue, 03 Jun 2025 14:49:50 +0000

Dropdowns can be challenging to handle due to dynamic options, inconsistent values, or differences between displayed text. In Cypress, you can overcome this challenge using the .select() command.

It allows you to handle (or select) dropdowns by visible text, value, or index. The Cypress .select() command is a built-in function that interacts with and performs tests on the selected elements in a web application.

In this blog, you will learn everything you need to know about using the Cypress .select() command.

What Is Cypress .select() Command?

The Cypress .select() command is a built-in function that is used to select a tag within the WebElement. It retrieves the selected tags and performs tests on them.

.select(value)
.select(values)
.select(value, options)
.select(values, options)

The Cypress .select() command takes in two arguments, the first being value, which can be any of the following; value, index, or text content of the tag.

The second argument is optional but can be specified as a configuration object. For example, (force: true) can be used to undo the default behavior of the .select() command.

HTML:

<select>
 <option value="one">apples</option>
 <option value="two">oranges</option>
 <option value="three">bananas</option>
</select>

JavaScript:

cy.get('select').select(0).should('have.value', 'one')

Here, we get the WebElement and pass in an integer with a value of zero; then, we assert that the selected WebElement should have a value of “one” as a means of validation before test execution.

The Cypress .select() command is used to handle both types of dropdowns: static and dynamic.

How to Handle Static Dropdowns?

Static dropdowns are a type of select control in which the selection content is loaded in the browser as soon as the page loads. They are usually hard-coded into the HTML of the web page.

There are different ways to select static dropdown options using the Cypress .select() command, including selecting by index, value, or text.

Select by Index

Select by index is one of the methods that can be used to select tag within the element. The index refers to an integer that represents the number of tags within the parent element. The first element is identified as 0, and then the second as 1, and so on.

To see this in action, let’s use the LambdaTest eCommerce Playground.

Open the LambdaTest eCommerce Playground on your web browser.
Press the Tab with F12 on your keyboard to launch the DevTools.

#entry_212434 #input-sort-212434

Copy the above CSS selector and press CTRL + F. Then, paste the CSS selector in the find box indicated by the red box.

This should target and select the right WebElement as highlighted in the yellow color below:

After identifying the selected element, run the Cypress test script below to execute the test case:

describe('Select the index', () => {
    it('select the option tag with an of 1', () => {
      cy.visit('https://ecommerce-playground.lambdatest.io/index.php?route=product/manufacturer/info&manufacturer_id=9')
      cy.get('#entry_212434 #input-sort-212434').select(1)

    // Wait for the page to update or stabilize
    cy.url().should('include', 'sort=order_quantity')

    // Assert the selected option's text is 'Best sellers'
    cy.get('#entry_212434 #input-sort-212434 option:selected')
      .should('have.text', 'Best sellers')
    })
  })

Your test run should be indicated as shown below:

In the image above, the Best Sellers option is selected in the select control.

Select by Value

Selecting a dropdown by value is very similar to selecting an element by index. Instead of passing integers as value to the .select() command, the value property of the tag is used instead.

describe('Select web element by value', () => {
    it('Select the option element by the value attribute', () => {
      cy.visit('https://ecommerce-playground.lambdatest.io/index.php?route=product/manufacturer/info&manufacturer_id=9')
      cy.get('#entry_212434 #input-sort-212434')
      .select('https://ecommerce-playground.lambdatest.io/index.php?route=product/manufacturer/info&manufacturer_id=9&sort=p.viewed&order=DESC')
    })
  })

The code above used the .select() command to interact with the WebElement and retrieve the tag with the value Popular text.

Here, the WebElement uses the value to choose the Popular option, which corresponds to the text displayed in the dropdown. The test simulates selecting the most popular items on the Canon product list by interacting with the dropdown element.

Select by Text

To select an element by text, the .select() command received the text content as an argument.

describe('Select web element by Text', () => {
    it('Select the option tag with a Newest', () => {
      cy.visit('https://ecommerce-playground.lambdatest.io/index.php?route=product/manufacturer/info&manufacturer_id=9')
      cy.get('#entry_212434 #input-sort-212434')
      .select('Newest')
    })
  })

Here, the text content of the element Newest is passed to the .select() command. This allows Cypress to retrieve the WebElement associated with Newest and then perform a test on it.

From the image above, the select control selected the element with the text content of the Newest element.

How to Handle Dynamic Dropdowns?

Dynamic dropdowns are selection controls in which the options are rendered dynamically depending on the content or user search input.

Initially, the _ _elements are not present when the page first loads. Instead, the dropdown waits for the user’s input or an event to trigger before it loads the options dynamically into the page.

Cypress sends requests by passing text into the input control. It then waits for the content to load on the page before interacting with it.

To handle dynamic dropdowns in Cypress, you can use .contains() and .each() commands.

.contains() Command

The .contains() command in Cypress retrieves the DOM element containing the text passed in. It can take more than one argument.

Syntax:

.contains(content)
.contains(content, options)
.contains(selector, content)
.contains(selector, content, options)

// getting web elements that contain
cy.contains(content)
cy.contains(content, options)
cy.contains(selector, content)
cy.contains(selector, content, options)

// usage
cy.get('.nav').contains('About') 
cy.contains('Hello')

To demonstrate, we will leverage the Cypress .contains() command to dynamically interact with dropdowns on a web page.

We will use the LambdaTest eCommerce Playground. When a user inputs “iPhone” into the navigation search bar, a list of matching product items is displayed as clickable links within the dropdown.

The Cypress .contains() command is used to assert that the search query is present within the returned product list and, if found, triggers a click action on the corresponding item. This approach is particularly useful for automating the testing of dynamic dropdowns and validating that search functionality behaves as expected.

  describe('Dynamic Dropdown Test', () => {
    it('should select a specific option from a dynamically loaded dropdown', () => {
      // Step 1: Visit the page  cy.visit('https://ecommerce-playground.lambdatest.io/index.php?route=common/home');  // Replace with your actual page URL

      // Step 2: Click on the dropdown to trigger the loading of dynamic options
      cy.get('#entry_217822 > div input[placeholder="Search For Products"]').click();  // Adjust selector for the dropdown

      // Step 3: Wait for the dropdown options to be visible (if required)
      cy.get('#entry_217822 > div input[placeholder="Search For Products"]') // Selector for the dropdown options container
        .should('be.visible');

      // Step 4: Optionally filter options by typing in the dropdown's input field
      cy.get('#entry_217822 > div input[placeholder="Search For Products"]').type('iPod Touch'); // Adjust if needed for input

      // Step 5: Select an option dynamically
      cy.contains('#search > div.search-input-group.flex-fill > div.dropdown > ul li', 'iPod Touch') // Adjust selector for dropdown item
        .click();

      // Step 6: Assert that the correct option is selected
      cy.get('#entry_217822 > div input[placeholder="Search For Products"]').should('have.value', 'iPod Touch');
    });
  });

Output:

.each() Command

The .each() command in the dynamic dropdown iterates through the elements that match the specified text and provides an interface to interact with the selected WebElement.

Syntax:

cy.get('ul>li').each(($el, index, $list) => {
 // $el is a wrapped jQuery element
 if ($el.someMethod() === 'something') {
   //Wrap this element so we can
   // use cypress commands on it
   cy.wrap($el).click()
 } else {
   // do something else
 }
})

Here, the below test script loads the specified web address and retrieves the DOM element of the input tag on the navbar.

describe('Dynamic Dropdown Test', () => {
    it('should select a specific option from a dynamically loaded dropdown', () => {
      // Step 1: Visit the page
      cy.visit('https://ecommerce-playground.lambdatest.io/index.php?route=common/home');  // Replace with your actual page URL

      // Step 2: Click on the dropdown to trigger the loading of dynamic options and type the text "iPod"
      cy.get('#entry_217822 > div input[placeholder="Search For Products"]').click().clear().type('iPod');  

      // Step 4: iterate over the the returned nodelist and check if "Nano" text exit and click it if Yes
      cy.get('#search > div.search-input-group.flex-fill > div.dropdown > ul li').each(($el, index, $list)=>{
        cy.log($el.text())
        if($el.text() === "Nano"){
            cy.wrap($el).click()
        }
      })
    });
  });

It clicks on the input tag and types the iPod text. Then it iterates over all the dynamic dropdowns and checks if the element that contains iPod matches the content Nano, and if this is true, a click operation is performed.

Advanced Use Cases of Cypress .select() Commands

When handling dropdowns, some WebElements are hidden or disabled by default, making them difficult to retrieve with the .select() command in Cypress.

Let’s look at how to handle disabled and hidden dropdowns.

Disabled Dropdowns

Disabled dropdowns are select controls set to disable using the disabled property in HTML, or :disabled CSS pseudo-class. Disabled elements prevent users from interacting with the specified WebElement.

When elements are set to disabled, it stops functioning as usual and does not respond to mouse input, keyboard events, or any other user-stimulated interaction. However, when using the Cypress .select() command, disabled elements are, by default, turned off as false. This means it cannot be selected with the Cypress .select() command.

To bypass this, the Cypress .select() command provides a second argument called force object. The force object takes in a boolean value as true to enable Cypress to select the disabled element on the DOM.

<section class="iphones" id="iphones">
<h1>Types of iPhone</h1>
<section id="iphone-versions">
    <label for="select-version">Choose an iPhone:</label>
            <select name="iPhones" id="select-version" disabled>
                <option value="">--Please choose an option--</option>
                <option value="iPhone-8">iPhone 8</option>
                <option value="iPhone-XR">iPhone XR</option>
                <option value="iPhone-11" >iPhone 11</option>
                <option value="iPhone-12">iPhone 12</option>
                <option value="iPhone-13">iPhone 13</option>
                <option value="iPhone-14">iPhone 14</option>
            </select>
</section>
</section>

Here, we have a select WebElement with a specified disabled element to prevent user interactions.

The WebElements with a disabled property specified, can not be accessed by Cypress. This is the default behavior in Cypress to fix this.

The Cypress .select() command is set to receive a second argument as {force: true}. When the {force: true} property is applied to an element, Cypress interacts with the element directly without enabling it or removing the disabled property in order to perform a test on it.

describe('Force Select an Element', () => {
    it('Force select a disabled element', () => {
      cy.visit('https://cdpn.io/pen/debug/MYgXLQy?authentication_hash=LQkExWmOvBxA')


      cy.get('#iphone-versions #select-version')


      .select('iPhone 11', {force: true})


      .invoke('val').should('eq', 'iPhone-11')
    })
  })

From the code above, the .select() command received a second argument as force and set its value to true. This enables the Cypress .select() command to interact with the disabled element while it’s still disabled or hidden.

Output:

Hidden Dropdowns

Hidden WebElements are HTML elements styled with display: none in CSS, making them invisible on the web page.

In Cypress, hidden elements are typically disabled from interaction. However, to interact with a hidden element, you can use the {force: true} option, allowing Cypress to forcefully interact with the specified element.

<section class="mac-book" id="mac-book">
<h1>Mac Book models released</h1>
<section id="mac-book-models">
    <label for="select-version">Choose a Mac Book:</label>
            <select name="mac-book" id="select-version" style="display: none;">
                <option value="">--Please choose an option--</option>
                <option value="iMac-Pro">iMac Pro (27-inch)</option>
                <option value="MacBook-Air">MacBook Air (Retina, 13-inch)</option>
                <option value="Mac-Pro" >Mac Pro</option>
                <option value="Mac-mini">MacBook Pro</option>
                <option value="Mac-Studio">Mac Studio</option>
                <option value="MacBook-Air">MacBook Air</option>
            </select>
</section>
</section>

The code above demonstrates a element with its display property set to none, which hides both the element and its child tags, preventing them from appearing on the web page.

Here, the element is set to display: none, which automatically removes the element from the DOM. In this case, the element becomes hidden from users and, as a result, stops Cypress from interacting with it.

To stop the behavior, {force: true} option is set to the .select() command, allowing Cypress to interact with the hidden element.

describe('Force Select an Element', () => {

    it('Force select a hidden element', () => {
      cy.visit('https://cdpn.io/pen/debug/dPbjbwK?authentication_hash=nqAwvJdQxbWr')

      cy.get('#mac-book-models #select-version')

      .select('Mac Studio', {force: true})

      .invoke('val').should('eq', 'Mac-Studio')
    })
  })

Output:

Select Multiple Elements

The Cypress .select() command can simultaneously select more than one . This is very useful as it lets you perform multiple test cases on numerous WebElements.

To interact with multiple elements at once, the Cypress .select() command accepts additional arguments in the form of multiple values. These values correspond to the text content of the tags that Cypress needs to select.

describe('Select multiple element', () => {
    it('Select more than one option web element', () => {
      cy.visit('https://ecommerce-playground.lambdatest.io/index.php?route=product/manufacturer/info&manufacturer_id=9')
      cy.get('#entry_212434 #input-sort-212434')


      .select(['Default'], ['Best sellers'], ['Popular'])

    })
  })

Output:

The Cypress .select() command selects the options passed as an argument starting from the Default option.

The above Cypress tests for handling dropdowns are run on the local grid. However, for better scalability and reliability, you can harness the capabilities offered by cloud grids such as LambdaTest.

LambdaTest is an AI-native test execution platform that lets you run tests on the Cypress cloud grid. It offers scalability, intelligent debugging, and AI-driven optimizations to streamline test automation.

Conclusion

The Cypress .select() command is a built-in function that interacts and runs tests on the WebElement and dynamic dropdown in the web application. The WebElement or dynamic dropdown are web controls that provide a menu or list of options for users on the web.

The .select() command can interact with dropdowns by their indexes, values, or text content. It can also run tests on multiple WebElements. However, to perform dynamic selection, more advanced techniques are required, such as .contains() and .each() Cypress commands.