One of the bigger goals of this framework is to allow bootstrapping the environment to run browsers against, as well as enabling better browser capture. To enable the former, we should add an extensibility point that allows assemblies to define actions that should be performed before, and after, test assembly execution.

To identify this, a new attribute and interface would be defined. The attribute would identify the type that hosts the Before and After methods, and the interface would define the contract for the method signatures.

Proposed types:

BeforeAfterAssemblyTestsAttribute

class BeforeAfterAssemblyTestsAttribute : Attribute
{
    public Type BeforeAfterAssemblyType { get; }
}

IBeforeAfterAssemblyTests

interface IBeforeAfterAssemblyTests
{
    Task Before();
    Task After();
}

Potential Issues

• Should IBeforeAfterAssemblyTests allow a parameterized constructor?
• Should the IBeforeAfterAssemblyTest interface simply be merged with BeforeAfterAssemblyTestsAttribute? I lean no one this, simply because the assembly might be interested in holding significant state inbetween Before and After and would allow cleaner code for the end user of the framework.

Changelog

Changed Before to be parameterless. If we're going to pass it an assembly info, we should do it in the constructor.

It is desirable that test classes be able to be informed of test errors before test class disposal to allow things like dumps and screenshotting. Current xUnit exposes BeforeAfterTestAttribute, but this attribute provides neither guarantees on when it will run nor does it allow After to know if the test succeeded or failed.

Proposed Solutions:

@pawelpabich has proposed the addition of two (or technically, three) new interfaces that a test class can implement:

INeedToKnowTestSuccess

    public interface INeedToKnowTestSuccess : INeedToKnowTestResult
    {
        void Handle(TestPassed result);
    }

INeedToKnowTestFailure

    public interface INeedToKnowTestFailure : INeedToKnowTestResult
    {
        void Handle(TestFailed result);
    }

INeedToKnowTestResult

    public interface INeedToKnowTestResult
    {
    }

These interfaces, if they exist, would be invoked after the Test Method has been invoked but before any other actions.

This is more a question. Will this new approach work with VS and/or R# test runner?