Nunit Data Driven Test

Code Examples

[TestCase(“BG”, “1000”, “Sofija”)] [TestCase(“BG”, “5000”, “Veliko Turnovo”)] [TestCase(“CA”, “M5S”, “Toronto”)] [TestCase(“GB”, “B1”, “Birmingham”)] [TestCase(“DE”, “01067”, “Dresden”)] public void TestZippopotamus( string countryCode, string zipCode, string expectedPlace) { … }

Unit testing C# with NUnit and .NET Core

This tutorial takes you through an interactive experience building a sample solution step-by-step to learn unit testing concepts. If you prefer to follow the tutorial using a pre-built solution, view or download the sample code before you begin. For download instructions, see Samples and Tutorials.

This article is about testing a .NET Core project. If you’re testing an ASP.NET Core project, see Integration tests in ASP.NET Core.

nunit parameterized test

## Tìm hiểu về NUnit Parameterized Test

NUnit Parameterized Test là một tính năng mạnh mẽ của NUnit cho phép chúng ta định nghĩa các bài kiểm tra có tham số. Điều này giúp chúng ta mở rộng khả năng kiểm thử của chương trình bằng cách tự động thực hiện các bài kiểm tra với nhiều giá trị đầu vào khác nhau.

Tính năng này rất hữu ích khi chúng ta cần kiểm tra một phương thức hoặc một tập hợp các phương thức với nhiều trường hợp khác nhau. Thay vì viết nhiều bài kiểm tra riêng lẻ cho mỗi trường hợp, chúng ta có thể sử dụng NUnit Parameterized Test để chỉ định danh sách các tham số và NUnit sẽ tự động thực hiện các bài kiểm tra với tất cả các giá trị tham số đã được chỉ định.

## Cách sử dụng NUnit Parameterized Test

Để sử dụng NUnit Parameterized Test, chúng ta cần thực hiện các bước sau:

1. Định nghĩa một phương thức kiểm thử và sử dụng attribute `[TestCase]` để đánh dấu phương thức đó là một bài kiểm tra có tham số.2. Chỉ định các tham số cho bài kiểm tra trong attribute `[TestCase]`. Chúng ta có thể chỉ định các giá trị cụ thể, hoặc sử dụng các tham số động bằng cách sử dụng attribute `[TestCaseSource]`.3. Sử dụng các phương thức Assert để kiểm tra các kết quả.

Dưới đây là một ví dụ minh họa:

“`csharp[TestFixture]public class CalculatorTests{[Test][TestCase(2, 3, 5)][TestCase(5, 5, 10)]public void Test_Addition(int a, int b, int expectedResult){var calculator = new Calculator();var result = calculator.Add(a, b);Assert.AreEqual(expectedResult, result);}}“`

Trong ví dụ trên, chúng ta định nghĩa một lớp kiểm thử `CalculatorTests` và một bài kiểm tra có tham số `Test_Addition`. Chúng ta sử dụng attribute `[TestCase]` để chỉ định các giá trị tham số cho bài kiểm tra. NUnit sẽ tự động thực hiện bài kiểm tra hai lần, một lần với tham số (2, 3, 5) và một lần với tham số (5, 5, 10).

## Các tình huống phổ biến và câu hỏi thường gặp

### 1. Làm thế nào để hiển thị tất cả các kết quả kiểm tra trong NUnit Parameterized Test?

Để hiển thị tất cả các kết quả kiểm tra trong NUnit Parameterized Test, chúng ta có thể sử dụng attribute `[ValueSource]`. Nó cho phép chúng ta chỉ định một phương thức trả về danh sách các tham số, và tất cả các giá trị trong danh sách đó sẽ được sử dụng làm các bài kiểm tra.

### 2. Tôi có thể sử dụng các loại dữ liệu động trong NUnit Parameterized Test không?

Có, chúng ta có thể sử dụng các loại dữ liệu động trong NUnit Parameterized Test. Chúng ta chỉ cần sử dụng attribute `[TestCaseSource]` và chỉ định một phương thức trả về danh sách các tham số. Phương thức này có thể đọc các giá trị từ một cơ sở dữ liệu, tệp hoặc các nguồn dữ liệu khác.

### 3. Làm thế nào để chỉ định tên của bài kiểm tra trong NUnit Parameterized Test?

Chúng ta có thể chỉ định tên của bài kiểm tra trong NUnit Parameterized Test bằng cách sử dụng attribute `[TestCase]`. Chúng ta chỉ cần thêm một tham số chuỗi vào attribute `[TestCase]`, và NUnit sẽ sử dụng giá trị này làm tên của bài kiểm tra.

### 4. Làm thế nào để kiểm tra ngoại lệ trong NUnit Parameterized Test?

Để kiểm tra ngoại lệ trong NUnit Parameterized Test, chúng ta có thể sử dụng attribute `[ExpectedException]`. Chúng ta chỉ cần đặt attribute này trên phương thức kiểm thử và chỉ định loại ngoại lệ mà chúng ta mong muốn nhận được. NUnit sẽ kiểm tra xem phương thức có ném ra ngoại lệ tương thích không.

## Kết luận

NUnit Parameterized Test là một tính năng mạnh mẽ trong NUnit cho phép chúng ta viết và thực hiện các bài kiểm tra có tham số. Điều này giúp chúng ta tăng cường khả năng kiểm thử của chương trình bằng cách tự động thực hiện nhiều trường hợp kiểm tra với các giá trị tham số khác nhau. Bài viết này đã giới thiệu sơ lược về NUnit Parameterized Test và cung cấp các tình huống phổ biến và câu hỏi thường gặp liên quan đến tính năng này.

Hình ảnh liên quan đến chủ đề nunit data driven test

Link bài viết: nunit data driven test.

Xem thêm thông tin về bài chủ đề này nunit data driven test.

Data-Driven Tests with NUnit – Gigi Labs
Data driven testing in C# with NUnit and RestSharp
Parameterized Tests – NUnit Docs
c# – Data-driven testing in NUnit? – Stack Overflow
NUnit Tutorial: Parameterized Tests With Examples
NUnit VS Inbuilt TDD – AnAr Solutions
Data Driven Testing Using Selenium (webdriver) in C#
MsTest vs NUnit: Which Should You Use And Why? – Ultimate QA
Data Driven Testing – Tutorialspoint
Kiểm thử tự động với NUnit theo hướng Data-Driven
nunit-data-driven-tests/GivenPrimeFactorCalculator.cs at master
Data Driven Testing with Nunit 3 – Assert.This
Chapter 7 – Data-Driven Tests – Test Automation University
Data driven tests by convention – Damir’s Corner

Xem thêm: https://hanoilaw.vn/category/blog blog

NUnit Tutorial: Parameterized Tests With Examples

Himanshu Sheth

Posted On: December 2, 2020

148344 Views

14 Min Read

This article is a part of our Content Hub. For more in-depth resources, check out our content hub on Selenium NUnit Tutorial.

Cross browser testing has become an integral part of the test process to ensure the product experience and behavior remains consistent across different combinations of web browsers, devices, and operating systems. As testing has to be performed on varied combinations, it can lead to code duplication as a lot of test methods will be doing the same thing but on different input combinations. I have come across many such situations during the code optimization process when I felt that a part of the code is either duplicated or redundant.

One important lesson I learned from these situations is that you should never leave such activities for the future as it becomes more challenging to optimize with the increase in LOC (Lines of Code). This is where a parameterized test can be beneficial as it enables testing the code/methods against different input values. Test parameterization should be explored in cross browser testing as the same tests need to be executed on different web browsers and different versions of the same web browser. In this blog, we learn how to execute NUnit parameterized tests with examples.

TABLE OF CONTENT

Data Driven Testing in NUnit for Playwright with C# .NET

TestCase Attribute

The TestCase attribute in NUnit marks a method with parameters as a test method. It also provides the inline data that needs to be used when that particular method is invoked. It can appear one or more times on the test method, with each appearance carrying values for the test case. Make more copies of the attribute if you want multiple cases. The data type of the values provided to the TestCase attribute should match with that of the arguments used in the actual test case.

This attribute that helps in coming up with an NUnit parameterized test also supports several additional named parameters like Author, Category, Description, ExpectedResult, TestName, etc. The execution order of the TestCase attribute can vary when used in combination with other data-providing attributes.

Demonstration – [TestCase] Attribute

The search for ‘LambdaTest’ on DuckDuckGo is carried out on the following browser + OS combinations.

The complete implementation is below:

Code WalkThrough

Step 1 – The data of IWebDriver is stored per-thread basis, and that is the reason for using the ThreadLocal class.

public class ParallelLTTests

ThreadLocal driver = new ThreadLocal();

Step 2 – The input combinations of browser, version, and platform constitute the parameters for the test case. These are supplied via the TestCase attribute. As the test has to be performed on four combinations, there are four occurrences of the attribute. The TestCase attribute is under the Test attribute, which defines the start of a test case.

As we want the test and its descendants to execute in parallel with other tests at the same level, ParallelScope is set to All using the Parallelizable attribute.

[Test]

[TestCase(“chrome”, “72.0”, “Windows 10”)]

[TestCase(“internet explorer”, “11.0”, “Windows 10”)]

[TestCase(“Safari”, “11.0”, “macOS High Sierra”)]

[TestCase(“MicrosoftEdge”, “18.0”, “Windows 10”)]

[Parallelizable(ParallelScope.All)]

Step 3 – We have not used the SetUp attribute as the steps being performed as a part of that attribute, i.e., creating instances of a remote Selenium WebDriver, setting browser capabilities, etc., are shifted to the TestCase attribute.

public void DuckDuckGo_TestCase_Demo(String browser, String version, String os)

String username = “user-name”;

String accesskey = “access-key”;

String gridURL = “@hub.lambdatest.com/wd/hub”;

DesiredCapabilities capabilities = new DesiredCapabilities();

capabilities.SetCapability(“user”, username);

capabilities.SetCapability(“accessKey”, accesskey);

capabilities.SetCapability(“browserName”, browser);

capabilities.SetCapability(“version”, version);

capabilities.SetCapability(“platform”, os);

Step 4 – The search box on DuckDuckGo is located using the XPath locator, for which we made use of the browser’s Inspect Tool. A search term is entered in the search box to perform the search operation.

driver.Value.Url = “https://www.duckduckgo.com”;

