1. Why do we need Test Automation in DevOps
2. Benefits of Implementing Automated Testing in DevOps
3. How Test Automation Contributes to Software Quality and Reliability
4. Conclusion
5. How can TestingXperts help you with Automation Testing using DevOps?

The combination of Test Automation and DevOps has restructured the software development landscape, bringing forth a new era characterized by enhanced efficiency, speed, and reliability. Using Test Automation in DevOps promotes a collaborative environment between development and operations, breaking down bottlenecks to ensure swift, iterative, and dependable software delivery.

Test automation is essential for agile DevOps, speeding up development, giving quick feedback, and enhancing software resilience in a changing environment. A strong DevOps automation strategy includes selecting tests, implementing parallel execution, and integrating automation into the CI/CD pipeline.

Why do we need Test Automation in DevOps?

Test automation plays a critical role in DevOps as it helps to ensure that software products are delivered quickly, efficiently, and with high quality. By automating testing processes, developers can focus on building new features and improving existing ones, while ensuring that their code is thoroughly tested and ready for deployment.

In Agile and DevOps methodologies, test automation is essential as it enables teams to continuously test and integrate code, ensuring that the software is always in a releasable state. This helps to reduce the risk of errors and defects in the final product, which can be costly to fix and impact customer satisfaction.

Benefits of Implementing Automated Testing in DevOps

Automated testing in DevOps offers several benefits, including faster feedback cycles, increased productivity, improved quality, and reduced costs. It enables developers to quickly identify and fix issues in their code, ensuring that software products are delivered faster and with fewer defects.

Automated testing also helps to reduce the risk of human error, as it eliminates the need for manual testing. This results in increased productivity and efficiency, as developers can focus on building new features rather than spending time on repetitive testing tasks. Overall, automated testing is a critical component of DevOps as it helps to ensure that software products are delivered quickly, efficiently, and with high quality.

Accelerated Testing

In the world of DevOps, integrating test automation can significantly speed up development processes and improve accuracy. It’s not just a tool but a strategic approach that allows for fast testing and feedback, which is essential for continuous improvement. By aligning with agile principles, test automation ensures that every code change undergoes thorough testing, preventing delays and ensuring a seamless integration into the development pipeline.

This acceleration is not just about speed, but also about promoting efficiency and reliability. A well-designed test automation strategy can drive agile development, where fast testing and feedback are the norm, resulting in quick iterations towards perfect software.

Enhanced Software Quality and Reliability

Test automation in DevOps plays a crucial role in improving software quality and reliability. By automating testing processes, DevOps teams can ensure that each code change undergoes rigorous testing, preventing errors and bugs from slipping into the production environment. This is especially important in agile and DevOps environments, where rapid iterations and frequent code changes are the norm.

A well-designed test automation strategy can help teams achieve enhanced software quality and reliability by providing fast and accurate feedback on code changes. This allows for quick identification and resolution of issues, reducing the number of defects in the final product. Additionally, test automation in DevOps can help teams identify and address performance issues early in the development process, resulting in a more stable and reliable product.

Improved customer satisfaction

Implementing test automation in DevOps can significantly improve customer satisfaction by ensuring that software products are of high quality and free from defects. By automating testing processes, DevOps teams can quickly identify and address issues, resulting in faster time-to-market and a more reliable product.

In agile and DevOps environments, where rapid iterations and frequent code changes are the norm, test automation is essential to ensure that products are thoroughly tested before being released to customers. This helps prevent issues such as crashes, bugs, and other defects that can negatively impact the user experience.

Furthermore, test automation can help teams identify and address performance issues early in the development process, resulting in a more stable and reliable product. This can lead to greater customer satisfaction, as users will have a positive experience with the software and be more likely to recommend it to others.

Easier incident management

It can make incident management easier by providing fast and accurate feedback on code changes. By automating testing processes, DevOps teams can quickly identify and address issues, reducing the likelihood of defects in the final product. This is especially important in agile and DevOps environments, where rapid iterations and frequent code changes can increase the risk of incidents.

A well-designed test automation strategy can help teams manage incidents more efficiently by providing a comprehensive view of the system’s health. This can help identify potential issues before they become critical and allow for quick resolution of incidents when they do occur. Additionally, test automation in DevOps can help teams identify and address performance issues early in the development process, resulting in a more stable and reliable product.

