DEV Community: Andrea Maxwell

How To Refresh Page Using Selenium C# [Complete Tutorial]

Andrea Maxwell — Mon, 30 Jan 2023 14:30:51 +0000

When working on web automation with Selenium, I encountered scenarios where I needed to refresh pages from time to time. When does this happen? One scenario is that I needed to refresh the page to check that the data I expected to see was still available even after refreshing. Another possibility is to clear form data without going through each input individually.

But perhaps the refresh is necessary to avoid the most common Selenium Exceptions like *StaleElementReferenceException*.

In this blog, we look at how to refresh page using Selenium C#.

What is StaleElementReferenceException in Selenium?

StaleElementReferenceException means that the web element you try to find on the page has become stale.

But what does it mean that an element on a web page is stale, and how does it get into that state? The common reasons why this happens are because the element has been deleted from the page or it is no longer attached to the DOM. An element can be deleted from the DOM because either the user has left the page that the element was on or that page has been reloaded.

It’s different from NoSuchElementException because, for the latter, the element was never found on the page, while with StaleElementreferenceException, the element has been found on the DOM, but the DOM changed.

Consider an example of LambdaTest eCommerce Playground; you locate a product, click on the product name, and open the product page. After validating the product, you go back to the previous page. The product is still there in the list, but the web element used to locate it might become stale. In this case, a refresh will ensure the element is found again, with no exception.

In the next section, we will explore how to refresh page using Selenium C#

Check this out: Regression testing - Complete Guide With Best Practices

How to Refresh Page using Selenium C#?

So, how do you refresh page using Selenium C#?

There are three ways to do this.

Using the Navigate().Refresh() command.
Using the Navigate().GoToUrl() using the current page URL.
Simulating the keypress for the F5 key.

In the next section of this blog on how to refresh page using Selenium C#, let’s see them in action with an example.

Run your C# automation scripts across 3000+ environments. Try LambdaTest Now!

Check this out: What is Regression testing — Complete Guide With Best Practices

Demo Example: Refresh Page using Selenium C

Let’s demonstrate how to refresh page using Selenium C#. I’ll use the same scenario, and demonstrate all three ways mentioned above, one by one.

Basically, the test will look the same, except for the line of code that performs the actual refresh of the page. At the time of writing this blog, I’m using C# latest version — 4.6.0, NUnit as a testing framework, the Page Object Model design pattern, and the LambdaTest cloud-based grid for Selenium automation testing.

Continuous quality clouds like LambdaTest let you perform manual and automation testing of your websites and mobile apps on an online device farm of 3000+ real browsers, devices, and operating system combinations. Its cloud-based C# automation testing platform lets you run automation tests using different testing frameworks like Selenium, Playwright, Cypress, and more. With parallel testing, you can further cut down your test execution times by multiple folds.

Subscribe to LambdaTest YouTube Channel and stay updated with detailed tutorials around Selenium testing, Cypress testing, and more.

POM is a design pattern used in automated UI testing, where web page controls are created in separate repositories called page objects. The page objects contain the web elements on their page, together with the methods that are applied to these elements. The test scripts then interact with the elements through these page objects.

The main reason to use POM is that it makes the tests more readable, and it also promotes code reusability and easier maintenance.

Check this out: Regression test — Complete Guide With Best Practices

Test Scenario

Following is the test scenario used to refresh page using Selenium C#.

Navigate to the LambdaTest Selenium Playground.
Click on the first Simple Form Demo link under the Input Forms card.
Go back to the first page.
Click on the Radio Buttons Demo link under the Input Forms card.

I’ll refresh the page between steps 3 and 4 to ensure that none of the links become stale.

Prerequisites

To get started, let’s look at the prerequisites for a new project.

The NUnit framework. When creating a new project, you need to select the NUnit project type in Visual Studio.

Add a name for the project, complete the next step, and create a brand-new test project.

The [SetUp] and [Test] are NUnit annotations, which mark the methods following them. The SetUp method will run before each test, and the method marked as Test will be recognized as a test method.

