Forem: AndreeaDraniceanu

A Beginner’s Guide To SpecFlow ScenarioContext

AndreeaDraniceanu — Thu, 18 Jan 2024 05:45:24 +0000

SpecFlow is a great .NET testing framework for a BDD test-first approach. It uses plain and readable language to describe the behavior of the software, which both technical and non-technical staff can understand. This helps bring together the different project stakeholders, product owners, developers, and Quality Assurance (QA) engineers to collaborate and deliver high-quality software with a focus on communication, collaboration, and a good understanding of the business requirements.

SpecFlow ScenarioContext is a SpecFlow framework feature commonly used in behavior-driven development (BDD) for .NET applications. ScenarioContext allows the sharing of data between different steps in a SpecFlow scenario. It acts as a storage container for scenario-specific data, allowing information to be passed between different scenario steps.

In this Selenium C# tutorial, we will write an automated step using SpecFlow ScenarioContext to share data between steps.

Need a fake IP address for your testing projects? Use our free online Random IP Generator to quickly generate fake IP addresses with just a few clicks.

Why use SpecFlow?

In my experience, using SpecFlow for automation testing has helped the teams more easily integrate newbies into the test automation process, and providing test reports to higher-ups who do not need to know the code behind the tests is easier.

With SpecFlow, the executable specifications are written in Gherkin syntax, which follows basic English language rules and can be read by anybody regardless of technical background. This is very helpful when working in teams where some QA members are not yet very experienced in writing code or when other team members read the test results.

Another cool thing about the Given-When-Then test style, which I will cover in more detail, is that it can be used outside the test automation framework. For example, the tests can be saved in a separate test management tool if the project requires it.

These tests are easy to follow because they are written in plain English. Also, the manual tests — the tests that cannot or should not be automated — can be written following the same style. If a test fails, you can simply copy the SpecFlow scenario as it is in the bug report. The steps to reproduce should be clear enough for anyone.

Stop using the same password for everything! Create strong and unique passwords that are difficult to guess with our Random Password Generator. Try it now.

If you are new to SpecFlow, you can go through this guide on getting started with SpecFlow.

You can subscribe to the LambdaTest YouTube Channel for more tutorials on Selenium testing, Playwright testing, Cypress testing, and more.

What is SpecFlow ScenarioContext?

A common case when working with SpecFlow is shared data between the test steps or scenarios. To avoid code duplication, we can use the ScenarioContext class.

The ScenarioContext class is a shared context object used in SpecFlow to share data between different steps and scenarios. It allows storing and retrieving data throughout the execution of the test scenarios, and it can be used to transfer data between different steps and scenarios.

Starting with SpecFlow 3.0, ScenarioContext.Current has been marked as obsolete. Moving away from these properties is because they do not work when running scenarios in parallel. So, in versions 3.0 and higher, you must use the constructor to create an instance of ScenarioContext using Context-Injection.

ScenarioContext can be used in any SpecFlow hook that executes a scenario. So we can use ScenarioContext in [BeforeScenario, AfterScenario] and [BeforeStep, After*Step], but it cannot be used in [*BeforeTestRun, AfterTestRun] or [BeforeFeature, AfterFeature].

It can also provide other information about the scenario, such as tags, titles, and descriptions. This information is available through the ScenarioContext.ScenarioInfo class:

Need to generate random text based on a regular expression for testing and generating sample data.? Use our online tool to create random text from RegEx.

Using ScenarioContext in Selenium

If you want to use SpecFlow, the best way is to work with Visual Studio. You will need to install SpecFlow as an extension. You can do this from the Extensions menu → Manage Extensions, and here search for the extension by name:

Once the installation is done, a new project template will be available when creating a new project:

Once you complete the New Project steps, you will have a new SpecFlow project created in Visual Studio.

The SpecFlow project will contain a feature file, which is the type of file where the Gherkin scenarios are written, and a steps definition file — which is a C# class with the code for the steps:

The feature file content looks like this:

Feature: Calculator
![Calculator](https://specflow.org/wp-content/uploads/2020/09/calculator.png)
Simple calculator for adding **two** numbers


Link to a feature: [Calculator](SpecFlowProject2/Features/Calculator.feature)
***Further read***: **[Learn more about how to generate Living Documentation](https://docs.specflow.org/projects/specflow-livingdoc/en/latest/LivingDocGenerator/Generating-Documentation.html)**


@mytag
Scenario: Add two numbers
    Given the first number is 50
    And the second number is 70
    When the two numbers are added
    Then the result should be 120

We’re interested in the Scenario — this is the test case itself. The SpecFlow scenarios have a Given — When — Then Gherkin structure, equivalent to AAA — Arrange, Act, Assert. The And keyword can also be used to avoid repetitions of the same keyword.

This scenario is straightforward to read and understand, even if you don’t know C# or other programming languages.

Generate custom QR codes for your business or personal needs with our fast and easy-to-use QR code generator online tool in seconds. Try it now.

The implementation for a step looks like this:

[Given("the first number is (.*)")]
        public void GivenTheFirstNumberIs(int number)
        {
            throw new PendingStepException();
        }

Of course, in the provided example on project creation, no actual implementation for the steps is done, so the step will just throw a PendingStepException.

For this sample scenario, an implementation could look something like:

[Given("the first number is (.*)")]
        public void GivenTheFirstNumberIs(int number)
        {
            a = number;
        }

But we will look into this in more detail with a realistic web test scenario.

This Random ISBN Generator is a free easy-to-use tool to generate random and unique ISBN numbers. Generate the most accurate and verified ISBNs instantly.

Writing the First Gherkin Test

Now that we know the structure, we can write our tests using the same format. Let’s first understand some of the most important Gherkin keywords and what they mean:

Feature: provides a high-level description of a software feature and the scenarios included in a file. The file structure in Gherkin for Selenium Testing is defined by how different lines of code are indented in a feature file. Each line typically starts with a special keyword, and the statements are terminated by line endings known as steps. The first word in any feature file must be Feature, followed by a colon (:), followed by a description of the feature.
Scenario: is a business rule or the equivalent of a test case. The first line of a test must begin with Scenario:, followed by the test description.
Given: is the Arrange step — it is more like a precondition to the entire test.
When: is used for action steps.
Then: means the assertion of the test.
And: if we need multiple Given, When, or Then steps, we can use And to avoid repeating the same keyword.
Background: is used when the same Given step would be repeated in all the tests inside a feature file. This is a precondition that is repeated before each of the scenarios of the feature.
Scenario Outline: is used for data-driven scenarios or when we want to have the same scenario with different data sets.
Examples: the Examples keyword precedes the data table containing the test data for the Scenario Outline.

A Gherkin test for a Login page can look something like this:

Feature: As an existing user, I want to be able to log in, so that I can access my account.


Background: I access the login page


Scenario: Login with a valid account
    Given I enter a valid username and password
    When I press the Sign in button
    Then I can see My account page

Implementing the Test Steps

The test steps must be implemented in a C# class, marked with the Binding attribute. You can auto-generate the steps implementation by right-clicking inside the feature file and selecting Define Steps.

At first, they will have an implementation that only throws an error (as above). You can copy the steps definitions or add them to a class.

The way the steps are linked to their definition is through regular expressions. So, in the following example:

[Given(@"I enter a valid username and password")]
public void GivenIEnterAValidUsernameAndPassword()
{
        // step code here
}

The code between the curly brackets will be executed for each Given step that matches the regular expression between the quotes. In this case, it has to match the exact string, but it’s not mandatory.

Need a barcode for your products? Create high-quality custom barcodes using our online barcode generator. Try our barcode generator tool and get one in seconds.

Using SpecFlow ScenarioContext

As it happens so often, some of the test data we use will be shared between the test steps. For example, if you use a username and password in the first step of the previous example, you may want to check on the My Account page that the correct username is displayed after the login.

You can do this by passing a variable in each step or sharing that information using SpecFlow ScenarioContext.

The SpecFlow ScenarioContext can be used inside Bindings for specific SpecFlow hooks. So, for example, we can use ScnearioContext inside the Given, When, Then steps, or inside [BeforeScenario, AfterScenario] or [BeforeStep, AfterStep], but not in [BeforeTestRun, AfterTestRun] or [BeforeFeature, AfterFeature]. This is because no scenario is executed for the last hooks.

In line with the entity-based step organization rule, one efficient method for sharing data between different steps related to the same entity within the same scenario is to define instance fields in the binding classes. To use ScenarioContext, a new instance needs to be created inside the constructor of the Bindings class, as shown below:

public Bindings(ScenarioContext scenarioContext)
{
    _scenarioContext = scenarioContext;
}

Then, you can set and read its properties:

_scenarioContext["property"] = "value";

Demonstration: SpecFlow ScenarioContext

Let’s look at a scenario to better understand how to use SpecFlow ScenarioContext.

Scenario

Navigate to the LambdaTest eCommerce Playground page.
Expand the Shop by Category menu.
Select a category.
Validate that the correct category page is loaded.

Implementation

Feature: ECommerce


As a user, I want to navigate between the product categories
So I can find the desired product in the list


Background:
    Given I navigate to the LambdaTest ecommerce playground page


Scenario Outline: Navigate to categories
    Given I extend the Shop by Category menu
    When I select the <category> category
    Then the correct page is loaded
Examples:
    | category   |
    | Components |
    | Cameras    |
    | Software   |

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


namespace SpecFlowScenarioContextDemo.StepDefinitions
{
    [Binding]
    internal class SetUp
    {
        protected static IWebDriver driver;
        public static 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");
        protected ScenarioContext scenarioContext;


        public SetUp(ScenarioContext _scenarioContext)
        {
            scenarioContext = _scenarioContext;
        }


        [BeforeScenario]
        internal static void RunSetup()
        {
            SafariOptions capabilities = new SafariOptions();
            capabilities.BrowserVersion = "latest";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "macOS Ventura");
            ltOptions.Add("build", "SpecFlow ScenarioContext");
            ltOptions.Add("project", ScenarioContext.Current.ScenarioInfo.Title);
            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);
        }


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


    }
}

The above code showcases utilizing a cloud grid like LambdaTest to run the test.

Catch errors before they impact your JavaScript validator code. Our validator and linter enforces coding standards and helps you catch errors. Validate your code today.

LambdaTest is an AI-based test orchestration and execution platform that allows you to run SpecFlow tests with Selenium on a scalable and reliable cloud grid. With LambdaTest, you can conduct Selenium C# testing using SpecFlow on over 3000 unique combinations of browsers, operating systems, and devices.

The process is quite straightforward when running your tests on an online Selenium Grid, as the necessary code modifications are only related to the infrastructure.

After creating an account on LambdaTest, it is important to take note of your username and access key from the Profile Section. This combination will be used to access the remote Selenium Grid on LambdaTest.

The Dashboard provides a comprehensive view of all your text logs, screenshots, and video recordings for your SpecFlow Selenium C# tests. Furthermore, you can utilize the LambdaTest Capabilities Generator to generate the desired browser and platform capabilities for automation testing.

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;
using SeleniumExtras.WaitHelpers;


namespace SpecFlowScenarioContextDemo.StepDefinitions
{
    [Binding]
    internal class ECommerceStepDefinition : SetUp
    {
        public ECommerceStepDefinition(ScenarioContext _scenarioContext) : base(_scenarioContext)
        {
        }


        [Given(@"I navigate to the LambdaTest ecommerce playground page")]
        public void GivenINavigateToTheLambdaTestEcommercePlaygroundPage()
        {
            driver.Navigate().GoToUrl("https://ecommerce-playground.lambdatest.io/");
        }


        [Given(@"I extend the Shop by Category menu")]
        public void GivenIExtendTheShopByCategoryMenu()
        {
            driver.FindElement(By.XPath("//a[normalize-space()='Shop by Category']")).Click();
            WaitForElement($"//h5[normalize-space()='Top categories']");
        }


        [When(@"I select the (.*) category")]
        public void WhenISelectTheCategoryCategory(string categoryName)
        {
            scenarioContext["Category"] = categoryName;
            driver.FindElement(By.XPath($"//span[normalize-space()='{scenarioContext["Category"]}']")).Click();
        }


        [Then(@"the correct page is loaded")]
        public void ThenTheCorrectPageIsLoaded()
        {
            WaitForElement($"//h3[text()='Filter']");
            Assert.That(driver.Title == scenarioContext["Category"].ToString());
        }


        private static void WaitForElement(string xpath)
        {
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(5));
            wait.Until(ExpectedConditions.ElementIsVisible(By.XPath(xpath)));
        }
    }
}

Code Walkthrough

eCommerce.feature (the feature file)

The feature file contains the test written in plain English, using the Gherkin keywords. The file starts with a short description of the feature. This is not mandatory, but since SpecFlow tests can also be used as documentation, including it is a good practice.

For this example, I ran the test 3 times for 3 categories. This means that we need to use Scenario Outline. They both start with the precondition that the page is loaded, defined in the Background.

Next comes the test scenario, or the ScenarioOutline, with 3 examples:

The <category> variable will receive a different value from the Examples table on each test run.

The beauty of using SpecFlow and Gherkin is that this scenario is easy to read and interpret as a regular test case. No programming language is needed to understand until this point, and we can show it to other members of our team who need to know what we are testing.

Test your native, hybrid, and web apps across all legacy and latest mobile operating systems on the most powerful Android emulator online.

SetUp.cs (the setup class)

This is where I have the BeforeScenario and AfterScenario methods, which must be executed before and after each scenario inside the solution.

The first part is the variable declaration:

I need to declare an IWebDriver variable, a variable of type ScenarioContext, and my LambdaTest credentials, which are stored on my machine as environment variables. I also have a constructor for the class:

 public SetUp(ScenarioContext _scenarioContext)
        {
            scenarioContext = _scenarioContext;
        }

In the BeforeScenario method, I have the code that needs to execute before the test steps:

I will run the test on Safari browser, which is why I will set the capabilities I want to use in the test. You can easily obtain those using the Capabilities Generator. Then, create a new instance of the driver using those capabilities.

The AfterScenario methods will close all the browser instances:

ECommerceStepDefinition.cs (the implementation class):

Here is where I have the implementations for the steps. The link between the class and the Gherkin steps is one through the [Bindings] attribute and the regular expressions that match the test steps.

Also, to have the before and after methods executed, this class needs to inherit the SetUp class:

Then come the steps. They use attributes as the keywords in the Gherkin tests (Given, When, Then). Alternatively, you can use the StepDefinition attribute to match any previous keywords.

The first step is to navigate to the webpage under test using Navigate().GoTo() Selenium command:

Next comes the test step that expands the “Shop by category” menu. This is done by clicking on the element found by XPath, using its tag (a), and the text it contains (normalize-space()=’Shop by Category’). Then, I used a common method that waits for an element to be visible, using an explicit wait in Selenium.

In the next step, I am using a string variable to pass each category that needs to be selected. To do this in SpecFlow, you can use the regular expression for any string, “(.*)”. This means that the test matches if it contains anything between the “I select the “ string and the “ category” string.

In the first line of the method, I use the scenario context to store the category name and pass it to the next test step.

Then, using an XPath again, the test clicks the category link.

Finally, the last step checks that the page is correctly loaded by validating that the page title is the same as the previously selected category. I could have used a variable again, but using scenarioContex, I don’t need to.

To ensure the validation is done before the page is loaded, I am using the WaitForElement() method to wait for the Filter menu to be displayed. Then, I assert that the page’s title is the same as the previously set category.

In this tutorial, learn what is Regression testing, its importance, types, and how to perform it.

Test Execution

The tests are available in the Test Explorer tab. I am using tests plural because a test is available for each example:

You can select one of them or one of the higher nodes (project name/feature name/scenario name) and press “Run all”.

Because I am using my LambdaTest account, the tests will be executed on the Selenium Grid, but I can also see the results in Visual Studio (the green check mark means they are passed).

Each test execution is also displayed in the test details.

I can also see the test results (including a replay) on my Dashboard.

Perform browser automation testing on the most powerful cloud infrastructure. Leverage LambdaTest automation testing for faster, reliable and scalable experience on cloud.

Best Practices for SpecFlow ScenarioContext

While ScenarioContext in SpecFlow is a powerful feature that allows data to be shared between steps within a scenario, there are situations where its usage might not be ideal. Now, let’s consider some scenarios where using alternatives or avoiding ScenarioContext in SpecFlow might be more suitable.

Parallel Execution

If you design tests that run in parallel scenarios, using the SpecFlow ScenarioContext may lead to unexpected behavior. This is because the ScenarioContext is shared across steps within a scenario, and concurrent execution of scenarios can result in data interference. It is advisable to consider using thread-safe alternatives or scenarios that do not rely on shared context in parallel execution environments.

Global State Management

SpecFlow ScenarioContext offers a way to share the state between steps; however, heavily relying on global state management can negatively impact test maintainability. It is recommended instead to aim for scenarios and steps that are independent of each other while encapsulating their required data. This approach promotes better test isolation and makes identifying the cause of failures easier.

Data-Driven Testing

When it comes to testing scenarios that rely on data, managing the complexity of the SpecFlow ScenarioContext can be challenging. One approach to tackle this is utilizing external data sources like tables in feature or external data files. By incorporating these sources, you can drive your tests with various datasets, making your testing more robust and adaptable.

Long-Running Scenarios

In scenarios that are long-running or involve multiple steps, using SpecFlow ScenarioContext to pass data between steps can sometimes create confusion in the test logic. Instead, it is recommended to break down complex scenarios into smaller, focused ones. Each of these smaller scenarios can then independently manage their context.

Performance Testing

When it comes to performance or stress testing, where we simulate large sets of data or high concurrent user loads, using SpecFlow ScenarioContext can sometimes cause bottlenecks or contention issues. In these situations, assessing the performance impact and exploring other approaches is important.

External Dependency Management

When dealing with external dependencies or services, avoiding relying solely on a shared state through SpecFlow ScenarioContext is important. This approach can present challenges when unexpected failures or changes occur in the external systems. Instead, techniques such as mocking or stubbing, which provide greater control over external dependencies, are worth considering. By employing these methods, you can better manage and mitigate potential issues.

Overall, it’s important to remember that the appropriate use of SpecFlow ScenarioContext depends on your tests’ specific requirements and characteristics. While it can help share the state between steps in a scenario, it’s crucial to exercise caution and consider alternative approaches when necessary.

Get ready to showcase your mastery and extensive know-how in employing Selenium for C# automation testing by obtaining the coveted Selenium C# 101 certification. This valuable certification will bolster your technical proficiency and solidify your reputation as a skilled and reliable tester.

Which are the most wanted automation testing tools that have climbed the top of the ladder so far? Let’s take a look.

Conclusion

Working with SpecFlow can be a very good idea, especially if you need teams and people with various skills to collaborate on the project. The scenarios are easy to read, written in plain English, and use the Given-When-Then structure.

SpecFlow ScenarioContext comes in as a great asset. Its main strength is its capacity to provide smooth data exchange between various processes in a scenario, improving reusability and encouraging a clear division of responsibilities. With ScenarioContext, you can pass information and context easily throughout test scenarios, making it a great tool for maintaining state and sharing relevant data during complex test executions.

You can also leverage SpecFlow Actions and take your test automation to new heights. It empowers you to execute tests across various browser versions and operating systems.

How to Run Multiple NUnit Test Cases

AndreeaDraniceanu — Fri, 01 Dec 2023 13:11:24 +0000

When it comes to automated testing in .NET, the NUnit framework is a go-to choice due to its simplicity and robust set of features. In this blog, I will show you how to run multiple test cases in NUnit and Selenium.

When working on complex projects, having multiple NUnit test cases to cover various scenarios and edge cases is common. NUnit provides methods to automate the execution of multiple test cases, saving time and effort while maintaining high code quality.

In the following sections, we will explore how to organize and structure test cases and execute them in bulk using attributes and data-driven testing. We will cover what NUnit is, how to run the same test with different test data, and how to run multiple NUnit test cases in parallel. Ultimately, we’ll have a short example of how all this information can be put together.

Want to ensure your website is optimized for mobile traffic? Our comprehensive guide to test website on mobile devices success covers everything you need to know.

What is NUnit?

Before demonstrating how to run multiple test cases in NUnit, let’s understand what NUnit is and why it’s a popular framework for automation testing.

NUnit is an open-source unit testing framework for .NET languages, including C# and VB.NET. When writing this blog on running multiple NUnit test cases, the latest version is 3.13.3. NUnit provides a simple and intuitive way to write and execute tests, allowing you to verify the behavior and code correctness.

NUnit follows the xUnit testing framework pattern, separating test setup, execution, and assertions.

One of NUnit’s main benefits is its compatibility with popular development environments like Visual Studio, which makes it a practical option for testing frameworks in .NET.

We will discuss its range of properties and NUnit assertions that help organize and structure tests. To increase flexibility and test coverage, NUnit also offers additional features like:

parameterized tests
test fixtures
test suites

Now that we have a basic understanding of this framework, let’s look at what are annotations in NUnit. After that, we will see how to run multiple NUnit test cases.

Getting started with Selenium testing with NUnit? Watch the tutorial below and expedite your learning.

Perform live mobile test on different devices with LT Browser 2.0. Test website on multiple mobile and tablet viewports and debug UI issues on the go across 50+ device viewports.

Subscribe to our LambdaTest YouTube Channel for the latest updates on tutorials around Selenium testing, Cypress testing, and more.

Annotations in NUnit

NUnit annotations, also called NUnit attributes, are special instructions or metadata that can be applied to test methods, classes, or assembly files to modify code execution or provide additional information, like descriptions and test case links (for integration with test management tools like TestRail).

The most common NUnit annotations are:

OneTimeSetup: This annotation marks a method that will run once before the entire test run.
OneTimeTearDown: This annotation marks a method that will be executed once after the entire test run.
Setup: This annotation marks a method that will run once before each test case.
TearDown: This annotation marks a method that will execute after each test case.
Test: This annotation marks test methods. Each test marked as such will be displayed in the Test Explorer panel of Visual Studio.
Ignore: This annotation marks a test method to be ignored — when the tests are automatically run, tests marked with ‘Ignore’ will not be executed.
Explicit: This annotation marks a method that will be ignored unless explicitly selected to run.
TestCase: An annotation we use for data-driven testing, i.e., for tests that run multiple times with different data sets.
Category: This annotation can be used to group tests, which can be run together by specifying their category.
Parallelization: This annotation marks a class or a method for parallelization.

The order in which the methods are executed is as follows:

[OneTimeSetup]
    [Setup]  
    TestMethod1
    [TearDown]

    [Setup]  
    TestMethod2
    [TearDown]
[OneTimeTearDown]

Explore how to test ios app on multiple devices, weighing their key features and benefits to select the perfect one for your mobile app project.

Data-Driven Testing to Run Multiple NUnit Test Cases

Data-driven testing is an approach to testing a software application using multiple input data sets. Instead of writing separate test methods for each data set, we can leverage NUnit’s data-driven testing feature to run a single test method with different inputs. This technique is especially useful when we want to test code against various scenarios or validate different data combinations, for example, cross browser testing.

Here’s an example of how to perform data-driven testing with NUnit using the TestCase attribute:

public class Tests
{
    [Test]
    [TestCase("Chrome")]
    [TestCase("Safari")]
    [TestCase("Edge")]
    public void TestOnMultipleBrowsers(string browser)
    {
        // Test code goes here
    }
}

In the above code, we have a Tests class with a TestOnMultipleBrowsers method containing code we want to run on multiple browsers. Instead of writing separate tests for each input/output pair, we use the [TestCase] attribute to specify multiple sets of input and expected output. NUnit will run the TestAddMethod test method three times, once for each test case.

The [TestCase] attribute also supports a variety of data sources, such as arrays, data tables, and CSV files. Here’s an example of using a data table with the TestCaseSource attribute:

public class Tests
{
    static object[] ItemData =
    {
        new object[] { new Item("Chrome", 114)},
        new object[] { new Item("Safari", 16.5)},
        new object[] { new Item("Edge", 114)},
    };


    [Test]
    [TestCaseSource(nameof(ItemData))]
    public void TestOnMultipleBrowsers(Item item)
    {
        // Test code goes here
    }
}

In this example, we have a class with a test method that uses a data table to define multiple browsers and browser versions.

We then use the TestCaseSource attribute to specify that NUnit should use the ItemData field as the data source for the test method. Again, NUnit will run the test method three times, once for each set of inputs.

How to Run Multiple Tests in Parallel Using NUnit?

By default, test cases in NUnit are run sequentially, meaning that a new test will only run after the previous one has completed its execution. This is all good when we don’t have a lot of tests, but as the projects get more complex, we want to save time on the test execution. To do this, we can [run the tests in parallel]

For parallelization, NUnit offers the annotation [Parallelizable] annotation, which can be used at the class level or at the method level. We, the designers of the tests, are in charge of ensuring that the tests are thread safe when executed concurrently.

Otherwise, unexpected behavior can result from concurrent tests that edit instance fields or properties without locks, just like it would in a multi-threaded program. This applies to scenarios where one test case can change the data used in a different test case. Keeping the tests as independent as possible is always a good practice.

When using the [Parallelizable] annotation, we need to specify the scope of the parallelization. Here are the available options:

ParallelScope.Self: When the test can run in parallel with other tests. This scope can be applied to classes and methods.
ParallelScope.Children: When the child tests can run in parallel with one another. This scope can be applied to the assembly and classes.
ParallelScope.Fixtures: When the fixtures (test classes) can run in parallel with one another. This scope applies to the assembly and classes.
ParallelScope.All: When the test and its descendants can run in parallel with others at the same level. This scope can be applied to classes and methods.

Perform live web device testing on different devices with LT Browser 2.0. Test on multiple mobile and tablet viewports and debug UI issues on the go across 50+ device viewports.

Demonstration: Running Multiple NUnit Test Cases in Parallel

In the next section of this NUnit tutorial, I will demo how we can use data-driven testing with Selenium and run multiple NUnit test cases in parallel, saving a lot of execution time. We will be using the already-mentioned annotations, assertions, and data-driven testing. This is equivalent to executing multiple NUnit test cases.

Test Scenarios

Scenario 1:

Navigate to the webpage: LambdaTest eCommerce Playground.
Open the Shop by Category menu.
Click on a category under the section Top Categories.
Validate that the correct page is loaded with the correct title.
Repeat the test for multiple categories.

Scenario 2:

Navigate to the webpage: LambdaTest eCommerce Playground.
Enter invalid credentials for the username and/or password.
Validate that the correct message is displayed: “No match for E-Mail Address and/or Password.

Implementation (Local Test Execution)

When writing this article, the latest version of Selenium is 4.10.0. One of the standout features in Selenium 4 is the adoption of the W3C WebDriver protocol, which takes the place of the JSON wire protocol used in Selenium 3. This shift has been a game-changer, making Selenium 4 distinct and more advanced compared to Selenium 3.

To know the difference between Selenium 3 and 4 versions, we recommend checking our article on Selenium 3 vs Selenium 4.

Let’s see how to run multiple NUnit test cases on a local machine. There are a few prerequisites before we start writing the tests.

First, create a new NUnit project:

Next, add the Selenium.WebDriver Nuget package. Also, add a NuGet package for the desired browser. As I use the Chrome browser, I will now add the Selenium.WebDriver.ChromeDriver package. I am also adding the package DotNetSeleniumExtras, which will be used for explicit waits in Selenium.

Once we are done with the above prerequisites, the next step is to write the test script.

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using SeleniumExtras.WaitHelpers;
using OpenQA.Selenium.Support.UI;


namespace NUnitDataDriven
{
    public class NUnitTest
    {
        private static IWebDriver driver;


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


        [Test]
        [TestCase("Components")]
        [TestCase("Cameras")]
        [TestCase("Software")]
        public void OpenCategory(string menuOption)
        {
            driver.Navigate().GoToUrl("https://ecommerce-playground.lambdatest.io/");
            driver.FindElement(By.XPath("//a[normalize-space()='Shop by Category']")).Click();
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(5));
            string xpath = $"//span[normalize-space()='{menuOption}']";
            wait.Until(ExpectedConditions.ElementIsVisible(By.XPath(xpath)));
            driver.FindElement(By.XPath(xpath)).Click();
            Assert.That(Equals(driver.Title, menuOption));
        }


        [Test]
        [TestCase("andreea", "test")]
        [TestCase("andreea@getnada.com", "")]
        [TestCase("andreea@getnada.com", "xxxx")]
        public void LoginInvalidCredentials(string email, string password)
        {
            driver.Navigate().GoToUrl("https://ecommerce-playground.lambdatest.io/index.php?route=account/login");
            driver.FindElement(By.Name("email")).SendKeys(email);
            driver.FindElement(By.Id("input-password")).SendKeys(password);
            driver.FindElement(By.CssSelector("input[value='Login']")).Click();
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(5));
            string xpath = "//div[@class='alert alert-danger alert-dismissible']";
            wait.Until(ExpectedConditions.ElementIsVisible(By.XPath(xpath)));
            Assert.That(driver.FindElement(By.XPath(xpath)).Text.Contains("No match for E-Mail Address and/or Password."));
        }


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

Check website on different devices with LT Browser 2.0. Test on multiple mobile and tablet viewports and debug UI issues on the go across 50+ device viewports.

Code Walkthrough

The first part is the same for all C# classes and contains the references to namespaces and packages to be used:

Then, we have the driver variable declared in the first part of the class using the IWebDriver Selenium interface:

We don’t need any other variables for this example, so we can go straight to the tests. However, we can use a common setup for all our tests to avoid code repetition in each test. We’ll do this using the [SetUp] annotation, so the code inside will execute before each test case. This line of code simply starts the Chrome browser.

Next, we can get started on the tests. We have two scenarios that will be executed with various test data. So we will have the [Test] annotation to instruct the test runner that the code inside is test code and the [TestCase] annotation, once for each set of data.

Let’s look at them individually:

In this test, we need to declare a string variable for selecting the menu option. We can call it menuOption, and inside each test case annotation, we need to pass the string value to use.

The first step of the test is to navigate to the desired URL using the Navigate Selenium command. After the page is loaded, we need to click the Shop by Category link — for this, we will use the FindElement() command to identify the web element using its XPath and the Click() command to perform the click.

Next, we want to click the category, but we can instruct Selenium to wait for the link to be visible before clicking it. For this, we can use an explicit wait, and the click will not be performed before the element is loaded on the page. We can use XPath again to identify the element and the Click() command to click on it.

The last step is the assertion, using the NUnit class Assert, and we want to validate that the correct page is loaded. For this, we compare the page title with the menu option, and these two strings should be equal.

In the second test case, we will need two variables — one for the user email and one for the password, and we will pass the values the same way we did in the previous test.

View Website on different devices with LT Browser 2.0. Test on multiple mobile and tablet viewports and debug UI issues on the go across 50+ device viewports.

The first line is the same as in the other test, except we navigate to a different URL.

Next, we need to identify the email and password fields, enter their values, and click the Login button. We can use Locators in Selenium to find the elements, such as Name, ID, or CSS Selectors.

Next, we again need Selenium Waits to ensure that the validation is not done before the warning is visible on the web page.

The last line is an assertion, which contains the validation that the correct message is displayed.

And last but not least, we have a teardown method that executes after each test case due to the [TearDown] annotation. We are closing the browser after each execution, using the Quit() command.

Local Test Execution

The tests can be run from the Test Explorer panel — you can see that each set of data is displayed as a separate test and can be run independently.

If you run all the tests, they will run sequentially, each test opening a new Chrome browser window. Running them in parallel can cause issues because each test tries to interact and simulate mouse and keyboard actions.

After running the tests, you can see the total time is almost 40 seconds — not more, but this is a sample project with simple tests. The more tests the project has, the longer it will take to execute them locally, and this means that the local machine cannot be used during this time.

Perform browser automation testing on the most powerful cloud infrastructure. Leverage LambdaTest automation testing platform for faster, reliable and scalable experience on cloud.

Running Multiple NUnit Test Cases on the Cloud

Let’s see how to write the tests, but this time for running them on the online Selenium grid offered by LambdaTest — an AI-powered test orchestration and execution platform to perform automated testing with NUnit at scale on over 3000+ real browsers and operating systems. With LambdaTest, you can run multiple NUnit test cases in parallel, reduce test execution time, and ramp up the feedback loop for deploying quality builds.

Looking to get started with Selenium automation with NUnit? Check out the documentation — NUnit with Selenium.

So you can test remotely and not on a local machine. To run the test on LambdaTest, first, we need to use the Capabilities Generator to set up the browser capabilities.

Here is how the code looks this time.

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;
using OpenQA.Selenium.Support.UI;
using SeleniumExtras.WaitHelpers;


[assembly:Parallelizable(ParallelScope.All)]


namespace NUnitDataDriven
{
    public class NUnitTest
    {
        ThreadLocal<IWebDriver> driver = new ThreadLocal<IWebDriver>();
        public static string gridURL = "@hub.lambdatest.com/wd/hub";


        public static string testURL_1 = "https://ecommerce-playground.lambdatest.io/";
        public static string testURL_2 = "https://ecommerce-playground.lambdatest.io/index.php?route=account/login";


        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()
        {
            ChromeOptions capabilities = new ChromeOptions();
            capabilities.BrowserVersion = "latest";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "Windows 11");
            ltOptions.Add("project", "NUnit Multiple Tests");
            ltOptions.Add("w3c", true);
            ltOptions.Add("plugin", "c#-c#");
            capabilities.AddAdditionalOption("LT:Options", ltOptions);
            driver.Value = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), capabilities);
        }


        [Test]
        [TestCase("Components")]
        [TestCase("Cameras")]
        [TestCase("Software")]
        public void OpenCategory(string menuOption)
        {
            IWebDriver currentDriver = driver.Value;


            currentDriver.Manage().Window.Maximize();
            currentDriver.Navigate().GoToUrl(testURL_1);
            currentDriver.FindElement(By.XPath("//a[normalize-space()='Shop by Category']")).Click();
            WebDriverWait wait = new WebDriverWait(currentDriver, TimeSpan.FromSeconds(5));
            string xpath = $"//span[normalize-space()='{menuOption}']";
            wait.Until(ExpectedConditions.ElementIsVisible(By.XPath(xpath)));
            currentDriver.FindElement(By.XPath(xpath)).Click();
            Assert.That(Equals(currentDriver.Title, menuOption));
        }


        [Test]
        [TestCase("andreea1", "test")]
        [TestCase("andreea2@getnada.com", "")]
        [TestCase("andreea3@getnada.com", "xxxx")]
        public void LoginInvalidCredentials(string email, string password)
        {
            IWebDriver currentDriver = driver.Value;


            currentDriver.Navigate().GoToUrl(testURL_2);
            currentDriver.FindElement(By.Name("email")).SendKeys(email);
            currentDriver.FindElement(By.Id("input-password")).SendKeys(password);
            currentDriver.FindElement(By.CssSelector("input[value='Login']")).Click();
            WebDriverWait wait = new WebDriverWait(currentDriver, TimeSpan.FromSeconds(5));
            string xpath = "//div[@class='alert alert-danger alert-dismissible']";
            wait.Until(ExpectedConditions.ElementIsVisible(By.XPath(xpath)));
            Assert.That(currentDriver.FindElement(By.XPath(xpath)).Text.Contains("No match for E-Mail Address and/or Password."));
        }


        [TearDown]
        public void Cleanup()
        {
            bool passed = TestContext.CurrentContext.Result.Outcome.Status == NUnit.Framework.Interfaces.TestStatus.Passed;
            try
            {
                // Logs the result to Lambdatest
                ((IJavaScriptExecutor)driver.Value).ExecuteScript("lambda-status=" + (passed ? "passed" : "failed"));
            }
            finally
            {
                // Terminates the remote webdriver session
                driver.Value.Quit();
            }
        }
    }
}

Code Walkthrough

Just like before, the first lines of code contain the references used in the class — this time, we need an additional reference, OpenQA.Selenium.Remote, which allows us to run the tests remotely:

Before the class name, we use the [assembly:Parallelizable(ParallelScope.All)] attribute, which will instruct the tests contained in the class to run in parallel with each other.

Next, we have the variables declaration for the variables we will use: the driver, the test URLs, your LambdaTest username and access key, which are stored as environment variables, and the grid URL.

Then, there is the [Setup]. In this method, we define the capabilities used when running the tests.

In the test, the only change is that we need to create a new variable for the current instance of the driver and use it in the interactions with the browser:

And in the teardown, before closing the browser, we also want to make sure that the results are saved to LambdaTest:

The rest of the code is the same.

Running multiple NUnit test cases in parallel on LambdaTest will help you reap the following benefits:

We can run the tests on different configurations from the ones we have on our local machines (browsers and browser versions).
Running multiple NUnit test cases in parallel saves time.
Running the multiple NUnit test cases in parallel on the local machine can be tricky if multiple tests interact simultaneously with different browser instances. This issue is avoided if the tests run on a scalable and reliable cloud grid like LambdaTest.

In this tutorial, learn what is Regression testing, its importance, types, and how to perform it.

Test Execution on Cloud

Starting the test execution on the LambdaTest cloud grid can be done the same way as the local execution by selecting to run the tests from the Test Explorer. This time, the execution will be done on the remote server, leaving the local machine available for other work.

Also, parallel execution of multiple NUnit test cases will depend on the number of allowed parallel tests in your LambdaTest account.

After running the multiple NUnit test cases in parallel, you can see both results in the Test Explorer. You can also see them in the browser, including a video recording of the test and details about the Selenium WebDriver NUnit commands that were sent.

In this tutorial, learn what is Regression testing, its importance, types, and how to perform it.

Conclusion

In this blog on running multiple NUnit test cases, we explored the powerful capabilities of NUnit for running multiple tests using data-driven testing and parallelization. By leveraging these features, we can write more efficient and comprehensive test suites that cover a wide range of scenarios and data combinations.

Data-driven testing allows us to test our code with multiple input datasets without writing separate test methods for each case. Using the [TestCase] attribute, we can pass different test case data and quickly validate the expected results.

This approach saves time and effort and promotes maintainability by keeping our test code concise and focused. Additionally, with NUnit, we can run our tests in parallel, which significantly reduces the overall test execution time, especially if we have a large number of tests.

By utilizing multiple threads or processes, NUnit can distribute the workload and execute tests concurrently, leading to faster feedback and quicker test cycles.

Remember, when using parallelization, it’s important to ensure that the tests are thread-safe and do not have any unintended dependencies or side effects.

In conclusion, NUnit offers robust features for running multiple tests using data-driven testing and parallelization. By adopting these techniques, we can enhance the efficiency and effectiveness of the test suite, resulting in improved code quality and faster delivery cycles. So go ahead, explore these features, and unlock the full potential of NUnit for your testing needs!

Best C# Testing Frameworks In 2023

AndreeaDraniceanu — Wed, 05 Jul 2023 05:05:34 +0000

Test automation has become an essential element of the Software Development Life Cycle, helping developers and quality assurance teams to simplify their testing processes, accelerate delivery, and increase efficiency.

And when it comes to test automation in C# projects, selecting the right framework can significantly impact the success of your testing efforts. To select the best framework for C# automation testing, you need to consider the project requirements, in-house expertise, and deadlines for the project.

Selecting the right test automation framework is a decision that holds great importance. A well-suited framework can help you to create robust test suites, execute tests efficiently, and obtain accurate results, saving valuable time and effort. On the other hand, an ill-fitting framework might introduce complexities, restrict flexibility, or fail to integrate with your existing development environment.

In this blog, I will discuss some popular C# testing frameworks for unit testing, web automation, mobile, and BDD testing. Whether you are a seasoned C# developer or just starting your journey, this guide seeks to help you find the right C# testing frameworks to meet your testing needs.

Let’s begin!

Which are the most wanted best automation testing tools that have climbed the top of the ladder so far? Let’s take a look.

C# Unit Testing Frameworks

Unit testing frameworks can be used at all levels of testing, not only unit testing. They provide the ability to mark methods as test methods, setup, and teardown methods, help with parallelization, and help with validations. They also provide runners, so they can be integrated with other automation testing frameworks that cannot run the tests, such as Selenium.

The three major C# testing frameworks for unit testing are MSTest, NUnit, and xUnit.

MSTest

MSTest is one of the popular C# testing frameworks for unit testing included by default with Microsoft Visual Studio. At the time I’m writing this blog, the latest MSTest is 3.0.2.

If you’re working with Visual Studio and start a new project, you will have the option to create a new MSTest project, and the NuGet package is automatically added:

MSTest uses annotations to instruct the underlying framework on how to interpret the source code.

Which are the most wanted automation testing tools that have climbed the top of the ladder so far? Let’s take a look.

Salient features of MSTest

The most common features you’ll need if you use MSTest as the testing framework in your project are:

Annotations that mark test classes and methods, for example, TestClass to mark a class containing tests, TestMethod to mark a test case, TestInitialize, TestCleanup, ClassInitialize, and ClassCleanup, for creating setups and teardowns for the tests.
Used for data-driven testing.
Assertions (using the Assert class) are used to validate expected behaviors.
Allows parallelization of tests.

Let’s dive into popular features of the MSTest framework and understand them in detail.

Annotations

Annotations (also known as attributes) are used to add metadata to a test method or class. They provide additional information to the testing framework about how a test method should be executed or how a test class should be treated.

If you have a test class, you need to mark it as such, and the MSTest annotation for this is [TestClass]. Then, you need annotations for the methods:

namespace MSTestExample
{
    [TestClass]
    public class ExampleTest
    {
        [AssemblyInitialize]
        // This method will execute before the test run
        public void BeforeAssembly()
        {
        }


        [ClassInitialize]
        // This method will execute before all the tests in the class
        public void BeforeClass()
        {
        }


        [TestInitialize]
        // This method will execute before each test in the class
        public void BeforeTest()
        {
        }


        [TestMethod]
        // This is the test method
        public void TestMethod()
        {
        }


        [TestCleanup]
        // This method will execute after each test in the class
        public void AfterTest()
        {
        }


        [ClassCleanup]
        // This method will execute after all the tests in the class
        public void AfterClass()
        {
        }


        [AssemblyCleanup]
        // This method will execute after the test run
        public void AfterAssembly()
        {
        }
    }
}

The running order for the annotated methods will be:

Assertions

Another important feature of unit testing frameworks is assertions. The test result is based on whether the assertion passes or fails. Here are the most important MSTest assertions:

// Assert that two values are equal
Assert.AreEqual(value1, value2);


// Assert that two values are not equal
Assert.AreNotEqual(value1, value2);


// Assert that two objects are equal
Assert.AreSame();


// Assert that two objects are not equal
Assert.AreNotSame(variable1, variable2);


// Assert that a condition is true
Assert.IsTrue(condition);


// Assert that a condition is false
Assert.IsFalse(condition);


// Assert that a value is null
Assert.IsNull(value);


//Assert that a value is not null
Assert.IsNotNull(value);


// Fail the test. This can be useful, for example, in a catch block
Assert.Fail();

You can also use assertions specific to string values:

// Assert that two string values are equal
StringAssert.Equals(value1, value2);


// Assert that a string value contains a substring value
StringAssert.Contains(value, substring);


// Assert that a string value matches a regular expression pattern
StringAssert.Matches(value, regEx);


// Assert that a string value does not match a regular expression pattern
StringAssert.DoesNotMatch(value, regEx);


// Assert that a string value starts with a substring value
StringAssert.StartsWith(value, substring);


// Assert that a string value ends with a substring value
StringAssert.EndsWith(value, substring);

This blog discusses the most exciting features of 13 best automation testing frameworks in 2021.

Data-driven testing

MSTest allows data-driven testing, i.e., running the same test with different sets of data. To run parameterized tests, you need the [DataRow] attribute for each set of data and the [DataTestMethod] annotation for the method:

[DataRow(“Chrome”,”113.0”,”Windows 11”)]
[DataRow(“Safari”,”16.0”,”macOS Ventura”)]
[DataTestMethod]
// This is the test method
public void TestMethod(string browser, string browserVersion, string os)
{
    // The test code goes here
}

In the above example, the test will run twice: once for Chrome version 112, on Windows 11, and then for Safari 16.0, on macOS Ventura.

Advantages of MSTest

The main advantages of MSTest as a unit testing framework are:

It’s open-source, you can access the code on GitHub and even contribute to it.
Offers cross-platform support (for .NET framework, .NET Core, and ASP.NET Core, as well as platforms like Windows, Mac, and Linux.)
Supports data-driven testing.

NUnit

NUnit is yet another one of the best C# testing frameworks for unit testing. It’s an open-source framework that was ported from Java’s JUnit. At the time of writing this article, the most recent version of NUnit is 3.13.3.

Salient features of NUnit

Some of the most common and useful features of NUnit are:

Just like MSTest, the use of annotation to mark the purpose of classes and methods: TestFixture for test classes, Test for test methods, SetUp, TearDown, OneTImeSetUp, OneTimeTeardown for setups and teardowns.
Support data-driven testing.
Uses assertions that validate our post-conditions.
Offers parallelization.

Improve your software testing process with our automation testing tutorial. Discover the benefits of automation testing, learn about the best tools and techniques, and get expert insights on optimizing your testing strategy.

Annotations

Just like MSTest, annotations in NUnit are used to mark methods and classes. For classes, there are two annotations: the [TestFixture], which marks a test class, and the [SetUpFixture], which marks a class that only contains the setup and the teardown that will run once before the entire test run.

Here are the rest of the most common annotations needed in a test framework:

namespace NUnitExample
{
    [TestFixture]
    public class ExampleTest
    {
        [OneTimeSetUp]
        // This method will run once before the test run, if included in a SetUpFixture class
        // Or it will run once before the test class, if included in a TestFixture class
        public void BeforeClass()
        {
        }


        [SetUp]
        // This method will execute before each test in the class
        public void BeforeTest()
        {
        }


        [Test]
        // This is the test method
        public void TestMethod()
        {
        }


        [TearDown]
        // This method will execute after each test in the class
        public void AfterTest()
        {
        }


        [OneTimeTearDown]
        // This method will run once after the test run, if included in a SetUpFixture class
        // Or it will run once after the test class, if included in a TestFixture class
        public void AfterClass()
        {
        }
    }
}

The running order for the annotated methods will be.

Assertions

For validation, NUnit uses assertions as well. The most useful NUnit assertions are:

// Assert that two values are equal
Assert.AreEqual(value1, value2);


// Assert that two values are not equal
Assert.AreNotEqual(value1, value2);


// Assert that two objects are equal
Assert.AreSame(variable1, variable2);


// Assert that two objects are not equal
Assert.AreNotSame(variable1, variable2);


// Assert that a condition is true
Assert.IsTrue(condition);


// Assert that a condition is false
Assert.IsFalse(condition);


// Assert that a collection contains an object
Assert.Contains(variable, collection);


// Fail the test. This can be useful, for example, in a catch block
Assert.Fail();


// Pass the test
Assert.Pass();


// Assert that an object is null
Assert.IsNull(variable);


// Assert that an object is not null
Assert.IsNotNull(variable);

And string assertions are as follows.

// Assert that two string values are equal
StringAssert.Equals(value1, value2);


// Assert that a string value starts with a substring value
StringAssert.StartsWith(substring, value);


// Assert that a string value does not start with a substring value
StringAssert.DoesNotStartWith(substring, value);


// Assert that a string value ends with a substring value
StringAssert.EndsWith(substring, value);


// Assert that a string value does not end with a substring value
StringAssert.DoesNotEndWith(substring, value);


// Assert that a string value contains a substring value
StringAssert.Contains(substring, value);


// Assert that a string value does not contain a substring value
StringAssert.DoesNotContain(substring, value);


// Assert that a string value matches a regular expression pattern
StringAssert.IsMatch(regex, value);


// Assert that a string value does not match a regular expression pattern
StringAssert.DoesNotMatch(regEx, value);

Discover the 17 key benefits of automation testing, which will help you decide whether this is the right call for your SDLC. Find out more.

Data-driven testing

Data-driven testing in NUnit is done using the [TestCase] annotation.

[TestCase("Chrome", "113.0", "Windows 11")]
[TestCase("Safari", "16.0", "macOS Ventura")]
[Test]
public void TestMethod(string browser, string browserVersion, string os)
{
    /// The test code goes here
}

Advantages of NUnit

Among the pros of NUnit, it’s worth mentioning:

Open-sourced with an active community on GitHub.
Has data-driven capabilities.
Test execution can be done from a console runner or using the NUnit runner in Visual Studio.

xUnit

The last C# testing framework for unit testing on the list is xUnit. The latest version of xUnit at the time of writing this article is 2.4.2. xUnit is an open-source framework for the .NET framework.

Salient features of xUnit

The most useful features of the xUnit framework are:

It’s open-source, and the community can contribute to the code.
Supports data-driven testing
The setup and teardown are replaced by constructors and IDisposable.

Annotations

Like the other frameworks, xUnit also uses annotations, but, as opposed to MSTest and NUnit, it doesn’t need an annotation for the test class and does not use annotations for setup and teardown methods.

So the remaining main annotations are:

[Fact]
// This is the test method
public void TestCase()
{
}


[Theory]
// This is a test method that will run once for each data set
[InlineData("Chrome", "113.0", "Windows 11")]
[InlineData("Safari", "16.0", "macOS Ventura")]
public void DataDrivenTestCase(string browser, string browserVersion, string os)
{
}

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

Assertions

Like before, assertions are used for validations. With xUnit, the string assertions are done through the Assert class, too:

// Assert that two string values are equal
Assert.Equal(value1, value2);

// Assert that two string values are not equal
Assert.NotEqual(value1, value2);


// Assert that a condition is true
Assert.True(condition);


// Assert that a condition is false
Assert.False(condition);


// Assert that a string value contains a substring value
Assert.Contains(substring, value);


// Assert that a string value does not contain a substring value
Assert.DoesNotContain(substring, value);


// Assert that a string value starts with a substring value
Assert.StartsWith(substring, value);


// Assert that a string value ends with a substring value
Assert.EndsWith(substring, value);


// Assert that a string value matches a regular expression pattern
Assert.Matches(regex, value);


// Assert that a string value does not match a regular expression pattern
Assert.DoesNotMatch(regex, value);


// Assert that an object is null
Assert.Null(object);


// Assert that an object is not null
Assert.NotNull(object);


// Assert that two objects are equal
Assert.Same(variable1, variable2);

Advantages of xUnit

The main advantages of using xUnit are:

Fewer annotations are needed because they are not required for the setup and teardown
In xUnit, parallel test execution using a Selenium Grid can be achieved at the thread level.

C# Testing Frameworks for Web

In this section, I will cover the most popular C# testing frameworks used for web automation.

Selenium

Selenium is still one of the best C# testing frameworks and is widely used by automation testers when it comes to web testing. Selenium is not a testing framework in itself but a framework that automates web browsers.

Many other popular automation testing frameworks are wrappers that use the Selenium libraries, so they perform actions using Selenium code. These frameworks also include validation, reporting capabilities, and other test-related functionalities.

Salient features of Selenium

The most important features of Selenium are:

Allows the most common actions a user can perform: clicking a button, entering input data, selecting values from drop-downs, checking and unchecking checkboxes.
Can automate multiple browsers such as Google Chrome, Mozilla Firefox, Microsoft Edge, Safari, and even Microsoft Internet Explorer.
Works on Windows, macOS, and Linux.

Code Example of Selenium with NUnit

Here’s what a Selenium test using the NUnit framework looks like:

using NUnit.Framework;
using OpenQA.Selenium;

namespace SeleniumLocators
{
    public class Tests
    {
        private static IWebDriver driver = new ChromeDriver();

        [Test]
        public void ValidateSignIn()
        {
            driver.Navigate().GoToUrl("https://ecommerce-playground.lambdatest.io/index.php?route=account/login");
            driver.FindElement(By.Name("email")).SendKeys("test@email.com");
            driver.FindElement(By.Id("input-password")).SendKeys("password");
            driver.FindElement(By.CssSelector("input[value='Login']")).Click();
        }
    }
}

This is a simple test that navigates to a given URL address, enters login credentials then presses a Login button.

Do you use a Mac and want to run the test in Internet Explorer? This article explores how to test Internet Explorer for Mac.

Advantages of Selenium

Here are some benefits of using Selenium as your C# testing framework:

Selenium is a well-established and widely used framework. There are over 50 thousand questions tagged Selenium on StackOverflow.
Great community support.
Is open-source.
Supports many programming languages, including C#, Java, Python, JavaScript, and Perl.

Disadvantages of Selenium

Some downsides of using Selenium WebDriver can be:

A steep learning curve.
Lack of built-in reporting and result analysis.

Playwright

Playwright, an open-source test automation framework, was first created by contributors from Microsoft. It has support for various programming languages such as Java, Python, C#, and Node.js and comes with an Apache 2.0 License.

Salient features of Playwright

Here are some of its most important features:

Supports multiple browsers: Chrome, Edge, Safari, and Firefox.
It can be used for API and UI testing. With a third-party plugin integration, Playwright can even be used for accessibility testing.
Supports parallel test execution — particularly useful when working with large test suites or performing cross browser testing.
Built-in reporters.

Playwright Code Example

Below is a code example of C# with the Playwright that runs on the LambdaTest platform.

using Microsoft.Playwright;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;


class PlaywrightTestSingle
{
    public static async Task main(string[] args)
    {
        using var playwright = await Playwright.CreateAsync();


        string user, accessKey;
        user = Environment.GetEnvironmentVariable("LT_USERNAME");
        accessKey = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");


        Dictionary<string, object> capabilities = new Dictionary<string, object>();
        Dictionary<string, string> ltOptions = new Dictionary<string, string>();


        ltOptions.Add("name", "Playwright Test");
        ltOptions.Add("build", "Playwright C-Sharp tests");
        ltOptions.Add("platform", "Windows 10");
        ltOptions.Add("user", user);
        ltOptions.Add("accessKey", accessKey);


        capabilities.Add("browserName", "Chrome");
        capabilities.Add("browserVersion", "latest");
        capabilities.Add("LT:Options", ltOptions);


        string capabilitiesJson = JsonConvert.SerializeObject(capabilities);


        string cdpUrl = "wss://cdp.lambdatest.com/playwright?capabilities=" + Uri.EscapeDataString(capabilitiesJson);


        await using var browser = await playwright.Chromium.ConnectAsync(cdpUrl);
        var page = await browser.NewPageAsync();
        try {
          await page.GotoAsync("https://www.bing.com");
          await page.Locator("[id='sb_form_q']").ClickAsync();
          await page.FillAsync("[id='sb_form_q']", "LambdaTest");
          await page.waitForTimeout(1000)
          await page.Keyboard.PressAsync("Enter");
          await page.waitForSelector("[class=' b_active'])
          var title = await page.TitleAsync();


          if (title.Contains("LambdaTest"))
          {
            // Use the following code to mark the test status.
            await SetTestStatus("passed", "Title matched", page);
          }
          else {
            await SetTestStatus("failed", "Title not matched", page);
          }
        }
        catch (Exception err) {
          await SetTestStatus("failed", err.Message, page);
        }
        await browser.CloseAsync();
    }


    public static async Task SetTestStatus(string status, string remark, IPage page) {
        await page.EvaluateAsync("_ => {}", "lambdatest_action: {\"action\": \"setTestStatus\", \"arguments\": {\"status\":\"" + status + "\", \"remark\": \"" + remark + "\"}}");
    }
}

This test opens the Bing homepage, searches for the keyword “LambdaTest”, waits for the results to load, and validates that the title contains “LambdaTest”.

Run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

Advantages of Playwright

The benefits of using Playwright as your web automation framework include:

Easy to set up and configure.
Multi-language support: C#, Java, Python, Javascript, and TypeScript.
Supports CI/CD integration.

Disadvantages of Playwright

And some of the cons of using Playwright are:

No support for legacy Microsoft Edge or IE11.
No support for desktop or native mobile apps.
Uses desktop browsers, and not devices, for emulating mobile devices.

C# Testing Frameworks for Mobile and Desktop

This section will cover two popular C# testing frameworks for mobile and desktop, i.e., Appium and Ranorex.

Appium

Appium is regarded as one of the best C# testing frameworks for mobile test automation. It is an open-source framework specifically designed for mobile applications. It leverages the mobile JSON wire protocol to enable users to create automated UI tests for native, web-based, and hybrid mobile applications on Android and iOS platforms.

It is compatible with various types of mobile applications, including native apps developed with the iOS or Android SDKs, mobile web apps accessed through a mobile browser, and hybrid apps that utilize WebView.

Appium is a popular choice among mobile game developers, who use advanced testing techniques to simulate user inputs in input-driven games. They can also test these games simultaneously on two separate platforms using the same script.

Salient features of Appium

Some of Appium’s important features are:

It has a very active community.
Supports test automation on real devices, simulators, and virtual machines.
Offers an Appium Inspector that can inspect Android and iOS apps’ native components.
Ability to handle end-to-end testing flows.

Code Example of Appium

Below, you can see an example of how an Appium test script looks like that runs on LambdaTest. This is a simple example that clicks a couple of elements.

using System;
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Support.UI;
using OpenQA.Selenium.Appium.iOS;
using System.Threading;


namespace csharp_appium_first
{
    class Program
    {
        static void Main(string[] args)
        {
            AppiumOptions caps = new AppiumOptions();


            caps.AddAdditionalCapability("LT_USERNAME", "username");
            caps.AddAdditionalCapability("LT_ACCESSKEY", "accessKey");  
            caps.AddAdditionalCapability("app", "APP_URL");
            caps.AddAdditionalCapability("deviceName", "iPhone 12");
            caps.AddAdditionalCapability("platformVersion", "15");
            caps.AddAdditionalCapability("platformName", "iOS");
            caps.AddAdditionalCapability("isRealMobile", true);
            caps.AddAdditionalCapability("network", false);


            IOSDriver<IOSElement> driver = new IOSDriver<IOSElement>(
                new Uri("https://mobile-hub.lambdatest.com/wd/hub"), caps);




            IOSElement nf = (IOSElement)new WebDriverWait(driver, TimeSpan.FromSeconds(30)).Until(
                SeleniumExtras.WaitHelpers.ExpectedConditions.ElementToBeClickable(MobileBy.Id("notification"))
            );
            nf.Click();


            driver.Navigate().Back();


            IOSElement st = (IOSElement)new WebDriverWait(driver, TimeSpan.FromSeconds(30)).Until(
                SeleniumExtras.WaitHelpers.ExpectedConditions.ElementToBeClickable(MobileBy.Id("speedTest"))
            );
            st.Click();
        }
    }
}

Advantages of Appium

It’s free and open-source.
Supports multiple programming languages: C#, Java, JavaScript, and so on.
Easy to learn for people who already know Selenium.

Disadvantages of Appium

But also keep in mind some of the disadvantages:

Limited report capabilities
Works on desktop apps, but the support is rather limited.
Does not support older Android versions (before 4.2).

Run your Selenium online Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

Ranorex

Ranorex is a test automation tool used to automate functional testing of desktop, web, and mobile applications. It provides a wide range of features, such as a record and playback functionality, an object repository, and a set of built-in actions. Ranorex tests can be written in C#, VB.NET, and Python and executed across multiple platforms and browsers.

Salient features of Ranorex

Some of Ranorex’s notable features are:

The Ranorex spy allows easy UI element identification.
Supports data-driven testing.
Built-in integration with test management tools like TestRail and Jira.
The object repository allows testers to manage and maintain test objects in a centralized location.
Reporting features enable the testers to generate detailed test reports that help identify issues and track test results over time.

Code Example of Ranorex

This is what a Ranorex test code looks like for automating login functionality in a desktop application.

[TestModule("36B3BA50-0797-4CDE-81E9-873F5EE516BD", ModuleType.UserCode, 1)]
    public class AddCredentialEntry : ITestModule
    {

        string _varTitle = "WordPressDemo";
        [TestVariable("8FCE8266-9831-4706-ACA6-BB8D8A06B5AE")]
        public string varTitle
        {
            get { return _varTitle; }
            set { _varTitle = value; }
        }

        string _varUsername = "admin";
        [TestVariable("E65F0C1D-2762-405A-96A0-4515BFA94FDD")]
        public string varUsername
        {
            get { return _varUsername; }
            set { _varUsername = value; }
        }


        string _varPassword = "demo123";
        [TestVariable("AE0C46C8-7A5D-45CC-83AB-44B0B8BF61C5")]
        public string varPassword
        {
            get { return _varPassword; }
            set { _varPassword = value; }
        }

        string _varURL = "bitly.com/wp_demo";
        [TestVariable("43C83430-F236-42FF-841D-A4BD6EB9C627")]
        public string varURL
        {
            get { return _varURL; }
            set { _varURL = value; }
        }


        string _varRepoIconIndex = "1";
        [TestVariable("D2BDF856-F604-4019-8F2A-8634CFFB3D18")]
        public string varRepoIconIndex
        {
            get { return _varRepoIconIndex; }
            set {
                    _varRepoIconIndex = value;
                    // Additionally set the Repository Variable in Setter-Method
                    MyRepo.varIconIndex = _varRepoIconIndex;
                }
        }


        string _varRepoExpires = "1 Year";
        [TestVariable("A4A86036-4706-4288-AFB4-B2E86A05D3C8")]
        public string varRepoExpires
        {
            get { return _varRepoExpires; }
            set {
                    _varRepoExpires = value;
                    // Additionally set the Repository Variable in Setter-Method
                    MyRepo.varExpires = _varRepoExpires;
                }
        }


        // Repository object to access UI Elements
        KeePassTestSuiteRepository MyRepo = KeePassTestSuiteRepository.Instance;

        /// Constructs a new instance.
        public AddCredentialEntry()
        {
            // Do not delete - a parameterless constructor is required!
        }

        void ITestModule.Run()
        {
            Mouse.DefaultMoveTime = 300;
            Keyboard.DefaultKeyPressTime = 100;
            Delay.SpeedFactor = 1.0;

            // Click 'Add Entry' Button MainMenu
            MyRepo.MainForm.Edit.Click();
            MyRepo.KeePass.AddEntry.Click();

            // Set text fields
            MyRepo.AddEntry.Title.TextValue = varTitle;
            MyRepo.AddEntry.UserName.TextValue = varUsername;
            MyRepo.AddEntry.Password.TextValue = varPassword;
            MyRepo.AddEntry.Repeat.TextValue = varPassword;
            MyRepo.AddEntry.URL.TextValue = varURL;

            // Choose an icon
            MyRepo.AddEntry.MBtnIcon.Click();
            MyRepo.IconPicker.LI_Icon.Click(Location.CenterLeft);
            MyRepo.IconPicker.ButtonClose.Click();

            // Set Expires
            MyRepo.AddEntry.MBtnStandardExpires.Click();
            MyRepo.KeePass.MI_Expires.Click();

            // Save Credential Entry
            MyRepo.AddEntry.ButtonOK.Click();
        }
    }

Advantages of Ranorex

The main advantage of Ranorex are as follows:

It supports testing on web, mobile, and desktop apps.
Supports real device testing as well.
It is easy to integrate into a CI/CD process with tools like Jenkins, Git, Travis CI, and Azure DevOps.

Disadvantages of Ranorex

The Ranorex tool comes with a few downsides as well. These are as follows.

No support for macOS.
No community support, which can make it hard to find solutions to your problems online.

C# Testing Frameworks for BDD

Behavior Driven Development (BDD) is a process that supports the collaboration between the technical people in the team and the non-technical people (either in the team or in the customer’s organization).

Popular C# testing frameworks for BDD are SpecFlow and BDDfy.

Run your Selenium Testing tool scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

SpecFlow

A really useful C# automation testing framework is SpecFlow — a BDD framework that uses Gherkin to write tests in a natural language. This makes it easy for non-technical people to understand what is being tested and to read the reports.

It can be integrated with other frameworks, such as NUnit with Selenium and with Visual Studio, so the tests can run directly from the IDE’s test runner.

Salient Features of SpecFlow

The most notable SpecFlow features are:

Integration with Visual Studio.
Good reporting capabilities — reports are easy to read.
Good support for parallel execution.
It’s a collaboration framework meant to reduce the gap between technical and non-technical staff.
Allows users to write tests in a natural language syntax, making it easy for non-technical stakeholders to understand and provide feedback.

Code Example of SpecFlow

SpecFlow tests are written in Gherkin, which in fact, looks exactly like plain English (although they allow other languages as well):

 Feature: Search
The user should be able to perform searches for products in the list


@mytag
Scenario: Search for product in category
    Given I navigate to the https://ecommerce-playground.lambdatest.io/ web page
    When I select the Laptops category
    And I search for "Lenovo"
    Then the result page contains only products containing "Lenovo" in their name

The implementation behind the steps is regular C# code.

Advantages of SpecFlow

Here are the most important pros of SpecFlow:

Good documentation is available online.
Open-source and free to use, making it accessible to teams of any size.
Supports a variety of .NET languages.
Parallel execution with SpecFlow can be performed by leveraging the parallelism capabilities of NUnit through SpecFlow’s dependency injection.

Disadvantages of SpecFlow

Some of the cons of SpecFlow framework you should consider:

Writing tests in Gherkin syntax may require additional time and effort upfront, which may not be suitable for teams with tight deadlines or limited resources.
Test execution may be slower due to the overhead of the Gherkin language and the need to convert it to executable code.

BDDfy

BDDfy is another C# testing framework for BDD that uses the Gherkin language for easier collaboration between tech and non-tech folks.

Salient Features of BDDfy

Some of the best features of BDDfy are:

Just like with SpecFlow, the tests can be written in the Given — When — Then Gherkin language, which makes the tests easy to write even by non-technical people on the team.
It has good test reporting capabilities.
Supports standalone scenarios that don’t necessarily need to be part of user stories.

Code Example of BDDfy

BDDfy’s tests look similar to those of SpecFlow since they can also use the Gherkin language. Here is a sample from their documentation:

 Scenario: Card has been disabled
Given the card is disabled
When the Account Holder requests $20
Then the ATM should retain the card
  And the ATM should say the card has been retained

With the implementation:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TestStack.BDDfy;


namespace BDDfy.Samples.Atm
{
    [TestClass]
    public class CardHasBeenDisabled
    {
        void GivenTheCardIsDisabled()
        {
            throw new NotImplementedException();
        }


        void WhenTheAccountHolderRequestsMoney()
        {
        }


        void ThenTheAtmShouldRetainTheCard()
        {
        }


        void AndTheAtmShouldSayTheCardHasBeenRetained()
        {
        }