IWebElement element = driver.Value.FindElement(By.XPath(“//*[@id=’search_form_input_homepage’]”));

element.SendKeys(“LambdaTest”);

/* Submit the Search */

element.Submit();

Step 5 – The resources used by the Selenium WebDriver instance is released as part of the TearDown attribute.

[TearDown]

public void Cleanup()

……………….

// Terminates the remote webdriver session

driver.Value.Quit();

As seen in the execution snapshot, the data passed in the TestCase attribute is used as parameters for executing tests in DuckDuckGo_TestCase_Demo(String browser, String version, String os).

As parallelism is enabled, the DuckDuckGo_TestCase_Demo test is executed on four different input combinations (supplied via the TestCase attribute) in one shot.

This NUnit Tutorial for beginners and professionals will help you learn how to use NUnit framework with Selenium C# for performing Selenium automation testing.

What is the difference between NUnit and MSTest?

NUnit and MSTest are both open source frameworks, but they are different in many ways. NUnit is ported from JUnit automated testing framework, is well-matured, while MSTest is relatively new. MSTest comes pre-bundled with Visual Studio, due to which many developers prefer MSTest over other frameworks, including NUnit.

Got Questions? Drop them on LambdaTest Community. Visit now

#17 - Data Driven Testing using NUnit for Selenium with C# .NET — #17 – Data Driven Testing using NUnit for Selenium with C# .NET

TestFixture Attribute

The TestFixture NUnit attribute marks a class that contains tests. Parameterized and generic test fixtures were introduced in NUnit 2.5. For an NUnit parameterized test, argument values are passed to the TestFixture NUnit attribute. The NUnit framework constructs a separate instance of TestFixture for each set of arguments.

From NUnit 2.5, test fixtures can take constructor arguments. In the example shown below, the test fixture would be instantiated by the NUnit framework three times, passing each set of arguments to the appropriate constructor.

[TestFixture(“chrome”, “72.0”, “Windows 10”)]

[TestFixture(“internet explorer”, “11.0”)]

[TestFixture(“Safari”, 11)]

Demonstration – [TestFixture] Attribute

A search for ‘LambdaTest’ is performed on the following browser and OS combinations.

The complete implementation is below:

Code WalkThrough

Step 1 – The browser and platform combinations are specified as arguments to the TestFixture attribute.

[TestFixture(“chrome”, “72.0”, “Windows 10”)]

[TestFixture(“internet explorer”, “11.0”, “Windows 10”)]

[TestFixture(“Safari”, “11.0”, “macOS High Sierra”)]

[TestFixture(“MicrosoftEdge”, “18.0”, “Windows 10”)]

[Parallelizable(ParallelScope.All)]

Step 2 – The arguments supplied via the TestFixture NUnit attribute are passed to the constructor that has three parameters of type String.

public ParallelLTTests(String browser, String version, String os)

this.browser = browser;

this.version = version;

this.os = os;

Step 3 – The implementation related to the instantiation of WebDriver and setting up the capabilities for testing on the remote Selenium grid is added to the SetUp attribute.

[SetUp]

public void Init()

String username = “user-name”;

String accesskey = “access-key”;

String gridURL = “@hub.lambdatest.com/wd/hub”;

DesiredCapabilities capabilities = new DesiredCapabilities();

……………….

Step 4 – The implementation of de-initialization remains unchanged and is included as a part of the TearDown attribute.

Shown below is the execution snapshot where it is observed that ParallelLTTests constructor is called four times, i.e., the number of times the TestFixture was instantiated by the NUnit framework.

What Is Parameterization In NUnit?

NUnit is a popular C# testing framework extensively employed for cross-browser testing, owing to its seamless integration with the Selenium test suite. Starting from NUnit 2.5, it has offered support for parameterized tests, allowing test methods to accept parameters. Various NUnit attributes facilitate the indication of which arguments the framework should provide. While some attributes permit specifying arguments directly within the method, others utilize a separate method or field for this purpose.

We will use Visual Studio 2019 (Community Edition) for development, which can be downloaded from here.

Note: This blog will only focus on creating NUnit parameterized test examples that will aid you in the process of cross browser testing or automated browser testing.

Master .NET and C# Unit Testing with NUnit and Moq : Data-Driven Testing

Summary

In this blog, we had a look at some of the widely used attributes in the NUnit framework that are used for test parameterization, including TestFixture NUnit. Apart from the attributes that we covered in the blog, there are other attributes that aid in creating parameterized tests in NUnit framework. However, many of those NUnit attributes are not useful for test scenarios related to cross browser testing or automated browser testing.

Cross browser testing on the local Selenium grid is not scalable; hence, it is recommended to perform automated browser testing on a remote Selenium grid. When choosing an attribute for an NUnit parameterized test, you should also look at the complexities involved in adding/removing test cases. To summarize, NUnit parameterized tests are extremely useful in cutting down duplication in tests that can unnecessarily bloat the test code’s size.

I hope the NUnit parameterized test example I have showcased above will help make a difference in your test strategies!

Happy testing!

Kiểm thử là một quá trình quan trọng trong quá trình phát triển phần mềm để đảm bảo rằng các chức năng và tính năng hoạt động đúng như mong đợi. NUnit là một framework kiểm thử đơn vị được sử dụng phổ biến cho ứng dụng.NET. Một trong những tính năng quan trọng của NUnit là khả năng thực hiện các kiểm thử có dữ liệu, cho phép bạn chạy cùng một kiểm thử với nhiều bộ dữ liệu đầu vào khác nhau. Trên thực tế, việc sử dụng kiểm thử có dữ liệu trong NUnit có thể giúp tiết kiệm thời gian và tăng tính mở rộng của kiểm thử.

Cách thiết kế kiểm thử có dữ liệu trong NUnit:

NUnit cung cấp hai đánh dấu quan trọng để thiết kế kiểm thử có dữ liệu: [TestCase] và [TestCaseSource].

– Đánh dấu [TestCase] cho phép bạn chỉ định các giá trị đầu vào trực tiếp trong mã kiểm thử.– Đánh dấu [TestCaseSource] cho phép bạn chỉ định một nguồn dữ liệu bên ngoài để tạo ra các bộ dữ liệu đầu vào cho kiểm thử. Nguồn dữ liệu có thể là một mảng, một danh sách, hoặc một tệp CSV.

Ngoài ra, NUnit cũng hỗ trợ sử dụng object để chứa các giá trị đầu vào cho kiểm thử. Điều này giúp tăng tính mô đun và khả năng kiểm soát của kiểm thử.

Kiểu dữ liệu đầu vào cho kiểm thử có dữ liệu:

Trong kiểm thử có dữ liệu, bạn có thể sử dụng các kiểu dữ liệu cơ bản như int, string, bool, float, và các kiểu dữ liệu phức tạp như các lớp hoặc các struct. Bạn cũng có thể sử dụng các kiểu dữ liệu từ một nguồn dữ liệu ngoài như tệp CSV.

Các tùy chọn cấu hình cho kiểm thử có dữ liệu:

NUnit cung cấp ba tùy chọn cấu hình cho kiểm thử có dữ liệu:

1. Tùy chọn chạy kiểm thử theo từng bộ dữ liệu đầu vào: Điều này cho phép bạn chạy kiểm thử một lần với mỗi bộ dữ liệu đầu vào. Nếu có nhiều bộ dữ liệu, tất cả các kiểm thử sẽ được chạy lần lượt dựa trên từng bộ dữ liệu.

2. Tùy chọn chạy tất cả các bộ dữ liệu đầu vào cùng một lúc: Điều này cho phép bạn chạy tất cả các kiểm thử cùng một lúc với tất cả các bộ dữ liệu đầu vào. Kết quả của các kiểm thử sẽ được tổng hợp thành một kết quả duy nhất.

3. Tùy chọn chạy từng bộ dữ liệu đầu vào theo thứ tự ngẫu nhiên: Điều này cho phép bạn chạy kiểm thử với tất cả các bộ dữ liệu đầu vào theo thứ tự ngẫu nhiên. Điều này giúp đảm bảo rằng kiểm thử không bị ảnh hưởng bởi thứ tự của các bộ dữ liệu.

Tích hợp kiểm thử có dữ liệu với NUnit Test Explorer:

Để tích hợp kiểm thử có dữ liệu với NUnit Test Explorer, bạn cần cài đặt NUnit Test Adapter. Sau đó, bạn có thể đánh dấu kiểm thử có dữ liệu để xuất hiện trong NUnit Test Explorer. Điều này giúp bạn dễ dàng quản lý và chạy các kiểm thử có dữ liệu.

Lợi ích của kiểm thử có dữ liệu trong NUnit:

Kiểm thử có dữ liệu trong NUnit mang lại nhiều lợi ích quan trọng:

1. Giảm thời gian thiết kế kiểm thử: Bằng cách sử dụng kiểm thử có dữ liệu, bạn có thể thiết kế một kiểm thử duy nhất và áp dụng nó cho nhiều bộ dữ liệu đầu vào khác nhau. Điều này giúp tiết kiệm thời gian và công sức trong việc xây dựng các kiểm thử.

2. Tăng tính mở rộng và bảo trì của kiểm thử: Việc sử dụng kiểm thử có dữ liệu giúp tạo ra một tập hợp các bộ dữ liệu đầu vào mà kiểm thử có thể kiểm tra. Khi có thay đổi trong code, bạn chỉ cần cập nhật một kiểm thử duy nhất thay vì cập nhật và duy trì nhiều kiểm thử riêng lẻ.

3. Phát hiện lỗi dễ dàng và nhanh chóng: Bằng cách chạy kiểm thử với nhiều bộ dữ liệu đầu vào khác nhau, bạn có thể phát hiện các lỗi nhanh chóng và dễ dàng hơn. Điều này giúp tăng độ tin cậy và chất lượng của ứng dụng.

4. Tăng cường khả năng tái sử dụng của kiểm thử: Việc sử dụng kiểm thử có dữ liệu giúp tạo ra các bộ dữ liệu đầu vào độc lập với code. Điều này cho phép bạn tái sử dụng các bộ dữ liệu đầu vào cho các kiểm thử khác mà không cần chỉnh sửa code.

FAQs:

1. Như vậy, NUnit có hỗ trợ kiểm thử có dữ liệu từ tệp CSV không?– Có, bạn có thể sử dụng đánh dấu [TestCaseSource] để chỉ định một tệp CSV làm nguồn dữ liệu cho kiểm thử.

2. Tôi có thể sử dụng kiểu dữ liệu phức tạp như lớp hoặc struct trong kiểm thử có dữ liệu của NUnit không?– Đúng, NUnit hỗ trợ sử dụng các kiểu dữ liệu phức tạp như lớp hoặc struct trong kiểm thử có dữ liệu.

3. Làm thế nào để chạy kiểm thử có dữ liệu theo thứ tự ngẫu nhiên trong NUnit?– Bạn có thể sử dụng tùy chọn cấu hình của NUnit để chạy kiểm thử theo thứ tự ngẫu nhiên.

4. Có mất nhiều thời gian hơn để chạy kiểm thử có dữ liệu trong NUnit so với kiểm thử thông thường không?– Thời gian chạy kiểm thử có dữ liệu trong NUnit tùy thuộc vào số lượng và phức tạp của bộ dữ liệu đầu vào. Tuy nhiên, việc sử dụng kiểm thử có dữ liệu có thể giúp tiết kiệm thời gian chạy kiểm thử so với việc thiết kế nhiều kiểm thử riêng lẻ.

Từ khoá người dùng tìm kiếm: nunit data driven test nunit testcase, nunit csv data driven, nunit parameterized test, nunit test cases in c#, nunit generic testcase, theory nunit, nunit testcasesource, nunit values

Chuyên mục: Top 80 nunit data driven test

Master .NET and C# Unit Testing with NUnit and Moq : Data-Driven Testing

Is NUnit used for test driven development?

Test Driven Development (TDD) là một phương pháp phát triển phần mềm trong đó việc viết mã kiểm thử được thực hiện trước khi viết mã chức năng thực tế. Mục tiêu của TDD là giúp tăng cường độ tin cậy và đảm bảo tính ổn định của phần mềm thông qua việc kiểm thử tự động.

NUnit là một công cụ kiểm thử tự động (unit testing) phổ biến dành cho các ứng dụng .NET. Sử dụng NUnit, nhà phát triển có thể tạo ra các bài kiểm tra tự động cho mã nguồn của mình, từ đó tiết kiệm thời gian và nỗ lực trong việc kiểm thử thủ công. Vì NUnit rất linh hoạt, nó đã trở thành một công cụ phù hợp cho cả TDD và các phương pháp phát triển phần mềm khác.

Khi sử dụng NUnit cho TDD, quá trình phát triển phần mềm được chia thành các vòng lặp nhỏ gọi là “Red-Green-Refactor”. Ban đầu, nhà phát triển viết một bài kiểm tra sẽ fail (Red), sau đó thêm mã chức năng cần kiểm thử để đảm bảo bài kiểm tra thành công (Green). Cuối cùng, một số điều chỉnh (Refactor) có thể được thực hiện để cải thiện mã nguồn. Quá trình này được lặp lại cho từng chức năng trong phần mềm.

Sử dụng NUnit để viết các bài kiểm tra cho phần mềm của bạn có nhiều lợi ích. Đầu tiên, NUnit cung cấp một cú pháp đơn giản để xác định và chạy các bài kiểm tra. Bạn có thể sử dụng các thuộc tính đánh dấu [Test] để chỉ định rằng một phương thức là một bài kiểm tra và sử dụng các phương thức khác để kiểm tra các điều kiện. Nếu các bài kiểm tra không thành công, NUnit sẽ cung cấp thông báo chi tiết về lỗi để bạn có thể dễ dàng xác định và sửa lỗi.

Thứ hai, NUnit cho phép tự động hóa kiểm thử, giúp tạo ra một bộ kiểm tra đáng tin cậy và liên tục để duy trì tính ổn định của phần mềm trong quá trình phát triển. Bạn có thể chạy tất cả các bài kiểm tra tự động bằng cách sử dụng các công cụ tích hợp mới như CI/CD (Continuous Integration/Continuous Deployment). Điều này giúp đảm bảo tính chính xác và đồng nhất của phần mềm dự án khi có các thay đổi.

Vậy NUnit có thể sử dụng được trong TDD hay không? Câu trả lời là có. NUnit cung cấp các tính năng và công cụ cần thiết để viết và chạy các bài kiểm tra tự động trong quy trình TDD. Bởi vì NUnit được tích hợp vào môi trường phát triển .NET phổ biến như Visual Studio, Rider, hoặc các công cụ khác, nó rất thuận tiện để sử dụng trong quy trình TDD.

FAQs:

1. NUnit và TDD có khác nhau không?NUnit và TDD là hai khái niệm khác nhau. NUnit là một công cụ kiểm thử tự động cho .NET, trong khi TDD là một phương pháp phát triển phần mềm. Tuy nhiên, NUnit có thể được sử dụng trong TDD để viết và chạy các bài kiểm tra tự động.

2. Có những công cụ khác nào có thể được sử dụng thay cho NUnit trong TDD?Ngoài NUnit, các công cụ khác cho kiểm thử đơn vị tự động như xUnit và MSTest cũng là các lựa chọn phổ biến trong cộng đồng .NET. Tuy nhiên, khái niệm chính của TDD vẫn được áp dụng cho bất kỳ công cụ nào bạn chọn.

3. Tôi có cần biết NUnit để sử dụng TDD không?Không cần thiết. Mặc dù NUnit là một công cụ phổ biến cho việc kiểm thử tự động trong TDD, nhưng bạn có thể sử dụng bất kỳ công cụ nào mà bạn cảm thấy thoải mái. Quan trọng hơn, bạn cần hiểu được khái niệm và phương pháp của TDD.

4. Tại sao kiểm thử tự động quan trọng trong TDD?Kiểm thử tự động là yếu tố quan trọng trong TDD vì nó giúp đảm bảo tính ổn định và tin cậy của phần mềm. Bằng cách tự động hóa quy trình kiểm thử, bạn có thể xác định các lỗi càng sớm càng tốt và nhanh chóng phản hồi, từ đó tăng cường chất lượng phần mềm.

What is data driven testing C#?

Trong lập trình, dữ liệu đầu vào chủ yếu được đưa vào thông qua các biến hay tham số. Trong trường hợp này, data driven testing cho phép chúng ta thực hiện kiểm tra bằng cách thay đổi giá trị của biến hoặc tham số đó. Điều này giúp chúng ta có thể kiểm tra tính ổn định và chính xác của chương trình khi sử dụng các dữ liệu đa dạng.

Trong ngôn ngữ lập trình C#, data driven testing có thể được thực hiện bằng nhiều cách khác nhau. Một trong những cách phổ biến nhất là sử dụng framework TestNG hoặc NUnit. Cả hai framework này đều cung cấp các chức năng cho phép chúng ta tạo và thực thi các bộ kiểm tra dựa trên dữ liệu.

Cụ thể, trong NUnit, chúng ta có thể sử dụng thuộc tính [TestCase] để đánh dấu một phương thức là một bộ kiểm tra dựa trên dữ liệu. Mỗi [TestCase] sẽ chứa các tham số đầu vào và kết quả mong đợi. NUnit sẽ thực thi phương thức kiểm tra này đối với từng tập dữ liệu đầu vào, và thông báo kết quả tương ứng.

Ví dụ, giả sử chúng ta có một phương thức kiểm tra tính cộng trong lớp Calculator:

“`public class Calculator {public int Add(int a, int b) {return a + b;}}“`

Chúng ta có thể tạo một bộ kiểm tra dựa trên dữ liệu trong NUnit như sau:

“`[TestFixture]public class CalculatorTests {private Calculator calculator;

[SetUp]public void Setup() {calculator = new Calculator();}

[TestCase(1, 2, ExpectedResult = 3)][TestCase(-1, 5, ExpectedResult = 4)][TestCase(0, 0, ExpectedResult = 0)]public int TestAdd(int a, int b) {return calculator.Add(a, b);}}“`

Trong ví dụ này, chúng ta đã sử dụng 3 bộ kiểm tra dựa trên dữ liệu để kiểm tra phương thức Add(). Mỗi bộ kiểm tra cung cấp các giá trị đầu vào khác nhau và kết quả mong đợi tương ứng. Khi chạy các bộ kiểm tra này, NUnit sẽ thực thi phương thức TestAdd() đối với từng tập dữ liệu đầu vào và thông báo kết quả.

Điểm mấu chốt của data driven testing là nó cho phép chúng ta kiểm tra chương trình với nhiều dạng dữ liệu khác nhau. Nó giúp chúng ta xác định được liệu chương trình có xử lý đúng trong mọi tình huống hay không. Đồng thời, data driven testing cũng giúp chúng ta tối ưu hóa công việc kiểm thử, bởi vì chúng ta có thể thực hiện nhiều bộ kiểm tra với một lượng dữ liệu lớn chỉ cần viết một phương thức kiểm tra duy nhất.

Tuy nhiên, data driven testing cũng có một số hạn chế. Trước hết, việc tạo và duy trì các bộ kiểm tra dựa trên dữ liệu có thể tốn nhiều thời gian và công sức. Điều này càng trở nên phức tạp hơn khi chương trình có nhiều tham số hoặc yêu cầu dữ liệu phức tạp.

Tiếp theo, việc tạo và quản lý dữ liệu đầu vào có thể gây khó khăn, đặc biệt khi chúng ta cần thay đổi hoặc mở rộng dữ liệu. Một phương pháp để giải quyết vấn đề này là sử dụng các công cụ hỗ trợ để quản lý và tạo dữ liệu đầu vào.

Cuối cùng, data driven testing có thể trở nên khá phức tạp trong việc phân tích kết quả kiểm tra. Mỗi kịch bản kiểm tra có thể trả về nhiều kết quả khác nhau, và chúng ta cần phải xác định kết quả mong đợi cho từng trường hợp. Điều này đòi hỏi chúng ta phải có một quy trình tốt để đảm bảo tính chính xác và một cách tiếp cận thích hợp để xử lý các kết quả không chính xác.

FAQs:1. Data driven testing có ưu điểm gì so với các phương pháp kiểm tra khác?Data driven testing giúp chúng ta kiểm tra chương trình với nhiều dạng dữ liệu khác nhau, giúp xác định tính ổn định và chính xác của chương trình trong mọi tình huống. Nó cũng giúp tối ưu hóa công việc kiểm thử bằng cách thực hiện nhiều bộ kiểm tra với một lượng dữ liệu lớn chỉ cần viết một phương thức kiểm tra duy nhất.

2. Có cách nào để quản lý dễ dàng các bộ kiểm tra dựa trên dữ liệu không?Có, chúng ta có thể sử dụng các công cụ hỗ trợ để quản lý và tạo dữ liệu đầu vào. Các công cụ này giúp chúng ta tạo dữ liệu mẫu, tự động hóa việc tạo các bộ kiểm tra và quản lý dữ liệu một cách dễ dàng.

3. Làm thế nào để xác định kết quả mong đợi cho từng kịch bản kiểm tra?Để xác định kết quả mong đợi cho từng kịch bản kiểm tra, chúng ta cần có một quy trình tốt để đảm bảo tính chính xác. Chúng ta cần phân tích các yêu cầu và kịch bản kiểm tra của chương trình, xác định kết quả mong đợi cho từng trường hợp và đặt các tiêu chí xác định kết quả mong đợi.

4. Data driven testing có hạn chế nào không?Data driven testing có thể tốn thời gian và công sức khi tạo và duy trì các bộ kiểm tra dựa trên dữ liệu đầu vào. Ngoài ra, việc tạo và quản lý dữ liệu đầu vào có thể gây khó khăn và data driven testing cũng có thể trở nên phức tạp trong việc phân tích kết quả kiểm tra.

Xem thêm tại đây: hanoilaw.vn

#18 - Data Driven Testing with external data source using JSON and NUnit for Selenium — #18 – Data Driven Testing with external data source using JSON and NUnit for Selenium

Creating the first test

You write one failing test, make it pass, and then repeat the process. In the PrimeService.Tests directory, rename the UnitTest1.cs file to PrimeService_IsPrimeShould.cs and replace its entire contents with the following code:

using NUnit.Framework; using Prime.Services; namespace Prime.UnitTests.Services { [TestFixture] public class PrimeService_IsPrimeShould { private PrimeService _primeService; [SetUp] public void SetUp() { _primeService = new PrimeService(); } [Test] public void IsPrime_InputIs1_ReturnFalse() { var result = _primeService.IsPrime(1); Assert.IsFalse(result, "1 should not be prime"); } } }

The
[TestFixture]
attribute denotes a class that contains unit tests. The
[Test]
attribute indicates a method is a test method.

Save this file and execute the
dotnet test
command to build the tests and the class library and run the tests. The NUnit test runner contains the program entry point to run your tests.
dotnet test
starts the test runner using the unit test project you’ve created.

Your test fails. You haven’t created the implementation yet. Make the test pass by writing the simplest code in the
PrimeService
class that works:

public bool IsPrime(int candidate) { if (candidate == 1) { return false; } throw new NotImplementedException("Please create a test first."); }

In the unit-testing-using-nunit directory, run
dotnet test
again. The
dotnet test
command runs a build for the
PrimeService
project and then for the
PrimeService.Tests
project. After you build both projects, it runs this single test. It passes.

ValueSource Attribute

The ValueSource attribute functions similarly like TestCaseSource, except that it is used as a Method parameter.

Using the ValueSource attribute for creating parameterized tests in NUnit for cross browser testing does not sound convincing as a list of tests is prepared based on the values supplied via the ValueSource attribute. For example, the input values shown below generate four test cases, i.e., chrome 70.0, chrome 71.0, Firefox 70.0, and Firefox 71.0

private static string[] AddBrowserConfs = new string[] {

“chrome”,

“Firefox”

};

private static string[] AddVerConfs = new string[] {

“70.0”,

“71.0”

};

Demonstration – [ValueSource] Attribute

For demonstrating the usage of ValueSource attribute, a DuckDuckGo search for LambdaTest is performed on the following browser + OS combinations.

The complete implementation is shown below:

Code WalkThrough

There are no changes in the core implementation for invoking the WebDriver instance, generating the browser capabilities, performing DuckDuckGo search, and performing de-initialization. You can refer to steps 1, 3, 4, and 5 from the ‘Code WalkThrough’ section of the TestCase attribute for more information.

Three string arrays consisting of browser type, browser versions, and platforms are created. These arrays are then passed as individual parameters to the test method (DuckDuckGo_ValueSource_Demo) using the ValueSource attribute.

A total of eight test combinations are generated from the input values passed to the test method i.e. (chrome + 70.0 + Windows 10), (chrome + 71.0 + macOS Mojave), (Firefox + 70.0 + Windows 10), (Firefox + 71.0 + macOS Mojave), etc.

private static string[] AddBrowserConfs = new string[] {

“chrome”,

“Firefox”

};

private static string[] AddVerConfs = new string[] {

“70.0”,

“71.0”

};

private static string[] AddOsConfs = new string[] {

“Windows 10”,

“macOS Mojave”

};

[Test]

public void DuckDuckGo_ValueSource_Demo(

[ValueSource(“AddBrowserConfs”)]String browser, [ValueSource(“AddVerConfs”)] String version, [ValueSource(“AddOsConfs”)] String os

……………….

};

The execution snapshot below shows that eight test combinations are created from the test parameters supplied through the ValueSource attribute.

Data driven testing in C# with NUnit and RestSharp

In a previous post, I gave some examples of how to write some basic tests in C# for RESTful APIs using NUnit and the RestSharp library. In this post, I would like to extend on that a little by showing you how to make these tests data driven.

For those of you that do not know what I mean with ‘data driven’: when I want to run tests that exercise the same logic or flow in my application under test multiple times with various combinations of input values and corresponding expected outcomes, I call that data driven testing.

This is especially useful when testing RESTful APIs, since these are all about sending and receiving data as well as exposing business logic to other layers in an application architecture (such as a graphical user interface) or to other applications (consumers of the API).

As a starting point, consider these three tests, written using RestSharp and NUnit:

[TestFixture] public class NonDataDrivenTests { private const string BASE_URL = "http://api.zippopotam.us"; [Test] public void RetrieveDataForUs90210_ShouldYieldBeverlyHills() { // arrange RestClient client = new RestClient(BASE_URL); RestRequest request = new RestRequest("us/90210", Method.GET); // act IRestResponse response = client.Execute(request); LocationResponse locationResponse = new JsonDeserializer(). Deserialize (response); // assert Assert.That( locationResponse.Places[0].PlaceName, Is.EqualTo("Beverly Hills") ); } [Test] public void RetrieveDataForUs12345_ShouldYieldSchenectady() { // arrange RestClient client = new RestClient(BASE_URL); RestRequest request = new RestRequest("us/12345", Method.GET); // act IRestResponse response = client.Execute(request); LocationResponse locationResponse = new JsonDeserializer(). Deserialize (response); // assert Assert.That( locationResponse.Places[0].PlaceName, Is.EqualTo("Schenectady") ); } [Test] public void RetrieveDataForCaY1A_ShouldYieldWhiteHorse() { // arrange RestClient client = new RestClient(BASE_URL); RestRequest request = new RestRequest("ca/Y1A", Method.GET); // act IRestResponse response = client.Execute(request); LocationResponse locationResponse = new JsonDeserializer(). Deserialize (response); // assert Assert.That( locationResponse.Places[0].PlaceName, Is.EqualTo("Whitehorse") ); } }

Please note that the
LocationResponse
type is a custom type I defined myself, see the GitHub repository for this post for its implementation.

These tests are a good example of what I wrote about earlier: I’m invoking the same logic (retrieving location data based on a country and zip code and then verifiying the corresponding place name from the API response) three times with different sets of test data.

This quickly gets very inefficient when you add more tests / more test data combinations, resulting in a lot of duplicated code. Luckily, NUnit provides several ways to make these tests data driven. Let’s look at two of them in some more detail.

Using the [TestCase] attribute

The first way to create data driven tests is by using the
[TestCase]
attribute that NUnit provides. You can add multiple
[TestCase]
attributes for a single test method, and specify the combinations of input and expected output parameters that the test method should take.

Additionally, you can specify other characteristics for the individual test cases. One of the most useful ones is the
TestName
property, which can be used to provide a legible and useful name for the individual test case. This name also turns up in the reporting, so I highly advise you to take the effort to specify one.

Here’s what our code looks like when we refactor it to use the
[TestCase]
attribute:

[TestFixture] public class DataDrivenUsingAttributesTests { private const string BASE_URL = "http://api.zippopotam.us"; [TestCase("us", "90210", "Beverly Hills", TestName = "Check that US zipcode 90210 yields Beverly Hills")] [TestCase("us", "12345", "Schenectady", TestName = "Check that US zipcode 12345 yields Schenectady")] [TestCase("ca", "Y1A", "Whitehorse", TestName = "Check that CA zipcode Y1A yields Whitehorse")] public void RetrieveDataFor_ShouldYield (string countryCode, string zipCode, string expectedPlaceName) { // arrange RestClient client = new RestClient(BASE_URL); RestRequest request = new RestRequest($"{countryCode}/{zipCode}", Method.GET); // act IRestResponse response = client.Execute(request); LocationResponse locationResponse = new JsonDeserializer(). Deserialize (response); // assert Assert.That( locationResponse.Places[0].PlaceName, Is.EqualTo(expectedPlaceName) ); } }

Much better! We now only have to define our test logic once, and NUnit takes care of iterating over the values defined in the
[TestCase]
attributes:

There are some downsides to using the
[TestCase]
attributes, though:

It’s all good when you just want to run a small amount of test iterations, but when you want to / have to test for larger numbers of combinations of input and output parameters, your code quickly gets messy (on a side note, if this is the case for you, try looking into property-based testing instead of the example-based testing we’re doing here).
You still have to hard code your test data in your code, which might give problems with scaling and maintaining your tests in the future.

This is where the
[TestCaseSource]
attribute comes in.

Using the [TestCaseSource] attribute

If you want to or need to work with larger numbers of combinations of test data and/or you want to be able to specify your test data outside of your test class, then using
[TestCaseSource]
might be a useful option to explore.

In this approach, you specify or read the test data in a separate method, which is then passed to the original test method. NUnit will take care of iterating over the different combinations of test data returned by the method that delivers the test data.

Here’s an example of how to apply
[TestCaseSource]
to our tests:

[TestFixture] public class DataDrivenUsingTestCaseSourceTests { private const string BASE_URL = "http://api.zippopotam.us"; [Test, TestCaseSource("LocationTestData")] public void RetrieveDataFor_ShouldYield (string countryCode, string zipCode, string expectedPlaceName) { // arrange RestClient client = new RestClient(BASE_URL); RestRequest request = new RestRequest($"{countryCode}/{zipCode}", Method.GET); // act IRestResponse response = client.Execute(request); LocationResponse locationResponse = new JsonDeserializer(). Deserialize (response); // assert Assert.That( locationResponse.Places[0].PlaceName, Is.EqualTo(expectedPlaceName) ); } private static IEnumerable LocationTestData() { yield return new TestCaseData("us", "90210", "Beverly Hills"). SetName("Check that US zipcode 90210 yields Beverly Hills"); yield return new TestCaseData("us", "12345", "Schenectady"). SetName("Check that US zipcode 12345 yields Schenectady"); yield return new TestCaseData("ca", "Y1A", "Whitehorse"). SetName("Check that CA zipcode Y1A yields Whitehorse"); } }

In this example, we specify our test data in a separate method
LocationTestData()
, and then tell the test method to use that method as the test data source using the
[TestDataSource]
attribute, which takes as its argument the name of the test data method.

For clarity, the test data is still hard coded in the body of the
LocationTestData()
method, but that’s not mandatory. You could just as easily write a method that reads the test data from any external source, as long as the test data method is static and returns an object of type
IEnumerable
, or any object that implements this interface.

Also, since the
[TestCase]
and
[TestCaseSource]
attributes are features of NUnit, and not of RestSharp, you can apply the principles illustrated in this post to other types of tests just as well.

Beware, though, before you use them for user interface-driven testing with tools like Selenium WebDriver. Chances are that you’re falling for a classic case of ‘just because you can, doesn’t mean you should’. I find data driven testing with Selenium WebDriver to be a test code smell: if you’re going through the same screen flow multiple times, and the only variation is in the test data, there’s a high chance that there’s a more efficient way to test the same underlying business logic (for example by leveraging APIs).

Chris McMahon explains this much more eloquently in a blog post of his. I highly recommend you reading that.

For other types of testing (API, unit, …), data driven testing could be a very powerful way to make your test code better maintainable and more powerful.

All example code in this blog post can be found on this GitHub page.

”

NUnit 2.5 supports parameterized tests. Test methods may have parameters and various attributes are available to indicate what arguments should be supplied by NUnit.

Multiple sets of arguments cause the creation of multiple tests. All arguments are created at the point of loading the tests, so the individual test cases are available for display and selection in the Gui, if desired.

Some attributes allow you to specify arguments inline – directly on the attribute – while others use a separate method, property or field to hold the arguments. In addition, some attributes identify complete test cases, including all the necessary arguments, while others only provide data for a single argument. This gives rise to four groups of attributes, as shown in the following table.

Complete Test Cases

Data for One Argument

Inline

TestCaseAttribute

RandomAttribute

RangeAttribute

ValuesAttribute

Separate

TestCaseSourceAttribute

ValueSourceAttribute

In addition, when data is specified for individual arguments, special attributes may be added to the test method itself in order to tell NUnit how to go about combining the arguments. Currently, the following attributes are provided:

This article shows how you can run the same unit test multiple times with different input data, using NUnit.

A Simple Scenario

Before we can learn about data-driven testing using NUnit, we need some actual logic to test. Let’s use the following class for this purpose:

public class PriceCalculator { private decimal adultPrice; public PriceCalculator(decimal adultPrice) { this.adultPrice = adultPrice; } public decimal CalculatePrice(int age) { decimal multiplier = 0.0m; if (age >= 5 && age < 16) // 5 to 15: half price multiplier = 0.5m; else if (age >= 16 && age < 60) // 16 to 59: full price multiplier = 1.0m; else if (age >= 60) // 60+: half price multiplier = 0.5m; return this.adultPrice * multiplier; } }

So, here we have a scenario where we have something to sell (whatever it is), and certain age ranges get discounts. Kids under 5 years of age are free; older kids under 16 pay half price, as do senior citizens from age 60 onwards.

If you want to run NUnit unit tests from within Visual Studio, make sure you have the NUnit Test Adapter. You can get it from Tools menu -> Extensions and Updates…:

Plain Old Unit Tests

To test this, you’d have to write several unit tests. One of them could look like this:

[Test] public void CalculatePriceTest() { // arrange const decimal adultPrice = 10m; var priceCalculator = new PriceCalculator(adultPrice); const int age = 10; // act decimal actualPrice = priceCalculator.CalculatePrice(age); // assert const decimal expectedPrice = 5m; Assert.AreEqual(expectedPrice, actualPrice); }

You’d have to write other similar tests to cover the various age ranges and edge cases (e.g. making sure that age boundaries are inclusive or exclusive as needed).

Copying this test code and varying the input data is a bit of a hassle and not quite DRY. An alternative could be to set up a list with the input data and expected result and iterate over it. That’s not necessary, because NUnit gives us a way to do this out of the box.

The TestCase Attribute

NUnit provides a feature called Parameterized Tests. These provide two mechanisms that allow you to easily run the same test with multiple input data.

The first of these is the [TestCase] attribute. This replaces the [Test] attribute we used before, and provides input data to pass to the test method via parameters:

[TestCase(1, 0)] [TestCase(10, 5)] [TestCase(20, 10)] [TestCase(70, 5)] public void CalculatePriceTest(int age, decimal expectedPrice) { // arrange const decimal adultPrice = 10m; var priceCalculator = new PriceCalculator(adultPrice); // act decimal actualPrice = priceCalculator.CalculatePrice(age); // assert Assert.AreEqual(expectedPrice, actualPrice); }

This can actually be simplified further by using the
ExpectedResult
named parameter, and replacing the
Assert
with a simple
return
statement:

[TestCase(1, ExpectedResult = 0)] [TestCase(10, ExpectedResult = 5)] [TestCase(20, ExpectedResult = 10)] [TestCase(70, ExpectedResult = 5)] public decimal CalculatePriceTest(int age) { // arrange const decimal adultPrice = 10m; var priceCalculator = new PriceCalculator(adultPrice); // act decimal actualPrice = priceCalculator.CalculatePrice(age); // assert return actualPrice; }

Note: technically we should declare the expected results as
decimal
s in this case, such as
ExpectedResult = 0m
. However, the attribute doesn’t seem to allow it. Integers work just fine.

The TestCaseSource Attribute

The [TestCase] attribute works great when you want to run the same test against a few different combinations of input data and expected results. However, it can still get very tedious for very exhaustive tests with a lot of input data.

A more fitting technique for such scenarios is to use the [TestCaseSource] attribute:

[TestCaseSource(“TestCases”)] public decimal CalculatePriceTest(int age) { // arrange const decimal adultPrice = 10m; var priceCalculator = new PriceCalculator(adultPrice); // act decimal actualPrice = priceCalculator.CalculatePrice(age); // assert return actualPrice; }

The [TestCaseSource] attribute takes the name of a public static property which will provide the input data (i.e. the same data that we passed in to the [TestCase] attribute earlier). You can use this to load the data from arbitrary sources such as databases, files, etc.

There are a number of ways of working with the [TestCaseSource] attribute (refer to the documentation), but a straightforward way to work with it is to use the
TestCaseData
class. You can provide it with any input data as well as an expected result. For instance, say we have the following CSV file mapping age to expected price, for ages between 0 and 99:

0,0 1,0 2,0 3,0 4,0 5,5 6,5 7,5 8,5 9,5 10,5 11,5 12,5 13,5 14,5 15,5 16,10 17,10 18,10 …

We can write a property that reads this and provides the necessary test case data as follows:

public static List

TestCases { get { var testCases = new List

(); using (var fs = File.OpenRead(@”C:\test.csv”)) using (var sr = new StreamReader(fs)) { string line = string.Empty; while (line != null) { line = sr.ReadLine(); if (line != null) { string[] split = line.Split(new char[] { ‘,’ }, StringSplitOptions.None); int age = Convert.ToInt32(split[0]); decimal expectedPrice = Convert.ToDecimal(split[1]); var testCase = new TestCaseData(age).Returns(expectedPrice); testCases.Add(testCase); } } } return testCases; } }

You can see the power of this approach when you run a hundred tests in the bat of an eyelid:

The first test takes a small performance penalty as the test data is loaded. But that’s a small price to pay for the development time saved in writing unit tests.

Creating the source project

Open a shell window. Create a directory called unit-testing-using-nunit to hold the solution. Inside this new directory, run the following command to create a new solution file for the class library and the test project:

dotnet new sln

Next, create a PrimeService directory. The following outline shows the directory and file structure so far:

/unit-testing-using-nunit unit-testing-using-nunit.sln /PrimeService

Make PrimeService the current directory and run the following command to create the source project:

dotnet new classlib

Rename Class1.cs to PrimeService.cs. You create a failing implementation of the
PrimeService
class:

using System; namespace Prime.Services { public class PrimeService { public bool IsPrime(int candidate) { throw new NotImplementedException("Please create a test first."); } } }

Change the directory back to the unit-testing-using-nunit directory. Run the following command to add the class library project to the solution:

dotnet sln add PrimeService/PrimeService.csproj

C# Unit Testing with Moq under 10 minutes | Basics of Unit Testing and Mock Testing

Phản hồi

Gửi và xem ý kiến phản hồi dành cho

Data-driven tests are a nice way to add variation to your test suite, while at the same time, reducing the boilerplate or repetitive code for cases when you need tests that perform the same actions, just with different datasets.

They can also provide a nice option for your less technical testers to contribute to automation by allowing them to add different permutations of data and not necessarily having to know how to code.

NUnit has a wide variety of different options for making your tests data-driven; the first we’ll take a look at is parameterizing your tests.

To enable our test to be data-driven, the first step is to create a test method that accepts parameters. The parameters to the test will serve as a means for NUnit to funnel new or different data into your test.

We’ll take a look at our
AddRoom
test, I’ll add a String parameter for “roomNumber” and for “Price”.

I’ve updated the test to use the new parameters, now we just need to tell NUnit what data to use.

The first way we can pass data into our test is using the
[Values]
attribute.

Unlike other attributes that we’ve used so far, that have gone on the test fixture class or on the test method, the
[Values]
attribute is specified for each parameter of the test.

First, we’ll add the
[Values]
attribute to the room number parameter and add two values: 9 and 999.

Then we’ll add a
[Values]
attribute for our price parameter and include two values: 100 and 1,000.

By default, what NUnit will do is create a test for all combinations of those values and we can see this by looking at the test explorer and you can see four tests have been created.

Let’s also add parameters for accessible and for room type.

The
Values
attribute has built-in support for enums and boolean parameters. So rather than to have to enter “true” and “false” for booleans, or include each value in an enum, you can just enter values without specifying any arguments and NUnit will automatically include all of the values.

Since, by default, NUnit uses a combinatorial approach and generates a test for all combinations, in this example we’ll have 40 tests.

That’s the 2 room number times the 2 price options times the 2 boolean options, then times 5 for the different room type options. So, what starts off well-intentioned, can result in explosive growth in your number of tests.

To help with this, NUnit provides two other attributes that give you some additional controls over how the values are combined to generate tests.

The first is the
[Pairwise]
attribute.

So rather than have tests for all the possible combinations of parameter values, this will only generate tests for all the unique pairs of those values. When we add the
[Pairwise]
attribute to our test method, the number of tests has shrunk from 40 to 10.

The other option is the
[Sequential]
attribute.

This will cause NUnit to use the order of data values to create test cases.

So, for example, the first test will use the first value in each of the values attributes.

Also, for this to work correctly, you probably want to have equal numbers of values for each parameter, otherwise you may end up with invalid test cases.

In addition to the
[Values]
attribute, there are two other attributes that you can use to generate values for numeric parameters.

The
[Random]
attribute lets you specify a minimum and maximum value to generate a random number for when the test is executed.

There’s also the
[Range]
attribute to specify a series of numbers to be used for an individual parameter.

Another way to parameterize tests is to use the
[test case]
attribute.

To use this, we’ll replace the
[Test]
attribute with the
[test case]
attribute.

Instead of using the
[Values]
attributes for each parameter of the test, we pass the parameters you’d want for this specific test case as arguments to the
[test case]
attributes, and this is going to be in the same order as the parameters of the test method.

Then, for each permutation of this test that you want to run, you’ll add another test case attribute and include parameter values designed for that test.

This removes some of the “magic” that using the
[Values]
attribute could introduce.

Each test permutation is clear listed separately above the test method signature, there’s no question what inputs will be passed to the test.

The
[Test]
attribute also has optional name parameters for things like test name and description and this allows each test case to have a clear intent.

There is also the
ExpectedRresult
parameter and you can use this to specify the expected value of a test.

To use this, your test method is going to need to return a value instead of void.

Then, if we add the
ExpectedRresult
parameter to the
test case
, NUnit will automatically compare the return value of the test method to the result of the value specified in the test case attribute.

When you use this, the test itself is not going to contain an
Assert
statement, so this approach may rub some people the wrong way

And I’m sure there’s some circumstances where this is a good fit, but I prefer not to have an implicit assertion inside of my test.

So far, we’ve supplied data individually to each test and this can get a little repetitive.

For example, in this case, we have a string parameter for the room price and perhaps, across our application, we have a variety of currency formats that we need to support.

Or maybe you want to use values from something like the Big List of Naughty Strings or Elisabeth Hendrickson’s test heuristics cheat sheet. Rather than copy and paste that into every test, we want to share it in a central common place to be used across tests.

For sharing data for a specific parameter of your test, you can use the
[ValueSource]
Attribute.

ValueSource
works very similarly to the
Values
attribute, except that instead of passing literal values, will provide the name of the source that will provide the data as a String.

The data source can be a static field, property or method that takes no parameters.

The source also needs to return an IEnumerable of the type that the parameter expects.

To see this, I’ll add a
static
method to our test class that returns a String array of some different currency format. And let’s call the method
CurrencyStrings
.

To use it, we’ll add the
[ValueSource]
attribute to our price parameter and rather than use the String will use C#’s
nameof
method and this will return a string value of the method’s name.

What’s nice about using
nameof
is that now our
ValueSources
method name is no longer a magic string. So, if the source method name changes, our editor or the compiler will let us know that the names don’t match.

If you want to centralize your data sources into separate classes, you can also do that.

I’ve created a new class called
TestData
and moved the
CurrencyStrings
method into it.

To use this method, we update the
ValueSource
so that the first argument is the type that contains the source method.

To do that, we’ll enter a
typeof
and then our class name and then, for the second argument, we’ll use the name of the method with the method’s name.

The
[TestCaseSource]
attribute is meant to provide all of the parameters for a task and it works similarly to the
ValueSource
where the data source can be a static field property or method that returns an IEnumerable type.

The values returned need to be compatible with the parameters of the test method signature.

I’ve updated the test to accept 3 parameters: room number, price and room type.

To hold our test data, let’s add another method in the
TestData
class called
RoomInfo
.

Since our test method signature accepts two Strings and a room type, we’ll use an
object
array to hold the different types of values for each test case.

To use it, we’ll go back to our test and add the
[TestCaseSource]
attribute to our test methods, and in it we’ll include our type and method name.

TestCaseSource
can also use methods that accept parameters and if you need to parameterize your test case source values, then you need to pass those arguments as an object array to the
TestCaseSource
.

Another option we can use to return data from a test case source is
TestCaseData
.

This is actually my favorite way to create data-driven tests because it adds so much flexibility to how you can use data to drive your tests.

Inside the
TestData
class, I’ve added a new method called
RoomTest caseData
— and this is a copy paste of the room data method, but instead of an
object
array, I’m using arrays of
TestCaseData
.

The constructor of
TestCaseData
will accept the arguments that we need to pass to our tests, but in addition to passing arguments,
TestCaseData
has methods that allow you to add attributes on that test case.

We can give each test case a name, a description, test cases can have their own categories assigned to them or be flagged as explicit or ignored. This group of tests can be fully explained, grouped, executed, and managed outside of the actual test code.

So far, we’ve been passing a series of parameters that are being used to set different properties on the room object.

Rather than do that, wouldn’t it be nice and cleaner to just pass the instance of the room object, itself instead of assembling it inside of the test?

Instead of hard-coding values into our test data, we can store it inside of a JSON, XML or CSV file or even in a database.

In this example, I’m reading a JSON file that contains room data and properties of a test, including its name, an array of categories and flags for explicit and ignore.

Then, in our
TestCaseSource
method, we’ll read the JSON file and build up a
List
of
TestCaseData
.

This will include the room parameter for the test as well as setting properties of the test defined in the JSON file.

By combining this external data with NUnit’s
test case
data, we’re able to dynamically build and manage the test suite from any external source.

Test fixtures can also be parameterized, and this allows your test setup and tear down code to be dynamic as well as your test.

To parameterize a fixture, we need to do two things:

First, we add a constructor to our class that will accept the parameters that we want to provide.

The second step is to add a text fixture attribute, and just like we did with
test case
, specify the value that we want to pass to the constructor when the fixture is loaded.

Test fixtures can also use
TestFixtureSource
and
TestFixtureData
just like we do with
TestCaseSource
and
TestCaseData
.

You can also use generic classes as your test fixtures. And can then vary the type of the class by specifying the type to be used as an argument to the test fixture attributes.

This may not be something you commonly need to use, but it can come in handy for unit testing different types.

NUnit has another concept called theories.

Per the NUnit documentation, a
Theory
is a special type of test used to verify a general statement about the system under development.

When we create normal tests, particularly data-driven tests, we are providing specific examples of input and output.

But a
Theory
isn’t meant for specific data values, it’s meant to prove, given a general set of inputs, that all of the assertions will pass, assuming that the arguments satisfy certain assumptions.

To create a
Theory
, instead of the
[Test]
attribute, we use the
[Theory]
attributes.

And the test method is required to accept parameters to verify the theory.

Data for the
Theory
is meant to be provided by a method, property or field inside the test fixture marked with the
[DataPointSource]
attribute.

When the
Theory
is run, NUnit automatically assembles all data points that match the types required for the test parameters and then supplies them to the test.

This is a pretty specialized use case. Notice how there’s only the
Theory
attribute. There’s no other attribute or visible code that indicates that this theory should use this
DataPointSource
.

NUnit is going to map these up because the theory parameter and the data point source both used doubles.

Adding more features

Now that you’ve made one test pass, it’s time to write more. There are a few other simple cases for prime numbers: 0, -1. You could add new tests with the
[Test]
attribute, but that quickly becomes tedious. There are other NUnit attributes that enable you to write a suite of similar tests. A
[TestCase]
attribute is used to create a suite of tests that execute the same code but have different input arguments. You can use the
[TestCase]
attribute to specify values for those inputs.

Instead of creating new tests, apply this attribute to create a single data-driven test. The data driven test is a method that tests several values less than two, which is the lowest prime number:

[TestCase(-1)] [TestCase(0)] [TestCase(1)] public void IsPrime_ValuesLessThan2_ReturnFalse(int value) { var result = _primeService?.IsPrime(value); Assert.That(result, Is.False, $"{value} should not be prime"); }

Run
dotnet test
, and two of these tests fail. To make all of the tests pass, change the
if
clause at the beginning of the
Main
method in the PrimeService.cs file:

if (candidate < 2)

Continue to iterate by adding more tests, theories, and code in the main library. You have the finished version of the tests and the complete implementation of the library.

You’ve built a small library and a set of unit tests for that library. You’ve also structured the solution so that adding new packages and tests is part of the standard workflow. You’ve concentrated most of your time and effort on solving the goals of the application.

Chapter-8: Unit Testing in ASP.NET Core Web API | Clean Architecture | Microservices Architecture

nunit testcase

Trong quá trình phát triển phần mềm, việc đảm bảo chất lượng sản phẩm là yếu tố quan trọng để đáp ứng được nhu cầu của người dùng. Kiểm thử phần mềm là một phương pháp quan trọng và hiệu quả để đảm bảo chất lượng sản phẩm. Và một trong những công cụ phổ biến được sử dụng trong việc kiểm thử này là NUnit.

NUnit là một framework kiểm thử phần mềm mã nguồn mở cho .NET. Nó cung cấp một môi trường linh hoạt và mạnh mẽ để xây dựng các bài kiểm thử tự động cho các ứng dụng trên nền tảng .NET. Được viết bằng C#, NUnit cung cấp các tính năng và phương pháp để viết các bài kiểm thử cho các hàm, lớp và thành phần của một dự án.

Đặc điểm nổi bật của NUnit là khả năng tự động hóa việc thực thi các bài kiểm thử, cho phép chúng chạy một cách độc lập và tự động giúp tiết kiệm thời gian và công sức cho nhà phát triển. Ngoài ra, NUnit còn hỗ trợ tính năng mạnh mẽ như tạo ra các báo cáo chi tiết, kiểm tra tự động, và các tiện ích liên quan khác.

Cách sử dụng NUnit cũng rất đơn giản. Đầu tiên, ta cần tải và cài đặt NUnit framework từ trang web chính thức của NUnit. Sau khi cài đặt thành công, tiếp theo là tạo một dự án mới và thêm thư viện NUnit vào dự án đó. Tiếp theo, ta tạo một class tests với các phương thức kiểm thử. Mỗi phương thức trong class tests sẽ là một bài kiểm thử đơn lẻ. Bài kiểm thử này sẽ kiểm tra tính đúng đắn của một phần mềm hay một thành phần cụ thể trong dự án.

Ví dụ, giả sử ta cần kiểm tra tính đúng đắn của một hàm tính toán đơn giản có tên là Add. Ta có thể viết một phương thức kiểm thử như sau:

“`[Test]public void Add_Test(){// Arrangeint a = 5;int b = 10;

// Actint result = Calculator.Add(a, b);

// AssertAssert.AreEqual(15, result);}“`

Trong ví dụ trên, phương thức kiểm thử Add_Test sẽ kiểm tra xem kết quả của hàm Add có đúng là 15 hay không, khi ta cung cấp 5 và 10 làm tham số vào hàm.

Cách viết bài kiểm thử trong NUnit rất linh hoạt và dễ dàng hiểu. NUnit cung cấp rất nhiều phương thức kiểm thử và các tùy chọn để kiểm tra đủ các trường hợp có thể. Bên cạnh đó, NUnit còn hỗ trợ việc kiểm tra các exception, kiểm tra sự hiệu quả và hiệu năng của ứng dụng, và nhiều tính năng khác.

FAQs (Các câu hỏi thường gặp)

1. NUnit có miễn phí không?– Vâng, NUnit là một framework mã nguồn mở và miễn phí sử dụng.

2. Tại sao nên sử dụng NUnit thay vì các framework kiểm thử khác?– NUnit chủ yếu được sử dụng trong việc kiểm thử phần mềm trên nền tảng .NET, và nó rất phổ biến và được công nhận trong cộng đồng phát triển phần mềm. Nó cung cấp nhiều tính năng và cách sử dụng dễ dàng, giúp cho quá trình kiểm thử dễ dàng và hiệu quả hơn.

3. Làm thế nào để cài đặt NUnit?– Bạn có thể tải NUnit từ trang web chính thức của NUnit (https://nunit.org/) và sau đó làm theo hướng dẫn cài đặt trên trang web.

4. NUnit có hỗ trợ kiểm thử GUI không?– Có, NUnit hỗ trợ kiểm thử GUI thông qua NUnit GUI Runner.

5. NUnit có hỗ trợ kiểm thử liên tục không?– Vâng, NUnit hỗ trợ việc kiểm thử liên tục thông qua công cụ như NUnit Continuous Testing hoặc NUnit Console Runner.

NUnit là một công cụ mạnh mẽ và hiệu quả để kiểm thử phần mềm trên nền tảng .NET. Bằng cách sử dụng NUnit, ta có thể tự động hóa việc kiểm thử và đảm bảo chất lượng sản phẩm một cách hiệu quả. Nếu bạn đang phát triển phần mềm trên nền tảng .NET, hãy thử sử dụng NUnit và trải nghiệm những lợi ích mà nó mang lại.

Kiểm thử tự động với NUnit theo hướng Data-Driven

Danh mục:

2. Thiết lập hướng sử dụng dữ liệu

NUnit hỗ trợ chúng ta thực thi kiểm thử theo hướng Data-Driven khá mạnh với nhiều từ khóa để sử dụng trong nhiều trường hợp khác nhau. Thực thi mã kiểm thử tự động theo hướng Data-Driven được thiết lập theo hai giai đoạn: Tạo dữ liệu và cách sử dụng dữ liệu.

Thiết lập dữ liệu

Trong NUnit, có 3 từ khóa dùng để tạo dữ liệu: Values, Range, RandomTừ khóa Values được sử dụng để cung cấp dữ liệu cho một tham số của phương thức kiểm thử. Các giá trị sử dụng trong Values phải là một giá trị hằng (constant) và phải được khai báo trực tiếp ở phương thức kiểm thử. Nhược điểm chính của từ khóa này là quá hardcoded.

[Test] public void Data_Values([Values(1, 2, 3)] int x, [Values(1, 2)] int y) { Console.WriteLine(x + ” ” + y); }

Từ khóa Range được sử dụng để tạo ra dữ liệu thay vì hardcoded như từ khóa Values. Dữ liệu từ Range tạo ra bởi giá trị bắt đầu và một giá trị kết thúc được cung cấp bởi kỹ sư kiểm thử. Đôi khi kỹ sư kiểm thử cũng cung cấp thêm một giá trị là bước nhảy để xác định khoảng cách giữa các giá trị dữ liệu được tạo ra. Vì giá trị được tạo ra bên trong một khoảng giá trị nên từ khóa này chỉ áp dụng với giá trị số mà thôi. Chuỗi thì không có khoảng cách giá trị, phải không :).

[Test] public void Data_Range([Values(1, 2, 3)] int x, [Range(1, 4)] int y) { Console.WriteLine(x + ” ” + y); }

Nếu từ khóa Range vẫn còn một cái gì đó cố định cho dữ liệu được tạo ra, chúng ta có từ khóa Random để tạo dữ liệu một cách ngẩu nhiên hoàn toàn. Với Random, kỹ sư kiểm thử chỉ cần cho biết số lượng dữ liệu cần tạo, hoặc thêm giá trị tối đa và tối thiểu.

[Test] public void Data_Random([Values(1, 2, 3)] int x, [Random(10)] int y) { Console.WriteLine(x + ” ” + y); }

Thiết lập hướng sử dụng dữ liệu

Sau khi tạo ra và thiết lập dữ liệu cho phương thức kiểm thử, chúng ta cần thiết lập chúng ta muốn thực thi kiểm thử với dữ liệu như thế nào. Với NUnit, chúng ta có các cách sử dụng dữ liệu: Combinatorial hoặc Sequential.Về mặc định, nếu khi chúng ta tạo dữ liệu mà không đề cập gì đến cách sử dụng dữ liệu, cách Combinatorial sẽ được áp dụng. Với Combinatorial, NUnit sẽ kết hợp các dữ liệu trong từng tham số của phương thức kiểm thử thành nhiều bộ dữ liệu theo cách tổ hợp A x B x C x… Điều này có thể dẫn đến trường hợp bùng nổ tổ hợp nếu chúng ta sử dụng quá nhiều tham số cho một phương thức kiểm thử.

[Test, Combinatorial] public void Data_Combine([Values(1, 2, 3)] int x, [Values(1, 2)] int y) { Console.WriteLine(x + ” ” + y); }

Theo như đoạn mã ở trên, chúng ta sẽ có 3 x 2 = 6 bộ dữ liệu cần thực thi kiểm thử.Ngược lại, cách Sequential sẽ tạo ra các bộ dữ liệu kiểm thử theo thứ tự của dữ liệu và kết hợp 1 – 1 từng tham số. Nếu tham số nào không đủ số lượng dữ liệu, giá trị null sẽ được sử dụng.

[Test, Sequential] public void Data_Sequential([Values(1, 2, 3)] int x, [Values(1, 2)] int y) { Console.WriteLine(x + ” ” + y); }

Theo như đoạn mã ở trên, chúng ta sẽ có 3 bộ dữ liệu cần thực thi kiểm thử: (1, 1); (2, 2); (3, null).Chi tiết về các từ khóa trên, các bạn có thể xem clip dưới đây hoặc download mã nguồn tại đây.Nunit còn hỗ trợ một số từ khóa khác với nhiều đặc biệt như giới hạn thời gian, tạo dữ liệu theo hướng đặc biệt, v.v… Các bạn có thể xem thêm tại trang chủ của NUnit.

BTV.Trần Thị Thu HuyềnPhòng Truyền Thông IMicroSoft Việt NamHotline: 0916 878 224Email: [email protected]

Bạn đang muốn tìm kiếm 1 công việc với mức thu nhập cao.✅ Hoặc là bạn đang muốn chuyển đổi công việc mà chưa biết theo học ngành nghề gì cho tốt.✅ Giới thiệu với bạn Chương trình đào tạo nhân sự dài hạn trong 12 tháng với những điều đặc biệt mà chỉ có tại IMIC và đây cũng chính là sự lựa chọn phù hợp nhất dành cho bạn:👉 Thứ nhất: Học viên được đào tạo bài bản kỹ năng, kiến thức chuyên môn lý thuyết, thực hành, thực chiến nhiều dự án và chia sẻ những kinh nghiệm thực tế từ Chuyên gia có nhiều năm kinh nghiệm dự án cũng như tâm huyết truyền nghề.👉 Thứ hai: Được ký hợp đồng cam kết chất lượng đào tạo cũng như mức lương sau tốt nghiệp và đi làm tại các đối tác tuyển dụng của IMIC. Trả lại học phí nếu không đúng những gì đã ký kết.👉 Thứ ba: Cam kết hỗ trợ giới thiệu công việc sang đối tác tuyển dụng trong vòng 10 năm liên tục.👉 Thứ tư: Được hỗ trợ tài chính với mức lãi suất 0 đồng qua ngân hàng VIB Bank.👉 Có 4 Chương trình đào tạo nhân sự dài hạn dành cho bạn lựa chọn theo học. Gồm có:1) Data Scientist full-stack2) Embedded System & IoT development full-stack3) Game development full-stack4) Web development full-stack✅ Cảm ơn bạn đã dành thời gian lắng nghe những chia sẻ của mình. Và tuyệt vời hơn nữa nếu IMIC được góp phần vào sự thành công của bạn.✅ Hãy liên hệ ngay với Phòng tư vấn tuyển sinh để được hỗ trợ về thủ tục nhập học.✅ Chúc bạn luôn có nhiều sức khỏe và thành công!

Data-Driven Tests with C#, NUnit and Selenium

Data-Driven Testing == running the same test case with multiple data This example demonstrates how to write data-driven NUnit tests:

Parameterized tests with
[TestCase]
Excel-based tests:
[TestCaseSource]
Data-driven Selenium tests (based on Selenium +
[TestCase]
)

Writing Test method using NUnit in Selenium C# -- Part 4 (Selenium automation with C#) — Writing Test method using NUnit in Selenium C# — Part 4 (Selenium automation with C#)

nunit csv data driven

NUnit là một framework kiểm thử đơn vị linh hoạt và mạnh mẽ cho phát triển ứng dụng .NET. Một trong số những tính năng nổi bật của NUnit là khả năng sử dụng dữ liệu đa dạng trong quá trình kiểm thử. Trong bài viết này, chúng ta sẽ tìm hiểu về cách sử dụng dữ liệu CSV (Comma Separated Values – Giá trị phân tách bằng dấu phẩy) trong quá trình kiểm thử của NUnit.

## Sử dụng NUnit CSV Data Driven

Đầu tiên, chúng ta cần cài đặt gói NUnit.Extension.Combines để hỗ trợ việc sử dụng dữ liệu từ file CSV. Bạn có thể cài đặt gói này thông qua NuGet Package Manager trong Visual Studio.

Sau khi cài đặt thành công gói NUnit.Extension.Combines, chúng ta cần tạo một file CSV chứa dữ liệu kiểm thử. Mỗi dòng của file CSV tương ứng với một bộ dữ liệu đầu vào cho phương thức kiểm thử. Các giá trị của mỗi dòng được phân tách bằng dấu phẩy.

Ví dụ, chúng ta có một phương thức kiểm thử ở trong một lớp TestClass với một tham số đầu vào là firstname và lastname. Chúng ta muốn kiểm thử phương thức này với các bộ dữ liệu khác nhau.

“`csharpusing NUnit.Framework;using NUnit.Extension.Combines;using System.IO;

namespace NUnitTests{[TestFixture]public class TestClass{[Test][Combines(nameof(FirstName), @”\NUnitTests\testdata.csv”)]public void TestMethod(string firstName, string lastName){// Kiểm tra kết quả phương thức kiểm thử với dữ liệu được tham số hóa}}}“`

Ở dòng code `[Combines(nameof(FirstName), @”\NUnitTests\testdata.csv”)]`, chúng ta sử dụng attribute `[Combines]` để chỉ định cho NUnit biết rằng chúng ta đang sử dụng dữ liệu từ file CSV `testdata.csv`. Chúng ta truyền tên của các tham số (firstname và lastname) vào attribute `[Combines]` thông qua `nameof()` để NUnit biết được thứ tự của các giá trị dữ liệu trong file CSV.

## FAQs (Các câu hỏi thường gặp)

### Q1: Làm thế nào để cài đặt gói NUnit.Extension.Combines?A1: Bạn có thể cài đặt gói NUnit.Extension.Combines thông qua NuGet Package Manager trong Visual Studio. Tìm kiếm gói NUnit.Extension.Combines và cài đặt gói này vào dự án của bạn.

### Q2: File CSV phải được đặt ở đâu trong dự án?A2: Bạn có thể đặt file CSV ở bất kỳ vị trí nào trong dự án. Trong ví dụ trên, file CSV được đặt trong thư mục “NUnitTests” của dự án. Bạn có thể chỉ định đường dẫn tới file CSV tương ứng với vị trí của file đó trong dự án của bạn.

### Q3: Định dạng dữ liệu trong file CSV như thế nào?A3: Mỗi dòng trong file CSV tương ứng với một bộ dữ liệu đầu vào cho phương thức kiểm thử. Các giá trị trong mỗi dòng được phân tách bằng dấu phẩy. Bạn có thể định dạng các giá trị dữ liệu theo mong muốn của bạn.

### Q4: Có thể sử dụng gói NUnit.Extension.Combines với các loại file dữ liệu khác không?A4: Hiện tại, NUnit.Extension.Combines chỉ hỗ trợ sử dụng dữ liệu từ file CSV. Để sử dụng dữ liệu từ các loại file dữ liệu khác, bạn cần xử lý thủ công hoặc tìm kiếm các gói mở rộng khác của NUnit.

## Kết luận

Qua bài viết này, chúng ta đã tìm hiểu về cách sử dụng dữ liệu CSV trong quá trình kiểm thử với NUnit. Sử dụng dữ liệu CSV giúp chúng ta kiểm thử phương thức với nhiều bộ dữ liệu khác nhau, từ đó tăng tính bao phủ và độ tin cậy của kiểm thử. Nếu bạn đã quen thuộc với NUnit, việc sử dụng dữ liệu CSV sẽ giúp bạn nhanh chóng và dễ dàng thực hiện kiểm thử và kiểm tra kết quả.

Creating the test project

Next, create the PrimeService.Tests directory. The following outline shows the directory structure:

/unit-testing-using-nunit unit-testing-using-nunit.sln /PrimeService Source Files PrimeService.csproj /PrimeService.Tests

Make the PrimeService.Tests directory the current directory and create a new project using the following command:

dotnet new nunit

The dotnet new command creates a test project that uses NUnit as the test library. The generated template configures the test runner in the PrimeService.Tests.csproj file:

all runtime; build; native; contentfiles; analyzers

The test project requires other packages to create and run unit tests. The
dotnet new
command in the previous step added the Microsoft test SDK, the NUnit test framework, and the NUnit test adapter. Now, add the
PrimeService
class library as another dependency to the project. Use the
dotnet add reference
command:

dotnet add reference ../PrimeService/PrimeService.csproj

You can see the entire file in the samples repository on GitHub.

The following outline shows the final solution layout:

/unit-testing-using-nunit unit-testing-using-nunit.sln /PrimeService Source Files PrimeService.csproj /PrimeService.Tests Test Source Files PrimeService.Tests.csproj

Execute the following command in the unit-testing-using-nunit directory:

dotnet sln add ./PrimeService.Tests/PrimeService.Tests.csproj

Unit testing your Web APIs [18 of 18] | Web APIs for Beginners

NUnit Parameterized Tests (Or Data-Driven Tests)

Parameterization of NUnit tests was introduced with version 2.5 (as mentioned above) and is considered extremely useful when used with the Selenium WebDriver. Using special attributes in NUnit, you can develop foolproof tests by verifying them on different browsers, browser versions, and platforms, which can be passed as parameters to the test.

To demonstrate an NUnit parameterized test example, we perform the test mentioned below:

Open DuckDuckGo in the intended web browser.
Locate the search box.
Enter search query i.e., LambdaTest.
Execute the search operation.
Free up the resources.

You can refer to our detailed article on NUnit, which walks you through the implementation of executing the above mentioned test without parameterization.

Cross browser testing on the local Selenium grid can hit a roadblock as it is not feasible to have an in-house setup with different combinations of browsers, platforms, and devices.Using a local Selenium grid for cross browser testing can lead to a reduction of test coverage. Instead, cross browser testing should be performed on cloud-based cross browser testing platforms like LambdaTest, where testing can be performed on 3000+ browsers, thereby providing wider test coverage.

To get started, you should create an account on LambdaTest and note the user-name & access-key from the Profile Page. Desired capabilities can be generated using LambdaTest Capabilities Generator, and these capabilities enable to execute tests using different browser + OS combinations on remote Selenium grid. Along with parameterization, the prerequisite is that the tests have to be executed in parallel to complete test execution within a shorter time. With my current plan, I can execute five tests in parallel on the remote Selenium Grid on LambdaTest.

Let’s explore the different attributes in NUnit using which we can come up with an NUnit parameterized test:

Take this certification to master the fundamentals of Selenium automation testing with C# and prove your credibility as a tester.

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

How NUnit is used in unit testing?

To use NUnit for unit testing with Selenium, we can use the Visual Studio IDE for development and execution. Using Visual Studio, developers can come up with test cases/test suites for different platforms like Windows, Android, iOS, Web, Cloud, etc.

Set up Visual Studio for development.
Install the NUnit framework & NUnit test adapter.
Setup Selenium WebDriver with Visual Studio
Start automated browser testing with NUnit for Selenium scripts

SpecFlow Selenium C# Tutorial Full Course 2023 | SpecFlow C# Tutorial

TestCaseSource Attribute

The TestCaseSource attribute can be applied to any test method, just like the TestCase attribute. The property, methods, or fields specified by the TestCaseSource attribute provide the arguments to the parameterized method. Unlike the TestCase attribute that is used to provide simple compile-time constants as parameters to the parameterized function, the TestCaseSource attribute can be used to provide more complicated parameter types.

The other major advantage of this attribute is that the source method is reusable across different tests. The object/data that is a part of the method using the TestCaseSource attribute can also be reused for multiple tests.

The source specified by the attribute can either return IEnumerable or a type that implements IEnumerable. For simple tests, object[] can be returned from the source. For more complicated tests, IEnumerable is used as the TestCaseData class provides additional test case information for a parameterized test, e.g., TestName, Result, ExpectedException, Properties, Result, etc.

For demonstrating the usage of TestCaseSource to create an NUnit parameterized test, the source method uses IEnumerable to provide values to the parameterized function.

Demonstration – [TestCaseSource] Attribute

We use the same test case that was used to showcase the usage of the TestCase attribute, i.e., a search for ‘LambdaTest’ is performed on the following browser and OS combinations.

The complete implementation is below:

Code WalkThrough

The core implementation that involves the following remains the same as the [TestCase] attribute:

Invocation of Selenium WebDriver in the target web browser.
Generation of browser capabilities.
Performing a search on DuckDuckGo, and
Releasing the resources used by the WebDriver instance as a part of the TearDown attribute.

You can refer to steps 1, 3, 4, and 5 from the ‘Code WalkThrough’ section of [TestCase] attribute for more detailed information on how the above requirements are implemented in the code.

As shown in the snippet below, AddBrowserConfs() is the source method that returns IEnumerable. The browser capabilities are passed to the parameterized function, i.e., DuckDuckGo_TestCaseSource_Demo(String browser, String version, String os) through the TestCaseData attribute.

The test case information provided via TestCaseData matches the argument type being used in DuckDuckGo_TestCaseSource_Demo, i.e., the arguments should be of type String.

The TestCaseSource attribute uses the AddBrowserConfs method to supply parameters to the test case DuckDuckGo_TestCaseSource_Demo.

private static IEnumerable AddBrowserConfs()

yield return new TestCaseData(“chrome”, “72.0”, “Windows 10”);

yield return new TestCaseData(“internet explorer”, “11.0”, “Windows 10”);

yield return new TestCaseData(“Safari”, “11.0”, “macOS High Sierra”);

yield return new TestCaseData(“MicrosoftEdge”, “18.0”, “Windows 10”); }

……………….

[Test, TestCaseSource(“AddBrowserConfs”)]

public void DuckDuckGo_TestCaseSource_Demo(String browser, String version, String os)

……………….

As shown in the execution snapshot, the four tests are executed in parallel on LambdaTest’s remote Selenium grid. The browser capabilities are passed to DuckDuckGo_TestCaseSource_Demo using the TestCaseSource attribute that is used on AddBrowserConfs, a parameterized test method.

Interesting Read: Top 28 Selenium WebDriver Commands in NUnit