If you have the Test Explorer open (if not, you can open it from View → Test Explorer), you will see the test displayed.

Assert is an NUnit class that allows us to make test validations. The current code will make our test pass every time because no real validation is added there.

3- You can start the tests from the Test Explorer pane.

4- Once the test is executed, it will be updated with the result.

The class and test method can be renamed to reflect what is being tested. I renamed them RefreshTest (the class) and RefreshPage (the test).

5- You’ll need to add the NuGet packages you’ll use in this project. You can add them from the user interface, from the Tools → NuGet Package Manager.

6- Go to the Browser tab and search for the needed packages.

Another way to install the required packages is by navigating to Tools → NuGet Package Manager and running the below command.

  PM> NuGet\Install-Package Selenium.WebDriver -Version 4.6.0

As I’ll be using LambdaTest for the browser, I only need the Selenium.WebDriver package. To use the LambdaTest Selenium grid, you will need to define the capabilities using LambdaTest Capabilities Generator.

Here are the ones I use to test on Safari 15 and capture screenshots on every command.

If you want to run the tests locally on the machine, you can skip this part and add the driver for the browser you want to use. Add another class to the project, call it something like PlaygroundHomePage.cs and let’s see what each class will contain.

Check this out: Online Automated Testing Platform - Accelerate your release velocity with blazing fast test automation on cloud

Implementation

In this blog section on how to refresh page using Selenium C#, we focus on the code implementation. Below is the test code for the PlaygroundHomePage.cs page object class.

  using OpenQA.Selenium;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace RefreshSelenium
    {
        internal class PlaygroundHomePage
        {
            private IWebDriver driver;
            public PlaygroundHomePage(IWebDriver driver)
            {
                this.driver = driver;
            }

            public IWebElement SimpleFormLink => driver.FindElement(By.LinkText("Simple Form Demo"));
            public IWebElement RadioButtonsLink => driver.FindElement(By.LinkText("Radio Buttons Demo"));

            internal void NavigateToLink(IWebElement pageLink)
            {
                pageLink.Click();
            }
        }
    }

Test script for Refresh.cs

   using OpenQA.Selenium;
    using OpenQA.Selenium.Remote;
    using OpenQA.Selenium.Safari;

    namespace RefreshSelenium
    {
        public class RefreshTest
        {

            private static IWebDriver driver;
            private static readonly string gridURL = "@hub.lambdatest.com/wd/hub";
            private static readonly string LT_USERNAME = Environment.GetEnvironmentVariable("LT_USERNAME");
            private static readonly string LT_ACCESS_KEY = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");

            [SetUp]
            public void Setup()
            {
                SafariOptions capabilities = new SafariOptions();
                capabilities.BrowserVersion = "15.0";
                Dictionary<string, object> ltOptions = new Dictionary<string, object>();
                ltOptions.Add("username", LT_USERNAME);
                ltOptions.Add("accessKey", LT_ACCESS_KEY);
                ltOptions.Add("visual", true);
                ltOptions.Add("platformName", "MacOS Monterey");
                ltOptions.Add("build", "Refresh");
                ltOptions.Add("project", "RefrestTest");
                ltOptions.Add("w3c", true);
                ltOptions.Add("plugin", "c#-nunit");
                capabilities.AddAdditionalOption("LT:Options", ltOptions);
                driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), capabilities);
            }

            [Test]
            public void RefreshPage()
            {
                PlaygroundHomePage homePage = new PlaygroundHomePage(driver);
                driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/");
                homePage.NavigateToLink(homePage.SimpleFormLink);
                driver.Navigate().Back();
                driver.Navigate().Refresh();
                homePage.NavigateToLink(homePage.RadioButtonsLink);  
            }

            [TearDown]
            public void TearDown()
            {
                driver.Quit();
            }
        }
    }

Code Explanation

This blog section on how to refresh page using Selenium C# deals with the explanation of our test codes.

PlaygroundHomePage.cs: This class stores the elements that I’ll be interacting with. Since the test is short, I only use two links on the page, but the class can be as big as needed if it needs to contain more elements or actions on the elements.

