public ISpecializedSuiteController<TSubject, TResult> CreateSpecializedSuiteController<TSubject, TResult> (
SuiteProvider provider,
ActionContainer<TSubject, TResult> actionContainer,
Action<ITestController> testControllerConfigurator)
{
return new SpecializedSuiteController<TSubject, TResult>(provider, actionContainer, testControllerConfigurator, this, _operationSorter);
}
public ISuiteProvider Load(IIntent assemblyIntent)
{
var assembly = Assembly.LoadFrom(assemblyIntent.Identity.Absolute);
var provider = SuiteProvider.Create(assemblyIntent.Identity, assembly.GetName().Name, ignoreReason: null);
var controller = _suiteControllerFactory.Create(provider);
var explorationData = _assemblyExplorer.Explore(assembly);
var suiteProviders = LoadSuiteProviders(
assemblyIntent,
explorationData.TestLoaderFactories.ToList(),
explorationData.PotentialSuiteTypes.ToList(),
explorationData.AssemblySetupTypes);
provider.SuiteProviders = suiteProviders;
explorationData.AssemblySetupTypes.Values
.Where(x => x.IsValueCreated)
.Select(x => x.Value)
.ForEach(
x => controller.AddSetupCleanup <SetupCommon, CleanupCommon>(
x.GetType().Name + ".Setup",
x.Setup,
x.GetType().Name + ".Cleanup",
x.Cleanup));
return(provider);
}
public ISuiteProvider Load(IIntent assemblyIntent)
{
var assembly = Assembly.LoadFrom(assemblyIntent.Identity.Absolute);
var provider = SuiteProvider.Create(assemblyIntent.Identity, assembly.GetName().Name, ignored: false);
var controller = _suiteControllerFactory.Create(provider);
var explorationData = _assemblyExplorer.Explore(assembly);
var lazyBootstraps = explorationData.BootstrapTypes.Select(x => new TypedLazy <ILazyBootstrap>(x)).ToList();
var suiteTypes = Filter(assemblyIntent, explorationData.SuiteTypes);
provider.SuiteProviders = suiteTypes.Select(x => Load(x, explorationData.TypeLoaders, lazyBootstraps, provider.Identity));
lazyBootstraps
.Where(x => x.IsValueCreated)
.Select(x => x.Value)
.ForEach(
x =>
controller.AddSetupCleanup <SetupCommon, CleanupCommon>(
x.GetType().Name + ".Setup",
x.Setup,
x.GetType().Name + ".Cleanup",
x.Cleanup));
return(provider);
}
public ITestController<TSubject, TResult, TVars, TSequence> CreateTestController<TSubject, TResult, TVars, TSequence> (
SuiteProvider suiteProvider,
TestProvider provider,
TestContext<TSubject, TResult, TVars, TSequence> context)
{
return new TestController<TSubject, TResult, TVars, TSequence>(suiteProvider, provider, context, _operationSorter, this);
}
protected SuiteProvider CreateSuiteProvider(string relativeId, string text, bool ignore)
{
var identity = _provider.Identity.CreateChildIdentity(relativeId);
var provider = SuiteProvider.Create(identity, text, ignore);
EnsureUniqueness(provider, _provider.TestProviders);
_provider.SuiteProviders = _provider.SuiteProviders.Concat(provider);
return(provider);
}
protected override void Initialize(Type suiteType, object suite, SuiteProvider provider)
{
var closedSpeckType = suiteType.GetClosedTypeOf(typeof(ISuite <>)).NotNull();
var subjectType = closedSpeckType.GetGenericArguments().Single();
var suiteController = _controllerFactory.CreateClassSuiteController(subjectType, provider);
suite.SetMemberValue("_classSuiteController", suiteController);
suite.SetMemberValue("_subjectFactory", _subjectFactory);
}
public TestController(
SuiteProvider suiteProvider,
TestProvider provider,
TestContext <TSubject, TResult, TVars, TSequence> context,
IOperationSorter operationSorter,
IControllerFactory controllerFactory)
: base(provider, context, operationSorter)
{
_suiteProvider = suiteProvider;
_provider = provider;
_context = context;
_controllerFactory = controllerFactory;
}
public SpecializedSuiteController(
SuiteProvider provider,
ActionContainer <TSubject, TResult> actionContainer,
Action <ITestController> testControllerConfigurator,
IControllerFactory controllerFactory,
IOperationSorter operationSorter)
: base(provider, operationSorter)
{
_provider = provider;
_actionContainer = actionContainer;
_testControllerConfigurator = testControllerConfigurator;
_controllerFactory = controllerFactory;
}
protected override void Initialize(Type suiteType, object suite, SuiteProvider provider)
{
var hierarchyTypes = HierarchyLoader.GetExecutionHierarchy(suiteType).ToList();
var behaviorTypes = suiteType.Descendants(x => GetBehaviorTypes(x)).ToList();
var setupOperationProviders = GetSetupOperationProviders(hierarchyTypes, behaviorTypes, suite, suiteType);
var assertionFields = GetFields <It>(suiteType).Concat(behaviorTypes.SelectMany(GetFields <It>));
var testProviders = assertionFields.Select(x => CreateTestProvider(provider.Identity, GetInstance(x.DeclaringType.NotNull(), suite), x));
provider.ContextProviders = setupOperationProviders;
provider.TestProviders = testProviders;
}
public ClassSuiteController(
SuiteProvider provider,
ISuite <TSubject> suite,
IEnumerable <ITestExtension> testExtensions,
IControllerFactory controllerFactory,
IOperationSorter operationSorter)
: base(provider, suite, testExtensions, operationSorter)
{
_provider = provider;
_suite = suite;
_controllerFactory = controllerFactory;
_testSetupCleanupTuples = new List <Tuple <Action <ITestContext <TSubject> >, Action <ITestContext <TSubject> > > >();
}
private SuiteProvider CreateSuiteProvider(Type suiteType, IIdentity assemblyIdentity)
{
var text = GetText(suiteType);
if (text == null)
{
return(null);
}
var identity = assemblyIdentity.CreateChildIdentity(suiteType.FullName);
var ignoreReason = suiteType.GetAttribute <IgnoreAttribute>().GetValueOrDefault(x => x.Reason);
var resources = suiteType.GetAttribute <ResourcesAttribute>().GetValueOrDefault(x => x.Resources);
return(SuiteProvider.Create(identity, text, ignoreReason, resources));
}
public ITestController <TSubject, TResult, Dummy, TNewSequence> SetSequences <TNewSequence> (IDictionary <string, TNewSequence> sequences)
{
var mainContext = (MainTestContext <TSubject, TResult, Dummy, TSequence>)(object) _context;
var configurator = mainContext.Configurator;
var actionContainer = mainContext.ActionContainer;
var combinationSuiteProvider = SuiteProvider.Create(_provider.Identity, _provider.Text, _provider.IgnoreReason);
_suiteProvider.SuiteProviders = _suiteProvider.SuiteProviders.Concat(new[] { combinationSuiteProvider });
_suiteProvider.TestProviders = _suiteProvider.TestProviders.Except(new[] { _provider });
var testControllers = sequences.Select(
x => CreateCombinationTestController(combinationSuiteProvider, configurator, actionContainer, x.Key, x.Value));
return(_controllerFactory.CreateCompositeTestController(testControllers));
}
public ITestController<TSubject, TResult, TVars, TSequence> CreateMainTestController<TSubject, TResult, TVars, TSequence> (
SuiteProvider suiteProvider,
TestProvider provider,
Action<ITestController> configurator,
ActionContainer<TSubject, TResult> actionContainer,
TSequence sequence)
{
var context = new MainTestContext<TSubject, TResult, TVars, TSequence>(actionContainer, configurator) { Sequence = sequence };
var controller = CreateTestController(suiteProvider, provider, context);
var wrappedAction = actionContainer.VoidAction != null
? GuardAction(context, actionContainer.VoidAction)
: GuardAction(context, x => context.Result = actionContainer.ResultAction.AssertNotNull()(x));
controller.AddAction<Act>(actionContainer.Text, x => wrappedAction());
configurator(controller);
return controller;
}
public ISuiteProvider Load(Type suiteType, ICollection <TypedLazy <ILazyBootstrap> > assemblySetups, IIdentity assemblyIdentity)
{
var uninitializedSuite = (TSuiteType)FormatterServices.GetUninitializedObject(suiteType);
var subjectAttribute = suiteType.GetAttributeData <SubjectAttributeBase>();
var displayFormatAttribute = subjectAttribute.Constructor.GetAttributeData <DisplayFormatAttribute>();
var text = _introspectionPresenter.Present(displayFormatAttribute.ToCommon(), subjectAttribute.ToCommon());
var identity = assemblyIdentity.CreateChildIdentity(suiteType.FullName);
var provider = SuiteProvider.Create(identity, text, ignored: false);
InitializeAssemblySetupFields(uninitializedSuite, assemblySetups.ToList());
InitializeTypeSpecificFields(uninitializedSuite, provider);
InvokeConstructor(uninitializedSuite);
return(provider);
}
private ITestController <TSubject, TResult, Dummy, TNewSequence> CreateCombinationTestController <TNewSequence> (
SuiteProvider suiteProvider,
Action <ITestController> configurator,
ActionContainer <TSubject, TResult> actionContainer,
string text,
TNewSequence sequence)
{
var identity = _provider.Identity.CreateChildIdentity(text);
var testProvider = TestProvider.Create(identity, text, _provider.IgnoreReason, filePath: _provider.FilePath, lineNumber: _provider.LineNumber);
suiteProvider.TestProviders = suiteProvider.TestProviders.Concat(new[] { testProvider });
return(_controllerFactory.CreateMainTestController <TSubject, TResult, Dummy, TNewSequence>(
suiteProvider,
testProvider,
configurator,
actionContainer,
sequence));
}
public ISuiteProvider Load(Type suiteType, IDictionary <Type, Lazy <IAssemblySetup> > assemblySetups, IIdentity assemblyIdentity)
{
var uninitializedSuite = FormatterServices.GetUninitializedObject(suiteType);
var subjectAttribute = suiteType.GetAttributeData <SuiteAttributeBase>();
var displayFormatAttribute = subjectAttribute.Constructor.GetAttributeData <DisplayFormatAttribute>();
var text = _introspectionPresenter.Present(displayFormatAttribute.ToCommon(), suiteType.ToCommon(), subjectAttribute.ToCommon());
var identity = assemblyIdentity.CreateChildIdentity(suiteType.FullName);
var resources = suiteType.GetAttribute <ResourcesAttribute>().GetValueOrDefault(x => x.Resources, () => new string[0]);
var provider = SuiteProvider.Create(identity, text, ignored: false, resources: resources);
InitializeAssemblySetupFields(uninitializedSuite, assemblySetups);
InitializeTypeSpecificFields(uninitializedSuite, provider);
InvokeConstructor(uninitializedSuite);
return(provider);
}
public ISuiteController Create(SuiteProvider suiteProvider)
{
return(new SuiteController(suiteProvider, _operationSorter));
}
public ClassSuiteController(SuiteProvider provider, object suite, IEnumerable <ITestExtension> testExtensions, IOperationSorter operationSorter)
: base(provider, operationSorter)
{
_suite = suite;
_testExtensions = testExtensions;
}
public SuiteController(SuiteProvider provider, IOperationSorter operationSorter)
{
_provider = provider;
_operationSorter = operationSorter;
}
public ISuiteController CreateClassSuiteController (object suite, Type subjectType, SuiteProvider provider)
{
var suiteControllerType = typeof (ClassSuiteController<>).MakeGenericType(subjectType);
return suiteControllerType.CreateInstance<ISuiteController>(provider, suite, _testExtensions, this, _operationSorter);
}
protected abstract void Initialize(Type suiteType, object suite, SuiteProvider provider);
protected abstract void InitializeTypeSpecificFields(TSuiteType suite, SuiteProvider provider);