        [TestMethod]
        public void Execute()
        {
            this.BDDfy();
        }
    }
}

Advantages of BDDfy

Among the main advantages of BDDfy, worth mentioning are:

It can run with any testing framework, or with no testing framework, which makes it really flexible.
It can be very easy for beginners to learn it, and the language is very intuitive.

Disadvantages of BDDfy

And some of the disadvantages of using BDDfy:

Documentation is somewhat limited when compared to SpecFlow.
The community of users is not vast at the time of writing this article.

Expediting your C# Testing with LambdaTest

For any developer, building quality software is a challenge. Developing testing skills is the key to creating a lasting product. C# testing frameworks are emerging to address the growing need for effective test automation.

With an automation testing framework for C#, you can easily perform automated testing for your website or mobile app.

Digital experience testing clouds like LambdaTest let you perform manual and automation testing of your websites and web apps on an online browser farm of 3000+ real browsers, devices, and operating system combinations. Its cloud-based automation testing platform lets you run C# automation tests using different C# testing frameworks like Selenium, Appium, SpecFlow, NUnit, and more. With LambdaTest, developers and testers can easily perform cross-browser testing and parallelize their tests.

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

LambdaTest also offers HyperExecute — a blazing-fast next-generation test automation cloud that helps you accelerate the release cycle while performing C# automation. It is up to 70% faster than any other conventional testing grid. HyperExecute provides optimal speed, test orchestration, and detailed execution logs to help you accelerate TTM (Time to Market).

Salient Features of LambdaTest

The main features of LambdaTest are:

Provides a live testing feature that allows users to interact with web applications in real time.
Supports automated testing using popular frameworks like Selenium, Cypress, Playwright, and Appium.
Integrations with popular project management and CI/CD tools like JIRA, Slack, Trello, Jenkins, Travis CI, etc.

Code Example for performing C# automation on LambdaTest

LambdaTest provides an online Selenium grid, so the main code will be of Selenium. But you will need to set the Selenium capabilities to use your LambdaTest account. And you can use the capabilities generator to generate the capabilities you want to include (such as operating system, browser version, resolution, etc.).

This can be done in a [SetUp] method:

[SetUp]
public void Setup()
{
    ChromeOptions capabilities = new ChromeOptions();
    capabilities.BrowserVersion = "108.0";
    Dictionary<string, object> ltOptions = new Dictionary<string, object>();
    ltOptions.Add("username", LT_USERNAME);
    ltOptions.Add("accessKey", LT_ACCESS_KEY);
    ltOptions.Add("platformName", "Windows 11");
    ltOptions.Add("project", "Selenium Scroll");
    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);
}

As a C# expert, you can also acquire a Selenium C# 101 Certification from LambdaTest to master the fundamentals of Selenium C# testing and expanding your career prospects.

Run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

Conclusion

Identifying the right C# testing frameworks for the job is crucial when starting a new automation testing project. Since no two projects are the same, the requirements will vary, so it is always a good idea to research all the pros and cons of the C# testing frameworks that are available.

When choosing a test automation framework, testers and test managers should carefully consider whether the features match the project’s requirements, what the learning curve is, and whether the pricing fits the budget.

For those interested in C# testing frameworks, this blog provides a list of frameworks with details about their features, advantages, and disadvantages.

IWebDriver Browser Commands In Selenium C#: A Detailed Guide

AndreeaDraniceanu — Mon, 01 May 2023 11:12:45 +0000

Selenium WebDriver is a popular tool for automating web application testing, and it supports various programming languages, including C#. Its primary testing tool is the IWebDriver interface, which simulates an ideal web browser.

In this blog on IWebDriver, we will explore the IWebDriver browser commands in C# and how they can be used to control the behavior of a web browser during testing.

Understanding these commands is essential for automating interactions in web pages or web applications. We will start with a brief overview of IWebDriver and then dive into the various commands, such as navigating to a URL, clicking elements, sending keys to elements, and more.

By the end of this blog on IWebDriver, you will understand IWebDriver browser commands in C# and how to use them effectively while performing C# automation testing.

Discover the top 70+ essential Snowflake test templates to ensure your data’s integrity, accuracy, and consistency. Download our comprehensive template now.

What is IWebDriver in Selenium C#?

IWebDriver in Selenium C# is an interface used to create a connection between Selenium WebDriver and the web browser to automate web applications.

Selenium WebDriver allows users to interact with web elements, navigate between pages, and execute actions on a web page.

The IWebDriver interface provides a set of commands and properties that enable developers and testers to perform automation testing of web applications using C# programming language.

With IWebDriver, users can write scripts that mimic human actions on a website, making it an essential tool for web developers and testers who need to test their web applications efficiently and accurately.

You can learn more about the IWebDriver interface through this blog on Selenium 4 WebDriver Hierarchy.

IWebDriver Browser Commands in Selenium C

IWebDriver browser commands in C# allow you to interact with a web browser programmatically. Some interactions possible using IWebDriver browser commands in C# are:

navigating to a URL
clicking elements
entering text into form fields

They are part of the IWebDriver interface in C# and provide a standard way to control a web browser for automated testing.

Common IWebDriver Browser Commands

The most common IWebDriver browser commands in Selenium are the ones that deal with the current web page information, navigating between pages, managing windows, and switching between windows, frames, and alerts. I’ll explain them briefly, but we must create a new driver instance before that. We will be demoing the same on the cloud grid like LambdaTest.

When performing Selenium C# testing, utilizing a cloud Selenium Grid like LambdaTest can offer numerous advantages that are difficult to achieve with a local Selenium Grid. Not only does it provide scalability, reliability, and security, but it also allows for a broader range of browser coverage and test execution in parallel. This level of flexibility and efficiency is impossible with a local Selenium Grid.

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

LambdaTest offers the added advantage of effortlessly obtaining browser properties through the Automation Capabilities Generator. The utility covers everything once you choose the desired OS, browser combination, and versions. This ensures accuracy and provides a plethora of valid combinations and data while minimizing any chances of error. With this feature, you can have your code ready to use quickly!

Get a head start on your Jenkins test templates with our pre-built template for continuous testing. Explore this comprehensive list of test cases and scenarios.

Below is the common code that will be a part of all the IWebDriver browser commands:

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;


namespace SeleniumCSharp_BrowserCommands
{
    public class BrowserCommandsTests
    {
        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");
        private static readonly string testUrl = "https://ecommerce-playground.lambdatest.io/";


        [SetUp]
        public void Setup()
        {
            ChromeOptions capabilities = new ChromeOptions();
            capabilities.BrowserVersion = "latest";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "Windows 11");
            ltOptions.Add("project", "Selenium Scroll");
            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);
        }
}

This code will be repeated before each test, so we only need to write it once. The first part of the class contains the using statements, which contain the libraries and namespaces used in the class:

Then comes the variables we need in our test:

To use the LambdaTest Selenium Grid to run the tests, we need to add the username and access key. The best way is to store them as environment variables and get the values from there.

However, before running the tests, you need to set the environment variables LT_USERNAME & LT_ACCESS_KEY from the terminal. You can check the account details on your LambdaTest Profile page.

For macOS:

export LT_USERNAME=LT_USERNAME export LT_ACCESS_KEY=LT_ACCESS_KEY

For Linux:

export LT_USERNAME=LT_USERNAME export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME set LT_ACCESS_KEY=LT_ACCESS_KEY

In addition, we need to declare the driver and the web page URL we would like to test.

The following part pertains to the test configuration, encompassing the conditions, requirements, or any other necessary code that must be executed before the commencement of the test. Here, we’re adding the desired capabilities to my Chrome driver so that the test will run on this specific configuration.

The method has the SetUp NUnit annotation, which means that it will be executed before each test. Of course, it’s not mandatory to use NUnit; other automation testing frameworks are available in C#, such as MSTest or xUnit.

Browser Navigation Commands in Selenium C

The Navigate() command in Selenium C# simulates how a user would navigate online. For example, going back and forward between the pages, going to a different URL, or refreshing a page using Selenium C#. Let’s look at how to use them:

Navigate().GoToUrl()

The GoToUrl() is the most used since this is usually the prerequisite step to add to our setup before testing the application.

Navigate().Refresh()

The Refresh() command will simulate the browser page refresh.

Navigate().Back() and Navigate().Forward()

The Navigate().Back() and Navigate().Forward() commands are used to simulate the back and forward actions in the browser.

So this is what the navigate commands look like when working with Selenium C#:

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;

namespace SeleniumCSharp_BrowserCommands
{
    public class BrowserCommandsTests
    {
        protected 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");
        protected static readonly string testUrl = "https://ecommerce-playground.lambdatest.io/";

        [SetUp]
        public void Setup()
        {
            ChromeOptions capabilities = new ChromeOptions();
            capabilities.BrowserVersion = "latest";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "Windows 11");
            ltOptions.Add("project", "Selenium Scroll");
            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 NavigateMethods()
        {
            // Navigate to the test URL
            driver.Navigate().GoToUrl(testUrl);

            // Refresh the current page
            driver.Navigate().Refresh();

            // Go back once
            driver.Navigate().Back();

            // Go forward
            driver.Navigate().Forward();
        }
    }
}

Browser Manage Commands in Selenium C

The Manage() interface instructs the driver to change its settings. This includes things like resizing the window and handling browser cookies.

Manage().Window

Using the same setup as before, you can use the following commands to change the size of the window:

[Test]
        public void ManageWindows()
        {
            // First, navigate to the URL
            driver.Navigate().GoToUrl(testUrl);

            // Maximize the browser window
            driver.Manage().Window.Maximize();

            // Minimize the browser window
            driver.Manage().Window.Minimize();

            // Modify the window size using the given parameters for width and height
            driver.Manage().Window.Size = new Size(500, 300);
        }

Manage().Cookies:

If you need to work with cookies, use the Manage() interface. To see the cookies the website uses in the browser, you can open the Developer Tools under the Application tab and check the Storage — Cookies menu. You can learn more about it through this blog on handling cookies in Selenium WebDriver.

Here are the cookies of our test website:

And this is how the commands look in a test:

[Test]
public void CookiesCommands()
{
    driver.Navigate().GoToUrl(testUrl);

    // Add a new cookie
    driver.Manage().Cookies.AddCookie(new Cookie("cookieName", "value"));

    // Retrieve a cookie based on its name
    // In this case, the "currency" cookie
    var cookie = driver.Manage().Cookies.GetCookieNamed("currency");

    // Delete a cookie based on its name
    // In this case, the "language" cookie
    driver.Manage().Cookies.DeleteCookieNamed("language");

    // Delete a given cookie
    // In this case, the cookie saved as a variable earlier
    driver.Manage().Cookies.DeleteCookie(cookie);

    // Deletes all the cookies
    driver.Manage().Cookies.DeleteAllCookies();
}

Switch Window Commands in Selenium C

Window switching or using the SwitchTo() command in test automation is a technique used to switch between different windows or frames within a web application. This command is used in Selenium, a popular test automation framework, to switch the driver’s focus to a different window or frame to perform the subsequent actions in the appropriate context.

The SwitchTo() commands in Selenium allow you to move the focus to a different window, a frame, or an alert. Let’s have a look at how they work.

SwitchTo().Window()

You can open multiple browser windows (or tabs) simultaneously where you want to interact with them one at a time — even if the interaction might mean only closing them. To get the full list of opened windows, you can use the CurrentWindowHandle or WindowHandles properties, then switch to the desired window:

[Test]
public void SwitchWindows()
{
    // Get the current window’s handle
    var handle = driver.CurrentWindowHandle;

    // Get the list of all opened windows’ handles
    var handles = driver.WindowHandles;

    //Switch to the window you want active in your test
    driver.SwitchTo().Window(handle);

    //Switch to the window you want active in your test, by selecting it from a list
    driver.SwitchTo().Window(handles[3]);
}

SwitchTo().Alert()

An alert is a dialog box that appears on the screen and interrupts the user’s interaction with the web application until it is either dismissed or handled.

Handling alerts in Selenium is an essential aspect of test automation because alerts are commonly used in web applications for various purposes, such as validation, confirmation, or error reporting. If an alert is not handled properly in a test automation script, it can cause the script to fail or produce inaccurate results.

Get a head start on your CI/CD pipeline with our pre-built template for automated testing. Explore this comprehensive list of CI/CD test cases and scenarios.

Here, we will see how the alerts work, taking LambdaTest Playground as an example.

I have an alert with a confirm box that allows adding a text before accepting or dismissing it. But before I act on the alert, I must switch to it. Here’s how the switch command for alerts looks and the available actions:

We have one scenario for dismissing the alert:

[Test]
public void DismissAlert()
{
    // Navigate to the desired page
driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo");

    // Identify the button to click
    driver.FindElement(By.XPath("//div[contains(text(),'Java Script Alert Box')]/following-sibling::p/button")).Click();

    // Dismiss the alert
    driver.SwitchTo().Alert().Dismiss();
}

And another one where we use both the SendKeys() and the Accept() commands:

[Test]
public void SendKeysAndAcceptAlert()
{
    // Navigate to the desired page
    driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo");

    // Identify the button to click
    driver.FindElement(By.XPath("//div[contains(text(),'Java Script Alert Box')]/following-sibling::p/button")).Click();

    // Enter text in the alert box
    driver.SwitchTo().Alert().SendKeys("It's me, Mario");

    // Accept the alert
    driver.SwitchTo().Alert().Accept();
}

To find an element on a page and click it (before the alert pops, you need to press the Click me buttons), you need to use the findElement() Selenium command.

SwitchTo().Frame()

Web pages can be divided into several sections using HTML frames, and each section can load a different HTML document. Sometimes you want to interact with elements that are inside a different frame than the active one, so you need, once more, to use the switch command in Selenium.

To demonstrate, let’s take a look at this web page. If you check its code, it contains several frames (marked by the HTML tag iframe). Here’s how you can work with them:

[Test]
public void SwitchToFrames()
{
    // Navigate to the desired page
    driver.Navigate().GoToUrl("https://codepen.io/fidabrj/pen/NWYeaqG");

    // Switch to frame by name
    driver.SwitchTo().Frame("result");

    // Switch to the parent frame
    driver.SwitchTo().ParentFrame();

    // Switch to the first frame or the main document of the web page
    driver.SwitchTo().DefaultContent();
}

Close and Quit Commands in Selenium C

If you want to close the browser instances opened by Selenium, you have two options. The first is to close the current window:

driver.Close();

Or close all opened windows. I recommend using a TearDown method for your tests — to close all opened instances of the browser at the end of each test. It should look like this:

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

Url, Title, and PageSource properties in Selenium C

The next three subpoints are not commands in Selenium C# but properties. They are nevertheless important and often used in UI tests.

Url

The first on the list is the Url property. This is the address of the opened web page and is stored as a string.

This can be useful when you want to check that the navigation was done correctly after other actions performed in the application, like clicking a link or pressing a button.

Discover the top 50+ essential Flutter test cases to ensure your mobile applications are bug-free before their release. Download our comprehensive template now.

PageTitle

Similarly, you can obtain the current page title as a string. This is handy to validate that the page has the correct title.

PageSource

And last but not the list, you can also obtain the page’s source code, similar to what you see in the browser when you right-click on the page and select “View page source”.

Using these three attributes in a test looks something like this:

[Test]
public void Properties()
{
    driver.Navigate().GoToUrl(testUrl);

    // Validate that the page title is correct
    Assert.That(driver.Title == "Your Store");

    // Validate that the page Url is correct
    Assert.That(driver.Url == testUrl);

    // Validate that the page source contains expected text
    Assert.That(driver.PageSource.Contains("Top Trending Categories"));
}

I will explain how the Assert works in a bit, too.

Demonstration — Selenium IWebDriver Browser Commands in C

In this section of the IWebDriver browser commands tutorial, let’s see a scenario that uses some of these IWebDriver browser commands to see them in a testing context.

Test Scenario

Navigate to the page https://ecommerce-playground.lambdatest.io/
Maximize the browser window.
Click on the Special link.
Validate that the page title is “Special offers”.
Go back to the previous page.
Validate that the URL is https://ecommerce-playground.lambdatest.io/
Validate that the cookie “currency” has the value “USD”.
Close the browser window.

Implementation

Below is the code you need for this test, created with Selenium 4.8 and NUnit testing framework. If you need help setting up the project and adding driver capabilities, follow the steps in this Selenium C# tutorial.

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;

namespace SeleniumCSharp_BrowserCommands
{
    public class BrowserCommandsTests
    {
        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");
        private static readonly string testUrl = "https://ecommerce-playground.lambdatest.io/";

        [SetUp]
        public void Setup()
        {
            ChromeOptions capabilities = new ChromeOptions();
            capabilities.BrowserVersion = "108.0";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "Windows 11");
            ltOptions.Add("project", "Selenium Scroll");
            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 NavigateTest()
        {    
            driver.Navigate().GoToUrl(testUrl);
            driver.Manage().Window.Maximize();
            driver.FindElement(By.PartialLinkText("Special")).Click();
            Assert.That(driver.Title.Equals("Special Offers"));
            driver.Navigate().Back();
            Assert.That(driver.Url.Equals(testUrl));
            var cookie = driver.Manage().Cookies.GetCookieNamed("currency");
            Assert.That(cookie.Value.Equals("USD"));
        }

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

Code Walkthrough

The first part is the setup we created above, so there’s no real need to get into its details again. So let’s jump directly to the test.

Again, the method is marked with the Nunit [Test] annotation, which means it will show up in the Test Explorer of Visual Studio:

Next, we will be using some of the commands discussed earlier. To navigate to the web page’s address, we have the Navigate() command:

Then, we maximize the window using:

Next up, we need to interact with an element to click on it. We can use XPath as a locator, and the Click() command to interact with the web element:

The fourth step of the test is to verify that the web page has the correct title. This is easily done using the Title attribute and comparing it with the expected value. We use the Assert class, provided by NUnit. The test will continue if the two values are equal and the validation passes. If the assertion fails, the test will fail, and the following steps will not be executed.

Moving on, we go back one page, using the command:

It’s usually a good practice to keep the number of assertions to a minimum; for the sake of this demonstration, I will use more than one assertion in this test.

Learn 43 excellent test cases for salesforce test cases by reading this guide. Every significant test case will be covered in detail in this guide, along with how to set up your Salesforce testing.

First, we want to check that the back navigation worked as expected, so we assert that the current Url of the page is the same as the first Url we used (the one stored in the testUrl variable):

We also want to verify that the currency cookie is set to USD. For this, we must first get the cookie information and store it in a variable:

And check that the cookie’s value is the expected one, using another assert:

The last step is closing the browser. However, I want this step to execute regardless of the status of the previous steps, so I added it to a teardown method. In this specific example, I only have one test, but in a real-life project with multiple tests, a method marked with the [TearDown] NUnit annotation will run after each test.

If you are a developer or tester who wants to take your Selenium C# skills to the next level, consider taking Selenium C# 101 certification by LambdaTest. The certification is designed to validate the skills and knowledge of testers and developers who work with Selenium and C#.

Read this tutorial about ServiceNow Test cases , to know what it is, it’s benefits, types and test cases.

Conclusion

Understanding the IWebDriver browser commands in Selenium C# is essential for any aspiring automation tester or developer who wants to build efficient and robust automated tests. This blog has provided an overview of the various IWebDriver browser commands available in Selenium’s IWebDriver interface, including navigation commands, window, and frame and cookie commands.

Additionally, we have seen how to use these commands in C# code examples. With this knowledge, you can build robust automated tests with Selenium and C# to help you deliver high-quality software applications.

How To Scroll Down A Page In Selenium WebDriver Using C#

AndreeaDraniceanu — Fri, 17 Mar 2023 04:34:12 +0000

Scrolling up or down, and even horizontally, is quite common when navigating a web page. In test automation, this becomes important when you want to check that all the expected elements are displayed on the page. For example, the button to scroll back up works fine or interacts with elements that otherwise are not visible.

In version 4.2, Selenium introduced scroll wheel actions; however, these only work with the Chromium browser. To scroll down a page in Selenium C#, you will need to stick with the JavaScriptExecutor for other browsers or if you are using an older Selenium version.

In this blog, we will look at how to scroll down a page in Selenium WebDriver using C#.

What is JavaScriptExecutor in Selenium?

So, I mentioned JavaScriptExecutor, but what is it exactly? In short, it’s an interface to use with Selenium to interact with the web elements on a page using JavaScript code. This is because even Selenium has some limitations when it comes to web interactions, and JavaScript is a front-end programming language, which means it was designed specifically for the visible part of a web app.

Some of these actions include scrolling up and down a page, going back a certain number of pages, and interacting with elements. Selenium does this as well, but I’ll explain why JavaScript Executor is sometimes better later.

The syntax for JavaScriptExecutor in Selenium is shown below.

IJavaScriptExecutor js = (IJavaScriptExecutor) driver;
js.ExecuteScript("script to execute");

The IJavaScriptExecutor is the interface you need to cast on the driver object. Then, using the ExecuteScript method, pass the JavaScript script as a parameter. We’ll see it in action in upcoming sections of this blog on how to scroll down a page in Selenium WebDriver using C#.

How Can JavaScriptExecutor Help in Selenium Exceptions?

Not only can JavaScriptExecuter perform additional actions, but it can also help avoid potential exceptions without requiring extra steps. Some of these Selenium Exceptions are listed below.

NoSuchElementException

If your test throws a NoSuchElementException, ensure you’re using the correct locator for the element. You can check that simply by typing the locator in the search bar of the Elements tab in Developer Tools.

The Developer Tools will show how many elements were found and highlight the currently selected element in the HTML of the web page and on the page itself (see above my search for an ID on the page).

Once that’s out of the way, you can know that the element is loaded on the web page and the right locator is used. In this case, it’s safe to assume that the exception comes from the fact that the element is not visible because the page needs to be scrolled down.

The command for this is shown below.

js.ExecuteScript("window.scrollBy(0,250)", "");

This means that the page will be scrolled down by 250 pixels. You can use the same command to scroll up using a negative value.

js.ExecuteScript("window.scrollBy(0,-250)", "");

ElementClickInterceptedException

The ElementClickInterceptedException is thrown when the element is found on the page, but a different element overlaps our element, and the click would be performed on this incorrect element.

For example, when a prompt is loaded on a page with some action like “sign in” or “sign up” or when a menu is expanded on top of the element that interests you. To overcome this, you can use the click from the JavaScriptExecutor instead of the Selenium one:

js.ExecuteScript("arguments[0].click();", myElement);

Demonstration: How to Scroll Down A Page In Selenium WebDriver using C

Before we look at some examples of how to scroll down a page in Selenium WebDriver using C# to perform various types of scrolling, let’s set up a new test project. I’ll use the LambdaTest eCommerce Playground for the following scenarios — scrolling up, scrolling down, and scrolling to a specific element.

Download and install Visual Studio.
Create a new Visual Studio (or Visual Code) project.
Next, add Selenium.WebDriver NuGet package — you can do this by right-clicking on the solution name in Solution Explorer → Manage NuGet Packages.

In this Appium Automation tutorial, learn about Appium 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.

You can also add the package from the console, in the Tools → NuGet Package Manager → Package Manager Console, by running the following command. At the time of writing this blog on how to scroll down a page in Selenium WebDriver using C#, the latest version of Selenium.WebDriver NuGet package is 4.7.0, so I will be using this moving forward.

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

Next, I’ll be using my LambdaTest platform to run my tests — this will help me run the tests on a different setup than what I have on my local machine or even run tests in parallel without using my machine’s resources.

LambdaTest is a continuous testing platform that lets you perform C# automation testing of websites and web applications across 3000+ real desktop and mobile browsers. You can automate your tests with frameworks like Selenium, Cypress, Playwright, and more. It further allows you to accelerate your test cycles by running automated C# tests in parallel.

Subscribe to the LambdaTest YouTube Channel to see our latest tutorials about Selenium testing, Cypress testing, Appium, and more.

I’ll be using the LambdaTest Automation Capabilities Generator to create this setup.

After generating the automation capabilities, I will copy it into my test class as shown below:

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;


namespace ScrollAction_SeleniumWebDriver
{
    public class ECommerceTests
    {
        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");
        private static readonly string testUrl = "https://ecommerce-playground.lambdatest.io/";