The first part of any C# class is the one where we define all namespaces we need inside the class. Next, we have the variables and constructors we need in the page object.

We need to create a new instance of the Selenium WebDriver that will be used later.

Here, I have the elements I will interact with.

I’ll only be working on links now, so I used one of the Locators in Selenium — LinkText. If you are using other elements, you might want to consider different strategies, such as Id, TagName, or even XPath and CSS Selectors.

In this case, using the Developer Tools to create complicated XPath or CSS Selectors wouldn’t make sense when I can use the visible link text. As a result, I added one method that could be reused on all links.

I’m passing an IWebElement parameter and using the Selenium .Click() command to click it. Alternatively, as shown below, I could use a different method for each link I want to click.

That’s it on my page object. You can expect normal page object classes to be larger and have more complex functions — this one is just a demo.

Refresh.cs: Just like the page object class, it begins with the using statements.

Inside the class, I need to declare the variables to use.

The driver variable is the one I use to interact with the browser. The following three variables: gridURL, LT_USERNAME, and LT_ACCESS_KEY, are related to my LambdaTest account.

In the meantime, I have them saved as environment variables, and my code reads them from there.

[SetUp] method: In the below test script, all the lines except the last one are directly copied from the LambdaTest Automation Capabilities Generator I mentioned above. The configuration I want to use: is Safari 15.0. But you can choose whatever suits your needs.

The last line creates a new RemoteWebDriver using my LambdaTest credentials. If you want to run the tests locally, you can add a NuGet package of the desired driver, such as Selenium.WebDriver.ChromeDriver, and update the setup to use a new ChromeDriver instance like this.

    private static IWebDriver driver;

    [SetUp]
    public void Setup()
    {            
            driver = new ChromeDriver();
    }

[Test] method: In the first line of code, I created a new instance of the PlaygroundHomePage object. Next, I used the Navigate*().GoToUrl()* method to open my desired page.

But before we proceed, let’s briefly discuss the Navigate method in Selenium. The Navigate() method returns an INavigation interface on which we can perform several actions.

We have GoToUrl*()*, which everybody uses to navigate a specific web page. You are probably already familiar with it, if not before, then from the lines of code we just discussed.

Then, we have the browser actions: Back(), Forward(), and Refresh(). They are all rather self-explanatory. What they basically do is simulate the respective button press in the browser.

Moving on with the code, after opening the web page, I called the generic method that navigates between links, and I passed it the desired element as a parameter:

The next part is where Navigate() comes into play again — I went back to the home page (to continue to verify the links), then I refreshed the page, to make sure that every element is loaded and none of them are stale.

And the last line of code is navigating again on one of the links, passing a different parameter. I also added a TearDown method — to close the browser window after my test is done, using the [TearDown] NUnit annotation, which marks a method that will run after each test execution.

Test Execution

Now that everything is clear, you can start the execution from Visual Studio’s Test Explorer the same way as before.

I’m running my tests on the LambdaTest cloud Selenium Grid. So once the test passes, you can only see the test result on the LambdaTest Automation Dashboard. But if you run it locally, you will see the browser window open up and all the steps performed.

On the left, you can see a video recording of the test, and on the right, configuration information (the capabilities I added in the setup) and details on each step. You can also reply to the video from a selected step.

I also added the screenshot capability so that each step will have a corresponding screenshot.

This is especially useful if any steps fail and a bug is found. This way, I have all the information I need to report the bug.

Refresh the Page with SendKeys()

