public void Verify_order() { var builder = new FuncBuilder(); var unitOfWork1 = new CountingUnitOfWork(); var unitOfWork2 = new CountingUnitOfWork(); var unitOfWork3 = new CountingUnitOfWork(); builder.Register <IManageUnitsOfWork>(() => unitOfWork1); builder.Register <IManageUnitsOfWork>(() => unitOfWork2); builder.Register <IManageUnitsOfWork>(() => unitOfWork3); var runner = new UnitOfWorkRunner { Builder = builder }; runner.Begin(); runner.End(); Assert.AreEqual(1, unitOfWork1.BeginCallIndex); Assert.AreEqual(2, unitOfWork2.BeginCallIndex); Assert.AreEqual(3, unitOfWork3.BeginCallIndex); Assert.AreEqual(3, unitOfWork1.EndCallIndex); Assert.AreEqual(2, unitOfWork2.EndCallIndex); Assert.AreEqual(1, unitOfWork3.EndCallIndex); }
public new void SetUp() { persister = new InMemorySagaPersister(); FuncBuilder.Register <ISagaPersister>(() => persister); Features.Sagas.Clear(); }
public void SetUp() { Builder = new FuncBuilder(); InMemoryFaultManager = new NServiceBus.Faults.InMemory.FaultManager(); FakeReceiver = new FakeReceiver(); var configurationBuilder = new BusConfiguration(); configurationBuilder.EndpointName("xyz"); configurationBuilder.AssembliesToScan(new Assembly[0]); Transport = new TransportReceiver(new TransactionSettings(true, TimeSpan.FromSeconds(30), IsolationLevel.ReadCommitted, 5, false, false), 1, 0, FakeReceiver, InMemoryFaultManager, new SettingsHolder(), configurationBuilder.BuildConfiguration()); RegisterTypes(); Builder.Register<IManageMessageFailures>(() => InMemoryFaultManager); Builder.Register<TransportReceiver>(() => Transport); //var configurer = new SatelliteConfigurer(); //configurer.Customize(configure); var launcher = new SatelliteLauncher(Builder); BeforeRun(); launcher.Start(); }
static IEnumerable <TItem> ApplyToAll <TItem>(this IEnumerable <TItem> items, Func <Type, string, object> getArguments) { if (ArgumentReader.TryReadId(getArguments, out var values)) { var predicate = FuncBuilder <TItem> .BuildPredicate("Id", Comparison.In, values); items = items.Where(predicate); } foreach (var where in ArgumentReader.ReadWhere(getArguments)) { var predicate = FuncBuilder <TItem> .BuildPredicate(where); items = items.Where(predicate); } items = Order(items, getArguments); if (ArgumentReader.TryReadSkip(getArguments, out var skip)) { items = items.Skip(skip); } if (ArgumentReader.TryReadTake(getArguments, out var take)) { items = items.Take(take); } return(items); }
public void Nullable() { var list = new List <TargetWithNullable> { new TargetWithNullable { Field = null }, new TargetWithNullable { Field = 10 } }; var resultFromString = list .Where(FuncBuilder <TargetWithNullable> .BuildPredicate("Field", Comparison.Equal, new[] { "10" })) .Single(); Assert.Equal(10, resultFromString.Field); var nullResult = list .Where(FuncBuilder <TargetWithNullable> .BuildPredicate("Field", Comparison.Equal, null)) .Single(); Assert.Null(nullResult.Field); }
public void Nullable_requiring_parse() { var guid = Guid.Parse("00000000-0000-0000-0000-000000000001"); var list = new List <TargetWithNullableRequiringParse> { new TargetWithNullableRequiringParse { Field = null }, new TargetWithNullableRequiringParse { Field = guid } }; var resultFromString = list .Where(FuncBuilder <TargetWithNullableRequiringParse> .BuildPredicate("Field", Comparison.Equal, new[] { guid.ToString() })) .Single(); Assert.Equal(guid, resultFromString.Field); var nullResult = list .Where(FuncBuilder <TargetWithNullableRequiringParse> .BuildPredicate("Field", Comparison.Equal, null)) .Single(); Assert.Null(nullResult.Field); }
public void Should_invoke_the_begin_and_end_on_the_message_module() { var endCalled = false; var messageModule = new StubMessageModule(); bool beginCalled = false; var receivedMessage = Helpers.Helpers.EmptyTransportMessage(); messageModule.OnBegin = () => { Assert.False(endCalled); beginCalled = true; Assert.AreEqual(bus.CurrentMessageContext.Id, receivedMessage.Id); }; messageModule.OnEnd = () => { Assert.True(beginCalled); endCalled = true; Assert.AreEqual(bus.CurrentMessageContext.Id, receivedMessage.Id); }; FuncBuilder.Register <IMessageModule>(() => messageModule); ReceiveMessage(receivedMessage); Assert.True(beginCalled); Assert.True(endCalled); }
public CompositeContainerContext(IContainerConfiguration configuration, IClassWrapperCreator classWrapperCreator, IContainerSelector containerSelector) { this.Configuration = configuration; ClassWrapperCreator = classWrapperCreator; typesHelper = new TypesHelper(); var funcHelper = new FuncHelper(); FuncBuilder = new FuncBuilder(); var classCreator = new ClassCreator(funcHelper); var constructorSelector = new ConstructorSelector(); CreationContext = new CreationContext(classCreator, constructorSelector, classWrapperCreator); var implementationTypesCollection = new ImplementationTypesCollection(configuration, typesHelper); ImplementationCache = new ImplementationCache(); abstractionsCollection = new AbstractionsCollection(implementationTypesCollection, ImplementationCache); ImplementationConfigurationCache = new ImplementationConfigurationCache(); var factory = new AutoAbstractionConfigurationFactory(typesHelper, abstractionsCollection, ImplementationConfigurationCache); compositeCollection = new CompositeCollection(new[] { new AbstractionConfigurationCollection(factory) }, containerSelector); compositeCollection.Add(typeof(IContainer), new StupidAbstractionConfiguration( new ContainerImplementationConfiguration())); }
public void Should_invoke_begin_and_end_message() { var endCalled = false; var messageModule = new StubMessageModule(); bool beginCalled = false; messageModule.OnBegin = () => { Assert.False(endCalled); beginCalled = true; }; messageModule.OnEnd = () => { Assert.True(beginCalled); endCalled = true; }; FuncBuilder.Register <IMessageModule>(() => messageModule); SimulateMessageBeeingAbortedDueToRetryCountExceeded(Helpers.Helpers.EmptyTransportMessage()); Assert.True(beginCalled); Assert.True(endCalled); }
public override void SetUp() { base.SetUp(); funcBuilder = new FuncBuilder(); contextMock = GetMock <IInjectionContext>(); containerMock = GetMock <IContainerForFuncBuilder>(); }
public void SetUp() { Builder = new FuncBuilder(); InMemoryFaultManager = new Faults.InMemory.FaultManager(); FakeReceiver = new FakeReceiver(); Transport = new TransportReceiver { Receiver = FakeReceiver, TransactionSettings = TransactionSettings.Default }; Configure.With(new Assembly[0]) .DefineEndpointName("Test") .DefaultBuilder(); Configure.Instance.Builder = Builder; RegisterTypes(); Builder.Register<IManageMessageFailures>(() => InMemoryFaultManager); Builder.Register<TransportReceiver>(() => Transport); var configurer = new SatelliteConfigurer(); configurer.Init(); var launcher = new SatelliteLauncher(); BeforeRun(); launcher.Start(); }
public static void ForEachBit(this FuncBuilder f, IntExpression expr, int offset, int count, bool bigEndian, ActionOnIntExpr action) { int inclusiveStart; int exclusiveEnd; int increment; if (!bigEndian) { inclusiveStart = offset; exclusiveEnd = offset + count; increment = 1; } else { inclusiveStart = offset + count - 1; exclusiveEnd = offset - 1; increment = -1; } f.For(i => i.Value = inclusiveStart, i => i < exclusiveEnd, i => i.Value = i + increment) .Do(i => { var mask = ((IntExpression)1).ShiftLeft(i); var bitInPosition = f.Declare.Int("bitInPosition"); bitInPosition.Value = expr & mask; action(bitInPosition); }); }
public void SetUp() { Builder = new FuncBuilder(); InMemoryFaultManager = new Faults.InMemory.FaultManager(); FakeReceiver = new FakeReceiver(); Transport = new TransportReceiver { Receiver = FakeReceiver, TransactionSettings = TransactionSettings.Default }; Configure.With(new Assembly[0]) .DefineEndpointName("Test") .DefaultBuilder(); Configure.Instance.Builder = Builder; RegisterTypes(); Builder.Register <IManageMessageFailures>(() => InMemoryFaultManager); Builder.Register <TransportReceiver>(() => Transport); var configurer = new SatelliteConfigurer(); configurer.Init(); var launcher = new SatelliteLauncher { Builder = Builder, }; BeforeRun(); launcher.Start(); }
public void SetUp() { Builder = new FuncBuilder(); InMemoryFaultManager = new NServiceBus.Faults.InMemory.FaultManager(); TransportBuilder = new FakeTransportBuilder(); Configure.With(new Assembly[0]); Configure.Instance.Builder = Builder; RegisterTypes(); Builder.Register<IManageMessageFailures>(() => InMemoryFaultManager); var configurer = new SatelliteConfigurer(); configurer.Init(); //configurer.Run(); var launcher = new NonThreadingSatelliteLauncher { Builder = Builder, TransportBuilder = TransportBuilder }; BeforeRun(); launcher.Run(); }
public void one_in_one_out() { MethodInfo method = type.GetMethod("OneInOneOut"); var func = FuncBuilder.ToFunc(type, method).ShouldBeOfType <Func <PropertyTarget, int, string> >(); func(new PropertyTarget(), 123).ShouldEqual("123"); }
public void SetUp() { Builder = new FuncBuilder(); InMemoryFaultManager = new Faults.InMemory.FaultManager(); FakeReceiver = new FakeReceiver(); var configurationBuilder = new BusConfiguration(); configurationBuilder.EndpointName("xyz"); configurationBuilder.AssembliesToScan(new Assembly[0]); Transport = new TransportReceiver(new TransactionSettings(true, TimeSpan.FromSeconds(30), IsolationLevel.ReadCommitted, 5, false, false), 1, 0, FakeReceiver, InMemoryFaultManager, new SettingsHolder(), configurationBuilder.BuildConfiguration()); RegisterTypes(); Builder.Register <IManageMessageFailures>(() => InMemoryFaultManager); Builder.Register <TransportReceiver>(() => Transport); //var configurer = new SatelliteConfigurer(); //configurer.Customize(configure); var launcher = new SatelliteLauncher(Builder); BeforeRun(); launcher.Start(); }
public ContainerContext(IContainerConfiguration configuration, IClassWrapperCreator classWrapperCreator) { Configuration = configuration; ClassWrapperCreator = classWrapperCreator; ITypesHelper typesHelper = new TypesHelper(); var funcHelper = new FuncHelper(); FuncBuilder = new FuncBuilder(); var classCreator = new ClassCreator(funcHelper); var constructorSelector = new ConstructorSelector(); CreationContext = new CreationContext(classCreator, constructorSelector, classWrapperCreator); var implementationTypesCollection = new ImplementationTypesCollection(configuration.GetTypesToScan(), typesHelper); ImplementationCache = new ImplementationCache(); IAbstractionsCollection abstractionsCollection = new AbstractionsCollection(implementationTypesCollection, ImplementationCache); ImplementationConfigurationCache = new ImplementationConfigurationCache(); //l var factory = new AutoAbstractionConfigurationFactory(typesHelper, abstractionsCollection, ImplementationConfigurationCache); AbstractionConfigurationCollection = new AbstractionConfigurationCollection(factory); AbstractionConfigurationCollection.Add(typeof(IContainer), new StupidAbstractionConfiguration(new ContainerImplementationConfiguration())); }
public void Verify_order() { var builder = new FuncBuilder(); var unitOfWork1 = new CountingUnitOfWork(); var unitOfWork2 = new CountingUnitOfWork(); var unitOfWork3 = new CountingUnitOfWork(); builder.Register<IManageUnitsOfWork>(() => unitOfWork1); builder.Register<IManageUnitsOfWork>(() => unitOfWork2); builder.Register<IManageUnitsOfWork>(() => unitOfWork3); var runner = new UnitOfWorkRunner { Builder = builder }; runner.Begin(); runner.End(); Assert.AreEqual(1, unitOfWork1.BeginCallIndex); Assert.AreEqual(2, unitOfWork2.BeginCallIndex); Assert.AreEqual(3, unitOfWork3.BeginCallIndex); Assert.AreEqual(3, unitOfWork1.EndCallIndex); Assert.AreEqual(2, unitOfWork2.EndCallIndex); Assert.AreEqual(1, unitOfWork3.EndCallIndex); }
private ValueDependency createLambda() { object lambda = HasOutput ? FuncBuilder.ToFunc(HandlerType, Method) : FuncBuilder.ToAction(HandlerType, Method); return(new ValueDependency(lambda.GetType(), lambda)); }
public void zero_in_one_out() { MethodInfo method = type.GetMethod("ZeroInOneOut"); var func = FuncBuilder.ToFunc(type, method).ShouldBeOfType <Func <PropertyTarget, string> >(); var target = new PropertyTarget(); func(target).ShouldEqual(target.ZeroInOneOut()); }
public void can_compile_getter() { var sample = new SampleClass { Message = "Success!" }; var func = FuncBuilder.CompileGetter(sample.GetType().GetProperty("Message")).As <Func <SampleClass, string> >(); var result = func(sample); result.ShouldBe(sample.Message); }
public object ToCorrelationIdFunc() { var property = MessageType.GetProperty(CorrelationId); if (property == null) { return(typeof(EmptyGuidMaker <>).CloseAndBuildAs <EmptyGuid>(MessageType).GetEmptyFunc()); } return(FuncBuilder.CompileGetter(property)); }
public new void SetUp() { persister = new InMemorySagaPersister(); FuncBuilder.Register <ISagaPersister>(() => persister); sagas = new Sagas(); FuncBuilder.Register <SagaConfigurationCache>(() => sagas.sagaConfigurationCache); conventions = new Conventions(); }
public void one_in_zero_out() { MethodInfo method = type.GetMethod("OneInZeroOut"); var action = FuncBuilder.ToAction(type, method).ShouldBeOfType <Action <PropertyTarget, string> >(); var target = new PropertyTarget(); action(target, "last name"); target.LastCallToGo.ShouldEqual("last name"); }
public void Should_append_end_exception_to_rethrow() { var builder = new FuncBuilder(); var unitOfWork = new UnitOfWorkThatThrowsFromEnd(); builder.Register<IManageUnitsOfWork>(() => unitOfWork); //since it is a single exception then it will not be an AggregateException var exception = Assert.Throws<InvalidOperationException>(() => InvokeBehavior(builder)); Assert.AreSame(unitOfWork.ExceptionThrownFromEnd, exception); }
public void Should_append_end_exception_to_rethrow() { var builder = new FuncBuilder(); var unitOfWork = new UnitOfWorkThatThrowsFromEnd(); builder.Register<IManageUnitsOfWork>(() => unitOfWork); var aggregateException = Assert.Throws<AggregateException>(() => InvokeBehavior(builder)); Assert.AreSame(unitOfWork.ExceptionThrownFromEnd, aggregateException.InnerExceptions[0]); }
public void can_compile_setter() { var message = "Success!"; var sample = new SampleClass { Message = "Failed!" }; var func = FuncBuilder.CompileSetter(sample.GetType().GetProperty("Message")).As <Action <SampleClass, string> >(); func(sample, message); sample.Message.ShouldBe(message); }
public void Should_append_end_exception_to_rethrow() { var builder = new FuncBuilder(); var unitOfWork = new UnitOfWorkThatThrowsFromEnd(); builder.Register <IManageUnitsOfWork>(() => unitOfWork); //since it is a single exception then it will not be an AggregateException var exception = Assert.Throws <InvalidOperationException>(() => InvokeBehavior(builder)); Assert.AreSame(unitOfWork.ExceptionThrownFromEnd, exception); }
public void Should_append_end_exception_to_rethrow() { var builder = new FuncBuilder(); var unitOfWork = new UnitOfWorkThatThrowsFromEnd(); builder.Register <IManageUnitsOfWork>(() => unitOfWork); var aggregateException = Assert.Throws <AggregateException>(() => InvokeBehavior(builder)); Assert.AreSame(unitOfWork.ExceptionThrownFromEnd, aggregateException.InnerExceptions[0]); }
public void SetUp() { Transport = new FakeTransport(); FuncBuilder = new FuncBuilder(); Configure.GetEndpointNameAction = () => "TestEndpoint"; const string localAddress = "endpointA"; MasterNodeAddress = new Address(localAddress, "MasterNode"); try { Address.InitializeLocalAddress(localAddress); } catch // intentional { } MessageSerializer = new XmlMessageSerializer(MessageMapper); ExtensionMethods.GetStaticOutgoingHeadersAction = () => MessageHeaderManager.staticHeaders; gatewayAddress = MasterNodeAddress.SubScope("gateway"); messageSender = MockRepository.GenerateStub <ISendMessages>(); subscriptionStorage = new FakeSubscriptionStorage(); FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => headerManager); FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new SentTimeMutator()); FuncBuilder.Register <DefaultDispatcherFactory>(() => new DefaultDispatcherFactory()); FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator); unicastBus = new UnicastBus { MasterNodeAddress = MasterNodeAddress, TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts"), MessageSerializer = MessageSerializer, Builder = FuncBuilder, MessageSender = messageSender, Transport = Transport, SubscriptionStorage = subscriptionStorage, AutoSubscribe = true, MessageMapper = MessageMapper, FailureManager = MockRepository.GenerateStub <IManageMessageFailures>() }; bus = unicastBus; FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new RelatedToMessageMutator { Bus = bus }); FuncBuilder.Register <IBus>(() => bus); ExtensionMethods.SetHeaderAction = headerManager.SetHeader; }
protected override IConfiguredInstance buildInstance() { Validate(); var instance = new ConfiguredInstance(determineHandlerType()); var lambda = HasOutput ? FuncBuilder.ToFunc(HandlerType, Method) : FuncBuilder.ToAction(HandlerType, Method); instance.Dependencies.Add(lambda.GetType(), lambda); return(instance); }
public void Should_pass_exception_to_cleanup() { var builder = new FuncBuilder(); var unitOfWork = new CaptureExceptionPassedToEndUnitOfWork(); var throwingUoW = new UnitOfWorkThatThrowsFromEnd(); builder.Register <IManageUnitsOfWork>(() => unitOfWork); builder.Register <IManageUnitsOfWork>(() => throwingUoW); var aggregateException = Assert.Throws <AggregateException>(() => InvokeBehavior(builder)); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, unitOfWork.Exception); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, aggregateException.InnerExceptions.Single()); }
public void Should_set_the_processing_headers() { FuncBuilder.Register <IManageUnitsOfWork>(() => new ProcessingStatistics { Bus = bus }); var receivedMessage = Helpers.Helpers.Serialize(new EventMessage()); RegisterMessageType <EventMessage>(); ReceiveMessage(receivedMessage); Assert.True(bus.CurrentMessageContext.Headers.ContainsKey("NServiceBus.ProcessingStarted")); Assert.True(bus.CurrentMessageContext.Headers.ContainsKey("NServiceBus.ProcessingEnded")); }
public void Should_pass_exception_to_cleanup() { var builder = new FuncBuilder(); var unitOfWork = new CaptureExceptionPassedToEndUnitOfWork(); var throwingUoW = new UnitOfWorkThatThrowsFromEnd(); builder.Register<IManageUnitsOfWork>(() => unitOfWork); builder.Register<IManageUnitsOfWork>(() => throwingUoW); var aggregateException = Assert.Throws<AggregateException>(() => InvokeBehavior(builder)); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, unitOfWork.Exception); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, aggregateException.InnerExceptions.Single()); }
public void Should_pass_exception_to_cleanup() { var builder = new FuncBuilder(); var unitOfWork = new CaptureExceptionPassedToEndUnitOfWork(); var throwingUoW = new UnitOfWorkThatThrowsFromEnd(); builder.Register <IManageUnitsOfWork>(() => unitOfWork); builder.Register <IManageUnitsOfWork>(() => throwingUoW); //since it is a single exception then it will not be an AggregateException var exception = Assert.Throws <InvalidOperationException>(() => InvokeBehavior(builder)); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, unitOfWork.Exception); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, exception); }
public void When_first_throw_second_is_cleaned_up() { var builder = new FuncBuilder(); var unitOfWorkThatThrowsFromEnd = new UnitOfWorkThatThrowsFromEnd(); var unitOfWork = new UnitOfWork(); builder.Register <IManageUnitsOfWork>(() => unitOfWorkThatThrowsFromEnd); builder.Register <IManageUnitsOfWork>(() => unitOfWork); Assert.Throws <AggregateException>(() => InvokeBehavior(builder)); Assert.IsTrue(unitOfWorkThatThrowsFromEnd.BeginCalled); Assert.IsTrue(unitOfWorkThatThrowsFromEnd.EndCalled); Assert.IsTrue(unitOfWork.BeginCalled); Assert.IsTrue(unitOfWork.EndCalled); }
public void Should_calculate_the_time_to_breach_sla() { FuncBuilder.Register <IManageUnitsOfWork>(() => new ProcessingStatistics { Bus = bus, EstimatedTimeToSLABreachCalculator = SLABreachCalculator }); var endpointSLA = TimeSpan.FromSeconds(60); SLABreachCalculator.Initialize(endpointSLA); var now = DateTime.UtcNow; RegisterMessageType <EventMessage>(); double secondsUntilSlaIsBreached = 0; SLABreachCalculator.SetCounterAction = d => secondsUntilSlaIsBreached = d; var receivedMessage = Helpers.Helpers.Serialize(new EventMessage()); receivedMessage.Headers[Headers.TimeSent] = now.ToWireFormattedString(); ReceiveMessage(receivedMessage); //need at least 2 messages to enable us to count Assert.AreEqual(0, secondsUntilSlaIsBreached); receivedMessage.Headers[Headers.TimeSent] = now.AddSeconds(-0.5).ToWireFormattedString(); ReceiveMessage(receivedMessage); //this should be rougly 2.1 since it takes 0.02 second to process both messages and the CT delta is 0.5 (since we fake a 0.5 delay) // 0,5/0,02 = 25 => means that the SLA will be busted in aprox 2 seconds var secondsUntilSlaIsBreached_2 = secondsUntilSlaIsBreached; Assert.Greater(secondsUntilSlaIsBreached_2, 1.5); Assert.Less(secondsUntilSlaIsBreached_2, 3.0); receivedMessage.Headers[Headers.TimeSent] = now.AddSeconds(-0.5).ToWireFormattedString(); ReceiveMessage(receivedMessage); var secondsUntilSlaIsBreached_3 = secondsUntilSlaIsBreached; Assert.Less(secondsUntilSlaIsBreached_2, secondsUntilSlaIsBreached_3); }
public void When_first_throw_second_is_cleaned_up() { var builder = new FuncBuilder(); var unitOfWorkThatThrowsFromEnd = new UnitOfWorkThatThrowsFromEnd(); var unitOfWork = new UnitOfWork(); builder.Register<IManageUnitsOfWork>(() => unitOfWorkThatThrowsFromEnd); builder.Register<IManageUnitsOfWork>(() => unitOfWork); //since it is a single exception then it will not be an AggregateException Assert.Throws<InvalidOperationException>(() => InvokeBehavior(builder)); Assert.IsTrue(unitOfWorkThatThrowsFromEnd.BeginCalled); Assert.IsTrue(unitOfWorkThatThrowsFromEnd.EndCalled); Assert.IsTrue(unitOfWork.BeginCalled); Assert.IsTrue(unitOfWork.EndCalled); }
public void Should_pass_exception_to_cleanup() { var builder = new FuncBuilder(); var unitOfWork = new CaptureExceptionPassedToEndUnitOfWork(); builder.Register<IManageUnitsOfWork>(() => unitOfWork); var runner = new UnitOfWorkRunner { Builder = builder }; var exception = new Exception(); runner.Begin(); var aggregateException = Assert.Throws<AggregateException>(() => runner.AppendEndExceptionsAndRethrow(exception)); Assert.AreSame(exception, unitOfWork.Exception); Assert.AreSame(exception, aggregateException.InnerExceptions.Single()); }
public void Should_append_end_exception_to_rethrow() { var builder = new FuncBuilder(); var unitOfWork = new UnitOfWorkThatThrowsFromEnd(); builder.Register<IManageUnitsOfWork>(() => unitOfWork); var runner = new UnitOfWorkRunner { Builder = builder }; var exception = new Exception(); runner.Begin(); var aggregateException = Assert.Throws<AggregateException>(() => runner.AppendEndExceptionsAndRethrow(exception)); var innerExceptions = aggregateException.InnerExceptions; Assert.AreSame(exception, innerExceptions[0]); Assert.AreSame(unitOfWork.ExceptionThrownFromEnd, innerExceptions[1]); }
public void When_first_throw_second_is_cleaned_up() { var builder = new FuncBuilder(); var unitOfWorkThatThrowsFromEnd = new UnitOfWorkThatThrowsFromEnd(); var unitOfWork = new UnitOfWork(); builder.Register<IManageUnitsOfWork>(() => unitOfWorkThatThrowsFromEnd); builder.Register<IManageUnitsOfWork>(() => unitOfWork); var runner = new UnitOfWorkRunner { Builder = builder }; runner.Begin(); Assert.Throws<InvalidOperationException>(runner.End); Assert.IsTrue(unitOfWorkThatThrowsFromEnd.BeginCalled); Assert.IsTrue(unitOfWorkThatThrowsFromEnd.EndCalled); Assert.IsTrue(unitOfWork.BeginCalled); Assert.IsTrue(unitOfWork.EndCalled); }
public void Verify_order() { var builder = new FuncBuilder(); var unitOfWork1 = new CountingUnitOfWork(); var unitOfWork2 = new CountingUnitOfWork(); var unitOfWork3 = new CountingUnitOfWork(); builder.Register<IManageUnitsOfWork>(() => unitOfWork1); builder.Register<IManageUnitsOfWork>(() => unitOfWork2); builder.Register<IManageUnitsOfWork>(() => unitOfWork3); InvokeBehavior(builder); Assert.AreEqual(1, unitOfWork1.BeginCallIndex); Assert.AreEqual(2, unitOfWork2.BeginCallIndex); Assert.AreEqual(3, unitOfWork3.BeginCallIndex); Assert.AreEqual(3, unitOfWork1.EndCallIndex); Assert.AreEqual(2, unitOfWork2.EndCallIndex); Assert.AreEqual(1, unitOfWork3.EndCallIndex); }
public void Should_pass_exception_to_cleanup() { var builder = new FuncBuilder(); var unitOfWork = new CaptureExceptionPassedToEndUnitOfWork(); var throwingUoW = new UnitOfWorkThatThrowsFromEnd(); builder.Register<IManageUnitsOfWork>(() => unitOfWork); builder.Register<IManageUnitsOfWork>(() => throwingUoW); //since it is a single exception then it will not be an AggregateException var exception = Assert.Throws<InvalidOperationException>(() => InvokeBehavior(builder)); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, unitOfWork.Exception); Assert.AreSame(throwingUoW.ExceptionThrownFromEnd, exception); }
private string Build(string template) { Dictionary<string, string> attrs = new Dictionary<string, string> { {"abc", "ABC"}, {"def", "DEF"}, {"ghi", null}, {"jkl", ""}, {"mno", "A+++ (-10%)"} }; Func<Dictionary<string, string>, string> func = new FuncBuilder().Build(template); return func(attrs); }