Xác định xem mã có đang chạy như một phần của bài kiểm tra đơn vị hay không

Tôi có một bài kiểm tra đơn vị (nUnit). Nhiều lớp bên dưới ngăn xếp cuộc gọi, một phương thức sẽ không thành công nếu nó đang chạy qua một bài kiểm tra đơn vị.

Lý tưởng nhất là bạn sẽ sử dụng một cái gì đó như mocking để thiết lập đối tượng mà phương pháp này phụ thuộc vào nhưng đây là mã của bên thứ 3 và tôi không thể làm điều đó nếu không có nhiều công việc.

Tôi không muốn thiết lập các phương thức cụ thể của nUnit - có quá nhiều cấp độ ở đây và cách thực hiện kiểm tra đơn vị kém.

Thay vào đó, những gì tôi muốn làm là thêm một cái gì đó như thế này vào sâu trong ngăn xếp cuộc gọi

#IF DEBUG // Unit tests only included in debug build
if (IsRunningInUnitTest)
   {
   // Do some setup to avoid error
   }
#endif

Vì vậy, bất kỳ ý tưởng về cách viết IsRunningInUnitTest?

Tái bút Tôi hoàn toàn biết rằng đây không phải là thiết kế tuyệt vời, nhưng tôi nghĩ nó tốt hơn các lựa chọn thay thế.

Tôi đã làm điều này trước đây - tôi đã phải giữ mũi khi làm việc đó, nhưng tôi đã làm được. Chủ nghĩa thực dụng đánh bại chủ nghĩa giáo điều mọi lúc. Tất nhiên, nếu có là một cách tốt đẹp, bạn có thể cấu trúc lại để tránh nó, đó sẽ là tuyệt vời.

Về cơ bản, tôi có một lớp "UnitTestDetector" để kiểm tra xem lắp ráp khung NUnit đã được tải trong AppDomain hiện tại hay chưa. Nó chỉ cần làm điều này một lần, sau đó lưu kết quả vào bộ nhớ cache. Xấu xí, nhưng đơn giản và hiệu quả.

Lấy ý tưởng của Jon, đây là điều tôi nghĩ ra -

using System;
using System.Reflection;

/// <summary>
/// Detect if we are running as part of a nUnit unit test.
/// This is DIRTY and should only be used if absolutely necessary 
/// as its usually a sign of bad design.
/// </summary>    
static class UnitTestDetector
{

    private static bool _runningFromNUnit = false;      

    static UnitTestDetector()
    {
        foreach (Assembly assem in AppDomain.CurrentDomain.GetAssemblies())
        {
            // Can't do something like this as it will load the nUnit assembly
            // if (assem == typeof(NUnit.Framework.Assert))

            if (assem.FullName.ToLowerInvariant().StartsWith("nunit.framework"))
            {
                _runningFromNUnit = true;
                break;
            }
        }
    }

    public static bool IsRunningFromNUnit
    {
        get { return _runningFromNUnit; }
    }
}

Nhìn xuống phía sau, tất cả chúng ta đều là những cậu bé đủ lớn để nhận ra khi nào chúng ta đang làm điều gì đó mà chúng ta có thể không nên;)

Phỏng theo câu trả lời của Ryan. Cái này dành cho khung kiểm tra đơn vị MS.

Lý do tôi cần điều này là vì tôi hiển thị một MessageBox về lỗi. Nhưng các bài kiểm tra đơn vị của tôi cũng kiểm tra mã xử lý lỗi và tôi không muốn MessageBox bật lên khi chạy kiểm tra đơn vị.

/// <summary>
/// Detects if we are running inside a unit test.
/// </summary>
public static class UnitTestDetector
{
    static UnitTestDetector()
    {
        string testAssemblyName = "Microsoft.VisualStudio.QualityTools.UnitTestFramework";
        UnitTestDetector.IsInUnitTest = AppDomain.CurrentDomain.GetAssemblies()
            .Any(a => a.FullName.StartsWith(testAssemblyName));
    }

    public static bool IsInUnitTest { get; private set; }
}

