public void Should_not_fail_when_reporting_trapped_constraint_outside_call_to_trap_constraints()
{
// Arrange
// Act, Assert
Assert.DoesNotThrow(() => ArgumentConstraintTrap.ReportTrappedConstraint(A.Dummy <IArgumentConstraint>()));
}
public void Should_fail_when_reporting_trapped_constraint_outside_call_to_trap_constraints()
{
// Act
var exception = Record.Exception(
() => ArgumentConstraintTrap.ReportTrappedConstraint(A.Dummy <IArgumentConstraint>()));
// Assert
exception.Should().BeAnExceptionOfType <InvalidOperationException>().WithMessage("A<T>.Ignored, A<T>._, and A<T>.That can only be used in the context of a call specification with A.CallTo()");
}
public void Should_track_constraints_supplied_in_calls_made_from_overlapping_threads()
{
// Ensures that constraints are properly trapped even when two constraint-trapping threads
// overlap. Uses the reset events to ensure that the threads consistently execute like this:
// |-----------------------------|
// |---------------|
// The thread that starts first will register to trap constraints before the second thread
// but will not actually report the constraint until after the second thread has reported
// its constraint and finished.
// Without per-thread constraint trapping, this would mean that the first thread's constraint
// would be lost.
// Arrange
var lateStartingLock = new ManualResetEventSlim(false);
var lateEndingLock = new ManualResetEventSlim(false);
var earlyStartingConstraint = A.Fake <IArgumentConstraint>();
A.CallTo(() => earlyStartingConstraint.ToString()).Returns("earlyStarter");
IArgumentConstraint?earlyStartingResult = null;
var lateStartingConstraint = A.Fake <IArgumentConstraint>();
A.CallTo(() => lateStartingConstraint.ToString()).Returns("lateStarter");
IArgumentConstraint?lateStartingResult = null;
// Act
var earlyStartingTask = Task.Run(() =>
{
earlyStartingResult = this.trap.TrapConstraintOrCreate(
() =>
{
lateStartingLock.Set();
lateEndingLock.Wait();
ArgumentConstraintTrap.ReportTrappedConstraint(earlyStartingConstraint);
},
UnusedConstraintFactory);
});
var lateStartingTask = Task.Run(() =>
{
lateStartingLock.Wait();
lateStartingResult = this.trap.TrapConstraintOrCreate(
() => ArgumentConstraintTrap.ReportTrappedConstraint(lateStartingConstraint),
UnusedConstraintFactory);
lateEndingLock.Set();
});
Task.WaitAll(earlyStartingTask, lateStartingTask);
// Assert
new[] { earlyStartingResult, lateStartingResult }
.Should().Equal(earlyStartingConstraint, lateStartingConstraint);
}
public void Should_not_fail_when_reporting_trapped_constraint_outside_call_to_trap_constraints()
{
// Act
var exception = Record.Exception(
() => ArgumentConstraintTrap.ReportTrappedConstraint(A.Dummy <IArgumentConstraint>()));
// Assert
exception.Should().BeNull();
}
public void Should_return_constraints_that_has_been_trapped()
{
// Arrange
var constraint1 = A.Dummy <IArgumentConstraint>();
var constraint2 = A.Dummy <IArgumentConstraint>();
// Act
var result = this.trap.TrapConstraints(() =>
{
ArgumentConstraintTrap.ReportTrappedConstraint(constraint1);
ArgumentConstraintTrap.ReportTrappedConstraint(constraint2);
});
// Assert
result.Should().BeEquivalentTo(constraint1, constraint2);
}
public void Should_not_return_constraints_from_previous_call()
{
// Arrange
var constraint1 = A.Dummy <IArgumentConstraint>();
var constraint2 = A.Dummy <IArgumentConstraint>();
this.trap.TrapConstraints(() => ArgumentConstraintTrap.ReportTrappedConstraint(constraint1));
// Act
var result = this.trap.TrapConstraints(() =>
{
ArgumentConstraintTrap.ReportTrappedConstraint(constraint2);
});
// Assert
result.Should().BeEquivalentTo(constraint2);
}
public static void RegisterDependencies(IServiceRegistrar registrar)
{
var bootstrapper = BootstrapperLocator.FindBootstrapper();
var typeCatalogue = new TypeCatalogue();
var assemblyFilesNames = bootstrapper.GetAssemblyFileNamesToScanForExtensions()
?? throw new InvalidOperationException(ExceptionMessages.GetAssemblyFileNamesToScanForExtensionsShouldntReturnNull);
typeCatalogue.Load(assemblyFilesNames);
var typeCatalogueInstanceProvider = new TypeCatalogueInstanceProvider(typeCatalogue);
var argumentValueFormatters = typeCatalogueInstanceProvider.InstantiateAllOfType <IArgumentValueFormatter>();
var dummyFactories = typeCatalogueInstanceProvider.InstantiateAllOfType <IDummyFactory>();
var fakeOptionsBuilders = typeCatalogueInstanceProvider.InstantiateAllOfType <IFakeOptionsBuilder>();
var implicitOptionsBuilderCatalogue = new ImplicitOptionsBuilderCatalogue(fakeOptionsBuilders);
var methodInfoManager = new MethodInfoManager();
var argumentConstraintTrap = new ArgumentConstraintTrap();
var expressionArgumentConstraintFactory = new ExpressionArgumentConstraintFactory(argumentConstraintTrap);
var fakeManagerAccessor = new DefaultFakeManagerAccessor();
var fakeObjectCreator = new FakeObjectCreator(
FakeCallProcessorProviderFactory,
new CastleDynamicProxyInterceptionValidator(methodInfoManager),
new DelegateProxyInterceptionValidator());
var callExpressionParser = new CallExpressionParser();
var interceptionAsserter = new DefaultInterceptionAsserter(fakeObjectCreator);
var argumentValueFormatter = new ArgumentValueFormatter(argumentValueFormatters);
var fakeObjectCallFormatter = new DefaultFakeObjectCallFormatter(argumentValueFormatter, fakeManagerAccessor);
var callWriter = new CallWriter(fakeObjectCallFormatter, new FakeCallEqualityComparer());
var configurationFactory = new ConfigurationFactory(RuleBuilderFactory);
registrar.Register <IExpressionCallMatcherFactory>(new ExpressionCallMatcherFactory(expressionArgumentConstraintFactory, methodInfoManager));
registrar.Register(expressionArgumentConstraintFactory);
registrar.Register <FakeAndDummyManager>(
new FakeAndDummyManager(
new DummyValueResolver(new DynamicDummyFactory(dummyFactories), fakeObjectCreator),
fakeObjectCreator,
implicitOptionsBuilderCatalogue));
registrar.Register <IArgumentConstraintManagerFactory>(new ArgumentConstraintManagerFactory());
registrar.Register(new EventHandlerArgumentProviderMap());
registrar.Register <SequentialCallContext.Factory>(SequentialCallContextFactory);
registrar.Register <IStartConfigurationFactory>(
new StartConfigurationFactory(ExpressionCallRuleFactory, configurationFactory, callExpressionParser, interceptionAsserter));
registrar.Register <IFakeConfigurationManager>(
new FakeConfigurationManager(configurationFactory, ExpressionCallRuleFactory, callExpressionParser, interceptionAsserter));
registrar.Register <IFakeManagerAccessor>(fakeManagerAccessor);
registrar.Register <ICallExpressionParser>(callExpressionParser);
registrar.Register((StringBuilderOutputWriter.Factory)StringBuilderOutputWriterFactory);
registrar.Register <IFakeObjectCallFormatter>(fakeObjectCallFormatter);
StringBuilderOutputWriter StringBuilderOutputWriterFactory() =>
new StringBuilderOutputWriter(argumentValueFormatter !);
FakeManager FakeManagerFactory(Type fakeObjectType, object proxy, string?name) =>
new FakeManager(fakeObjectType, proxy, name);
IFakeCallProcessorProvider FakeCallProcessorProviderFactory(Type typeOfFake, IProxyOptions proxyOptions) =>
new FakeManagerProvider(FakeManagerFactory, fakeManagerAccessor, typeOfFake, proxyOptions);
ExpressionCallRule ExpressionCallRuleFactory(ParsedCallExpression callSpecification) =>
new ExpressionCallRule(new ExpressionCallMatcher(callSpecification, expressionArgumentConstraintFactory, methodInfoManager));
IFakeAsserter FakeAsserterFactory(IEnumerable <CompletedFakeObjectCall> calls, int lastSequenceNumber) =>
new FakeAsserter(calls, lastSequenceNumber, callWriter, StringBuilderOutputWriterFactory);
SequentialCallContext SequentialCallContextFactory() =>
new SequentialCallContext(callWriter, StringBuilderOutputWriterFactory);
RuleBuilder RuleBuilderFactory(BuildableCallRule rule, FakeManager fake) =>
new RuleBuilder(rule, fake, FakeAsserterFactory);
}