How Test Automation Contributes to Software Quality and Reliability

Test automation plays a crucial role in ensuring overall software quality and reliability. By automating testing processes, DevOps teams can ensure that each code change undergoes rigorous testing, preventing errors and bugs from slipping into the production environment.

It can help teams achieve enhanced software quality and reliability by providing fast and accurate feedback on code changes. This allows for quick identification and resolution of issues, reducing the likelihood of defects in the final product. Additionally, test automation in DevOps can help teams identify and address performance issues early in the development process, resulting in a more stable and reliable product.

Furthermore, it ensures that each code change is thoroughly tested before being released to customers, resulting in higher customer satisfaction. It also helps teams manage incidents more efficiently by providing a comprehensive view of the system’s health and identifying potential issues before they become critical.

Conclusion

Test automation in DevOps helps in providing faster feedback, enhancing software quality and reliability, improving customer satisfaction, and easier incident management. It promotes a collaboration between development and operations, breaking down barriers to ensure swift, iterative, and dependable software delivery. By automating testing processes, DevOps teams can ensure that each code change undergoes rigorous testing, preventing errors and bugs from slipping into the production environment. This results in increased productivity, efficiency, and reliability, as developers can focus on building new features rather than spending time on repetitive testing tasks. Overall, test automation is a critical component of a successful software development process, contributing significantly to overall software quality and reliability.

How can TestingXperts help you with Automation Testing using DevOps?

TestingXperts can help you with Automation Testing using DevOps by providing comprehensive testing solutions that are tailored to your specific needs. Our team of experts has extensive experience in implementing test automation and can assist you in developing a strategy that aligns with your DevOps process and business goals.

We specialize in automating functional, regression, performance, and security testing, ensuring your software products are thoroughly tested before release. Additionally, we can help you seamlessly integrate automated testing into your CI/CD pipeline, enabling faster feedback cycles and reducing the time to market. With our expertise in test automation, we can help you achieve faster time-to-market, higher quality products, and greater customer satisfaction.

The post How Does Test Automation in DevOps Enhances Software Quality and Reliability first appeared on TestingXperts.

The post How Does Test Automation in DevOps Enhances Software Quality and Reliability appeared first on ProdSens.live.

TL;DR: We’re building an integration that brings Chromatic into Cypress. That gives you all of Chromatic’s visual testing capabilities, scanning every possible state of UI, within your E2E tests. All it takes to get started is a couple lines of code. Join early access now.

Every team needs the confidence that their apps work and look great for their users. Today, we’re sharing how you gain get that through Chromatic’s new integration for Cypress: E2E Visual Tests. This lets you bring Chromatic’s visual testing into your existing E2E workflow, and all it takes to get started is two tiny changes in your code.

Read on for an overview of how E2E Visual Tests for Cypress works, and how you can try it now in early access.

Using Playwright? You’ll want to head here

Why integrate Chromatic and Cypress?

As a visual testing tool, Chromatic doesn’t just capture an image of each page you test. Instead, E2E Visual Test snapshots are living re-creations of a page’s DOM, styling, and assets. Whenever you’re reviewing test results, you receive high-fidelity renderings that are fully inspectable. This makes it painless to reproduce and confirm changes, because you’re seeing exactly the same UI as your users.

Snapshots are taken in a controlled cloud environment, using consistently-versioned, modern browsers. Whether you’re testing in one browser or four, they run in parallel so your test suite stays fast.

Every snapshot taken is saved to Chromatic’s CDN. Having your snapshots on Chromatic’s servers, rather than in your local filesystem, means that you’re not tracking and pushing up to your repo what can grow to be an enormous set of images!

Finally, by integrating Chromatic into your E2E tests, you gain all the benefits of the Chromatic platform. This includes visual testing down to the pixel, a single location for designers and other stakeholders to sign-off on work, plus a published library of all your snapshots. All of this happens out of the box just by integrating Chromatic into Cypress—without any other changes to your tests.

Get started with two small steps

Firstly: in cypress/support/e2e.js, import Chromatic’s test-archiver for Cypress:

// cypress/support/e2e.js
import '@chromaui/test-archiver/cypress/support';

Then, in cypress.config.js, add our archiveCypress task:

// cypress.config.js

const { defineConfig } = require("cypress");
const { archiveCypress } = require('@chromaui/test-archiver/cypress');

module.exports = defineConfig({  
  e2e: {
    setupNodeEvents(on, config) {
      // implement node event listeners here
      on('task', {        
        archiveCypress
      })
    },
  },
});

That’s it! You’re now set up to start benefiting from Chromatic in all of your Cypress tests, without adding any more code! Chromatic will now take a snapshot at the end of every Cypress E2E test.

Here’s how it works

Imagine you’re a developer on an online shopping product. You’re tasked with verifying how data flows from the backend to the frontend for a critical product detail page.

To begin, let’s just make sure we can successfully visit the page. We’ll use Cypress’s built-in cy.visit() command to navigate to the product page. Then, we’ll use cy.title().should() to verify that the page title renders as expected:

describe('My First Test', () => {
  it('Visits product page', () => {
        // 👇 go to the Amazon product page
    cy.visit('https://www.amazon.com/Tungsten-Cube-Biggest-Size/dp/B07WK9WLZ8/')
        // 👇 verify the page title
        cy.title().should('eq', 'Amazon.com: The 4" Tungsten Cube - Biggest Size : Toys & Games')
  })
})

There’s not much to this test. So, presumably, the page will render and the test will pass. However, in addition to the test being green, you now also gain a visual snapshot of the page taken at the completion of the test. You can view that snapshot in Chromatic’s UI:

Remember, though, that you were tasked with verifying how data flows from the backend to the frontend, not just that the page loads. To do that, we could add to the initial test and write new assertions to ensure every value on the page—price, description, product title, etc.—match our expectations. But that would quickly grow verbose.

Instead, you can verify all those details in a single glance with the snapshot you just created. And if the data ever changes, Chromatic will catch it and highlight it in a visual diff for you to verify or deny. Now you’re testing that the data flows correctly and that the appearance of the page is correct, too. And with much less code!

Now, another example. This time, we want to test the interaction of the search bar on the product page.

To begin, you start again by visiting the product page URL in Cypress. But once there, you find the main search field on the page and type in a search:

describe('My First Test', () => {
  it('Searches from product page 1', () => {
        // 👇 go to the product page
    cy.visit('https://www.amazon.com/Tungsten-Cube-Biggest-Size/dp/B07WK9WLZ8/')
        // 👇 verify the page title
        cy.title().should('eq', 'Amazon.com: The 4" Tungsten Cube - Biggest Size : Toys & Games')
        // 👇 find the main search field and type in it
    cy.get('.nav-search-field > input').type('rubik’s cube')
  })
})

Ok, cool. We should get some passing tests again and a snapshot of the final state of the UI, showing ‘rubik’s cube’ typed into the search field.

But what if we want some snapshots taken during that process? Easy! You can use cy.takeChromaticArchive() to take a manual snapshot at specific points during your tests. So let’s use this method to take a snapshot when we first focus the search field to see what that looks like:

describe('My First Test', () => {
  it('Searches from product page 2', () => {
        // 👇 go to the product page
    cy.visit('https://www.amazon.com/Tungsten-Cube-Biggest-Size/dp/B07WK9WLZ8/')
        // 👇 verify the page title
        cy.title().should('eq', 'Amazon.com: The 4" Tungsten Cube - Biggest Size : Toys & Games')
        // 👇 find & focus the search field
    cy.get('.nav-search-field > input').focus()
        // 👇 tell Chromatic to take a snapshot here
    cy.takeChromaticArchive()
        // 👇 finish the test as before
    cy.get('.nav-search-field > input').type('rubik’s cube')
  })
})

When this test runs, Chromatic will capture two snapshots: the one we’ve manually taken of the focused search field and the one automatically taken at the end of the test.

One line of code to snapshot two different states of the page, plus the functional tests you already had? Not bad.

Sign up for early access

Help us bring Chromatic’s Cypress integration over the finish line by signing up for early access! Try it out and give feedback so that we can ship the best package possible.

 Sign up here

