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);
        }
Example #2
0
        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);
    }
Example #7
0
        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()));
        }
Example #9
0
        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);
        }
Example #10
0
 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();
        }
Example #15
0
        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);
        }
Example #19
0
        private ValueDependency createLambda()
        {
            object lambda = HasOutput
                                ? FuncBuilder.ToFunc(HandlerType, Method)
                                : FuncBuilder.ToAction(HandlerType, Method);

            return(new ValueDependency(lambda.GetType(), lambda));
        }
Example #20
0
        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());
        }
Example #21
0
        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);
        }
Example #22
0
        public object ToCorrelationIdFunc()
        {
            var property = MessageType.GetProperty(CorrelationId);

            if (property == null)
            {
                return(typeof(EmptyGuidMaker <>).CloseAndBuildAs <EmptyGuid>(MessageType).GetEmptyFunc());
            }

            return(FuncBuilder.CompileGetter(property));
        }
Example #23
0
        public new void SetUp()
        {
            persister = new InMemorySagaPersister();
            FuncBuilder.Register <ISagaPersister>(() => persister);

            sagas = new Sagas();

            FuncBuilder.Register <SagaConfigurationCache>(() => sagas.sagaConfigurationCache);

            conventions = new Conventions();
        }
Example #24
0
        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]);
        }
Example #27
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);
        }
Example #29
0
        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;
        }
Example #31
0
        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);
        }
Example #32
0
        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());
        }
Example #33
0
        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);
        }
Example #36
0
        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);
        }
Example #37
0
        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);
        }
Example #44
0
        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);
        }