        [SetUp]
        public void Setup()
        {
            ChromeOptions capabilities = new ChromeOptions();
            capabilities.BrowserVersion = "108.0";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "Windows 11");
            ltOptions.Add("project", "Selenium Scroll");
            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);
        }
    }
}

Code Walkthrough

In this blog section of how to scroll down a page in Selenium WebDriver using C#, we will use the JavaScriptExecutor to scroll a page, let’s understand the above code.

In the above test script, the class starts with using statements. These are used to instruct the code about the packages that will be used inside our class.

The only difference between these two using statements is that to run on the Selenium Grid with LambdaTest, you need to use the OpenQA.Selenium.Remote namespace.

Moving on, we have the variables we need to set up for our tests.

Again, if you run your tests locally, you don’t need to define the gridURL, LT_USERNAME, and LT_ACCESS_KEY. You only need the driver, which is the object that receives the requests from Selenium and sends them to the actual browser, and the testURL, a string that stores our website URL, so we don’t have to write it again every time.

If you test on the cloud grid, you also need the username and access key — I have them stored as environment variables because I find it safer, and if they change, I only need to change them in one place and not update all my projects that use them. The gridURL is a string I will be using a bit later.

Next comes the setup method: thanks to NUnit, using the SetUp annotation, the code knows that the method marked as SetUp needs to run before each test. We have a SetUp method whether we test on the grid:

We will use all the capabilities defined above with the Capabilities Generator. Then the driver will be a new instance of the remote driver, using the URI created using the username, access key, and the gridURL variable we declared first.

How to Scroll to the Bottom of the Page in Selenium C#?

The first test I’ll write will scroll to the bottom of a web page. I’ll use the LambdaTest eCommerce Playground to do this. The idea is that to interact with the elements at the bottom of the page, I need to bring them into view.

As previously mentioned, we will need a JavaScriptExecutor to do this. The test class will look like this:

[Test]
public void ScrollToTheBottom()
{
    IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
    driver.Navigate().GoToUrl(testUrl);
    js.ExecuteScript("window.scrollTo(0, document.body.scrollHeight)");
}

What happens here is that I used the NUnit [Test] annotation to mark my method as a test method — pretty straightforward here. This means that it will show up in my Test Explorer, and I can run it:

The first line inside the method is where I declare a new variable of the type IJavaScriptExecutor, which will cast upon the driver:

Next up comes opening the test site (the testUrl variable declared before) using the Navigate().GoToUrl() Selenium command:

And last but not least, we have the scrollTo command that performs the actual scroll.

What happens here is the first parameter of the scroll represents the horizontal value. I don’t want to scroll horizontally, so I will leave it to 0. For the second parameter, I don’t know the exact length of the page, so I give it the document.body.scrollHeight value. This value represents the height of the loaded page.

You can see the scrollHeight in the browser using the Console of Developer Tools.

I’ll also add a TearDown method so the browser doesn’t stay open after the test completes

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

The TearDown Annotation in NUnit is a method to be run after each test. The single command I need is the one that closes all instances of the driver — Quit().

The result can be seen when running the test on the LambdaTest platform.

We can see here that all the test steps were executed and passed successfully.

In this Data driven testing tutorial, let us deep dive into what data driven testing is, its pros & cons, its types, data driven testing in an agile environment, benefits, and their best practices.

How to Scroll to the Top of the Page in Selenium C#?

By default, the page will load and scroll to the top, so simply executing a script that scrolls up will look like the test didn’t do anything.

In this blog section of how to scroll down a page in Selenium WebDriver using C#, I will modify my existing test to scroll back up after scrolling down, so both scrolls can be visible in the test execution.

[Test]
public void ScrollToTheBottomAndBackToTheTop()
{
    IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
    driver.Navigate().GoToUrl(testUrl);
    js.ExecuteScript("window.scrollTo(0, document.body.scrollHeight)");
    js.ExecuteScript("window.scrollTo(0, -document.body.scrollHeight)");
}

The only new line of code is the last one. It looks the same as the one above, with the notable difference that it will use the same scroll amount but in the negative.

You can see the below video logs of the test execution that the page has scrolled down and then to the top.

How to Scroll Down a Page in Selenium WebDriver with C# by Given the Number of Pixels?

If you know the precise position where you want to scroll, you can execute a script that scrolls by that number of pixels. I’ll write a new test this time that opens the same web page and scrolls it down by 500 pixels:

[Test]
public void ScrollByAmount()
{
    IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
    driver.Navigate().GoToUrl(testUrl);
    js.ExecuteScript("window.scrollBy(0,500)");
}

To scroll up, use the same command, but by a negative number of pixels:

js.ExecuteScript("window.scrollBy(0,-500)");

How to Scroll to an Element with Selenium C#?

The above scenario is probably not a very likely one. It will, however, be more common to want to scroll to a specific element on the page.

For this, you first want to identify the element on the page using the Selenium locators.

For this example, I want to scroll to the Shop Now button highlighted in the screenshot:

As you can see that the page is scrolled around the middle, the same things I want my test to perform. But I don’t want to give a specific number of pixels. Instead, I will specify the element I want to bring into view.

To identify the element, I will use XPath as a locator and the SelectorsHub Chrome extension to get it.

The steps are:

Right-click on the element and choose Inspect.
As shown below in the screenshot, copy the relative XPath from SelectorsHub and use it in the test.

And here’s how the test looks like:

[Test]
public void ScrollToElement()
{
    IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
    driver.Navigate().GoToUrl(testUrl);
    var button = driver.FindElement(By.XPath("//a[@class='btn btn-outline-primary btn-lg']"));
    js.ExecuteScript("arguments[0].scrollIntoView();", button);
}

In this test, we have a new variable for the element.

I am using the driver.*FindElement* command, with the chosen selector XPath, and using the XPath from before. For more information about the driver.FindElement command, check out this article on using the driver.FindElement And driver.FindElements In Selenium C#.

And the last line is the JavaScriptExecuteScript, where I tell my code to scroll to the element

How to Scroll Horizontally with Selenium C#?

In this blog section of how to scroll down a page in Selenium WebDriver using C#, we will learn how to scroll horizontally. To demonstrate this, I will use a different page, the LambdaTest Web Technologies Browser Compatibility, and I will resize the browser window to make sure that the horizontal scroll is visible:

The code will look like this:

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;
using System.Drawing;


namespace ScrollAction_SeleniumWebDriver
{
    public class ECommerceTests
    {
        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");
        private static readonly string testUrl = "https://www.lambdatest.com/web-technologies";


        [SetUp]
        public void Setup()
        {
            ChromeOptions capabilities = new ChromeOptions();
            capabilities.BrowserVersion = "108.0";
            Dictionary<string, object> ltOptions = new Dictionary<string, object>();
            ltOptions.Add("username", LT_USERNAME);
            ltOptions.Add("accessKey", LT_ACCESS_KEY);
            ltOptions.Add("platformName", "Windows 11");
            ltOptions.Add("project", "Selenium Scroll");
            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 ScrollHorizontally()
        {
            IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
            driver.Manage().Window.Size = new Size(200, 1500);
            driver.Navigate().GoToUrl(testUrl);
            js.ExecuteScript("window.scrollBy(50,0)");
        }
    }
}

What I have different now is the System.Drawing namespace, which allows me to give the new size to the window, the different testUrl, and the driver.Manage().Window.Size method.

<

driver.Manage().Window.Size = new Size(200, 1500);

The above line of command changes the driver window size to 200 by 1500 pixels. This allows the horizontal scroll to appear so I can run my test. The JavaScript command is the same as the one used for vertical scrolling by a given number of pixels, except this time, I gave a value to the first argument of the scrollBy() method, which signifies the horizontal amount, and 0 to the second argument, which is the vertical amount.

You can scroll vertically and horizontally simultaneously by giving both values in pixels:

js.ExecuteScript("window.scrollBy(50,100)");

Let’s see how that looks:

As you can see, the content of the page was moved as the scroll was performed.

To demonstrate your expertise as a tester the Selenium C# 101 certification from LambdaTest is a great way to demonstrate your proficiency as a tester. By earning this certificate, you can stand out from the crowd and highlight your C# automation skills.

In this XCUITest tutorial, learn about XCUITest framework and its benefits for mobile automation testing. Take a look at how XCUITest works and see how to use it to test your mobile applications.

Summing Up

With this, you now know how to scroll down a page in Selenium WebDriver using C#. In web automation with Selenium, we can sometimes find ourselves in situations where using just simple Selenium commands is not enough to achieve our goals. One of these situations is where the web page under test has a vertical or horizontal scroll or both, and scrolling needs to be done on the page.

While Selenium only provides scrolling capabilities limited to specific browsers, we can insert JavaScript commands in our Selenium tests to overcome these limitations. We can do this by using the IJavaScriptExecutor interface provided by Selenium, which sends JavaScript commands to the browser that allow us to scroll up, down, horizontally, or to a specific web element on the page.

How To Use driver.FindElement And driver.FindElements In Selenium C#

AndreeaDraniceanu — Tue, 21 Feb 2023 06:41:00 +0000

One of the essential parts when performing automated UI testing, whether using Selenium or another framework, is identifying the correct web elements the tests will interact with. However, if the web elements are not located correctly, you might get NoSuchElementException in Selenium. This would cause a false negative result because we won’t get to the actual functionality check. Instead, our test will fail simply because it failed to interact with the correct element.

To do this, we have two methods: driver.FindElement and driver.FindElements in Selenium C#. The first one is needed when we want to identify a single element, such as an input field where we want to enter some text or a button on which we want to click. The second one is useful when we need to check multiple elements of the same type — for example, when we want to check that a drop-down list contains all the expected values.

In this blog on using driver.FindElement and driver.FindElements in Selenium C#, I will use Selenium 4.4.0. But, before we deep dive into how and when to use each of the FindElement and FindElements commands, let’s discuss how to identify the web elements on the page.

When we use the FindElement() and FindElements() commands, we need to identify the web elements by locators. The syntax is as follows:

1 driver.FindElement(By.locator_strategy)

Locators enable testers to select an HTML DOM element to interact with. Selecting the right locator strategies for these web elements can be crucial for the stability of the UI tests. You don’t want your tests to fail just because they didn’t find the correct button to click on or the correct text input to write in, right?

The locators are available for selection, and I will explain each of them below:

This tutorial dive deep into web testing to help you understand its life cycle, elements, angles, the role of automation, and more.

Traditional Locators in Selenium

Selenium supports multiple locator strategies. Firstly, we have the traditional locators. These are locators that relate directly to the web element’s attributes. Traditional locators are supported in all versions of Selenium. The eight traditional locators are explained below:

ID locator in Selenium

In a perfect world, each web element on our applications under test has an ID attribute. To find if the element has an ID or to see its ID, you simply have to right-click the element on the page and select Inspect (below I will demonstrate using the Chrome browser, but all major browsers have this functionality):

This will open up the Elements pane in the Developer Tools, which contains the page’s HTML code. Here, you can see the attributes of the HTML element. In my example, the field has an ID so I could use it in my UI tests.

Perform manual or automated cross browser web testing on 3000+ browsers online. Deploy and scale faster with the most powerful cross browser testing tool online.

So what I need to use in my tests is this:

1 driver.FindElement(By.Id("user-message"));

To learn more about it, you can refer to our earlier blog on ID locator in Selenium.

ClassName locator in Selenium

The class attribute in HTML is commonly used to point to a class in the CSS sheet. Multiple elements can share the same class and therefore the same styling.

The same element can also have multiple classes. You can see the class name (if the element has one) in the same panel as above:

If the element has multiple classes, they are all displayed and separated by a space character. You can select one of the classes to use in the tests, which will translate to

1 driver.FindElement(By.ClassName("w-full"));

To learn more about it, you can refer to our earlier blog on the ClassName locator in Selenium.

Name locator in Selenium

This is the Name attribute of the web element. The same as the ID and the ClassName, which you can find in the Elements panel of the Developer Tools.

This means:

driver.FindElement(By.Name("SearchDualList"));

To learn more about it, you can refer to our earlier blog on the Name locator in Selenium.

Tag Name locator in Selenium

This is the actual HTML tag of the element. So it will be a button, input, label, select, etc.

driver.FindElement(By.TagName(“Input”));

To learn more about it, you can refer to our earlier blog on the Name locator in Selenium.

Link Text locator in Selenium

This applies to link elements (the “a” tag in HTML) and refers to the visible link text.

It’s crucial to debug websites for Safari before pushing them live. In this article, we look at how to debug websites using dev tools in Safari Developer .

So to use this in your test, you will need:

driver.FindElement(By.LinkText("Simple Form Demo"));

To learn more about it, you can refer to our earlier blog on the Link Text locator in Selenium.

Partial Link Text locator in Selenium

The same as above, but using only a part of the text link. For the example above, I can have something like:

driver.FindElement(By.PartialLinkText("Form Demo"));

To learn more about it, you can refer to our earlier blog on the Partial Link Text locator in Selenium.

CSS Selector in Selenium

I left CSS Selectors and XPath last because, although they are widely used, they are not as straightforward as the other locators. The CSS Selector in Selenium is a combination of an element’s CSS Selectors and the selector’s value, used to identify the element on the web page. The basic syntax for CSS Selectors is node[attribute = ‘attribute_value’]. For our example above, we would have:

driver.FindElement(By.CssSelector("input[id=’user_message’]"));

The big advantage of using CSS Selectors is that they allow us to combine multiple attributes to identify a single element, which is very useful when our elements don’t have an ID, a Name, or a ClassName, or when these attributes are not unique. It also allows us to identify elements relative to their position on the page (for example, the child input element of a span element).

XPath in Selenium

Another very common locator strategy is XPath in Selenium. XPath is a language used for querying XML documents. It works on both HTML and XML documents, allowing us to navigate through the XML structure of any document. It contains a path expression and some conditions. The basic XPath syntax is //tag[@attribute=’value’]. For example:

driver.FindElement(By.XPath("//input[@id=’user-message’]"));

It’s important to note that when deciding on a locator strategy, some are faster, and some are slower. The ID locator strategy is the fastest and usually more recommended, while XPath tends to be slower.

Relative Locators in Selenium

Relative locators have been introduced with Selenium 4, and they can be used to locate elements on the web page in relation to another element on that page. To learn more about it, you can go through our earlier log on Relative Locators in Selenium 4.

This article explains the emulator vs simulator vs real device differences, the learning of which can help you select the right mobile testing solution for your business.

The available relative locators are:

Above

Above identifies an element that is located above a different element.

RelativeBy.WithLocator(By.TagName("input")).Above(By.Id("showInput"))

Below

Below identifies an element that is located below a different element.

RelativeBy.WithLocator(By.TagName("input")).Below(By.TagName("li"))

LeftOf

You probably already figured out how this goes. Yes, the element is located based on an element that can be found to its left.

RelativeBy.WithLocator(By.TagName("input")).LeftOf(By.TagName("p"))

RightOf

Similar to the previous locator, it will retrieve the element based on an element to its right.

RelativeBy.WithLocator(By.TagName("input")).RightOf(By.TagName("p"))

Near

Near will locate an element relative to an element that is within 50px.

RelativeBy.WithLocator(By.TagName("input")).Near(By.TagName("p"))

How to find a single web element using driver.FindElement in Selenium C#?

Finding unique elements to interact with is the first common situation when writing automated tests with Selenium. For these cases, you will want to use the command driver.FindElement in Selenium C#. This will look something along these lines:

driver.FindElement(By.Id("user-message"));

This will return a web element. Then, you can perform any actions available for web elements in Selenium C#, such as SendKeys() to enter text, Click() to click on it, Clear() to clear its text, and so on.

To learn more about SendKeys, you can go through our earlier blog on SendKeys in Selenium.

Let’s look at an example.

Test Scenario:

I will exemplify this with a simple login test case. Here are the test steps:

Navigate to the webpage https://ecommerce-playground.lambdatest.io/index.php?route=account/login.
Enter valid credentials (EMail and Password).
Press the Login button.
Validate that the user account page is loaded.

For all the web elements interaction stated, we are looking to identify a single element to perform actions on:

Insert text into the E-Mail Address input.
Insert text into the Password input.
Click the Login button.
Find the MyAccount header on the page.

In this Selenium C# tutorial on using driver.FindElement and driver.FindElements in Selenium C#, I’ll be running my tests on the LambdaTest cloud grid using different OS and browser configurations.

Cloud testing platforms like LambdaTest allow you to perform manual and automated cross browser testing on an online browser farm of 3000+ browsers and browser versions at scale. It provides support for different automation testing frameworks like Selenium, Cypress, Playwright, and more. Furthermore, using parallel test execution, you can also trim down lead time by multiple folds.

Subscribe to the LambdaTest YouTube Channel to see our latest tutorials about Selenium automation, Appium automation, Playwright automation, and more.

So, let’s get started!

Need a great solution for testing of Safari browser on windows Forget about emulators or simulators — use real online browsers. Try LambdaTest for free.

Project Setup

The first step of the implementation is setting up the project in Visual Studio. I’ll be using NUnit as my test framework, but if you have other preferences, like xUnit or MSTest, they will do the trick just as well. You can see a detailed comparison between NUnit vs. XUnit vs. MSTest to choose the right framework for your testing needs.

For this, select the project type you need in Visual Studio:

Enter a name for the project, select the location, and you should end up with a default created test class that looks like this

using NUnit.Framework; namespace SeleniumLocators { public class Tests { [SetUp] public void Setup() { } [Test] public void Test1() { Assert.Pass(); } } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 using NUnit.Framework; namespace SeleniumLocators { public class Tests { [SetUp] public void Setup() { } [Test] public void Test1() { Assert.Pass(); } } }

Next, we need to add the NuGet packages for Selenium. You can do this by right-clicking on the project name in the solution explorer and selecting Manage NuGet packages:

This will open up the package manager. In the browse tab, look for each of the following packages and click install for each of them:

Selenium.WebDriver
Selenium.Support
DotNetSeleniumExtras.WaitHelpers

Once installed, they will be visible in the Installed tab, along with the installed version:

I am not testing locally. I want to do my tests on the latest version of Safari (currently 16.0). Since I’m a Windows user, the LambdaTest Grid is helpful because it allows me to test a configuration I cannot set up on my machine. I am using the Automation Capabilities Generator to generate the desired configuration.

Implementation

Now that everything’s set up, here’s the implementation for our test scenario:

using NUnit.Framework; using OpenQA.Selenium; using OpenQA.Selenium.Remote; using OpenQA.Selenium.Safari; using OpenQA.Selenium.Support.UI; using SeleniumExtras.WaitHelpers;

namespace SeleniumLocators { public class Tests { 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"); private readonly string loginURL = "https://ecommerce-playground.lambdatest.io/index.php?route=account/login"; private readonly string homePageURL = "https://ecommerce-playground.lambdatest.io/index.php";

[SetUp] public void Setup() { DriverOptions capabilities = new SafariOptions(); capabilities.BrowserVersion = "16.0"; Dictionary<string, object> ltOptions = new Dictionary<string, object>(); ltOptions.Add("username", LT_USERNAME); ltOptions.Add("accessKey", LT_ACCESS_KEY); ltOptions.Add("platformName", "MacOS Ventura"); ltOptions.Add("build", "[DEMO] E-commerce"); ltOptions.Add("w3c", true); ltOptions.Add("project", "LambdaTest Playground"); ltOptions.Add("plugin", "c#-c#"); capabilities.AddAdditionalOption("LT:Options", ltOptions); driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), capabilities); }

[Test] public void ValidateSignIn() { driver.Navigate().GoToUrl("https://ecommerce-playground.lambdatest.io/index.php?route=account/login"); driver.FindElement(By.Name("email")).SendKeys("andreea@getnada.com"); driver.FindElement(By.Id("input-password")).SendKeys("test"); driver.FindElement(By.CssSelector("input[value='Login']")).Click(); WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(5)); wait.Until(ExpectedConditions.ElementExists(By.XPath("//h2[text()='My Account']"))); } } }

Code Walkthrough

Let’s walk through the code now and see what’s going on.

The first lines of code, the using ones, are there to instruct our test class on what packages to use:

Next, we have the class, which contains our actual test. In the first part, I declared the variables I’ll need in my tests:

I need an IWebDriver instance to interact with the browser. And the gridURL, LT_USERNAME, and LT_ACCESS_KEY are string variables that I will be using in the setup to connect to my LambdaTest Grid account. I also stored the login page URL as a variable to make it easier to read. It’s also a good idea to store credentials (such as the LT_USERNAME and LT_ACCESS_KEY) as environment variables in your operating system.

The [SetUp] is an NUnit attribute, marking a method that will run before each test method. Consider this method as the precondition of the tests. Here I set up my driver and my LambdaTest configuration.

Then all this goes into the SetUp method and a new instance of the driver, which is linked to my account URL.

Next comes the actual test, where you can see the FindElement in action. Again, we have an NUnit attribute, which is [Test]. This marks a test method. If you open the Test Explorer of Visual Studio (from the Test menu → Test Explorer), you will see all the methods with this attribute. I currently have just one:

The first line is the navigate command, which instructs the browser to go to the desired URL. In our case, the Login page.

Next, we have various interactions with web elements on the page. I tried to use as many of the available locators, so as you can see, I’ve used: driver.FindElement(By.Name(“email”)) to locate the Email input field:

driver.FindElement(By.Id(“input-password”)) to locate the Password field:

And driver.FindElement(By.CssSelector(“input[value=’Login’]”))using a CSS Selector build on the value attribute, to locate the Login button:

Next, once the elements are correctly located, simply use Selenium’s methods to interact with them:

SendKeys() to enter text in the input fields (for email and password)
Click() to press the login button.

You can learn more about the Action Class through this blog on Action Class in Selenium. The following lines instruct the browser to wait for 5 seconds or until the element with the given XPath exists, using an explicit wait. The test will fail if the element is not found within 5 seconds.

Now my test is displayed in Visual Studio’s Test Explorer, and I can run it from here by right-clicking on it and selecting Run or by pressing the Run button at the top:

Once the test finishes running, I can see the result in the same panel (green means passed)

As well as in my Dashboard in LambdaTest Selenium Grid in the Automation tab:

From here, I can go deeper into details and see a recording of my test, as well as each detailed step:

LambdaTest Analytics is a comprehensive solution that helps you manage and optimize your QA processes and test data through access to powerful analytics capabilities.

With LambdaTest Analytics, you can easily access, analyze, and streamline your QA efforts, ensuring that your product is successful by incorporating key analytics insights. Whether you are looking to improve your testing efficiency or simply want to better understand the performance of your product, LambdaTest Analytics is what you need.

Perform manual or automated cross browser testing on 3000+ browsers online. Deploy and scale faster with the most powerful cross browser testing tool online.

How to find multiple web elements using driver.FindElements in Selenium C#?

The second case I’ll present is when you are not looking for a single element but trying to find all the elements that meet certain criteria. The Selenium C# method used for this is FindElements(), and it works pretty much the same way as FindElement(), except that this method returns a collection of web elements:

driver.FindElements(By.XPath("//a[text()='HTC Touch HD']"));

It’s better to illustrate this with an example as well.

Test Scenario:

Navigate to the ecommerce-playground.lambdatest.io/index.php?route=common/home page.
Search for “HTC” products.
Validate the required number of products returned (in this case, 8).

Implementation

[Test] public void ValidateNumberOfProducts() { int expectedNumber = 8; driver.Navigate().GoToUrl("https://ecommerce-playground.lambdatest.io/index.php?route=common/home"); driver.FindElement(By.Name("search")).SendKeys("htc"); driver.FindElement(By.XPath("//button[text()='Search']")).Click(); WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(5)); wait.Until(ExpectedConditions.ElementExists(By.XPath("//h1[text()='Search - htc']"))); var results = driver.FindElements(By.XPath("//a[text()='HTC Touch HD']")); Assert.That(results, Has.Count.EqualTo(expectedNumber)); }

Code Walkthrough

I also added a new string variable for the URL:

Next, inside the test, I created a simple integer variable that stores the expected number of results, which I will use later:

This test should be easy to understand after we already went over the first one. The second line is the same, except we navigate to a different page:

Next, using the Selenium driver.FindElement() method, I have two interactions with elements:

I used a wait again to ensure that I validated after loading the correct page. I’m using the H1 web element with the text “Search — htc” to be displayed:

And then we have the driver.FindElements() in Selenium C#, where we identify all the elements that have the same locator, in this case, the same XPath:

The collection of elements is saved within a variable, which I used in the last line. Here I verify the number of web elements returned by the driver.FindElements() in Selenium C# is the number I expect:

Assert is a class provided by NUnit, which allows us to make validations. If the condition we pass as a parameter is true, then the test passes. Otherwise, it will fail.

Now that the tests are written, you can see them both in the Test Explorer. To run them both, you just need to press the Run All button, right-click and select Run, or use the Ctrl+R, T shortcut, just like before:

After the tests are finished running, you’ll be able to see the results in Visual Studio:

And now, you can see the new test execution in your LambdaTest account, under the Automation tab:

And, if you click on one of the runs, you can see a video recording of the test, the configuration on which the test ran

And a step-by-step description of the Selenium commands sent:

If you are a tester seeking to improve your abilities, consider obtaining the Selenium C# 101 certification from LambdaTest as a way to demonstrate your expertise. This certification can help you to stand out and highlight your skills to potential employers or clients.

Final Thoughts

The driver.FindElement() and driver.FindElements() in Selenium C# are two of the most common commands when working on web UI automation. Here are the most important things to remember:

The syntax in Selenium C# for finding elements is:

driver.FindElement(By.locator_strategy); driver.FindElements(By.locator_strategy);

driver.FindElement() in Selenium C# returns the first web element found using the provided locator. If you need to select a specific element, ensure that the locator strategy will return only one element.
driver.FindElements() in Selenium C# returns a collection of web elements.
It’s crucial to use a good locator strategy; otherwise, you can end up with unwanted exceptions, or Selenium might try to interact with the incorrect element on the web page.

## How To Use WebDriverWait In Selenium C#

AndreeaDraniceanu — Tue, 21 Feb 2023 06:21:00 +0000

The more you work with Selenium automation, the more you will come across various exceptions, such as NoSuchElementException (when an element is not visible on the page) or StaleElementReferenceException. Or there will be times when you will try to interact with an element that is not yet in the state you expect it to be (e.g., clickable).

To do this, you can instruct Selenium WebDriver to wait for certain conditions to be met explicitly. Explicit waits in Selenium are a way to deal with the dynamic nature of web pages, where elements may take longer to load or become available for interaction. By using explicit waits, you can tell Selenium to wait for a specific condition to be met before executing the next step in your automation script. This allows for a more flexible and robust automation solution.

In this Selenium C# tutorial, I will show you how you can use the WebDriverWait in Selenium C# to increase the reliability of your test.

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

What are Selenium Waits?

Before we dig deeper, let’s understand the waits in Selenium and why we use them. Selenium WebDriver doesn’t keep track of the DOM’s live, active state. Its default page load method waits for the document.readyState to become “complete”. This can happen before all the elements on the page are loaded and can cause the tests to throw NoSuchElementException. You can refer to this blog on the most common Selenium exceptions to learn more about it.

Consider a test where you try to click on a button that has not yet loaded or is not yet enabled (though visible) on the page. If Selenium WebDriver attempts to click on a button that is not available in the DOM, it will throw a NoSuchElementException. You might also witness the Element Is Not Clickable at Point exception if the element is visible in the DOM but not clickable at a particular point.

This will cause all further steps to fail, although the application works as expected when clicking the button at the correct time. To prevent this, we use waits. With waits, we can tell our tests to wait a certain amount or for specific conditions before moving on to the next steps.

Types of Waits in Selenium C

There are several ways to wait for a web element to appear on a web page. I will go through each one and then expand more on the explicit waits, which are the focus of this blog.

Thread.Sleep()

System.Threading.Thread.Sleep(milliseconds) is not a Selenium WebDriver method but a built-in one in .Net. What it does is it suspends the current thread for the number of milliseconds passed as a parameter.

However, this is not recommended when working with automated web UI testing, because it is very rigid — the specified time has to pass before moving to the next step, regardless of whether the element you are waiting for was loaded faster.

For example, if your web element takes 3 seconds to load, and the Sleep parameter is set to 5 seconds, the test will wait 5 seconds before moving to the next step:

Thread.Sleep(5000);
driver.FindElement(By.Id("slowButton")).Click();

Test your website or web app online for iOS browser compatibility, including on the latest iPhone Simulator, by using an iPhone tester. Perform seamless cross-browser testing on this device to ensure a flawless user experience. You can even try it for free.

It might not sound like a big deal, but if you have hundreds of tests and many of them use Thread.Sleep(), which can add a lot of unnecessary wait time to the test execution. If the test takes around 5 seconds, adding up the Sleep time of another 5 seconds, that means doubling the time it takes to run the test!

Also, if the time it takes for the button to load exceeds those 5 seconds, you will still get a NoSuchElementException.

Implicit Wait

Then, we have the Selenium implicit wait:

driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(20);

The implicit wait in Selenium is dynamic — it waits until an element is visible on the page or until the given timespan has elapsed. If the element has not been found before the given time duration, an ElementNotVisibleException or NoSuchElementException will be thrown.

The Selenium implicit wait applies to all the web elements in the test script and is a much-preferred method to Thread.Sleep().

Explicit Wait

However, if you want even more flexibility, you should go for the explicit wait. The WebDriverWait in Selenium C# is part of the OpenQA.Selenium.Support.UI package.

WebDriverWait in Selenium C# allows Selenium not only to wait for an element to be visible on the web page but also until specific conditions are met.

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(20));
wait.PollingInterval = TimeSpan.FromMilliseconds(200);          wait.Until(ExpectedConditions.ElementIsVisible(By.Id("my-element']"))).Click();

A complete WebDriver tutorial that covers what WebDriver is, its features, architecture and best practices.

This is how WebDriverWait in Selenium C# works:

The condition is checked. If the condition is true, the next lines of code are executed.
If the condition is false, a thread sleep is called at a polling interval. The default value of this polling interval is 250 ms, but a different value can be specified:

wait.PollingInterval = TimeSpan.FromMilliseconds(200);

After this interval elapses, the condition is rechecked.
This step repeats until the given wait time expires or the condition is met.

Expected Conditions with Explicit Wait

Here are some examples of Expected Conditions in Selenium I have used the most in my tests (your tests might have different needs, but these are just to illustrate how explicit waits can be useful):

ElementExists: waits for the element to exist in the DOM of the page, even if it’s not visible.
ElementIsVisible: waits for the element to be visible on the page. There are cases when the element can exist in the DOM but is not yet displayed on the page, so we cannot interact with it.
ElementToBeClickable: wait for an element to become clickable — can be useful when a button is quickly loaded on the page but cannot be clicked right away because it is disabled or cannot be clicked until a different action is performed.
AlertIsPresent: waits for the presence of an alert — alerts are usually triggered by another action, and it can take some time to display them. If you interact with an element on the alert (like dismiss/confirm the alert or try to confirm its text) too soon, you can get a NoAlertPresentException.
InvisibilityOfElementLocated: waits for an element to not be visible on the page. For instance, you want to check that after inserting invalid data in an input field, the warning message is no longer displayed when the correct data is entered.
TextToBePresentInElement: waits for a given text to be displayed inside a certain web element.
ElementToBeSelected: waits for an element to be selected — can be used for checkboxes that are automatically selected through other actions.

Demonstration: How to use WebDriverWait in Selenium C

In this section, we will go over an example of using WebDriverWait in Selenium C# to handle the dynamic nature of web pages. The WebDriverWait class is a useful tool for waiting for specific conditions to be met before executing the next step in your automation script. This helps to make your scripts more flexible and robust, allowing for a better automation solution.

Test Scenario

Navigate to the JQuery Download Progress Bar page.
Click the Start Download button.
Click the Close button when it’s available:

Implementation

If this is your first test, you will need to create a new project. In this WebDriverWait in Selenium C# tutorial, I’ll be using the MSTest framework, which is Microsoft’s tool for running tests in .NET applications. If you prefer to work with NUnit, you can check out the Selenium NUnit tutorial.

To learn more about MSTest, NUnit, and other popular unit testing frameworks like xUnit, you can go through this blog on NUnit vs xUnit vs MSTest.

Finally, we will be executing the test on the LambdaTest cloud grid. Cloud testing platforms like LambdaTest allow you to perform cross browser testing at scale over an online device farm of 3000+ browsers and browser versions.

By using an iPhone emulator, such as the iOS simulator by LambdaTest, you can effortlessly test your websites and web applications across a range of devices, operating system versions, and browsers, from the latest models to older ones. Additionally, you can test your iOS app online across 200+ device and iOS environments. Register for free and start testing today.

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

To create a new test project in Visual Studio, select the MSTest Test Project type:
Install the following NuGet packages from the Package Manager:

Selenium.WebDriver: For this WebDriverWait in Selenium C# tutorial, I am using version 3.141.0, which is still one of the most used versions in existing Selenium projects.
Selenium.Support: It should be the same version as the Selenium.WebDriver package; this is the package that contains the Selenium WebDriverWait.

Install the NuGet packages from the UI, from the Tools menu → NuGet Package Manager → Manage NuGet Packages for Solution… and search for them in the list:

Or you can run the install command from the Package Manager Console (Tools menu → NuGet Package Manager → Package Manager Console):

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

I used the LambdaTest Capabilities Generator to create the configuration where I want to run my tests. You can create your custom setup, depending on the configuration you want to use in your tests. I’m keeping it simple, testing on Windows 11 with Chrome version 101 and a resolution of 1280×800.

Before running the tests, please set the environment variables LT_USERNAME & LT_ACCESS_KEY from the terminal. The account details are available on your LambdaTest Profile page.

For macOS:

export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

For Linux:

export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME
set LT_ACCESS_KEY=LT_ACCESS_KEY

Create a new class containing the following code:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Remote;
using System;
using OpenQA.Selenium.Support.UI;


namespace SeleniumExplicitWaits
{
    [TestClass]
    public class SeleniumWebDriverWaits
    {
        private static IWebDriver driver;
        public static string gridURL = "@hub.lambdatest.com/wd/hub";
        public static string LT_USERNAME = Environment.GetEnvironmentVariable("LT_USERNAME");
        public static string LT_ACCESS_KEY = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");


        [TestInitialize]
        public void SetUp()
        {
            var desiredCapabilities = new DesiredCapabilities();
            desiredCapabilities.SetCapability("browserName", "Chrome");
            desiredCapabilities.SetCapability("platform", "Windows 11");
            desiredCapabilities.SetCapability("version", "101.0");
            desiredCapabilities.SetCapability("screenResolution", "1280x800");
            desiredCapabilities.SetCapability("user", LT_USERNAME);
            desiredCapabilities.SetCapability("accessKey", LT_ACCESS_KEY);
            desiredCapabilities.SetCapability("build", "Selenium C-Sharp");
            desiredCapabilities.SetCapability("name", "Selenium Test");
            driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), desiredCapabilities, TimeSpan.FromSeconds(600));


        }


        [TestMethod]
        public void DownloadFile()
        {
            driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/jquery-download-progress-bar-demo");
            driver.FindElement(By.Id("downloadButton")).Click();
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(20));
            wait.PollingInterval = TimeSpan.FromMilliseconds(200);
            wait.Until(ExpectedConditions.ElementToBeClickable(By.XPath("//button[contains(text(),'Close') and @class='ui-button ui-corner-all ui-widget']"))).Click();


        }

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

Perform browser automation testing on the most powerful cloud infrastructure. Leverage LambdaTest automation testing platform for faster, reliable and scalable experience on cloud.

Code Walkthrough

The using statements in any C# class contain the packages that will be used:

The [TestClass] attribute from MSTest marks the class as a test class:

In the next part, I’m declaring all the variables that will be used in the methods:

The driver is a new instance of the IWebDriver interface. Through it, we control the browser.

The next lines of code are related to my LambdaTest Account because I want my tests to run on cloud Selenium Grid. This way, I can specify configurations where my tests will run, which can be different from my local configuration.

This brings us to the next part:

This method is triggered before each test case. It will create a new browser instance with specific capabilities.

The next method is the actual test:

The [TestMethod] attribute informs that the method is a test method. The Navigate().GoToUrl() is the Selenium C# method to go to a specific URL.

Then, the FindElement() in Selenium is the method that allows us to identify web elements on the web page based on locators, such as

ID
Name
Class Name
XPath
CSSSelector
Link text or partial link text

For the first element I’m interacting with, I’m using the ID locator in Selenium. It’s usually recommended because it should be unique. To retrieve this information from the browser, right-click the element and select Inspect. This will open up (if it’s not already open) the Developer Tools, where you can see the details of the element:

Next, I’m using the actual explicit wait:

I created a new variable of type WebDriverWait, giving it a time span of 20 seconds — this is the maximum amount of type I am instructing Selenium to wait for my condition to be met.

Next, I am using a polling interval of 200 milliseconds — this is completely optional, but I wanted to show you how it can be used. Selenium will retry to find the web element every 200 milliseconds.

Finally, I specified the condition I wanted to wait for, which was for the button to become clickable. The button doesn’t have an Id, so I am using an XPath with a combination of 2 attributes: text and class name. I can see this in Developer Tools as well:

<button type="button" class="ui-button ui-corner-all ui-widget">Close</button>

The last method is the cleanup, marked by the attribute [TestCleanup], which will run after every test. It simply closes the browser using the Selenium Quit() method.

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

Execution

The test will be visible in Visual Studio’s test explorer, and you can run it from there. If you choose to run it locally, you will see the browser open up and perform all the steps. If you are using cloud Selenium Grid, like me, you will see the test result when it finishes running:

And you will see the results online:

You can also see all the retries performed before the element was found:

Perform browser automation testing on the most powerful cloud infrastructure. Leverage LambdaTest testing automation cloud for faster, reliable and scalable experience on cloud.

However, my test was successful because after waiting less than the given time, the element was found and clickable.

Demonstrate your expertise and knowledge in using Selenium for C# automation testing with this Selenium C# 101 certification. This will enhance your technical skills and establish your credibility as a tester.

Conclusion

Having the option to wait for web elements to be loaded or meet a certain condition can be very important in automated UI testing.

In this blog on WebDriverWait in Selenium C#, I covered how to create explicit waits using WebDriverWait in Selenium C# to create more stable tests and why they can be preferred to implicit waits. I also showed how you can run the tests on the cloud, so you don’t have to use your local settings and configuration, and how to see the results on the LambdaTest cloud Selenium Grid.

Getting Started with SpecFlow Actions [SpecFlow Automation Tutorial]

AndreeaDraniceanu — Mon, 21 Nov 2022 16:10:45 +0000

With the rise of Agile, teams have been trying to minimize the gap between the stakeholders and the development team.

Behavior Driven Development, or BDD, is a great way to bring together technical and non-technical folks by focusing more on the behavior of the apps, and a good understanding of the requirements, from a behavioral perspective.

BDD is centered on explicitly defining a feature’s desired behavior from the beginning. Specification by example is a method for identifying behaviors that use concrete examples rather than abstract, general language to describe the intended behavior. They act as the product’s requirements/acceptance criteria (before development) and test cases (after development).

In this SpecFlow automation tutorial, I’ll demonstrate how a BDD web test can be written using SpecFlow and Selenium C# and how to run it on the cloud Selenium Grid with SpecFlow Actions. I am using Visual Studio 2022, but you can use an older version to follow along.

It’s crucial to debug websites for Safari before pushing them live. In this article, we look at how to debug websites using dev tools on safari.

What is BDD testing?

BDD is built on TDD (Test-driven development), which makes it an approach where tests are written first.

Since BDD is a collaborative approach, the product owner (stockholder), developers, project managers, QAs, and user acceptance testers come together to discuss which test scenarios should be passed to consider this software/application successful. They create a set of test scenarios in this way.

Since all of these test scripts are written in plain English, they also serve as documentation for the project. SpecFlow is a framework for defining these scenarios in a more structured way and tying them to tests that run against the code.

These two approaches — in isolation and together — can help you write better code and provide higher-quality software faster.

Cucumber and the Gherkin language

Cucumber is one of the most important tools that support BDD. It provides a means to write tests everyone can understand regardless of their technical skills.

Cucumber reads plain language executable specs and verifies that the program performs what it is supposed to. The specifications provide several scenarios. For example:

Scenario: We only work on weekdays
   Given today is Sunday
   When I get up
   Then I don’t have to work

Each scenario consists of a series of actions that the Cucumber must perform. Cucumber checks whether the program matches the specification and produces a report stating if each scenario was successful or unsuccessful.

The Cucumber files use the extension .feature, and the scenarios must follow syntax rules called Gherkin. The lines in Gherkin should start with keywords.

The most important keywords in Gherkin are:

Feature: provides a high-level description of the feature being tested and groups related scenarios.
Scenario: a practical example of a business rule. It includes a series of steps.
Given: a keyword that marks a step that gives an initial context of the system — the preconditions of the scenario.
When: used for steps that describe an action.
Then: marks a step that describes the expected result of the scenario.
And / But: are used when multiple Given, When, or Then steps need to be used.

Introduction to SpecFlow Actions

SpecFlow is a BDD automation framework for .NET that uses the Gherkin language. It is provided as a Visual Studio extension. While writing this SpecFlow automation tutorial, the latest SpecFlow version is 3.9, released in November 2021.

SpecFlow uses the official Gherkin parser, with support for over 70 languages — which means that you can write your Given/When/Then scenarios in languages other than English, too. Then, using bindings, these tests are connected to the application code, enabling you to run the tests using the testing framework of your choice (such as NUnit, in our case).

To use SpecFlow, you need to install the Visual Studio extension. That can be easily done from the Visual Studio → Extension menu → Manage extensions, and search for SpecFlow.
Then, to create a new SpecFlow project, from the New Project wizard, select the SpecFlow Project type:

Choose a target framework and your preferred test automation framework and complete the wizard. In this SpecFlow automation tutorial, we’ll be using NUnit from here on, and I’ll explain along the way the NUnit methods.

Subscribe to the LambdaTest YouTube Channel to see our latest tutorials about Selenium automation, Appium automation, Playwright automation, and more.

By default, the project will have a Features folder containing a file with the .feature extension and a StepDefinitions folder, which includes the implementations of the features:

What are SpecFlow Actions?

SpecFlow Actions is a solution provided by SpecFlow that enables us to integrate our SpecFlow tests with Selenium. It manages the browser’s lifetime and offers simple configuration options and Selenium helper methods.

The aim is to address typical issues testers run into when automating websites, applications, or APIs, such as working with multiple browsers or always being up-to-date with the latest browser version.

In the upcoming sections of this SpecFlow automation tutorial, I will walk you through the steps you need to integrate SpecFlow Actions with continuous testing clouds like LambdaTest to run tests in parallel on an online browser farm of 3000+ real browsers, devices, and OS.

Demonstration: SpecFlow Actions on Cloud Grid

Before starting with SpecFlow automation, follow the steps above to install the SpecFlow extension and create a new SpecFlow project.

Next, you’ll need to install the following NuGet packages:

Selenium.WebDriver: At the time of writing this SpecFlow automation tutorial, SpecFlow.Actions for LambdaTest worked with version 3.141.0 of Selenium.WebDriver, so this is the version I have installed, too.
SpecFlow.Actions.LambdaTest: I’ll use the latest version (0.1.332) for this SpecFlow automation tutorial.

There are more ways to install a NuGet package. You can do it from the NuGet Package Manager of the project:

1- Right-click on the project name and select Manage NuGet Package), and here, in the Browse tab, search for the desired package:

Or you can use the NuGet Package Manager Console (Tools → NuGet Package Manager → Package Manager Console, and run the command:

dotnet add <PROJECT> package [options] <PACKAGE_NAME>

For example:

dotnet add package Selenium.WebDriver --version 3.141.0

Now the project should look like this:

2- To run the tests on the cloud, create in the project folder a new .json file called specflow.actions, and add the Selenium settings you want to use:

{
  "selenium": {
    "defaultTimeout": 60,
    "pollingInterval": 5,
    "lambdatest": {
      "url": "@hub.lambdatest.com/wd/hub">https://${LT_USERNAME}:${LT_ACCESS_KEY}@hub.lambdatest.com/wd/hub"
    }
  }
}

3- You can get your LambdaTest username and access key from the LambdaTest Automation tab by clicking on Access Key:

4- Then, add one .json file for each environment where you want to run your tests. For example, I’ll test Firefox on Windows 10 and Chrome on Windows 11.

I can use a specific browser version by providing the exact version number, instructing SpecFlow Actions to use the latest version, or telling it to go back to a certain number of versions.

Let me illustrate that. Here is the specflow.actions.windows10.firefox.json file, where I am using the latest version of Firefox:

{
  "selenium": {
    "browser": "Firefox",
    "capabilities": {
      "platform": "Windows 10",
      "version": "latest",
      "build": "[Demo - 2] SpecFlow Actions on LambdaTest",
      "project": "SpecFlow Actions Demo",
      "selenium_version": "3.141.59"
    }
  }
}

And the specflow.actions.windows11.chrome.json file, where I am using the 4th latest version of Chrome:

{
  "selenium": {
    "browser": "Chrome",
    "capabilities": {
      "platform": "Windows 11",
      "version": "latest-4",
      "build": "[Demo - 1] SpecFlow Actions on LambdaTest",
      "project": "SpecFlow Actions Demo",
      "selenium_version": "3.141.59"
    }
  }
}

Most of the browser capabilities are optional, but they are helpful when you need specific configurations or want to personalize the results, for example with the build and project names.

You can use the same capabilities you would obtain using the LambdaTest Automation Capabilities Generator, but in JSON format:

Every modern web browser has a robust set of developer tools for testing element alignment and functionality. This article will show how to inspect elements on iPhone and iPad(how to inspect on mac).

Test Scenario

I’ll use a fairly simple scenario to demonstrate how to write a BDD test scenario using SpecFlow.Actions with Selenium in C#. The test will be:

Navigate to the page https://ecommerce-playground.lambdatest.io/.
Select a category and perform a search.
Validate that the correct number of results is returned.

Code Implementation

The .feature file contains the test scenarios written using the Gherkin language. I am testing two scenarios — see how easy they are to read:

Feature: ECommerce Playground Demo

@searchItems
Scenario: Search for iPod Nano
    Given I select the Software category
    When I search for iPod Nano
    Then I should get 4 results for iPod Nano

@searchItems
Scenario: Search for HTC Touch HD
    Given I select the Tablets category
    When I search for HTC Touch HD
    Then I should get 8 results for HTC Touch HD

The class containing the implementation (I named it SearchItemsStepDefinitions.cs) of the steps should look like this:

using NUnit.Framework;
using OpenQA.Selenium;
using SpecFlow.Actions.Selenium;
using TechTalk.SpecFlow;

[assembly: Parallelizable(ParallelScope.Fixtures)]
[assembly: LevelOfParallelism(4)]
namespace LTSpecFlow.StepDefinitions
{
    [Binding]
    public class AddItemsToCartStepDefinitions
    {
        private readonly IBrowserInteractions _browserInteractions;
        public AddItemsToCartStepDefinitions(IBrowserInteractions browserInteractions)
        {
            _browserInteractions = browserInteractions;
        }

        [BeforeScenario]
        public void SetUp()
        {
            _browserInteractions.GoToUrl("https://ecommerce-playground.lambdatest.io/");
        }

        [Given(@"I select the (.*) category")]
        public void GivenISelectTheCategory(string category)
        {
            _browserInteractions.WaitAndReturnElement(By.XPath("(//div[@class='dropdown search-category']/button[@type='button'])[1]")).Click();
            _browserInteractions.WaitAndReturnElement(By.XPath($"(//a[text()='{category}'])[1]")).Click();
        }

        [When(@"I search for (.*)")]
        public void WhenISearchForProduct(string product)
        {
            _browserInteractions.WaitAndReturnElement(By.XPath("(//input[@name='search'])[1]")).SendKeys(product);
            _browserInteractions.WaitAndReturnElement(By.XPath("(//button[normalize-space()='Search'])[1]")).Click();
        }

        [Then(@"I should get (.*) results for (.*)")]
        public void ThenIShouldGetResults(int itemsCount, string product)
        {
            int actualCount = _browserInteractions.WaitAndReturnElements(By.XPath($"//div[@class='row']//div[@class='carousel-item active']/img[@alt='{product}']")).Count();
            Assert.AreEqual(itemsCount, actualCount);
        }

    }
}

Code Walkthrough

Let’s begin with the feature file. Each feature file should, ideally, test only one feature of the application. This is defined by the “Feature” keyword, which should be the file’s first line. In my case, I am testing website’s search functionality, so the name I gave to the feature is “Search products”:

Feature: Search products

Next, before my test scenario, I added a tag. These tags are used to identify and group related scenarios or scenarios that will be run together at some point.

@searchItems

One scenario can have multiple tags, for example:

@SmokeTests @RegressionTests @FunctionalityTests

Next comes the actual test scenario:

@searchItems
Scenario: Search for iPod Nano
    Given I select the Software category
    When I search for iPod Nano
    Then I should get 4 results for iPod Nano

It’s written in plain English and uses the Gherkin keywords:

Scenario: this is the title of the test. It should be concise but also detailed enough to understand what it’s testing.
Given: the keyword used for preconditions of the tests. This is the test step that will need to run before the actual test begins.
When: the keyword used before the test steps.
Then: This keyword marks the expected result of the test.

The beauty here is that the entire test is extremely easy to read by anybody, not just technical people or automation testers. And also, anybody can write this type of scenario without understanding the inner workings of a test automation framework.

And thanks to the SpecFlow extension, for any new Gherkin steps written, you can generate the code steps, by right-clicking on the steps and selecting Define steps. You’ll get something like this:

Then you’ll have to write the implementation for the steps. This brings us to the Steps Definition class. The first part contains the packages used in the class:

using NUnit.Framework;
using OpenQA.Selenium;
using SpecFlow.Actions.Selenium;
using TechTalk.SpecFlow;

We are using Selenium, SpecFlow, SpecFlow Actions, and NUnit, which I use for the test’s assertions.

Then, using NUnit’s Parallelizable attribute, I define that 4 tests from the same assembly can run in parallel (so all the tests from the example, since we have 2 tests and 2 browser configurations). To learn more about parallel execution with SpecFlow, NUnit, and Selenium, please go through the following video:

[assembly: Parallelizable(ParallelScope.Fixtures)]
[assembly: LevelOfParallelism(4)]

Now comes the actual implementation. The [Binding] attribute marks the class as a step implementation class.

The first thing you need to do is create a constructor, and instantiate an IBrowserInteractions variable (this is the SpecFlow Actions equivalent of Selenium’s IWebDriver):

private readonly IBrowserInteractions _browserInteractions;
        public AddItemsToCartStepDefinitions(IBrowserInteractions browserInteractions)
        {
            _browserInteractions = browserInteractions;
        }

Next, use the [BeforeScenario] hook, which marks the following method to run before each scenario. I prefer using this type of hook instead of writing an explicit Gherkin step for starting the app because, while this step is mandatory before any other steps, I don’t find that it reflects a part of the user behavior:

[BeforeScenario]
        public void SetUp()
        {
            _browserInteractions.GoToUrl("https://ecommerce-playground.lambdatest.io/");
        }

The following methods will be the test steps. For each method to be bound to the correct feature step, it needs to have a matching attribute (Given / When / Then), followed by a regular expression that matches the Gherkin step. For example, the

[Given(@"I select the (.*) category")]

Regular expression matches both

Given I select the Software category

and

Given I select the Tablets category

The (.*) pattern means that my expression will match any value. Then the method needs to have a parameter of the relevant type — string in this case, and int and string in the last step.

I should get (.*) results for (.*)

The actual implementation is fairly similar to a Selenium implementation, except this time we are using the methods provided by SpecFlow Actions. To identify elements, you need to use WaitAndReturnElement (for a single element) and WaitAndReturnElements (for a list of elements), and then to interact with them, you can use Click() and SendKeys() — the same way you would if you would use Selenium WebDriver.

For this particular SpecFlow automation tutorial, I used the XPath locator for the web elements on the page because the web elements do not have unique IDs. XPath is one of the most used locators in Selenium WebDriver for navigating across a page’s HTML structure. Any element on a web page can be located using the HTML DOM framework for both HTML and XML documents.

The basic fundamental format of an XPath is:

//tagname[@attribute=’value’]

Where:

//: indicates the active node;
tagname: indicates the node’s tag (for example, a for hyperlinks, button for buttons, etc.);
The @ character marks the node’s attribute;
Attribute: the name of the node’s attribute;
Value: the chosen attribute’s value.

To get the elements’ XPath, you can use the Developer Tools provided by the browser (right-click on the element and select Inspect) and build it based on its attributes.
You can even select Copy → XPath, although this might not always return the best XPath or even a unique one. You can also use Chrome extensions that help identify the best locator for web elements, I use and recommend SelectorsHub:

You can use the Console to see how many elements are returned for a specific XPath:

So what you need to do is:

1- Click on the category button to expand the menu, and then click on the given category (which will be passed as a parameter):

[Given(@"I select the (.*) category")]
public void GivenISelectTheCategory(string category)
{
  _browserInteractions.WaitAndReturnElement(By.XPath("(//div[@class='dropdown search-category']/button[@type='button'])[1]")).Click();
  _browserInteractions.WaitAndReturnElement(By.XPath($"(//a[text()='{category}'])[1]")).Click();
}

2- Type in the search keyword (also passed a parameter) and click the Search button:

[When(@"I search for (.*)")]
public void WhenISearchForProduct(string product)
{
  _browserInteractions.WaitAndReturnElement(By.XPath("(//input[@name='search'])[1]")).SendKeys(product);
  _browserInteractions.WaitAndReturnElement(By.XPath("(//button[normalize-space()='Search'])[1]")).Click();
}

3- Validate that the number of actual results matches the expected number:

[Then(@"I should get (.*) results")]
public void ThenIShouldGetResults(int itemsCount)
{
  int actualCount = _browserInteractions.WaitAndReturnElements(By.XPath("//div[@class='carousel-item active']")).Count();
  Assert.AreEqual(itemsCount, actualCount);
}

Here, you can use the Assert class from NUnit to compare two values. If the values are equal, the test will pass; if not, the test will fail.

And that’s all! Now let’s put our tests to work!

Execution

You will be able to see the tests in Test Explorer (Test → Test Explorer), just like in any other Visual Studio Project:

The number of tests will match the number of scenarios defined in the feature file(s) times the number of browser configurations. In this SpecFlow automation tutorial, I have 2 scenarios and 2 browser configurations, so I’ll see 4 tests in the explorer window. The Traits column is populated with the tags I used for the scenarios.

Now, if you press Run All, you’ll see that the tests start executing, and if you define the parallelization, they will run in parallel. No browser window will open since we’re running the tests on the cloud. Still, you can see the tests running on the LambdaTest Dashboard:

Once they finish running, you can see them in your LambdaTest account, in Automation → Builds:

To see the details, you can click on each test, where you will find a video recording of the test run, the configuration details, the time it took for the test to run, its result, and the step details with each of their results. You can also click on each step to see the recording at that exact time:

Are you a tester looking to hone your skills? Prove your worth by earning the Selenium C# 101 certification by LambdaTest.

How to inspect elements on iPhone? Read the blog to know more about how to inspect elemtns on mac.

Wrapping Up

In this Selenium C# tutorial, we have seen why SpecFlow is an excellent framework for writing behavior-driven scenarios because the tests can be written in simple English and understood by anyone on the team.

And on top of this, using SpecFlow Actions can power up your test automation even further since it enables you to run the tests on various browser versions and operating systems and run them in parallel on the Selenium IDE cloud.

How To Perform Web How To Start Running Automated Tests With Selenium C#

AndreeaDraniceanu — Mon, 21 Nov 2022 14:58:09 +0000

The Selenium framework itself is a set of different tools, but the most popular and the most useful to new and experienced testers alike is WebDriver. Selenium WebDriver is a free and open-source tool that allows you to interact with a website for web automation testing. It also supports popular programming languages like C#, Java, JavaScript, Python, Ruby, and PHP. As per reports, C# is just behind Python, C, Java, and C++ in terms of popularity. I’ve been working mostly with Selenium C# for some time, and I’ll tell you why.

If I’m just starting a project, I like to use the same language the development team uses for two main reasons:

The test project can be integrated with the existing solution.
The development team can help with improvements in the testing framework.

Selenium is my preferred and one of the best test automation frameworks since I can use the C# bindings for Selenium to write automated tests. At the time of writing this blog on C# Automation testing, the latest Selenium version available is 4.2.0, so I’ll be using that version for the following Selenium C# tutorial.

By the end of this Selenium with C# tutorial, you will be in a position to write automated tests that work seamlessly on local and cloud Selenium Grid.

So let’s get started!

Before you get started, you need to have a code editor installed on your machine. For this Selenium C# tutorial, I’ll be using Visual Studio, but you can use any IDE you prefer for editing your code.

Try an Selenium online Grid to run your browser automation testing scripts. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

How to create a new Selenium C# project?

The steps to create a new project in Visual Studio are pretty straightforward. Please follow the below steps to create a new project in Selenium with C#.

Click “Create a new project” from the splash window:

Then select the type of project you want to use. We continue with the “NUnit Test Project” for .NET Core for this blog.

I’m using NUnit because it’s one of the most used frameworks to automate web testing and will help simplify our test writing process. You can go through this Selenium NUnit tutorial to learn more about setting up NUnit with Visual Studio. The latest version of NUnit is 3.13.3. Here are some of my favorite features of NUnit that help me in my Selenium C# projects:

Annotations — These are NUnit attributes (or tags) that tell the code how the methods implemented under it are interpreted. The syntax is the attribute name between square brackets. Some of the commonly used NUnit annotations, and the most used, in my experience, are:
[SetUp]: marks a method that is executed before each test method
[Test]: the attribute that marks a test method
[TearDown]: the method implemented under TearDown will be executed after each test method
[OneTimeSetUp]: an attribute used to indicate that the method will be called once before the tests run
[OneTimeTearDown]: marks a method that will be executed after all the tests finish running
[TestFixture]: marks a class that contains tests. Starting with NUnit 2.5, it has become optional — a class that contains tests (marked with the [Test] attribute) will be identified even without the TestFixture attribute.
Assertions — Use NUnit assertions to validate if the test has the expected result. I usually stick to the “classic” assertions:
Assert.IsTrue(): checks that a given condition is true.
Assert.IsFalse(): checks that a given condition is false
Assert.AreEqual(): checks that two given objects are equal
Parallelization: Allows parallel execution in NUnit.
Data-driven testing: Using parameterization in NUnit, we can run the same test using different datasets.

Select a name and a location for it, and hit “Create”:

You’ll see that Visual Studio automatically created a test class called UnitTest1.cs:

using NUnit.Framework;

namespace NUnitTestProject1
{
    public class Tests
    {
        [SetUp]
        public void Setup()
        {
        }

        [Test]
        public void Test1()
        {
            Assert.Pass();
        }
    }
}

How to run Selenium C# tests from Visual Studio?

If you want to see and run the tests in the solution, you need to follow the below steps:

Open the Test Explorer (if it’s not already opened). You can do that from the View menu → Test Explorer. In this panel, you can see all available tests, grouped by project and test.
Currently, we only have the one that VS has created for us, but we can right-click on it (or any tree in the node) and run it. We’ll see that it passes and the time it took for the test to run:

Now let’s move on and see how to write our own Selenium WebDriver automated tests.

How to run your first Selenium C# test?

It’s time for some action 🙂 Now that I have covered the essentials of Selenium with C#, let’s run a simple automation test with Selenium C# that uses the NUnit framework.

Test Scenario

I’ll use a simple scenario to illustrate how to automate some basic steps using Selenium with C#. Here are the steps I want my test to execute:

Navigate to the https://www.lambdatest.com/selenium-playground/simple-form-demo web page.
Enter a text in the “Enter Message” input field.
Click “Get Checked value”.

Validate that the message is displayed.

Simple, right? Let’s go!

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, CI/CD, and more.

Test on Selenium Testing Tool Grid Cloud of 3000+ Desktop & Mobile Browsers.

Installing Selenium WebDriver using NuGet Package Manager

Before we start interacting with the browser, the web pages, and the WebElements in the DOM, we have to prepare our project.

For this, we need to add the Selenium.WebDriver NuGet package, which allows the test code to interact with the WebElements on the page using methods that are a part of the package. To add a NuGet package to the project, please follow the below-mentioned steps:

1- Right-click on the project name in the Solution Explorer → Select “Manage NuGet packages…”:

This will open the NuGet packages panel, where you can see the packages already installed on your project and add more.

2- In the Browse tab, search for “selenium”, and select Selenium.WebDriver from the results. From the details panel on the right-hand side, choose an option from the Version drop-down, then click Install. I’ll be using Selenium version 3.141.0 for this Selenium C# tutorial:

Alternatively, you can install NuGet packages from the command line by running this command in the project location:

dotnet add package Selenium.WebDriver --version 3.141.0

Now, if you go to the Installed tab, you will see that Selenium.WebDriver is added to the list of installed packages:

Note: You might need to use Selenium WebDriver commands to automate various browser actions. You can refer to our earlier article on Selenium WebDriver Commands in NUnit to learn more about it, which might come in handy while performing automated UI testing with Selenium C#.

Adding the Browser Driver

Another thing we need to set up before we start writing the test is to add a browser driver. I’ll be performing a test on Chrome browser for now, so I need to add ChromeDriver. It can also be added as a NuGet package, so follow the same steps as before to add Selenium.WebDriver.ChromeDriver.

One thing to make sure of here — install the same driver version as the browser you have installed on your machine. For example, I have Chrome 101.0.4951.67, so I need to install the same driver version:

You can check the browser version from Help → About Google Chrome.

You can use the browser of your choice, and you can add the drivers the same way, for example, Selenium.WebDriver.MSEdgeDriver (for Microsoft Edge), Selenium.WebDriver.GeckoDriver (for Mozilla Firefox).

Implementing Selenium C# test

Now, we should be ready to start our Selenium C# test. Let’s use the previously created class, but rename it to something meaningful:

And here is the Selenium C# test for the mentioned scenario:

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace SeleniumTutorial
{
    public class SeleniumTests
    {
        private IWebDriver driver;

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

        [Test]
        public void ValidateTheMessageIsDisplayed()
        {
            driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/simple-form-demo");
            driver.FindElement(By.Id("user-message")).SendKeys("LambdaTest rules");
            driver.FindElement(By.Id("showInput")).Click();
            Assert.IsTrue(driver.FindElement(By.Id("message")).Text.Equals("LambdaTest rules"), "The expected message was not displayed.");
        }

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

Selenium C# code walkthrough

The used packages are added at the beginning of the test class:

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

Then, we need to create a new instance of the IWebDriver:

private IWebDriver driver;

As a precondition to the test, we need to start the browser. I did this in the SetUp method because it’s something that will be used in all future tests, so here is where I instantiate the driver:

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

Next, there is our actual test. I used the previously mentioned [Test] attribute from NUnit, and inside the test method, the test steps:

To navigate to a specific URL, Selenium with C# uses the method Navigate().GoToUrl(), with the URL, passed as a string parameter:

driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/simple-form-demo");

Then, we need to interact with three WebElements on the page, which means we need to locate these elements. For this, we have the FindElement() and FindElements() methods in Selenium WebDriver. The FindElement() method returns a web element object, while the FindElements() returns a list of web elements. For the purpose of our test, FindElement() will do the job.

driver.FindElement(By.Locator("Value"));

The FindElement() method takes a By method parameter and returns the first element that matches that method.
The By class provides the mechanism to find the elements on our web page.
The locator is the strategy used to identify the element.

There are several Selenium locators strategies that we can use to identify the web elements based on their attributes:

ID — ID locator in Selenium uses the ID attribute of the element
Name — Name locator in Selenium uses the Name attribute of the element
LinkText and PartialLinkText — LinkText and PartialLinkText locators in Selenium applies to link elements
ClassName — ClassName locator in Selenium uses the Class attribute of the element
TagName — TagName locator in Selenium uses a tag name to identify the attribute
CssSelector — CssSelector locator in Selenium combines an element selector and a selector value to find the web element.
XPath — XPath locator in Selenium uses the HTML DOM structure to locate any element in a web page
The Value is the string value of that attribute.

You can refer to this Selenium locators cheat sheet to quickly navigate through all the Selenium locators with their easy-to-use syntax.

When using FindElement(), it’s a good practice to create a unique locator; otherwise, your test might interact with a different element than the intended one. You can use Chrome’s Developer Tools to find the best locator strategy for each element.

You can right-click on a WebElement on the page and select Inspect. This will open the Elements tab of the Developer Tools, where you can see the element’s information. Here is the code for the input text:

The recommended locator is Id because it’s usually faster. Luckily, we have unique Ids on all the elements we need, so we can use them going forward. The *SendKeys() *method in Selenium C# is used to enter text in input fields. It takes a string parameter:

driver.FindElement(By.Id("user-message")).SendKeys("LambdaTest rules");

The Click() method is used to simulate the mouse click:

 driver.FindElement(By.Id("showInput")).Click();

The Text is a string attribute that represents the inner value of the web element, and we use the Assert.IsTrue() method to validate that the message has the message we expect. I also like my test to display a message if it fails, making it easier to debug:

Assert.IsTrue(driver.FindElement(By.Id("message")).Text.Equals("LambdaTest rules"), "The expected message was not displayed.");

To close the browser at the end of the test, use the TearDown attribute and this method:

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

There are two similar methods in Selenium WebDriver:

The Close() method, which closes the current window.
The Quit() method, which closes all windows associated with the driver.

For the TearDown, I prefer the second one in case some of the tests open additional windows (remember that the TearDown method runs after each test).

Running the Selenium C# test

Now that the test is ready, you can build the project (right-click on the project name and select Build or use the Ctrl+B shortcut) and run the test locally. The test will be visible in the Test Explorer:

From here, you can run it just like you did the previous test. If everything goes well, you will see a browser window open up, navigate the web page, enter the text, and click the button. The test will pass, and close the browser window at the end.

How to run Selenium C# tests on cloud Selenium Grid?

What if you want to run the automated tests cross-platform or cross-browser? Or using a setup different from your own machine? These situations will likely happen quite often because we want our applications to work for all our users, and they will have various configurations set up on their computers.

The solution for this is porting the existing Selenium C# tests to a cloud-based Selenium Grid like LambdaTest. Cloud-based cross browser testing platforms like LambdaTest provides an online device farm of 3000+ browsers and operating systems to perform Selenium C# testing at scale. Here’s a glimpse of the LambdaTest cloud Selenium Grid:

The best part is that not much porting effort is involved in porting the existing tests from the local Selenium Grid to the LambdaTest cloud grid.

Here’s is my version of the code, updated to run the tests in LambdaTest Grid:

Implementation:

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Remote;
using System;
using System.Threading;

namespace SeleniumTutorial
{
    public class SeleniumTests
    {
        private static IWebDriver driver;
        public static string gridURL = "@hub.lambdatest.com/wd/hub";
        public static string LT_USERNAME = "LT_USERNAME"; // Add your LambdaTest username here
        public static string LT_ACCESS_KEY = "LT_ACCESS_KEY"; // Add your LambdaTest access key here

        [SetUp]
        public void Setup()
        {
            var desiredCapabilities = new DesiredCapabilities();
            desiredCapabilities.SetCapability("browserName", "Chrome");
            desiredCapabilities.SetCapability("platform", "Windows 11");
            desiredCapabilities.SetCapability("version", "101.0");
            desiredCapabilities.SetCapability("screenResolution", "1280x800");
            desiredCapabilities.SetCapability("user", LT_USERNAME);
            desiredCapabilities.SetCapability("accessKey", LT_ACCESS_KEY);
            desiredCapabilities.SetCapability("build", "Selenium C-Sharp");
            desiredCapabilities.SetCapability("name", "Selenium Test");
            driver = new RemoteWebDriver(new Uri("https://" + LT_USERNAME + ":" + LT_ACCESS_KEY + gridURL), desiredCapabilities, TimeSpan.FromSeconds(600));
        }

        [Test]
        public void ValidateTheMessageIsDisplayed()
        {
            driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/simple-form-demo");
            driver.FindElement(By.Id("user-message")).SendKeys("LambdaTest rules");
            driver.FindElement(By.Id("showInput")).Click();
            Assert.IsTrue(driver.FindElement(By.Id("message")).Text.Equals("LambdaTest rules"), "The expected message was not displayed.");
        }

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

Code Walkthrough:

Again, we have the packages are added:

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Remote;
using System;
using System.Threading;

Next, we declare our variables:

private static IWebDriver driver;
        public static string gridURL = "@hub.lambdatest.com/wd/hub";
        public static string LT_USERNAME = "LT_USERNAME"; // Add your LamdaTest username here
        public static string LT_ACCESS_KEY = "LT_ACCESS_KEY"; // Add your LamdaTest access key here

When using LambdaTest, you need to make sure you use your username and access key. You can find them on your LambdaTest Profile Section. A good idea is to store them as environment variables and read them from there. This way, in case any of the values change, you only need to update them in one place.

The biggest change, as you can see, is in the Setup:

        [SetUp]
        public void Setup()
        {
            var desiredCapabilities = new DesiredCapabilities();
            desiredCapabilities.SetCapability("browserName", "Chrome");
            desiredCapabilities.SetCapability("platform", "Windows 11");
            desiredCapabilities.SetCapability("version", "101.0");
            desiredCapabilities.SetCapability("screenResolution", "1280x800");
            desiredCapabilities.SetCapability("user", LT_USERNAME);
            desiredCapabilities.SetCapability("accessKey", LT_ACCESS_KEY);
            desiredCapabilities.SetCapability("build", "Selenium C-Sharp");
            desiredCapabilities.SetCapability("name", "Selenium Test");
            driver = new RemoteWebDriver(new Uri("https://" + LT_USERNAME + ":" + LT_ACCESS_KEY + gridURL), desiredCapabilities, TimeSpan.FromSeconds(600));
        }

DesiredCapabilities is a Selenium class used to configure browser attributes for cross-browser testing. You can use LambdaTest Capabilities Generator to create your desired setup:

The test has remained unchanged, I am still testing the same scenario:

[Test]
        public void ValidateTheMessageIsDisplayed()
        {
            driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/simple-form-demo");
            driver.FindElement(By.Id("user-message")).SendKeys("LambdaTest rules");
            driver.FindElement(By.Id("showInput")).Click();
            Assert.IsTrue(driver.FindElement(By.Id("message")).Text.Equals("LambdaTest rules"), "The expected message was not displayed.");
        }

And in the teardown, I only added a short sleep so the browser doesn’t close too quickly, and I see in the recording what happened:

[TearDown]

        public void TearDown()

        {

            Thread.Sleep(3000);

            driver.Quit();

        }

Executing Selenium C# tests on Cloud

Now run the test, the same as before, from Visual Studio. This time the browser will not open locally. But if you connect to your LambdaTest account, you will see in the LambdaTest Automation Tab that the test is running:

This is a fairly simple test, so it will finish fast, the same as it did on the local machine. But this time you can also see a recording of the test execution. I find this particularly helpful if the test fails and you want to see why. But I personally like to see the passed tests, too, because I want to make sure that the intended actions have been correctly executed, so I avoid false positives.

You can use the right-hand panel to navigate to a specific step and see what happened there:

Of course, you can use multiple setups to validate the scenario on multiple configurations, and, as the project grows, you can take advantage of the ability to run tests in parallel.

You can navigate to the LambdaTest Analytics Dashboard to use advanced features for analyzing the performance of your tests. From the Test Summary section, you can see all test results, along with their status and the total number of tests passed or failed. From the Test Overview section, you can see the snapshots of recently executed test runs.

If you are a developer or a tester and want to master the fundamentals of Selenium automation testing with C#, you can take the Selenium C# 101 certification to prove your credibility as a tester.

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

Perform manual or automated cross browser testing web on 3000+ browsers online. Deploy and scale faster with the most powerful cross browser testing tool online.

Conclusion

Using Selenium with C# and NUnit can be a great choice if you are just getting started with test automation. In this Selenium C# tutorial, we covered the main steps for getting started with a test automation project, from selecting the testing framework to identifying the WebElements, interacting with them, and adding validations. We’ve also seen how to run the tests remotely on a different setup and see the results and the recording.

How To Select Dropdown In Selenium C#

AndreeaDraniceanu — Mon, 21 Nov 2022 13:49:57 +0000

Dropdowns and multi-selects are extremely common in today’s web pages. Dropdowns can be a great option to allow your users to choose from several options without having to scroll through a whole page. In HTML, these web elements are defined by the tag < select >, with multiple < option > child tags representing the available options to choose from.

In this Selenium C# tutorial, I’ll show you how to select dropdown in Selenium C# and multiple select menus. Here, I will be running tests with different test data and demonstrate how to run them in parallel on the cloud Selenium Grid.

So, let’s get started!

Upload your app for testing within seconds using the LambdaTest cloud and perform mobile app testing right away. Find bugs early on, improve performance, quality, user experience and make the most of Mobile App Testing on LambdaTest.

How to get started with a Selenium project?

We first need to set up a new Selenium project in Visual Studio (or Visual Studio Code). For this Selenium C# tutorial, I will be using NUnit as a test framework. However, there are other frameworks available, such as XUnit or MSTest.

Step 1: Add the Selenium packages we will use in the project. To do this, right-click on the project name in the Solution Explorer pane, and select Manage NuGet packages:

Step 2: Search for and install:

Selenium.WebDriver: we need it to interact with the WebElements on the page.
Selenium.Support: it’s the package that enables us to work with dropdowns in Selenium.
Selenium.WebDriver.ChromeDriver (or a different driver if you want to test on another browser): allows the interaction with the browser.

You will then have them in the list of installed packages:

In the next section of this article on how to select dropdown in Selenium C#, we will learn about the SelectElement Class in Selenium.

The SelectElement Class in Selenium C

The SelectElement class in Selenium C# is part of the Selenium.Support NuGet package. It allows us to interact with the dropdown and multiple select menus on web pages.

It also allows you to select and deselect options from the dropdown, validate if it allows multiple selections, see all the available options, and see what options are currently selected.

To understand how to select dropdown in Selenium C#, let me show how a dropdown looks in the Inspector from Developer Tools:

This is a simple dropdown that allows you to choose a day of the week.

Methods in the SelectElement class:

SelectByValue(): will select the option based on the value from the HTML.
SelectByText(): used to select the dropdown option based on the displayed text.
SelectByIndex(): selects the option based on index. The index starts from 0, not 1!
SelectedOption(): returns the selected WebElement.
AllSelectedOptions(): returns a list of the selected WebElements. It should be used only on multiple selections.
IsMultiple(): a boolean attribute with the value True if the selection allows multiple selections and False if it doesn’t.
DeelectByValue(): will deselect the option based on its value.
DeselectByText(): used to deselect the dropdown option based on the text.
DeselectByIndex(): deselects the option based on index.
DeselectAll(): will deselect all previously selected options.

These are the main things you need to know while you are learning how to select dropdown in Selenium C#. Now let’s see it in action.

How to select dropdown in Selenium C# with an example?

I’m going to demonstrate how to select dropdown in Selenium C# with a simple scenario.

Test Scenario

Navigate to the LambdaTest Playground Dropdown Demo page.
Select Wednesday from the dropdown.
Validate that the text displays the selected day of the week.

Implementation

Before you get started, make sure you create a new NUnit test project in Visual Studio or Visual Code, and add the following NuGet packages:

Selenium.WebDriver — I’m using version 3.141.0 in this tutorial.
Selenium.Support — should have the same version as Selenium.WebDriver.
Selenium.Support.ChromeDriver, Selenium.WebDriver.IEDriver, Selenium.Firefox.WebDriver, etc.— depending on the browser you want to use in your test. Going forward, I will use Google Chrome for my tests, but feel free to choose your favorite browser.

Then, in a new class, we need to write the following Selenium C# code to perform the dropdown test:

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;
using System;
using OpenQA.Selenium.Remote;

namespace SeleniumTutorial
{
    public class DropDown
    {
        private static IWebDriver driver;
        public static string gridURL = "@hub.lambdatest.com/wd/hub";
        public static string LT_USERNAME = "LT_USERNAME";
        public static string LT_ACCESS_KEY = "LT_ACCESS_KEY";

        [SetUp]
        public void Setup()
        {
            var desiredCapabilities = new DesiredCapabilities();
            desiredCapabilities.SetCapability("browserName", "Chrome");
            desiredCapabilities.SetCapability("platform", "Windows 11");
            desiredCapabilities.SetCapability("version", "101.0");
            desiredCapabilities.SetCapability("screenResolution", "1280x800");
            desiredCapabilities.SetCapability("user", LT_USERNAME);
            desiredCapabilities.SetCapability("accessKey", LT_ACCESS_KEY);
            desiredCapabilities.SetCapability("build", "Selenium C-Sharp");
            desiredCapabilities.SetCapability("name", "Selenium Test");
            driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), desiredCapabilities, TimeSpan.FromSeconds(600));
        }

        [Test]
        public void ValidateDropDownSelection()
        {
            string dayOfTheWeek = "Wednesday";
            driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/select-dropdown-demo");
            SelectElement dropDown = new SelectElement(driver.FindElement(By.Id("select-demo")));
            dropDown.SelectByValue(dayOfTheWeek);
            string actualText = driver.FindElement(By.CssSelector(".selected-value.text-size-14")).Text;
            Assert.True(actualText.Contains(dayOfTheWeek), $"The expected day of the week {dayOfTheWeek} was not selected. The actual text was: {actualText}.");
        }

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

Code Walkthrough

Now let me guide you through the lines of code to get a clear picture of how to select dropdown in Selenium C#.

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;
using System;
using OpenQA.Selenium.Remote;

This part contains the packages used in the class.

private static IWebDriver driver;
public static string gridURL = "@hub.lambdatest.com/wd/hub";
public static string LT_USERNAME = "LT_USERNAME";
public static string LT_ACCESS_KEY = "LT_ACCESS_KEY";

The first line, above, is where I declare the WebDriver, and the next variables are related to my LambdaTest account.

LambdaTest is a cloud-based cross browser testing platform that allows you to perform Selenium C# automation testing at scale over an online browser farm of 3000+ browsers and operating systems. With LambdaTest, you can run your automated C# test scripts faster and more efficiently by running them in parallel on the fastest cloud-based infrastructure. Therefore, you can test more in less time and ship quality products faster.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, CI/CD, and more.

Replace LT_USERNAME and LT_ACCESS_KEY with your own credentials, i.e., username and the access key from your LambdaTest Profile Section.

[SetUp]
public void Setup()
{
      var desiredCapabilities = new DesiredCapabilities();
      desiredCapabilities.SetCapability("browserName", "Chrome");
      desiredCapabilities.SetCapability("platform", "Windows 11");
      desiredCapabilities.SetCapability("version", "101.0");
      desiredCapabilities.SetCapability("screenResolution", "1280x800");
      desiredCapabilities.SetCapability("user", LT_USERNAME);
      desiredCapabilities.SetCapability("accessKey", LT_ACCESS_KEY);
      desiredCapabilities.SetCapability("build", "Selenium C-Sharp");
      desiredCapabilities.SetCapability("name", "Selenium Test");
      driver = new RemoteWebDriver(new Uri($"https://{LT_USERNAME}:{LT_ACCESS_KEY}{gridURL}"), desiredCapabilities, TimeSpan.FromSeconds(600));
}

Using the [SetUp] annotation in NUnit, I let my code know that this method needs to be run before each of my tests. Then, inside it, I set the driver’s capabilities based on the browser type, version, OS, and screen resolution I want to use in my tests.

I use the Capabilities Generator from LambdaTest, so I don’t have to enter them by hand:

This way, I just select my configuration, select the C# language, and simply copy them into my code.

Then, in the new driver instance, I use the capabilities I copied before and the URL created by combining my username, access key, and the LambdaTest Selenium Grid URL. I like using string interpolation because it reads much easier than concatenation.

Moving on to the test, let me break it down a bit more:

The [Test] annotation marks the method beneath it as a test method. After the project is built, I can see this test in the Test Explorer and run it from there:

string dayOfTheWeek = "Wednesday";

This one is pretty straightforward. I created a string variable to store the value I want to test because I am using it in more than one place, and I don’t want to update it in multiple places if the value changes.

driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/select-dropdown-demo");

The Navigate() method in Selenium C# instructs the browser to navigate to a specific location, in my case, to the given URL (using the GoToUrl() method).

The next part is the actual dropdown selection, which shows how to select dropdown in Selenium C#.

SelectElement dropDown = new SelectElement(driver.FindElement(By.Id("select-demo")));
dropDown.SelectByValue(dayOfTheWeek);

The dropdown web element in Selenium C# has the type SelectElement and has to be declared as a new instance of the SelectElement class. The dropdown web element has an Id value, so I will use the Id locator.

You can use the browser’s Developer Tools to inspect an element (right-click on the element and select Inspect, and you will see its HTML attributes):

If you’re not familiar with Selenium C# element interaction, you can check out my previous tutorial on automation testing with Selenium C#.

I prefer to use SelectByValue() or SelectByText() for selecting the dropdown value, which in this particular case would accept the same parameter. Using SelectByIndex() also works, but then I would need to know the exact order of the options and ensure that the order doesn’t change. For a day of the week dropdown, that’s fine, but in most cases, the available options might change.

The last part is the validation, where I verify that the app works as expected:

string actualText = driver.FindElement(By.CssSelector(".selected-value.text-size-14")).Text;
Assert.True(actualText.Contains(dayOfTheWeek), $"The expected day of the week {dayOfTheWeek} was not selected. The actual text was: {actualText}.");

I identified the text displayed based on its CSS Selector, then used the Assert class from NUnit to check that it contains the day of the week I previously selected. In case the NUnit assertion fails, the test will display a message — I am using string interpolation to insert the string variables in the text.

The final method is executed after each test, and what it does is close all driver instances:

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

Try an online Selenium Testing Grid to run your browser automation testing scripts. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

How to select dropdown in Selenium C# and run the test in parallel?

In this section of this article on how to select dropdown in Selenium C#, I will show you how you can run the same test with different data. The steps will remain the same, so we want to use the same method with different parameters.

With NUnit, this is achieved with the TestCase attribute. And since we will have more tests now, it’s a good idea to perform parallel testing, so they don’t take so long to execute. For this, we have the Parallelizable attribute. However, NUnit parallelization is not thread-safe, so the tests in a class share the same instance of the driver which might result in unexpected failures.

So the test method now should look like this:

[Test]
[TestCase("Monday")]
[TestCase("Tuesday")]
[TestCase("Wednesday")]
[TestCase("Thursday")]
[TestCase("Friday")]
[TestCase("Saturday")]
[TestCase("Sunday")]
[Parallelizable(ParallelScope.All)]
public void ValidateDropDownSelection(string dayOfTheWeek)
{    driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/select-dropdown-demo");
    SelectElement dropDown = new SelectElement(driver.FindElement(By.Id("select-demo")));
    dropDown.SelectByValue(dayOfTheWeek);
    string actualText = driver.FindElement(By.CssSelector(".selected-value.text-size-14")).Text;
    Assert.True(actualText.Contains(dayOfTheWeek), $"The expected day of the week {dayOfTheWeek} was not selected. The actual text was: {actualText}.");
}

Code Walkthrough

[Test]
[TestCase("Monday")]
[TestCase("Tuesday")]
[TestCase("Wednesday")]
[TestCase("Thursday")]
[TestCase("Friday")]
[TestCase("Saturday")]
[TestCase("Sunday")]
[Parallelizable(ParallelScope.All)]

With these lines of code, we instruct the test to run once for each day of the week string value.

The [Parallelizable(ParallelScope.All)] line means that the test can be run in parallel with other tests at the same level — in our case, the method level.

There are other scopes of parallelization in NUnit:

All: the test and its children can run in parallel with others at the same level.
Children: the scope is defined at the class or assembly level, and child tests of the class or assembly can run in parallel.
Fixtures: fixtures can run in parallel.
Self: the test itself can run in parallel with other tests.

public void ValidateDropDownSelection(string dayOfTheWeek)

The test method also takes a parameter now. You can see I removed the line:

string dayOfTheWeek = "Wednesday";

This is because the value of the dayOfTheWeek variable now comes from the TestCase attribute.

Everything else stays the same. Now you will see seven tests available in the Test Explorer. When you run them on the Selenium Grid, they will also run in parallel:

You can see the tests in LamdaTest in real-time while they are running and also see the video recordings afterwards:

On the left-hand side, there is the recording, and the right side displays the test steps, the step duration, and the result. If you click on the timestamp of a step, the video will jump to that point so you can see the action in the recording.

You can analyze your test performance through the LambdaTest Analytics Dashboard. The Test Summary section shows all test results, their status, and the total number of tests passed or failed. The Test Overview section shows snapshots of recently executed test runs.

LambdaTest also provides some advanced features like HyperExecute, which helps in achieving up to 70% faster execution of your Selenium NUnit test cases. HyperExecute is a blazing fast test end-to-end test orchestration cloud that allows you to group and distribute tests intelligently across runner environments.

So far, we have seen how to select dropdown in Selenium C#. In the next section, we will learn to handle multiple select menus.

How to handle multiple select in Selenium C#?

In this section of this article on how to select dropdown in Selenium C#, I want to show you how to work with a multi select dropdown using Selenium C#. We’ve already discussed the available methods, so let’s jump in.

Test Scenario

Navigate to the LambdaTest Playground Dropdown Demo page.
Verify that the Multi-Select List Demo allows multiple selections — if not, display a message.
If it does allow multiple selections, select Florida, New York, and Texas
Deselect all values.

Implementation

The SetUp and TearDown methods are the same as before, so I will just show you the test method code:

[Test]
public void ValidateMultipleSelection()
{
    driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/select-dropdown-demo");
    string[] selectedStates = { "Florida", "New York", "Texas" };
    var multiSelect = new SelectElement(driver.FindElement(By.Id("multi-select")));
    Assert.IsTrue(multiSelect.IsMultiple, "The Select does not allow multiple selection.");
    foreach (var state in selectedStates)
    {
        multiSelect.SelectByText(state);
    }
    multiSelect.DeselectAll();
}

Code Walkthrough

The first few lines don’t have anything new. We need to navigate to the web page (the same as before), create an array of strings with the values we want to select, and declare the multiSelect dropdown using the FindElement() method in Selenium.

driver.Navigate().GoToUrl("https://www.lambdatest.com/selenium-playground/select-dropdown-demo");
    string[] selectedStates = { "Florida", "New York", "Texas" };
    var multiSelect = new SelectElement(driver.FindElement(By.Id("multi-select")));

In Developer Tools, you can see that the select element has an ID, which I used above:

Next, I want to validate that the SelectElement allows multiple selections. As I previously mentioned, the IsMultiple attribute will let me know if I can select multiple options or not.

Assert.IsTrue(multiSelect.IsMultiple, "The Select does not allow multiple selection.");

If this assertion fails, the test will simply fail and stop executing the following steps. Of course, I expect it to pass, and if multiple selections is allowed, I want to perform the next actions:

foreach (var state in selectedStates)
{
    multiSelect.SelectByText(state);
}

This is a simple loop that goes through each value of the selectedStates array, and then selects the value, using the text this time — once again, the text and the value of the options are the same.

The last step deselects all the previously selected values:

multiSelect.DeselectAll();

Are you a tester looking to hone your craft? Prove your worth by earning the Selenium C# 101 certification from LambdaTest:

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

Test on Selenium Automation Grid Cloud of 3000+ Desktop & Mobile Browsers.

Conclusion

If you followed this tutorial blog on how to select dropdown in Selenium C#, you should now know how to select or deselect a dropdown value using Selenium C#, how to work with multiple selects, and also how to run the same test with different test data in NUnit.

And as a bonus, you could also see how to parallelize the tests and run them on the remote Selenium grid to save the test execution time.