Và đây là một bài kiểm tra đơn vị cho nó:

    [TestMethod]
    public void IsInUnitTest()
    {
        Assert.IsTrue(UnitTestDetector.IsInUnitTest, 
            "Should detect that we are running inside a unit test."); // lol
    }

Đơn giản hóa giải pháp của Ryan, bạn chỉ có thể thêm thuộc tính tĩnh sau vào bất kỳ lớp nào:

    public static readonly bool IsRunningFromNUnit = 
        AppDomain.CurrentDomain.GetAssemblies().Any(
            a => a.FullName.ToLowerInvariant().StartsWith("nunit.framework"));

Tôi sử dụng một cách tiếp cận tương tự như highseth

Đây là mã cơ bản có thể dễ dàng sửa đổi để đưa vào bộ nhớ đệm. Một ý tưởng hay khác là thêm một setter vào IsRunningInUnitTestvà gọi UnitTestDetector.IsRunningInUnitTest = falseđến điểm nhập chính của dự án của bạn để tránh thực thi mã.

public static class UnitTestDetector
{
    public static readonly HashSet<string> UnitTestAttributes = new HashSet<string> 
    {
        "Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute",
        "NUnit.Framework.TestFixtureAttribute",
    };
    public static bool IsRunningInUnitTest
    {
        get
        {
            foreach (var f in new StackTrace().GetFrames())
                if (f.GetMethod().DeclaringType.GetCustomAttributes(false).Any(x => UnitTestAttributes.Contains(x.GetType().FullName)))
                    return true;
            return false;
        }
    }
}

Có thể hữu ích, hãy kiểm tra ProcessName hiện tại:

public static bool UnitTestMode
{
    get 
    { 
        string processName = System.Diagnostics.Process.GetCurrentProcess().ProcessName;

        return processName == "VSTestHost"
                || processName.StartsWith("vstest.executionengine") //it can be vstest.executionengine.x86 or vstest.executionengine.x86.clr20
                || processName.StartsWith("QTAgent");   //QTAgent32 or QTAgent32_35
    }
}

Và chức năng này cũng nên được kiểm tra bằng cách:

[TestClass]
public class TestUnittestRunning
{
    [TestMethod]
    public void UnitTestRunningTest()
    {
        Assert.IsTrue(MyTools.UnitTestMode);
    }
}

Tài liệu tham khảo:
Matthew Watson trong http://social.msdn.microsoft.com/Forums/en-US/csharplanguage/thread/11e68468-c95e-4c43-b02b-7045a52b407e/

Trong chế độ thử nghiệm, Assembly.GetEntryAssembly()dường như được null.

#IF DEBUG // Unit tests only included in debug build 
  if (Assembly.GetEntryAssembly() == null)    
  {
    // Do some setup to avoid error    
  }
#endif 

Lưu ý rằng nếu Assembly.GetEntryAssembly()có null, Assembly.GetExecutingAssembly()thì không.

Các tài liệu cho biết: Các GetEntryAssemblyphương pháp có thể trở lại nullkhi một quản lý lắp ráp đã được tải từ một ứng dụng không được quản lý.

Một nơi nào đó trong dự án đang được thử nghiệm:

public static class Startup
{
    public static bool IsRunningInUnitTest { get; set; }
}

Ở đâu đó trong dự án thử nghiệm đơn vị của bạn:

[TestClass]
public static class AssemblyInitializer
{
    [AssemblyInitialize]
    public static void Initialize(TestContext context)
    {
        Startup.IsRunningInUnitTest = true;
    }
}

Thanh lịch, không. Nhưng đơn giản và nhanh chóng. AssemblyInitializerdành cho Thử nghiệm MS. Tôi mong đợi các khuôn khổ thử nghiệm khác có các khung tương đương.

Tôi sử dụng này chỉ cho bỏ qua logic mà vô hiệu hóa tất cả TraceAppenders trong log4net trong khởi động khi không có debugger được đính kèm. Điều này cho phép các bài kiểm tra đơn vị đăng nhập vào cửa sổ kết quả Resharper ngay cả khi chạy ở chế độ không gỡ lỗi.