The post Introducing Chromatic’s Cypress integration appeared first on ProdSens.live.

Table of Contents

1. Quality Assurance vs Quality Engineering
2. Making a Move from Quality Assurance to Quality Engineering
3. The Limitations of Traditional Quality Assurance Practices
4. Why is this Change Important?
5. Conclusion
6. How can TestingXperts help you with Quality Engineering Services?

As per a survey, organizations with a strong focus on Quality Engineering experience up to a 40% reduction in post-release defects compared to those relying solely on Quality Assurance practices.

Another survey of software development teams depicts, “68% of project failures were attributed to a lack of clarity and understanding regarding the distinction between Quality Engineering and Quality Assurance.”

These numbers clearly underscore the impact of quality engineering and how important it is to know the difference to understand project objectives better, run efficient processes, and ultimately aim for product quality.

Quality Assurance vs Quality Engineering

“While ‘Quality Assurance’ focuses on ensuring the quality of the final product, ‘Quality Engineering’ takes a proactive role in shaping the development of high-quality products and efficient processes. In simple words, QA primarily identifies defects in the software that has already been developed, while QE represents a technical evolution, shifting from predominantly manual processes to predominantly automated ones. Moreover, QE adheres to a ‘shift-left’ methodology and starts test automation early in the software development life cycle to catch and address issues in the beginning.”

Here’s the major difference between Quality Assurance and Quality Engineering:

Both Quality Assurance and Quality Engineering play crucial roles in delivering high-quality software, but they differ in their approach and scope. QE is a more proactive and integrated approach that aims to prevent defects, while QA focuses on post-development validation and compliance.

Making a Move from Quality Assurance to Quality Engineering

Moving from QA to QE is a manageable shift that demands a shift in mindset and processes rather than substantial financial resources. The encouraging aspect is that you don’t need the financial muscle of a tech giant to embrace robust Quality Engineering practices. This transformation can be accomplished by introducing adjustments to your current workflows, including:

QA engineering team transformation

Companies have the capability to retrain their current workforce to effectively navigate the shift from QA to QE. This entails a transformation of the organizational culture and the team’s perspective, along with the enhancement of skills and tools. Given that the existing QA engineers already possess a solid grasp of the product, their transition to QE is likely to be more seamless.

Shift-Left Approach

The ‘shift-left’ methodology incorporates Quality Assurance (QA) right from the inception of the development life cycle, enabling active involvement in software design sessions and the formulation of testing strategies. In a similar vein, Quality Engineering (QE) also engages from the early stages of the development life cycle. However, its primary emphasis lies in crafting a comprehensive test strategy geared towards achieving higher levels of test automation.

DevOps Implementation

Continuous Integration (CI) and Continuous Deployment (CD) pipelines offer substantial time and effort savings by replacing manual and error-prone deployment tasks. These pipelines complement the ‘shift-left’ testing approach, promoting quality right from the initiation of the software development lifecycle. Furthermore, it’s possible to include automated tests that are scheduled to be executed after each deployment.

The transition from QA to QE is a pivotal step for organizations, empowering them to facilitate digital transformation and ensure a consistent, desired customer experience. Quality Engineering (QE) plays a crucial role in creating versatile platforms that integrate a wide range of tools, utilities, and advanced technologies like AI/ML with lifecycle automation encompassing business processes, functional UI, API, test data, and environments. Additionally, this transition provides superior and highly efficient coverage across both code and functionality, leading to a continuous enhancement of product quality.

Automation Testing with AI/ML capabilities

Equipping testers with automation testing expertise enables the utilization of intelligent test automation, resulting in expanded coverage and enhanced quality. The creation of a sturdy automation framework facilitates a seamless transition from traditional QA to more comprehensive Quality Engineering (QE) practices.

The Limitations of Traditional Quality Assurance Practices

Recent shifts in software delivery have been significantly influenced by alterations in software assurance approaches. The surge of agile and iterative development methodologies is chiefly responsible for these transformations. This shift in paradigm has led to the adoption of more frequent, smaller software releases, departing from the lengthy timelines of the past. It encourages teams to embrace simplified approaches and nurtures a culture of adaptability.

