单元测试异步事件

Question

我有一个设置，其中更改类的变量引发异步运行的事件，我尝试单元测试。

class A { 

    Action<int> OnIntChange; 

    private int _a; 
    public int a { 
     set { 
      OnIntChange(value); 
     } 
    } 
} 

class B { 

    RaiseAsyncEvent(int value) { 
     Task.Factory.StartNew(() => {c = value;}); 
    } 

    int c; 
} 

以前的一切是同步的，所以很容易地我能单元测试：

B b = new B(); 
A.OnIntChange += b.RaiseAsyncEvent;  
A.a = 10; 
Assert.AreEqual(10, A.b.c); 

但是现在这个失败。我不能使用ManualResetEvents，因为我没有直接提出这个事件，并且不能没有代码重组。看来我唯一的选择是在调用A.a = 10之后添加一个System.Threading.Thread.Sleep（）调用，但我正在寻找其他选项。建议？

~~~~~~~~~~编辑~~~~~~~~

我在寻找一个潜在的解决方案是让RaiseAsyncEvent返回它创建的任务和字段设置到任务。喜欢的东西：

class B { 

    Task task; 

    RaiseAsyncEvent(int value) { 
     task = Task.Factory.StartNew(() => {c = value;}); 
    } 

    int c; 
} 


B b = new B(); 
A.OnIntChange += b.RaiseAsyncEvent; 
b.task.Wait(); 
A.a = 10; 
Assert.AreEqual(10, A.b.c); 

~~~~~~~~~~进一步编辑~~~~~~~~~~

我最终什么事做这是改变B到解决以下：

class B { 

    bool RunAsync = true; 

    RaiseAsyncEvent(int value) { 
     Task task = Task.Factory.StartNew(() => {c = value;}); 
     if(!RunAsync) { task.Wait();} 
    } 

    int c; 
} 

，并改变了测试：

B b = new B(); 
b.RunAsync = false; 
A.OnIntChange += b.RaiseAsyncEvent;  
A.a = 10; 
Assert.AreEqual(10, A.b.c); 

Answer 1

您可以在B的构造函数的定制版本通过一个 TaskScheduler可以等待单元测试中所有任务的完成。

class B { 
    public B(TaskScheduler taskScheduler) 
    { 
     _taskScheduler = taskScheduler; 
    } 


    public B(): this(TaskScheduler.Default) 
    { 
    } 


    public void RaiseAsyncEvent(int value) 
    { 
     Task.Factory.StartNew(() => {c = value;}, CancellationToken.None, 
     TaskCreationOptions.DenyChildAttach, _taskScheduler); 
    } 

    TaskScheduler _taskScheduler; 

} 

ConcurrentExclusiveSchedulerPair有能力等待我们寻找的完成。

// Unit test 

var schedulerPair = new ConcurrentExclusiveSchedulerPair(); 

B b = new B(schedulerPair.ConcurrentScheduler); 
A.OnIntChange += b.RaiseAsyncEvent;  
A.a = 10; 

schedulerPair.Complete(); 
schedulerPair.Completion.Wait(); 

Assert.AreEqual(10, A.b.c); 

当你需要留意一个以上的异步操作它扩展到更高级的情景：

B b1 = new B(schedulerPair.ConcurrentScheduler); 
B b2 = new B(schedulerPair.ConcurrentScheduler); 
B b3 = new B(schedulerPair.ConcurrentScheduler); 

A.OnIntChange += b1.RaiseAsyncEvent;  
A.OnIntChange += b2.RaiseAsyncEvent;  
A.OnIntChange += b3.RaiseAsyncEvent;  
A.a = 10; 

schedulerPair.Complete(); 
schedulerPair.Completion.Wait(); 

Assert.AreEqual(10, b1.c); 
Assert.AreEqual(10, b2.c); 
Assert.AreEqual(10, b3.c); 

编辑：TaskScheduler情况下也可以使用一个静态属性共享，在这种情况下， B构造函数签名不会更改。

static class EventScheduler 
{ 

    public static TaskScheduler TaskScheduler 
    { 
     get {return _taskScheduler; } 
     set {_taskScheduler = value; } 
    } 

    static TaskScheduler _taskScheduler = TaskScheduler.Default; 

    public static Task RunAsync(Action<T> action) 
    { 
     return Task.Factory.StartNew(() => {c = value;}, 
     CancellationToken.None, TaskCreationOptions.DenyChildAttach, 
     _taskScheduler); 
    } 
} 

class B 
{ 
    public void RaiseAsyncEvent(int value) 
    { 
     EventScheduler.RunAsync(()=>{c = value;}); 
    } 
} 

// Unit test 

var schedulerPair = new ConcurrentExclusiveSchedulerPair(); 
EventScheduler.TaskScheduler = schedulerPair.ConcurrentScheduler; 

B b = new B(); 
A.OnIntChange += b.RaiseAsyncEvent;  
A.a = 10; 

schedulerPair.Complete(); 
schedulerPair.Completion.Wait(); 

Assert.AreEqual(10, A.b.c);