Phương thức sử dụng chức năng này được gọi khi khởi động ứng dụng hoặc khi bắt đầu một lịch thi đấu.

Nó tương tự như bài đăng của Ryan nhưng sử dụng LINQ, bỏ yêu cầu System.Reflection, không lưu kết quả vào bộ nhớ cache và ở chế độ riêng tư để ngăn chặn việc lạm dụng (vô tình).

    private static bool IsNUnitRunning()
    {
        return AppDomain.CurrentDomain.GetAssemblies().Any(assembly => assembly.FullName.ToLowerInvariant().StartsWith("nunit.framework"));
    }

Có một tham chiếu đến khung nunit không có nghĩa là thử nghiệm đó thực sự đang chạy. Ví dụ trong Unity khi bạn kích hoạt kiểm tra chế độ chơi, các tham chiếu nunit được thêm vào dự án. Và khi bạn chạy một trò chơi, các tham chiếu vẫn tồn tại, vì vậy UnitTestDetector sẽ không hoạt động chính xác.

Thay vì kiểm tra lắp ráp nunit, chúng ta có thể yêu cầu nunit api kiểm tra xem mã có đang thực thi kiểm tra ngay bây giờ hay không.

using NUnit.Framework;

// ...

if (TestContext.CurrentContext != null)
{
    // nunit test detected
    // Do some setup to avoid error
}

Biên tập:

Lưu ý rằng TestContext có thể được tạo tự động nếu nó được yêu cầu.

Chỉ cần sử dụng cái này:

AppDomain.CurrentDomain.IsDefaultAppDomain()

Trong chế độ thử nghiệm, nó sẽ trả về false.

Tôi không vui khi có vấn đề này gần đây. Tôi đã giải quyết nó theo một cách hơi khác. Đầu tiên, tôi không muốn đưa ra giả định rằng khung công tác nunit sẽ không bao giờ được tải bên ngoài môi trường thử nghiệm; Tôi đặc biệt lo lắng về việc các nhà phát triển chạy ứng dụng trên máy của họ. Vì vậy, tôi đã đi bộ cuộc gọi thay thế. Thứ hai, tôi có thể đưa ra giả định rằng mã thử nghiệm sẽ không bao giờ được chạy dựa trên các mã nhị phân phát hành, vì vậy tôi đảm bảo rằng mã này không tồn tại trong hệ thống phát hành.

internal abstract class TestModeDetector
{
    internal abstract bool RunningInUnitTest();

    internal static TestModeDetector GetInstance()
    {
    #if DEBUG
        return new DebugImplementation();
    #else
        return new ReleaseImplementation();
    #endif
    }

    private class ReleaseImplementation : TestModeDetector
    {
        internal override bool RunningInUnitTest()
        {
            return false;
        }
    }

    private class DebugImplementation : TestModeDetector
    {
        private Mode mode_;

        internal override bool RunningInUnitTest()
        {
            if (mode_ == Mode.Unknown)
            {
                mode_ = DetectMode();
            }

            return mode_ == Mode.Test;
        }

        private Mode DetectMode()
        {
            return HasUnitTestInStack(new StackTrace()) ? Mode.Test : Mode.Regular;
        }

        private static bool HasUnitTestInStack(StackTrace callStack)
        {
            return GetStackFrames(callStack).SelectMany(stackFrame => stackFrame.GetMethod().GetCustomAttributes(false)).Any(NunitAttribute);
        }

        private static IEnumerable<StackFrame> GetStackFrames(StackTrace callStack)
        {
            return callStack.GetFrames() ?? new StackFrame[0];
        }

        private static bool NunitAttribute(object attr)
        {
            var type = attr.GetType();
            if (type.FullName != null)
            {
                return type.FullName.StartsWith("nunit.framework", StringComparison.OrdinalIgnoreCase);
            }
            return false;
        }

