How to Run Multiple NUnit Test Cases

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: TestMu AI 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: TestMu AI 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("[email protected]", "")]
        [TestCase("[email protected]", "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();
        }
    }
}

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.

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.

Note: Perform NUnit automation testing on cloud Selenium grid. Try TestMu AI Today!

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 TestMu AI – 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 TestMu AI, 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 TestMu AI, 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("[email protected]", "")]
        [TestCase("[email protected]", "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 TestMu AI 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 TestMu AI:

The rest of the code is the same.

Running multiple NUnit test cases in parallel on TestMu AI 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 TestMu AI.

Test Execution on Cloud

Starting the test execution on the TestMu AI 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 TestMu AI 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.