In this blog section on how to refresh page using Selenium C#, let’s look at another way of refreshing the page. This time we’ll use the SendKeys() command in Selenium SendKeys. The page object class stays the same, and the test code will look like this.

   using OpenQA.Selenium;
    using OpenQA.Selenium.Remote;
    using OpenQA.Selenium.Safari;

    namespace RefreshSelenium
    {
        public class RefreshTest
        {

            private static IWebDriver driver;
            private static readonly string gridURL = "@hub.lambdatest.com/wd/hub";
            private static readonly string LT_USERNAME = Environment.GetEnvironmentVariable("LT_USERNAME");
            private static readonly string LT_ACCESS_KEY = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");

            [SetUp]
            public void Setup()
            {
                SafariOptions capabilities = new SafariOptions();
                capabilities.BrowserVersion = "15.0";
                Dictionary<string, object> ltOptions = new Dictionary<string, object>();
                ltOptions.Add("username", LT_USERNAME);
                ltOptions.Add("accessKey", LT_ACCESS_KEY);
                ltOptions.Add("visual", true);
                ltOptions.Add("platformName", "MacOS Monterey");
                ltOptions.Add("build", "Refresh");
                ltOptions.Add("project", "RefrestTest");
                ltOptions.Add("w3c", true);
                ltOptions.Add("plugin", "c#-nunit");
                capabilities.AddAdditionalOption("LT:Options", ltOptions);
                driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), capabilities);
            }

            [Test]
            public void RefreshPage()
            {
                PlaygroundHomePage homePage = new PlaygroundHomePage(driver);
                driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/");
                homePage.NavigateToLink(homePage.SimpleFormLink);
                driver.Navigate().Back();
                driver.Navigate().Refresh();
                homePage.RadioButtonsLink.SendKeys(Keys.F5);
                homePage.NavigateToLink(homePage.RadioButtonsLink);  
            }

            [TearDown]
            public void TearDown()
            {
                driver.Quit();
            }
        }
    }

The only thing that differs in this version is the line of code that refreshes the page.

What we need here is the Selenium SendKeys() command. SendKeys() is a Selenium keyboard action performed on a web element. It’s typically used to enter text inside an element such as an input (think form fields such as username and password, search bars, contact forms, and so on).

In my specific case, I am not trying to add text to use any element on the page. I am using the RadioButtonsLink from the LambdaTest Playground Home page because it’s an element I’m using in my test anyway. I don’t want to add additional code to the page object class.

The test execution is done the same way and will have the same result as before.

Check this out: 30 Top Automated Testing Tools In 2022

Refresh the Page using Navigate().GoToUrl()

Now, there is another way to refresh page using Selenium C#. I will stick to the same scenario while keeping the same setup and tear down. The only thing that changes is the line that refreshes the page.

Let’s refresh page using Selenium C# with Navigate(), but this time using the GoToUrl() command. The class will now look like this.

   using OpenQA.Selenium;
    using OpenQA.Selenium.Remote;
    using OpenQA.Selenium.Safari;

    namespace RefreshSelenium
    {
        public class RefreshTest
        {

            private static IWebDriver driver;
            private static readonly string gridURL = "@hub.lambdatest.com/wd/hub";
            private static readonly string LT_USERNAME = Environment.GetEnvironmentVariable("LT_USERNAME");
            private static readonly string LT_ACCESS_KEY = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");

            [SetUp]
            public void Setup()
            {
                SafariOptions capabilities = new SafariOptions();
                capabilities.BrowserVersion = "15.0";
                Dictionary<string, object> ltOptions = new Dictionary<string, object>();
                ltOptions.Add("username", LT_USERNAME);
                ltOptions.Add("accessKey", LT_ACCESS_KEY);
                ltOptions.Add("visual", true);
                ltOptions.Add("platformName", "MacOS Monterey");
                ltOptions.Add("build", "Refresh");
                ltOptions.Add("project", "RefrestTest");
                ltOptions.Add("w3c", true);
                ltOptions.Add("plugin", "c#-nunit");
                capabilities.AddAdditionalOption("LT:Options", ltOptions);
                driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), capabilities);
            }

            [Test]
            public void RefreshPage()
            {
                PlaygroundHomePage homePage = new PlaygroundHomePage(driver);
                driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/");
                homePage.NavigateToLink(homePage.SimpleFormLink);
                driver.Navigate().Back();
                driver.Navigate().GoToUrl(driver.Url);
                homePage.NavigateToLink(homePage.RadioButtonsLink);  
            }

            [TearDown]
            public void TearDown()
            {
                driver.Quit();
            }
        }
    }

