Làm cách nào để chạy một phương thức thử nghiệm với nhiều tham số trong MSTest?

NUnit có một tính năng gọi là Giá trị, như dưới đây:

[Test]
public void MyTest(
    [Values(1,2,3)] int x,
    [Values("A","B")] string s)
{
    // ...
}

Điều này có nghĩa là phương pháp thử nghiệm sẽ chạy 6 lần:

MyTest(1, "A")
MyTest(1, "B")
MyTest(2, "A")
MyTest(2, "B")
MyTest(3, "A")
MyTest(3, "B")

Hiện tại chúng tôi đang sử dụng MSTest, có điều gì tương đương với điều này để tôi có thể chạy thử nghiệm tương tự với nhiều tham số không?

[TestMethod]
public void Mytest()
{
    // ...
}

Thật không may, không được hỗ trợ trong MSTest. Rõ ràng có một mô hình mở rộng và bạn có thể tự thực hiện nó . Một lựa chọn khác là sử dụng các bài kiểm tra dựa trên dữ liệu .

Ý kiến ​​cá nhân của tôi sẽ chỉ gắn bó với NUnit mặc dù ...

EDIT: Kể từ Visual Studio 2012, cập nhật 1, MSTest có một tính năng tương tự. Xem câu trả lời của @ McAden bên dưới.

EDIT 4 : Có vẻ như điều này đã được hoàn thành trong MSTest V2 ngày 17 tháng 6 năm 2016: https://bloss.msdn.microsoft.com/visualstudioalm/2016/06/17/taking-the-mstest-framework-forward-with-mstest- v2 /

Câu trả lời gốc :

Kể từ khoảng một tuần trước trong Visual Studio 2012 Update 1, một cái gì đó tương tự hiện có thể:

[DataTestMethod]
[DataRow(12,3,4)]
[DataRow(12,2,6)]
[DataRow(12,4,3)]
public void DivideTest(int n, int d, int q)
{
  Assert.AreEqual( q, n / d );
}

EDIT : Dường như điều này chỉ khả dụng trong dự án thử nghiệm đơn vị cho WinRT / Metro . Bummer

EDIT 2 : Sau đây là siêu dữ liệu được tìm thấy bằng cách sử dụng "Chuyển đến định nghĩa" trong Visual Studio:

#region Assembly Microsoft.VisualStudio.TestPlatform.UnitTestFramework.dll, v11.0.0.0
// C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0\ExtensionSDKs\MSTestFramework\11.0\References\CommonConfiguration\neutral\Microsoft.VisualStudio.TestPlatform.UnitTestFramework.dll
#endregion

using System;

namespace Microsoft.VisualStudio.TestPlatform.UnitTestFramework
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public class DataTestMethodAttribute : TestMethodAttribute
    {
        public DataTestMethodAttribute();

        public override TestResult[] Execute(ITestMethod testMethod);
    }
}

EDIT 3 : Vấn đề này đã được đưa lên trong các diễn đàn UserVoice của Visual Studio. Cập nhật lần cuối:

BẮT ĐẦU · Nhóm Visual Studio Nhóm ADMIN Visual Studio (Nhóm sản phẩm, Microsoft Visual Studio) đã trả lời · 25 tháng 4 năm 2016 Cảm ơn bạn đã phản hồi. Chúng tôi đã bắt đầu làm việc này.

Phòng thu hình ảnh của Pratap Lakshman

https://visualstudio.uservoice.com/forums/330519-team-service/suggestions/3865310-allow-use-of-datatestmethod-datarow-in-all-unit

Tính năng này hiện đang được phát hành trước và hoạt động với VS 2015.

Ví dụ:

[TestClass]
public class UnitTest1
{
    [DataTestMethod]
    [DataRow(1, 2, 2)]
    [DataRow(2, 3, 5)]
    [DataRow(3, 5, 8)]
    public void AdditionTest(int a, int b, int result)
    {
        Assert.AreEqual(result, a + b);
    }
}

Vì không ai đề cập - không hoàn toàn giống với các thuộc tính Value(hoặc TestCase) của NUnit , nhưng MSTest có DataSourcethuộc tính, cho phép bạn thực hiện điều tương tự. Bạn có thể nối nó với cơ sở dữ liệu hoặc tệp XML - không đơn giản như tính năng của NUnit, nhưng thực hiện công việc.

MSTest có một thuộc tính mạnh mẽ được gọi là DataSource , bằng cách này, bạn có thể thực hiện kiểm tra theo hướng dữ liệu như bạn đã yêu cầu. Bạn có thể có dữ liệu thử nghiệm của mình bằng XML, CSV hoặc trong cơ sở dữ liệu. Dưới đây là một vài liên kết sẽ hướng dẫn bạn

http://visualstudiomagazine.com/articles/2009/09/15/unit-testing-with-vsts2008-part-3.aspx http://msdn.microsoft.com/en-us/l Library / ms182527.aspx
http: //msdn.microsoft.com/en-us/l Library / ms243192.aspx

Hy vọng điều này sẽ giúp bạn.

Cách thực hiện rất đơn giản - bạn nên sử dụng thuộc TestContexttính và TestPropertyAttribute.

Thí dụ

