public void Execute(Type testClass, Convention convention, Case[] cases)
{
foreach (var @case in cases)
{
var exceptions = @case.Exceptions;
try
{
var instance = construct(testClass);
var fixture = new Fixture(testClass, instance, convention.CaseExecution.Behavior, new[] { @case });
convention.InstanceExecution.Behavior.Execute(fixture);
Lifecycle.Dispose(instance);
}
catch (PreservedException preservedException)
{
var constructionException = preservedException.OriginalException;
exceptions.Add(constructionException);
}
catch (Exception constructionException)
{
exceptions.Add(constructionException);
}
}
}
protected LifecycleTests()
{
FailingMembers = null;
Convention = new Convention();
Convention.Classes.Where(testClass => testClass == typeof(SampleTestClass));
Convention.Methods.Where(method => method.Name == "Pass" || method.Name == "Fail");
}
public void EmptyConventionShouldDiscoverConcreteClassesAsTestClasses()
{
var emptyConvention = new Convention();
emptyConvention.Classes
.Filter(CandidateTypes)
.Select(x => x.Name)
.ShouldEqual("PublicTests", "OtherPublicTests", "PublicMissingNamingConvention", "PublicWithNoDefaultConstructorTests",
"PrivateTests", "OtherPrivateTests", "PrivateMissingNamingConvention", "PrivateWithNoDefaultConstructorTests");
}
public void CanDiscoverMethodsByNonInheritedAttributes()
{
var customConvention = new Convention();
customConvention
.Classes
.Has<NonInheritedAttribute>();
DiscoveredTestClasses(customConvention)
.ShouldEqual(typeof(AttributeSample));
}
public void EmptyConventionShouldDiscoverPublicInstanceMethodsForTestCases()
{
var emptyConvention = new Convention();
var testClass = typeof(DiscoveryTestClass);
emptyConvention.Methods
.Filter(testClass)
.OrderBy(x => x.Name, StringComparer.Ordinal)
.Select(x => x.Name)
.ShouldEqual("PublicInstanceNoArgsVoid", "PublicInstanceNoArgsWithReturn",
"PublicInstanceWithArgsVoid", "PublicInstanceWithArgsWithReturn");
}
public ConventionResult Run(Convention convention, Listener listener, params Type[] candidateTypes)
{
var executionPlan = new ExecutionPlan(convention);
var conventionResult = new ConventionResult(convention.GetType().FullName);
foreach (var testClass in convention.Classes.Filter(candidateTypes))
{
var classResult = new ClassResult(testClass.FullName);
var methods = convention.Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(convention, method)).ToArray();
var casesBySkipState = cases.ToLookup(convention.CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
{
var skipResult = new SkipResult(@case, convention.CaseExecution.SkipReasonProvider(@case));
listener.CaseSkipped(skipResult);
classResult.Add(CaseResult.Skipped(skipResult.Case.Name, skipResult.Reason));
}
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (caseExecutions.Any())
{
convention.ClassExecution.OrderCases(caseExecutions);
var classExecution = new ClassExecution(executionPlan, testClass, caseExecutions);
executionPlan.Execute(classExecution);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
{
var failResult = new FailResult(caseExecution, convention.HideExceptionDetails);
listener.CaseFailed(failResult);
classResult.Add(CaseResult.Failed(failResult.Case.Name, failResult.Duration, failResult.ExceptionSummary));
}
else
{
var passResult = new PassResult(caseExecution);
listener.CasePassed(passResult);
classResult.Add(CaseResult.Passed(passResult.Case.Name, passResult.Duration));
}
}
}
conventionResult.Add(classResult);
}
return conventionResult;
}
public ExecuteCasesTests()
{
log = new List<string>();
testClass = typeof(SampleTestClass);
convention = new SelfTestConvention();
convention.CaseExecution.Wrap((@case, instance, innerBehavior) =>
{
log.Add(@case.Method.Name);
innerBehavior();
});
}
public void EmptyConventionShouldTreatPublicInstanceMethodsAsCases()
{
var emptyConvention = new Convention();
var testClass = typeof(DiscoveryTestClass);
emptyConvention.Cases
.Filter(testClass)
.OrderBy(x => x.Name)
.Select(x => x.Name)
.ShouldEqual("PublicInstanceNoArgsVoid", "PublicInstanceNoArgsWithReturn",
"PublicInstanceWithArgsVoid", "PublicInstanceWithArgsWithReturn");
}
public void ShouldDiscoverClassesSatisfyingAllSpecifiedConditions()
{
var customConvention = new Convention();
customConvention
.Classes
.Where(type => type.IsInNamespace("Fixie.Tests"))
.Where(type => type.Name.StartsWith("No"));
DiscoveredTestClasses(customConvention)
.ShouldEqual(typeof(NoDefaultConstructor));
}
public void CanDiscoverClassesByInheritedAttributes()
{
var customConvention = new Convention();
customConvention
.Classes
.HasOrInherits<InheritedAttribute>();
DiscoveredTestClasses(customConvention)
.ShouldEqual(
typeof(AttributeSampleBase),
typeof(AttributeSample));
}
public void ShouldConsiderOnlyConcreteClasses()
{
var customConvention = new Convention();
DiscoveredTestClasses(customConvention)
.ShouldEqual(
typeof(DefaultConstructor),
typeof(NoDefaultConstructor),
typeof(NameEndsWithTests),
typeof(String),
typeof(AttributeSampleBase),
typeof(AttributeSample));
}
public void CanDiscoverClassesByTypeNameSuffixes()
{
var convention = new Convention();
convention
.Classes
.NameEndsWith("Constructor", "Sample");
DiscoveredTestClasses(convention)
.ShouldEqual(
typeof(DefaultConstructor),
typeof(NoDefaultConstructor),
typeof(AttributeSample));
}
public void Execute(Type testClass, Convention convention, CaseExecution[] caseExecutions)
{
try
{
outer(testClass, convention, caseExecutions, () => inner.Execute(testClass, convention, caseExecutions));
}
catch (Exception exception)
{
foreach (var caseExecution in caseExecutions)
{
caseExecution.Fail(exception);
}
}
}
public void Execute(Type testClass, Convention convention, Case[] cases)
{
try
{
outer(testClass, convention, cases, () => inner.Execute(testClass, convention, cases));
}
catch (Exception exception)
{
foreach (var @case in cases)
{
@case.Exceptions.Add(exception);
}
}
}
public void Execute(Type testClass, Convention convention, CaseExecution[] caseExecutions)
{
try
{
var instance = construct(testClass);
var fixture = new Fixture(testClass, instance, convention.CaseExecution.Behavior, caseExecutions);
convention.InstanceExecution.Behavior.Execute(fixture);
Dispose(instance);
}
catch (Exception exception)
{
foreach (var caseExecution in caseExecutions)
caseExecution.Fail(exception);
}
}
public void Execute(Type testClass, Convention convention, Case[] cases)
{
foreach (var @case in cases)
{
try
{
var instance = construct(testClass);
var fixture = new Fixture(testClass, instance, convention.CaseExecution.Behavior, new InvokeMethod(), new[] { @case });
convention.InstanceExecution.Behavior.Execute(fixture);
Dispose(instance);
}
catch (Exception exception)
{
@case.Fail(exception);
}
}
}
static IEnumerable<Case> CasesForMethod(Convention convention, MethodInfo method)
{
var casesForKnownInputParameters = convention.MethodCallParameterBuilder(method)
.Select(parameters => new Case(method, parameters));
bool any = false;
foreach (var actualCase in casesForKnownInputParameters)
{
any = true;
yield return actualCase;
}
if (!any)
{
if (method.GetParameters().Any())
yield return new UncallableParameterizedCase(method);
else
yield return new Case(method);
}
}
public void ShouldNotConsiderCompilerGeneratedClosureClasses()
{
var nested = typeof(ClassThatCausesCompilerGeneratedNestedClosureClass)
.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)
.Single();
//Confirm that a nested closure class has actually been generated.
nested.Has<CompilerGeneratedAttribute>().ShouldBeTrue();
//Confirm that the nested closure class is omitted from test class discovery.
var customConvention = new Convention();
DiscoveredTestClasses(customConvention, nested)
.ShouldEqual(
typeof(DefaultConstructor),
typeof(NoDefaultConstructor),
typeof(NameEndsWithTests),
typeof(String),
typeof(AttributeSampleBase),
typeof(AttributeSample));
}
public void Execute(Type testClass, Convention convention, Case[] cases)
{
try
{
outer(testClass, convention, cases, () => inner.Execute(testClass, convention, cases));
}
catch (Exception exception)
{
foreach (var @case in cases)
@case.Fail(exception);
}
}
public void DoesNotMindIfMultipleTypesPointToSameNamespace()
{
var convention = new Convention();
convention
.Classes
.InTheSameNamespaceAs(typeof(DefaultConstructor), typeof(NestedNamespace.InNestedNamespace), typeof(NoDefaultConstructor));
DiscoveredTestClasses(convention, typeof(NestedNamespace.InNestedNamespace))
.ShouldEqual(
typeof(DefaultConstructor),
typeof(NoDefaultConstructor),
typeof(NameEndsWithTests),
typeof(AttributeSampleBase),
typeof(AttributeSample),
typeof(NestedNamespace.InNestedNamespace));
}
static IEnumerable<Type> DiscoveredTestClasses(Convention convention, params Type[] additionalCandidates)
{
return new ClassDiscoverer(convention.Config)
.TestClasses(CandidateTypes.Concat(additionalCandidates));
}
public void CanDiscoverClassesInAnyOfTheSpecifiedNamespaces()
{
var convention = new Convention();
convention
.Classes
.InTheSameNamespaceAs(typeof(DefaultConstructor), typeof(DateTime));
DiscoveredTestClasses(convention, typeof(NestedNamespace.InNestedNamespace))
.ShouldEqual(
typeof(DefaultConstructor),
typeof(NoDefaultConstructor),
typeof(NameEndsWithTests),
typeof(String),
typeof(AttributeSampleBase),
typeof(AttributeSample),
typeof(NestedNamespace.InNestedNamespace));
}
static IEnumerable<Type> DiscoveredTestClasses(Convention convention)
{
return new ClassDiscoverer(convention.Config)
.TestClasses(CandidateTypes);
}
public void ShouldFailWithClearExplanationWhenAnyGivenConditionThrows()
{
var customConvention = new Convention();
customConvention
.Classes
.Where(type => { throw new Exception("Unsafe class-discovery predicate threw!"); });
Action attemptFaultyDiscovery = () => DiscoveredTestClasses(customConvention);
var exception = attemptFaultyDiscovery.ShouldThrow<Exception>(
"Exception thrown while attempting to run a custom class-discovery predicate. " +
"Check the inner exception for more details.");
exception.InnerException.Message.ShouldEqual("Unsafe class-discovery predicate threw!");
}
public static void Run(this Type sampleTestClass, Listener listener, Convention convention)
{
new Runner(listener).RunType(sampleTestClass.Assembly, convention, sampleTestClass);
}