Once again, the Setup() and the TearDown() remain the same. What happens here differently is that Selenium uses the current page URL to navigate to it instead of giving the exact URL as a parameter. It’s similar to manually pressing the Enter key inside the browser’s address bar. You will get the same result if you run the test with this code.

Master Selenium automation testing with C# with this certification and establish your credibility as a tester.

Check this out: 30 Top Tools for automation testing In 2022

Key Takeaways

This blog shows how to refresh page using Selenium C#, with NUnit as a testing framework, and a demo of the Page Object Model design pattern.

If you went over all the steps, you should now understand what the StaleElementException is and how you can avoid it. You can also use the refresh page for different scenarios, the same ones where you would need to refresh the page if performing the tests in the browser manually.

The refresh can be done in multiple ways; it is up to you to decide which works best.

Understanding The Difference Between Cross Browser Testing & Responsive Testing

Andrea Maxwell — Mon, 28 Nov 2022 20:52:21 +0000

The ubiquity of the internet today is undeniable. It is thus incumbent upon website developers to make sure that web user’s online experience is easy, convenient, hassle-free, and even enjoyable, if possible. This requires a well-organized release cycle where developers and testers do their best to deliver a robust and competitive product to the market. However, we often forget or get confused between the literal meaning of Responsive testing and Cross Browser Testing. This underscores the importance of cross browser testing and responsive testing. Both are crucial in website development but are quite distinct from each other. Both also happen to be offered by LambdaTest and we will be looking at each of them in this article after understanding the basic difference between the two types of testing.

Cross browser testing deals with functionality and interoperability, while responsive web testing focuses on aesthetics and adaptability. The former is thus concerned with what browser web users are using; the latter, on the other hand, is focused on what devices web users are using. Still confused? Don’t worry! I will be talking about them in detail. By the end of this article, I will help you evade the ambiguity between Cross browser testing and Responsive testing.

Run your Jest automation tests in massive parallel across multiple browser and OS combinations with LambdaTest.

What Is Responsive Testing?

The generation we live in, demands for convenience. Gone are the days when PC or Laptop were the only ways of accessing a website. Advancement in technology of mobile phones, tabs, and high-speed internet has significantly impacted the user’s preference for accessing the web.
Responsive testing is a process that ensures the rendering of web pages across viewports of multiple devices. Its end-goal is to make sure that web pages look good & provide relevant information to the website visitors on every device.

Which are the best automation testing tools in 2023 that have climbed the top of the ladder so far?

With this Responsive testing tutorial for beginners, you will learn how to perform Responsive Testing of your website on the LambdaTest platform.

Why Is Responsive Testing Important?

Imagine the number of devices your customers may be using. Screen size for mobile will be far different than that of desktop devices. Also, not all mobile will offer the same viewport or screen resolution. Now, are you going to come up with a dedicated web page for each device view? Imagine how many devices that would be. For that purpose, organizations prefer to opt for Responsive Web Design(RWD). The idea behind RWD is to save the time and effort required to create dedicated web pages for different screen sizes. So, you develop a single website or web-app with RWD to help it render seamlessly across different devices. Post development, comes testing. The testing procedure for validating the RWD works as intended is what we term as Responsive Testing.

Similar to Cross browser testing, Responsive testing is critical for offering your customers a good UI & UX. If a site is unresponsive then the content of the web page stays static irrespective of the screen resolution used to view the website. So you miss out on relaying the relevant information to your customers.

Now, let us have a look at a non-responsive website.

Source- Unresponsive Website

In this blog, we covered the top codeless automation testing tools out there for 2021 (with features). Read now to choose the best that suits your needs.

Did you notice the hindrance from the end-user point of view? Now, let us evaluate a responsive website. I will be demonstrating LambdaTest.

Responsive Website

Did you notice that the only scroll bar here is for vertical-scrolling unlike the unresponsive website where we had a scroll bar for horizontal-scrolling as well? That is not all. The content is auto adjusted and you can view the whole website in a neat and presentable manner, along with a hamburger menu on top to help you navigate through different tabs of a web product. Visit LambdaTest homepage to understand how the content of web-page has been adjusted into a mobile screen resolution.