public TestContext TestContext { get; set; }
private List<string> GetProperties()
{
    return TestContext.Properties
        .Cast<KeyValuePair<string, object>>()
        .Where(_ => _.Key.StartsWith("par"))
        .Select(_ => _.Value as string)
        .ToList();
}

//usage
[TestMethod]
[TestProperty("par1", "http://getbootstrap.com/components/")]
[TestProperty("par2", "http://www.wsj.com/europe")]
public void SomeTest()
{
    var pars = GetProperties();
    //...
}

BIÊN TẬP:

Tôi đã chuẩn bị một vài phương thức mở rộng để đơn giản hóa quyền truy cập vào TestContexttài sản và hành động như chúng ta có một số trường hợp thử nghiệm. Xem ví dụ với việc xử lý các thuộc tính thử nghiệm đơn giản tại đây:

[TestMethod]
[TestProperty("fileName1", @".\test_file1")]
[TestProperty("fileName2", @".\test_file2")]
[TestProperty("fileName3", @".\test_file3")]
public void TestMethod3()
{
    TestContext.GetMany<string>("fileName").ForEach(fileName =>
    {
        //Arrange
        var f = new FileInfo(fileName);

        //Act
        var isExists = f.Exists;

        //Asssert
        Assert.IsFalse(isExists);
    });
}

và ví dụ với việc tạo các đối tượng thử nghiệm phức tạp:

[TestMethod]
//Case 1
[TestProperty(nameof(FileDescriptor.FileVersionId), "673C9C2D-A29E-4ACC-90D4-67C52FBA84E4")]
//...
public void TestMethod2()
{
    //Arrange
    TestContext.For<FileDescriptor>().Fill(fi => fi.FileVersionId).Fill(fi => fi.Extension).Fill(fi => fi.Name).Fill(fi => fi.CreatedOn, new CultureInfo("en-US", false)).Fill(fi => fi.AccessPolicy)
        .ForEach(fileInfo =>
        {
            //Act
            var fileInfoString = fileInfo.ToString();

            //Assert
            Assert.AreEqual($"Id: {fileInfo.FileVersionId}; Ext: {fileInfo.Extension}; Name: {fileInfo.Name}; Created: {fileInfo.CreatedOn}; AccessPolicy: {fileInfo.AccessPolicy};", fileInfoString);
        });
}

Hãy xem các phương pháp mở rộng và tập hợp các mẫu để biết thêm chi tiết.

Tất nhiên, có một cách khác để làm điều này chưa được thảo luận trong luồng này, tức là bằng cách kế thừa lớp chứa TestMethod. Trong ví dụ sau, chỉ có một TestMethod được xác định nhưng hai trường hợp thử nghiệm đã được thực hiện.

Trong Visual Studio 2012, nó tạo ra hai thử nghiệm trong TestExplorer:

1. DemoTest_B10_A5.test

2. DemoTest_A12_B4.test

   public class Demo
   {
       int a, b;
   
       public Demo(int _a, int _b)
       {
           this.a = _a;
           this.b = _b;
       }
   
       public int Sum()
       {
           return this.a + this.b;
       }
   }
   
   public abstract class DemoTestBase
   {
       Demo objUnderTest;
       int expectedSum;
   
       public DemoTestBase(int _a, int _b, int _expectedSum)
       {
           objUnderTest = new Demo(_a, _b);
           this.expectedSum = _expectedSum;
       }
   
       [TestMethod]
       public void test()
       {
           Assert.AreEqual(this.expectedSum, this.objUnderTest.Sum());
       }
   }
   
   [TestClass]
   public class DemoTest_A12_B4 : DemoTestBase
   {
       public DemoTest_A12_B4() : base(12, 4, 16) { }
   }
   
   public abstract class DemoTest_B10_Base : DemoTestBase
   {
       public DemoTest_B10_Base(int _a) : base(_a, 10, _a + 10) { }
   }
   
   [TestClass]
   public class DemoTest_B10_A5 : DemoTest_B10_Base
   {
       public DemoTest_B10_A5() : base(5) { }
   }

MsTest không hỗ trợ tính năng đó nhưng bạn có thể triển khai thuộc tính của riêng mình để đạt được điều đó. có một cái nhìn dưới đây:

http://blog.drorhelper.com/2011/09/eneac-parameterized-tests-in-mstest.html

Tôi không thể có được The DataRowAttributeto work trong Visual Studio 2015, đây là những gì tôi đã kết thúc với:

[TestClass]
public class Tests
{
    private Foo _toTest;

    [TestInitialize]
    public void Setup()
    {
        this._toTest = new Foo();       
    }

    [TestMethod]
    public void ATest()
    {
        this.Perform_ATest(1, 1, 2);
        this.Setup();

        this.Perform_ATest(100, 200, 300);
        this.Setup();

        this.Perform_ATest(817001, 212, 817213);
        this.Setup();

    }

    private void Perform_ATest(int a, int b, int expected)
    {
        //Obviously this would be way more complex...

        Assert.IsTrue(this._toTest.Add(a,b) == expected);    
    }
}

public class Foo
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

Giải pháp thực sự ở đây là chỉ sử dụng NUnit (trừ khi bạn bị mắc kẹt trong MSTest như tôi trong trường hợp cụ thể này).