The role of quality analysis has undergone significant evolution due to these dynamic methodologies. To align with sprint cycles, comprehensive system testing is now performed more frequently, typically every two or three weeks, in response to the evolving demands of quality analysis. This represents a departure from the previous, slower paradigm where testing was less frequent and more sporadic in nature.

Transitioning from the antiquated paradigm to these contemporary approaches poses certain challenges.

Continuous Demand for Maintaining Good Quality:

It is essential due to the shift towards agile and iterative development, which necessitates the integration of quality into every phase of the development lifecycle, as opposed to relegating it solely to the final stages.

Focus on Automation:

In this evolving context, automation plays a vital role, and there is a proactive pursuit of testing automation solutions to ensure that testing procedures are both effective and thorough.

Enhanced Functions for Quality assurance companies:

Organizations are gaining increased significance and prominence in response to the changing landscape, as they play a crucial role in ensuring that the ongoing adoption of agile and iterative methodologies consistently yields high-quality software products.

Why is this Change Important?

The shift from Quality Assurance (QA) to Quality Engineering (QE) is primarily motivated by the evolution of service-oriented architectural models. In this contemporary mindset, development teams often conceptualize their business implementations as sets of services that collaborate while maintaining individual functionality, guided by rigorous contractual regulations. This transformation has given rise to a range of alterations and factors to be taken into account.

Challenges for QA Engineers:

Conventional QA engineers have faced notable hurdles, including the requirement to generate code prior to its actual existence, engaging in post-design stages to pinpoint critical tests and essential functionalities, and embracing frameworks that replicate dependencies. These adaptations are intended to streamline the workflow and minimize dependence on both upstream and downstream factors.

Shift in Testing Phases:

Unit testing has been moved to an earlier stage in the development process, and integration testing now demands the participation of QA teams at a much earlier point compared to previous practices. This reconfiguration of the testing stages guarantees a more comprehensive and tightly integrated approach to ensuring quality.

Holistic Software Quality:

The shift towards Quality Engineering (QE) represents a comprehensive perspective on software quality, in which quality is not solely the result of testing but is intrinsically woven into the entire development process. This transformation is rooted in the concept that quality engineering commences with the initial architectural choices and extends through development, risk mitigation, early issue identification, and ongoing enhancements.

Conclusion

The choice between Quality Assurance (QA) and Quality Engineering (QE) is a critical consideration for any business. While QA has traditionally focused on testing at the later stages of development, QE embraces a holistic approach, embedding quality throughout the entire software development lifecycle.

In today’s dynamic and competitive landscape, businesses must prioritize not only the end product but also the processes that lead to it. QE, with its emphasis on proactive risk management, early issue detection, and continuous improvement, offers a strategic advantage. Ultimately, the decision between QA and QE hinges on the extent to which a business is willing to invest in engineering quality and ensuring that it is not just a goal, but an integral part of the software development journey. The choice between QA and QE is a critical one that can significantly impact a business’s ability to deliver high-quality software in a rapidly evolving digital world.

How can TestingXperts help you with Quality Engineering Services?

With a proven history of reducing the number of post-production defects by up to 50% and cutting testing costs by 30%, TestingXperts delivers tangible business value by enhancing software quality, reducing rework, and increasing the efficiency of your development processes. By harnessing advanced test automation techniques, our experts help increase test coverage and significantly reduce testing cycle times, thereby saving both time and resources. TestingXperts expertise in continuous testing ensures that quality is upheld throughout the development process, leading to faster time-to-market and improved customer satisfaction.

The post Quality Assurance vs. Quality Engineering – What your Business Needs first appeared on TestingXperts.

The post Quality Assurance vs. Quality Engineering – What your Business Needs appeared first on ProdSens.live.

Welcome! Today we’re going to look into the pop-up windows handling using Selenium. If you like this article please feel free to follow me on Telegram channel, there are many more thought related to development, processes and test automation.

Introduction

Sooner or later in the life of any testing automation specialist (regardless of the programming language you work with), a situation arises where it becomes necessary to handle pop-up windows in the browser. One might think that in the era of reactive applications, phenomena like pop-up windows should have taken a back seat, as modern tools offer a rich variety of implementing modal windows through HTML code on the page rather than relying on the browser’s features. However, it’s important not to forget that our world is not perfect, and not all projects are built using React/Vue/Angular. Therefore, it’s reasonable to expect that dealing with browser pop-up windows is still something we might encounter.