        private enum Mode
        {
            Unknown,
            Test,
            Regular
        }

hoạt động như một sự quyến rũ

if (AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x => x.FullName.ToLowerInvariant().StartsWith("nunit.framework")) != null)
{
    fileName = @"C:\Users\blabla\xxx.txt";
}
else
{
    var sfd = new SaveFileDialog
    {     ...     };
    var dialogResult = sfd.ShowDialog();
    if (dialogResult != DialogResult.OK)
        return;
    fileName = sfd.FileName;
}

.

Bài kiểm tra đơn vị sẽ bỏ qua điểm đầu vào của ứng dụng. Ít nhất đối với wpf, ứng dụng winforms và console main()không được gọi.

Nếu phương thức chính được gọi hơn chúng ta đang trong thời gian chạy , nếu không, chúng ta đang ở chế độ kiểm tra đơn vị :

public static bool IsUnitTest { get; private set; } = true;

[STAThread]
public static void main()
{
    IsUnitTest = false;
    ...
}

Xem xét mã của bạn là bình thường khi chạy trong chuỗi chính (gui) của ứng dụng biểu mẫu windows và bạn muốn nó hoạt động khác khi chạy trong một thử nghiệm, bạn có thể kiểm tra

if (SynchronizationContext.Current == null)
{
    // code running in a background thread or from within a unit test
    DoSomething();
}
else
{
    // code running in the main thread or any other thread where
    // a SynchronizationContext has been set with
    // SynchronizationContext.SetSynchronizationContext(synchronizationContext);
    DoSomethingAsync();
}

Tôi đang sử dụng điều này cho mã mà tôi muốn fire and forgottrong ứng dụng gui nhưng trong các bài kiểm tra đơn vị, tôi có thể cần kết quả được tính toán để xác nhận và tôi không muốn gây rối với nhiều luồng đang chạy.

Hoạt động cho MSTest. Ưu điểm là mã của tôi không cần phải kiểm tra chính khung thử nghiệm và nếu tôi thực sự cần hành vi không đồng bộ trong một thử nghiệm nhất định, tôi có thể đặt SynchronizationContext của riêng mình.

Lưu ý rằng đây không phải là một phương pháp đáng tin cậy Determine if code is running as part of a unit testtheo yêu cầu của OP vì mã có thể đang chạy bên trong một chuỗi nhưng đối với một số trường hợp nhất định thì đây có thể là một giải pháp tốt (ngoài ra: Nếu tôi đang chạy từ một chuỗi nền, thì có thể không cần thiết để bắt đầu một cái mới).

Application.Current là rỗng khi chạy dưới trình kiểm tra đơn vị. Ít nhất là đối với ứng dụng WPF của tôi bằng cách sử dụng MS Unit tester. Đó là một bài kiểm tra dễ thực hiện nếu cần. Ngoài ra, một số điều cần lưu ý khi sử dụng Application.Current trong mã của bạn.

Tôi đã sử dụng phần sau trong VB trong mã của mình để kiểm tra xem chúng ta có đang kiểm tra đơn vị hay không. đặc biệt là tôi không muốn bài kiểm tra mở Word

    If Not Application.ProductName.ToLower().Contains("test") then
        ' Do something 
    End If

Làm thế nào về việc sử dụng phản chiếu và những thứ tương tự như thế này:

var underTest = Assembly.GetCallingAssembly ()! = typeof (MainForm) .Assembly;

Hợp ngữ gọi sẽ là nơi chứa các trường hợp thử nghiệm của bạn và chỉ thay thế cho MainForm một số loại trong mã của bạn đang được thử nghiệm.

Có một giải pháp thực sự đơn giản khi bạn đang kiểm tra một lớp ...

Đơn giản chỉ cần cung cấp cho lớp bạn đang kiểm tra một thuộc tính như sau:

// For testing purposes to avoid running certain code in unit tests.
public bool thisIsUnitTest { get; set; }

Giờ đây, bài kiểm tra đơn vị của bạn có thể đặt boolean "thisIsUnitTest" thành true, vì vậy, trong đoạn mã bạn muốn bỏ qua, hãy thêm:

   if (thisIsUnitTest)
   {
       return;
   } 

Nó dễ dàng và nhanh hơn so với việc kiểm tra các cụm lắp ráp. Làm tôi nhớ đến Ruby On Rails, nơi bạn muốn xem liệu mình có đang ở trong môi trường TEST hay không.