public static async void FailedAfter()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest {
ThrowInAfter = true
};
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List <BeforeAfterTestAttribute> {
attribute
}, lambda: () => Assert.True(false));
await invoker.RunAsync();
var aggEx = Assert.IsType <AggregateException>(invoker.Aggregator.ToException());
Assert.Collection(
aggEx.InnerExceptions,
ex => Assert.IsType <TrueException>(ex),
ex => Assert.IsType <SpyBeforeAfterTest.AfterException>(ex)
);
Assert.Collection(
messageBus.Messages,
msg => Assert.IsType <_TestClassConstructionStarting>(msg),
msg => Assert.IsType <_TestClassConstructionFinished>(msg),
msg => Assert.IsType <_BeforeTestStarting>(msg),
msg => Assert.IsType <_BeforeTestFinished>(msg),
msg => Assert.IsType <_AfterTestStarting>(msg),
msg => Assert.IsType <_AfterTestFinished>(msg)
);
}
public static async void Success()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest();
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List <BeforeAfterTestAttribute> {
attribute
});
await invoker.RunAsync();
Assert.Null(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom <ITestClassConstructionStarting>(msg), // From TestInvoker
msg => Assert.IsAssignableFrom <ITestClassConstructionFinished>(msg), // From TestInvoker
msg =>
{
var beforeStarting = Assert.IsAssignableFrom <IBeforeTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeStarting.TestCollection);
Assert.Same(invoker.TestCase, beforeStarting.TestCase);
Assert.Equal("Display Name", beforeStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeStarting.AttributeName);
},
msg =>
{
var beforeFinished = Assert.IsAssignableFrom <IBeforeTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeFinished.TestCollection);
Assert.Same(invoker.TestCase, beforeFinished.TestCase);
Assert.Equal("Display Name", beforeFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeFinished.AttributeName);
},
// Test method is invoked here; no directly observable message (tested below)
msg =>
{
var afterStarting = Assert.IsAssignableFrom <IAfterTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterStarting.TestCollection);
Assert.Same(invoker.TestCase, afterStarting.TestCase);
Assert.Equal("Display Name", afterStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterStarting.AttributeName);
},
msg =>
{
var afterFinished = Assert.IsAssignableFrom <IAfterTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterFinished.TestCollection);
Assert.Same(invoker.TestCase, afterFinished.TestCase);
Assert.Equal("Display Name", afterFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterFinished.AttributeName);
}
);
}
public static async void FailedBefore()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest { ThrowInBefore = true };
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List<BeforeAfterTestAttribute> { attribute }, lambda: () => Assert.True(false));
await invoker.RunAsync();
Assert.IsType<SpyBeforeAfterTest.BeforeException>(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom<ITestClassConstructionStarting>(msg),
msg => Assert.IsAssignableFrom<ITestClassConstructionFinished>(msg),
msg => Assert.IsAssignableFrom<IBeforeTestStarting>(msg),
msg => Assert.IsAssignableFrom<IBeforeTestFinished>(msg)
);
}
public static async void Success()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest();
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List<BeforeAfterTestAttribute> { attribute });
await invoker.RunAsync();
Assert.Null(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom<ITestClassConstructionStarting>(msg), // From TestInvoker
msg => Assert.IsAssignableFrom<ITestClassConstructionFinished>(msg), // From TestInvoker
msg =>
{
var beforeStarting = Assert.IsAssignableFrom<IBeforeTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeStarting.TestCollection);
Assert.Same(invoker.TestCase, beforeStarting.TestCase);
Assert.Equal("Display Name", beforeStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeStarting.AttributeName);
},
msg =>
{
var beforeFinished = Assert.IsAssignableFrom<IBeforeTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeFinished.TestCollection);
Assert.Same(invoker.TestCase, beforeFinished.TestCase);
Assert.Equal("Display Name", beforeFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeFinished.AttributeName);
},
// Test method is invoked here; no directly observable message (tested below)
msg =>
{
var afterStarting = Assert.IsAssignableFrom<IAfterTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterStarting.TestCollection);
Assert.Same(invoker.TestCase, afterStarting.TestCase);
Assert.Equal("Display Name", afterStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterStarting.AttributeName);
},
msg =>
{
var afterFinished = Assert.IsAssignableFrom<IAfterTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterFinished.TestCollection);
Assert.Same(invoker.TestCase, afterFinished.TestCase);
Assert.Equal("Display Name", afterFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterFinished.AttributeName);
}
);
}
public static async void FailedBefore()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest {
ThrowInBefore = true
};
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List <BeforeAfterTestAttribute> {
attribute
}, lambda: () => Assert.True(false));
await invoker.RunAsync();
Assert.IsType <SpyBeforeAfterTest.BeforeException>(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom <ITestClassConstructionStarting>(msg),
msg => Assert.IsAssignableFrom <ITestClassConstructionFinished>(msg),
msg => Assert.IsAssignableFrom <IBeforeTestStarting>(msg),
msg => Assert.IsAssignableFrom <IBeforeTestFinished>(msg)
);
}
public static async void Success()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest();
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List <BeforeAfterTestAttribute> {
attribute
});
await invoker.RunAsync();
Assert.Null(invoker.Aggregator.ToException());
Assert.Collection(
messageBus.Messages,
msg => Assert.IsType <_TestClassConstructionStarting>(msg), // From TestInvoker
msg => Assert.IsType <_TestClassConstructionFinished>(msg), // From TestInvoker
msg =>
{
var beforeStarting = Assert.IsType <_BeforeTestStarting>(msg);
Assert.Equal("assembly-id", beforeStarting.AssemblyUniqueID);
Assert.Equal("SpyBeforeAfterTest", beforeStarting.AttributeName);
Assert.Equal("case-id", beforeStarting.TestCaseUniqueID);
Assert.Equal("class-id", beforeStarting.TestClassUniqueID);
Assert.Equal("collection-id", beforeStarting.TestCollectionUniqueID);
Assert.Equal("method-id", beforeStarting.TestMethodUniqueID);
Assert.Equal("test-id", beforeStarting.TestUniqueID);
},
msg =>
{
var beforeFinished = Assert.IsType <_BeforeTestFinished>(msg);
Assert.Equal("assembly-id", beforeFinished.AssemblyUniqueID);
Assert.Equal("SpyBeforeAfterTest", beforeFinished.AttributeName);
Assert.Equal("case-id", beforeFinished.TestCaseUniqueID);
Assert.Equal("class-id", beforeFinished.TestClassUniqueID);
Assert.Equal("collection-id", beforeFinished.TestCollectionUniqueID);
Assert.Equal("method-id", beforeFinished.TestMethodUniqueID);
Assert.Equal("test-id", beforeFinished.TestUniqueID);
},
// Test method is invoked here; no directly observable message (tested below)
msg =>
{
var afterStarting = Assert.IsType <_AfterTestStarting>(msg);
Assert.Equal("assembly-id", afterStarting.AssemblyUniqueID);
Assert.Equal("SpyBeforeAfterTest", afterStarting.AttributeName);
Assert.Equal("case-id", afterStarting.TestCaseUniqueID);
Assert.Equal("class-id", afterStarting.TestClassUniqueID);
Assert.Equal("collection-id", afterStarting.TestCollectionUniqueID);
Assert.Equal("method-id", afterStarting.TestMethodUniqueID);
Assert.Equal("test-id", afterStarting.TestUniqueID);
},
msg =>
{
var afterFinished = Assert.IsType <_AfterTestFinished>(msg);
Assert.Equal("assembly-id", afterFinished.AssemblyUniqueID);
Assert.Equal("SpyBeforeAfterTest", afterFinished.AttributeName);
Assert.Equal("case-id", afterFinished.TestCaseUniqueID);
Assert.Equal("class-id", afterFinished.TestClassUniqueID);
Assert.Equal("collection-id", afterFinished.TestCollectionUniqueID);
Assert.Equal("method-id", afterFinished.TestMethodUniqueID);
Assert.Equal("test-id", afterFinished.TestUniqueID);
}
);
}