What Are Pop-Up Windows?

Pop-up windows are a browser feature that has come to us from the distant years when web development wasn’t yet mainstream. However, pop-up windows still exist even in modern versions of JavaScript. Developers have taken care of backward compatibility to avoid breaking projects that were written long ago.

Pop-up windows serve two main purposes:

• User Interaction: When we need to convey important information to the user or request certain data without which further progress is impossible, a pop-up window comes to the rescue.

• Preventing User Interaction: They prevent users from interacting with the web page’s interface until the user responds to a message by clicking a button.

Types of Pop-Up Messages

Simple Alert

This message contains a single button — OK. By clicking on it, we simply close the pop-up window and can continue working with the web interface. Let’s see what it looks like.

Open the developer console in your browser (F12) and navigate to the Console tab:

We have the JavaScript command line before us, where we can write code that the browser will execute. Enter the command alert(‘This is alert’); in the interpreter and press Enter. As a result of execution, we see a pop-up window with the message ‘This is alert’:

Such a window can be used to display important information to the user for their awareness, without giving them the option to make any choice.

Confirmation Window

This window presents a message with two possible actions — OK and Cancel. The behavior of such a window is more complex than that of a simple alert. Different code fragments will be executed based on the option chosen by the user. The purpose of this article is to learn how to handle such pop-up windows using Selenium tools, so we won’t delve into the detailed implementation of different user choices.

To invoke a confirmation window, we need to perform the same steps as we did to bring up an alert, but use a different command: confirm(‘Choose your destiny:’);. As a result of executing this code, the following window will be displayed:

Input window

And finally, the last type of pop-up window is an input window, where the user can not only choose from two available options but also write their own response. This type of window can also be triggered from JavaScript by executing the following command: prompt(‘What is your favorite test automation library?’, ‘Selenium’);. The prompt command takes two arguments – the message that will be displayed to the user and the default response (in our case, Selenium). As a result of executing this code, the following window will be shown with the suggested response (though we can, of course, enter our own response or even decline to provide any data by clicking the Cancel button):

Why Handling Pop-Up Windows in Selenium is Necessary

To answer this question, let’s perform a small exercise for all three types of pop-up windows:

• While on any webpage in your browser, open the developer console and trigger a pop-up window.
• As soon as the window appears on the screen, try interacting with the elements on the page (images, links, etc.).
• Close the pop-up windows using various methods (by clicking available buttons or by providing information in the prompt window). Take note of what is displayed in the developer console when closing the windows in different ways.

If you’ve done everything correctly, the answer to why handling pop-up windows in test automation is necessary becomes quite clear:

1. A pop-up window prevents the user from interacting with the elements on the page. Consequently, while the window is open, a Selenium automated test cannot proceed further.
2. By clicking different buttons and entering information (only for prompt-type windows), we obtain different values. This means we can emulate various user scenarios. Thus, we can create a set of automated tests that cover all possible user interaction scenarios.

Interacting with Pop-Up Windows in Selenium

Now that we understand where pop-up windows come from and why they are important, let’s practice and learn how to work with them in Selenium. We already have a web page that is perfect for this purpose: https://testpages.herokuapp.com/styled/alerts/alert-test.html

Switching to a Pop-Up Window

Let’s write a simple test that clicks a button and triggers the appearance of a pop-up window. All examples are written in the Java programming language using the selenium-java library. However, the code can be easily adapted to other programming languages since the Selenium library interface is similar across all languages. In the code example below, the WebDriver initialization is omitted, as we are focusing on working with windows:

// Clicking on the button that causes alert message
driver.findElement(By.id("alertexamples")).click();

// Switching WebDriver context to the pop-up window
driver.switchTo().alert();

Retrieving Text from a Pop-Up Window

In the example above, in the last line, we switched Selenium’s focus to the alert (this will also work for confirm or prompt windows). Calling the alert() method returns a special class called Alert, which helps us work with pop-up windows.

Now we can write a complete test that verifies the text of the alert against the expected text. To do this, we will use the getText() method in the Alert class:

@Test
void testAlert() {
    driver.findElement(By.id("alertexamples")).click();

    // Get pop-up window text message
    String message = driver.switchTo().alert().getText();

    assertEquals("I am an alert box!", message);
}

Closing a Pop-Up Window

Our example is quite simple. In practice, it’s often not enough to just retrieve text from a window, you might need to close pop-up windows to continue working. To achieve this, you need to learn how to close pop-up windows using Selenium.

For practice, let’s try the second type of pop-up window — confirm. On our test page, the user’s choice is displayed in a separate message that appears below the button. We will use this to test various methods of interacting with pop-up windows.

The Alert class has two methods:

• accept(): This method makes Selenium click the “OK” button of the pop-up window of any type.
• dismiss(): Similar effect, but it will click the “Cancel” button of the pop-up window.

@Test
void testAcceptConfirm() {
    driver.findElement(By.id("confirmexample")).click();

    // Accept the confirm (OK)
    driver.switchTo().alert().accept();

    boolean result = Boolean.parseBoolean(driver.findElement(By.id("confirmreturn")).getText());
    String clickedButton = driver.findElement(By.id("confirmexplanation")).getText();

    assertTrue(result);
    assertTrue(clickedButton.contains("You clicked OK"));
}

@Test
void testDismissConfirm() {
    driver.findElement(By.id("confirmexample")).click();

    // Dismiss the confirm (Cancel)
    driver.switchTo().alert().dismiss();

    boolean result = Boolean.parseBoolean(driver.findElement(By.id("confirmreturn")).getText());
    String clickedButton = driver.findElement(By.id("confirmexplanation")).getText();

    assertFalse(result);
    assertTrue(clickedButton.contains("You clicked Cancel"));
}

Entering User Input

We’ve come a long way, but there’s one last scenario to cover: entering our own message into a pop-up window. Let’s see how we can achieve this, especially considering that the last button on our web page remains untested.

So, here are our two test scenarios:

1. Click the button, enter a message, and click “OK.”
2. Click the button, enter a message, and click “Cancel.”

To implement these scenarios, you need to familiarize yourself with a new method of the Alert class:

sendKeys() – used to enter text into a prompt-type window. Let’s look at the tests that utilize this method:

@Test
void testAcceptPrompt() {
    driver.findElement(By.id("promptexample")).click();
    String text = "I like test automation!";

    // Enter text and press ОК
    driver.switchTo().alert().sendKeys(text);
    driver.switchTo().alert().accept();

    String message = driver.findElement(By.id("promptreturn")).getText();
    String clickedButton = driver.findElement(By.id("promptexplanation")).getText();

    assertEquals(message, text);
    assertTrue(clickedButton.contains("You clicked OK"));
}

@Test
void testDismissPrompt() {
    driver.findElement(By.id("promptexample")).click();
    String text = "I like test automation!";

    // Enter text and press Cancel
    driver.switchTo().alert().sendKeys(text);
    driver.switchTo().alert().dismiss();

    String message = driver.findElement(By.id("promptreturn")).getText();
    String clickedButton = driver.findElement(By.id("promptexplanation")).getText();

    assertEquals(message, "");
    assertTrue(clickedButton.contains("You clicked Cancel"));
}

Conclusion

In this article, we covered working with pop-up windows in Selenium:

• We learned that different types of pop-up windows exist: alert, confirm, prompt.
• We learned how to trigger the appearance of pop-up windows using JavaScript commands.
• We discovered that Selenium has a special class, Alert, for working with pop-up windows.
• Using the getText() method, we learned how to retrieve the message within a pop-up window.
• With the accept() and dismiss() methods of the Alert class, we learned how to click “OK” and “Cancel” buttons in pop-up windows, thus deciding the user’s path.
• Using the sendKeys() method, we learned how to input our own message into prompt-type windows.

As seen from the code, working with pop-up windows isn’t as complex as it might seem. The “magic” has already been written by the developers of the Selenium library, and we simply need to utilize the provided methods. Keep these code examples, use them in your daily work, and, of course, don’t stop to automate!

The post Handling Pop-Up Windows in Selenium appeared first on ProdSens.live.