Our article on ‘9 Mistakes to Avoid While Optimizing Your Site for Mobile Devices’ explains that optimizing a website to be mobile-friendly is important as it ensures proper rendering across a range of devices. There is no need to create a mobile version of the same website. Consequently, costs are reduced and it won’t take as many man-hours to complete.

Perform Responsive Testing On 50+ Mobile Views With LT Browser

In this detailed walkthrough of LT Browser tutorial video, we will help you get started with LT Browser.

Learn why Python is the top choice for automation testing. This comprehensive tutorial provides a step-by-step guide to automation testing using python to help you streamline your testing process.

What Is Cross Browser Testing?

Cross browser testing is a process of testing a website or web-app across numerous browsers, browser versions running on different operating systems to ensure rendering of the website stays as intended.

The primary reason of performing cross browser testing lies with the differences between rendering engines of different browsers. Every browser possesses a distinctive rendering engine for summoning your web elements when someone types your website’s URL in the address bar. Basically, rendering engine of Google Chrome will interpret the code of your website differently than rendering engine of Mozilla Firefox, Safari, Opera etc. Also, every browser version will have a unique rendering engine too. So, Chrome 68 may differ in rendering a website than Chrome 69, Chrome 67, etc.

In this Selenium javascript for automation testing tutorial, as we deep dive into the basic concepts, explained the best practices and executed automation scripts with JavaScript on cloud-based Selenium Grid.

Why Is Cross Browser Testing Important?

Imagine all the hard work you put in for developing a top-notch website using Google Chrome, only to watch it fail miserably on Safari, IE, any other desktop browser, or mobile browser.

If you go live with your web-app without incorporating web based browser testing in your SDLC then you are at a potential risk of offering a troublesome user-experience to your website visitors. Not only are you failing to attract a new customer for your web product, but you are also letting down your existing users to quit on your web product. It’s simple, If you won’t offer them a good, consistent user experience then somebody else will.

UX is not the only reason, you also have to keep in mind the UI(User Interface) of your web product. Cross browser testing will ensure better accessibility and readability to your users. For instance, say you are creating an HTML form, you are declaring different form input types, one such HTML input type is of Range for the purpose of specifying the annual income, bulk order etc. Range input type in HTML is pivotal for every website or web-app. However, it is not rendered in a consistent manner across different browsers.

Range input type In IE11

Range input type in Google Chrome 72

Given these points, it can be said that a website’s lack of browser compatibility is detrimental; rather than switch browsers, web users are likely to look for a different website.

Now, that we realize how imperative Cross browser testing is for a website! The questions arise on the approach to perform cross browser testing

Well, there are 2 approaches to perform cross browser testing.

Manual Cross Browser Testing
Automated Cross Browser Testing

Both of the approaches have significance in their own ways. Manual cross browser testing is important for test verification. Automated cross browser testing is important for test validation point of view.

Automated cross browser testing will help to load off the repetitive test cases and speed up your test cycles. Manual cross browser testing will help to provide better test scenarios for generating your automation test scripts.

Learn why Python is the top choice for automation testing. This comprehensive tutorial provides a step-by-step guide to python for automation testing to help you streamline your testing process.

The Common Goal Of Cross Browser Testing & Responsive Testing

By far, I am sure we are well versed with the difference between the two terms i.e. Cross browser testing & Responsive testing.
Well, can you think of the common goal for performing these two different types of testing?

Time’s up!! Common goal would be to provide a flawless user journey to your customers. Another key thing to highlight here is that responsive testing happens to be a subset of Cross browser testing.

Achieving The Common Goal With LambdaTest

LambdaTest is a cross browser testing cloud which offering more than 3000+ real browsers and browser versions running on different OS to help you deliver a consistent website or web page to your users. With LambdaTest, you can do both, Cross browser testing as well as Responsive testing / mobile website test.

Performing Cross Browser Testing With LambdaTest

LambdaTest offers an intuitive UI for performing both manual, and automated cross browser testing with Selenium Grid.

Manual Cross Browser Testing *— LambdaTest offers a feature called *“Real Time Testing” that allows you to perform live-interactive testing with your web-app by providing a VM(Virtual Machine) based on your selected OS + browser configuration.

However, performing live-interactive testing will definitely be time-consuming. What if you want to have a quick look of your website to validate browser compatibility testing?

LambdaTest offers Screenshot testing to help you capture screenshots in bulk for your website over different desktop and mobile browsers. Select up to 25 configuration of your desired browser + OS configuration in a single test session. You can switch to mobile view of website using the toggle next to Desktop icon. Simply, place the URL you wish to test, select your configurations and hit the Capture button.

In this Appium tutorial, learn about Appium automation testing and its benefits for mobile automation testing. Take a look at how Appium works and see how to perform Appium testing of your mobile applications.

Automated Cross Browser Testing — As explained in earlier section, automated cross browser testing is relevant to pace the test cycles by automating the repetitive test cases. LambdaTest offers a cloud-based Selenium Grid to help you execute your automation test scripts on more than 3000 real browsers and browser versions.

Selenium Grid offered by LambdaTest provides compatibility with every test automation framework that supports Selenium.

LambdaTest also offer integrations with multiple CI/CD tools to help you speed up your go-to-market launch.

You can also perform parallel testing to run multiple automation tests simultaneously.

You can find all the logs of your test execution such as network logs, command logs, Selenium logs, command-by-command screenshots, video recording and more.

When you execute automated cross browser testing then reporting becomes vital to keep a track of numerous test case execution. LambdaTest recently went live with restful API to help your extract your test results from LambdaTest in order to build powerful reports.

Still, it should be noted that despite the automation, observing the running script with pen and paper at the ready is a useful technique. This way, you can spot problems that even automated checks can’t. Creating a browser compatibility matrix is also a helpful technique, as it is a means to make sure that you cover all the possible browser and operating system versions along with all the devices.

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

Here’s a short glimpse of the Selenium 101 certification from LambdaTest:

Get started with this complete automation testing using Selenium tutorial. Learn what Selenium is, its architecture, advantages and more for automated cross browser testing.

Performing Responsive Testing With LambdaTest

Before I tell you about performing responsive testing with LambdaTest. I would like to inform you the oldest trick in the book to perform responsive testing. Open the website you wish to test on your local browser window and minimize your browser. Now, pick any corner of your browser window and drag it either horizontally, vertically, or diagonally. You will be able to notice whether your website is changing dynamically according to browser window’s size.

Main drawback here is that when you are testing responsiveness of your website through this approach then you are viewing everything from the perspective of your local browser’s rendering engine. In reality, your users may be using Safari, Opera, Yandex, Edge, IE, or any other browser. A different browser possessing a different rendering engine over a different device than yours can have a major difference in the look and feel, in comparison to your browser-window dragging approach. This is why you need to perform it over different devices through device labs, or emulators/simulators. Device labs could be very expensive and unaffordable to many small start ups, freelancers etc., so a good choice would be to go with a cloud-based service provider such as LambdaTest.

LambdaTest allows you to perform responsive testing on 46 mobile and desktop devices in a single go. Just provide the URL you wish to test and hit the Generate button. You can change the defer time for capturing screenshot, adjust the monitor size, can view a device in portrait or landscape mode according to your reference and do a lot more. Follow our documentation on Responsive testing to know it all.
You can use LT Browser, a mobile friendly tester to build, test, and debug your responsive website.

Increasing Importance

With increasing updates in various browsers, many web elements are being deprecated, and many web elements that were previously unsupported among majority of browsers are now being cross browser compatible. Without a doubt, both cross browser testing and responsive testing are important, especially in today’s internet-dependent world. Keep in mind, that responsive testing is a subset of cross browser testing, and both are critical in delivering a pixel-perfect user journey to every visitor on your website. Happy Testing! 🙂