public void Should_properly_handle_exception() { IPipe <ConsumeContext> pipe = Pipe.New <ConsumeContext>(x => { x.UseTransaction(); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(async payload => { await Task.Yield(); using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); scope.Complete(); } throw new InvalidOperationException("This is a friendly boom"); }); x.UseExecute(payload => Console.WriteLine("After Transaction: {0}", Thread.CurrentThread.ManagedThreadId)); }); var context = new TestConsumeContext <PingMessage>(new PingMessage()); Assert.That(async() => await pipe.Send(context), Throws.InvalidOperationException); //Console.WriteLine(exception.Message); }
public async Task Should_allow_just_enough_threads_at_once() { int currentCount = 0; int maxCount = 0; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseConcurrencyLimit(32); x.UseExecuteAsync(async payload => { int current = Interlocked.Increment(ref currentCount); while (current > maxCount) { Interlocked.CompareExchange(ref maxCount, current, maxCount); } await Task.Delay(10); Interlocked.Decrement(ref currentCount); }); }); var context = new TestConsumeContext <A>(new A()); Task[] tasks = Enumerable.Range(0, 500) .Select(index => Task.Run(async() => await pipe.Send(context))) .ToArray(); await Task.WhenAll(tasks); maxCount.ShouldBe(32); }
public void Should_properly_handle_exception() { IPipe<ConsumeContext> pipe = Pipe.New<ConsumeContext>(x => { x.UseTransaction(); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(async payload => { await Task.Yield(); using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); scope.Complete(); } throw new InvalidOperationException("This is a friendly boom"); }); x.UseExecute(payload => Console.WriteLine("After Transaction: {0}", Thread.CurrentThread.ManagedThreadId)); }); var context = new TestConsumeContext<PingMessage>(new PingMessage()); Assert.That(async () => await pipe.Send(context), Throws.InvalidOperationException); //Console.WriteLine(exception.Message); }
public async Task FeatureToggleShowDeployedEnvironmentIsUpdatedCorrectly() { //arrange var app = Application.Create("TestApp", "DEV", false); app.AddFeatureToggle("TestToggle-1", "TestNotes-1", "workItemId1"); app.AddFeatureToggle("TestToggle-2", "TestNotes-2", "workItemId2"); await _appRepository.AddAsync(app); FeatureToggleTestHelper.UpdateFeatureToggleDeployedStatus(app, "TestToggle-1", "DEV", true); var context = new TestConsumeContext <RegisteredTogglesUpdate>(new RegisteredTogglesUpdate { Environment = "dev", AppName = "testapp", FeatureToggles = new [] { "TestToggle-2" } }); //act _sut = new FeatureToggleDeployStatusConsumer(_appRepository); await _sut.Consume(context); //assert var updatedApp = await _appRepository.FindByIdAsync(app.Id); FeatureToggleTestHelper.GetFeatureToggleDeployedStatus(updatedApp, "TestToggle-1", "DEV").Should().BeFalse(); FeatureToggleTestHelper.GetFeatureToggleDeployedStatus(updatedApp, "TestToggle-2", "DEV").Should().BeTrue(); }
public async Task Should_allow_the_first_call() { var count = 0; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseCircuitBreaker(v => { v.ResetInterval = TimeSpan.FromSeconds(60); v.Handle<IntentionalTestException>(); }); x.UseExecute(payload => { Interlocked.Increment(ref count); throw new IntentionalTestException(); }); }); var context = new TestConsumeContext<A>(new A()); for (var i = 0; i < 100; i++) Assert.That(async () => await pipe.Send(context), Throws.TypeOf<IntentionalTestException>()); count.ShouldBe(6); }
public async Task Should_allow_just_enough_threads_at_once() { int currentCount = 0; int maxCount = 0; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseConcurrencyLimit(32); x.UseExecuteAsync(async payload => { int current = Interlocked.Increment(ref currentCount); while (current > maxCount) Interlocked.CompareExchange(ref maxCount, current, maxCount); await Task.Delay(10); Interlocked.Decrement(ref currentCount); }); }); var context = new TestConsumeContext<A>(new A()); Task[] tasks = Enumerable.Range(0, 500) .Select(index => Task.Run(async () => await pipe.Send(context))) .ToArray(); await Task.WhenAll(tasks); maxCount.ShouldBe(32); }
public void Just_how_fast_are_you() { var message = new SerializationTestMessage { DecimalValue = 123.45m, LongValue = 098123213, BoolValue = true, ByteValue = 127, IntValue = 123, DateTimeValue = new DateTime(2008, 9, 8, 7, 6, 5, 4), TimeSpanValue = TimeSpan.FromSeconds(30), GuidValue = Guid.NewGuid(), StringValue = "Chris's Sample Code", DoubleValue = 1823.172 }; var sendContext = new MessageSendContext <SerializationTestMessage>(message); ReceiveContext receiveContext = null; //warm it up for (var i = 0; i < 10; i++) { byte[] data = Serialize(sendContext); var transportMessage = new InMemoryTransportMessage(Guid.NewGuid(), data, Serializer.ContentType.MediaType, TypeMetadataCache <SerializationTestMessage> .ShortName); receiveContext = new InMemoryReceiveContext(transportMessage, TestConsumeContext.GetContext()); Deserialize <SerializationTestMessage>(receiveContext); } var timer = Stopwatch.StartNew(); const int iterations = 50000; for (var i = 0; i < iterations; i++) { Serialize(sendContext); } timer.Stop(); var perSecond = iterations * 1000 / timer.ElapsedMilliseconds; Console.WriteLine("Serialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond); timer = Stopwatch.StartNew(); for (var i = 0; i < 50000; i++) { Deserialize <SerializationTestMessage>(receiveContext); } timer.Stop(); perSecond = iterations * 1000 / timer.ElapsedMilliseconds; Console.WriteLine("Deserialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond); }
public async Task Should_keep_track_of_only_the_last_value() { ILatestFilter <ConsumeContext <A> > latestFilter = null; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseLatest(l => l.Created = filter => latestFilter = filter); x.UseExecute(payload => { }); }); latestFilter.ShouldNotBe(null); for (int i = 0; i <= 100; i++) { var context = new TestConsumeContext <A>(new A { Index = i }); await pipe.Send(context); } ConsumeContext <A> latest = await latestFilter.Latest; latest.Message.Index.ShouldBe(100); }
public async Task Should_allow_the_first_call() { var count = 0; IPipe <ConsumeContext <Running_two_in_memory_transports.A> > pipe = Pipe.New <ConsumeContext <Running_two_in_memory_transports.A> >(x => { x.UseCircuitBreaker(v => { v.ResetInterval = TimeSpan.FromSeconds(60); v.Handle <IntentionalTestException>(); }); x.UseExecute(payload => { Interlocked.Increment(ref count); throw new IntentionalTestException(); }); }); var context = new TestConsumeContext <Running_two_in_memory_transports.A>(new Running_two_in_memory_transports.A()); for (var i = 0; i < 100; i++) { Assert.That(async() => await pipe.Send(context), Throws.TypeOf <IntentionalTestException>()); } count.ShouldBe(6); }
public async Task Should_prevent_too_many_threads_at_one_time() { var currentCount = 0; var maxCount = 0; IPipe <ConsumeContext <Running_two_in_memory_transports.A> > pipe = Pipe.New <ConsumeContext <Running_two_in_memory_transports.A> >(x => { x.UseConcurrencyLimit(1); x.UseExecuteAsync(async payload => { var current = Interlocked.Increment(ref currentCount); while (current > maxCount) { Interlocked.CompareExchange(ref maxCount, current, maxCount); } await Task.Delay(10); Interlocked.Decrement(ref currentCount); }); }); var context = new TestConsumeContext <Running_two_in_memory_transports.A>(new Running_two_in_memory_transports.A()); Task[] tasks = Enumerable.Range(0, 50) .Select(index => Task.Run(async() => await pipe.Send(context))) .ToArray(); await Task.WhenAll(tasks); maxCount.ShouldBe(1); }
public void Should_timeout() { IPipe <ConsumeContext> pipe = Pipe.New <ConsumeContext>(x => { x.UseTransaction(t => t.Timeout = TimeSpan.FromSeconds(1)); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(async payload => { await Task.Yield(); using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); Thread.Sleep(2000); scope.Complete(); } Console.WriteLine("Exited Scope"); }); x.UseExecute(payload => Console.WriteLine("After Transaction: {0}", Thread.CurrentThread.ManagedThreadId)); }); var context = new TestConsumeContext <PingMessage>(new PingMessage()); Assert.That(async() => await pipe.Send(context), Throws.TypeOf <TransactionAbortedException>()); //Console.WriteLine(exception.Message); }
public async Task Should_only_do_n_messages_per_interval() { int count = 0; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseRateLimit(10, TimeSpan.FromSeconds(1)); x.UseExecute(payload => { Interlocked.Increment(ref count); }); }); var context = new TestConsumeContext <A>(new A()); var timer = Stopwatch.StartNew(); Task[] tasks = Enumerable.Range(0, 101) .Select(index => Task.Run(async() => await pipe.Send(context))) .ToArray(); await Task.WhenAll(tasks); timer.Stop(); timer.ElapsedMilliseconds.ShouldBeGreaterThan(9500); }
public void Should_support_overloading_downstream_on_cc() { int count = 0; IPipe <ConsumeContext> pipe = Pipe.New <ConsumeContext>(x => { x.UseRetry(r => { r.Handle <IntentionalTestException>(); r.Interval(4, TimeSpan.FromMilliseconds(2)); }); x.UseRetry(r => { r.Handle <IntentionalTestException>(); r.None(); }); x.UseDispatch(new ConsumeContextConverterFactory(), d => { d.Pipe <ConsumeContext <A> >(a => { a.UseExecute(payload => { count++; throw new IntentionalTestException("Kaboom!"); }); }); }); }); var context = new TestConsumeContext <A>(new A()); Assert.That(async() => await pipe.Send(context), Throws.TypeOf <IntentionalTestException>()); count.ShouldBe(1); }
public void Should_convert_a_simple_correlation_expression() { var message = new CorrelatedMessage { CorrelationId = NewId.NextGuid() }; ConsumeContext <CorrelatedMessage> consumeContext = new TestConsumeContext <CorrelatedMessage>(message); var converter = new EventCorrelationExpressionConverter <TestState, CorrelatedMessage>(consumeContext); Expression <Func <TestState, bool> > result = converter .Convert((state, context) => state.CorrelationId == context.Message.CorrelationId); Console.WriteLine(result); }
public void Should_convert_a_simple_correlation_expression() { var message = new CorrelatedMessage { CorrelationId = NewId.NextGuid() }; ConsumeContext<CorrelatedMessage> consumeContext = new TestConsumeContext<CorrelatedMessage>(message); var converter = new EventCorrelationExpressionConverter<TestState, CorrelatedMessage>(consumeContext); Expression<Func<TestState, bool>> result = converter .Convert((state, context) => state.CorrelationId == context.Message.CorrelationId); Console.WriteLine(result); }
public async Task Should_receive_a_test_message() { IConsumePipe filter = CreateConsumePipe(); TaskCompletionSource <PingMessage> received = GetTask <PingMessage>(); ConnectHandle connectHandle = filter.ConnectHandler <PingMessage>(async context => received.TrySetResult(context.Message)); var consumeContext = new TestConsumeContext <PingMessage>(new PingMessage()); await filter.Send(consumeContext); await received.Task; }
public async Task Should_receive_a_test_message() { IConsumePipe filter = CreateConsumePipe(); TaskCompletionSource<PingMessage> received = GetTask<PingMessage>(); ConnectHandle connectHandle = filter.ConnectHandler<PingMessage>(async context => received.TrySetResult(context.Message)); var consumeContext = new TestConsumeContext<PingMessage>(new PingMessage()); await filter.Send(consumeContext); await received.Task; }
public async Task Should_receive_a_message_via_object() { IConsumePipe filter = CreateConsumePipe(); OneMessageConsumer consumer = GetOneMessageConsumer(); object subscribeConsumer = consumer; filter.ConnectInstance(subscribeConsumer); var consumeContext = new TestConsumeContext <MessageA>(new MessageA()); await filter.Send(consumeContext); await consumer.Task; }
public async Task Should_receive_a_message_via_object() { IConsumePipe filter = CreateConsumePipe(); OneMessageConsumer consumer = GetOneMessageConsumer(); object subscribeConsumer = consumer; filter.ConnectInstance(subscribeConsumer); var consumeContext = new TestConsumeContext<MessageA>(new MessageA()); await filter.Send(consumeContext); await consumer.Task; }
public async Task Should_receive_a_message() { IConsumePipe filter = CreateConsumePipe(); OneMessageConsumer consumer = GetOneMessageConsumer(); IConsumerFactory<OneMessageConsumer> factory = GetInstanceConsumerFactory(consumer); filter.ConnectConsumer(factory); var consumeContext = new TestConsumeContext<MessageA>(new MessageA()); await filter.Send(consumeContext); await consumer.Task; }
public async Task Should_receive_a_message() { IConsumePipe filter = CreateConsumePipe(); OneMessageConsumer consumer = GetOneMessageConsumer(); IConsumerFactory <OneMessageConsumer> factory = GetInstanceConsumerFactory(consumer); filter.ConnectConsumer(factory); var consumeContext = new TestConsumeContext <MessageA>(new MessageA()); await filter.Send(consumeContext); await consumer.Task; }
public void When_all_check_passes_should_call_Executeworkflow() { _userService.Setup(x => x.GetUserAsync(It.IsAny <string>())) .ReturnsAsync(() => null); _workflowActivityServiceMock.Setup(x => x.IsUserBeingCreated(It.IsAny <string>())).Returns(false); var createUserConsumer = CreateCreateUserConsumerInstance(); var consumeContext = new TestConsumeContext <ICreateUserCommand>(new CreateUserCommandTest { Email = "*****@*****.**" }); createUserConsumer.Consume(consumeContext); _createUserWorkflowBuilderMock.Verify(x => x.Execute(consumeContext)); }
public void Should_retry_the_specified_times_and_fail() { int count = 0; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseRetry(Retry.Interval(4, TimeSpan.FromMilliseconds(2))); x.UseExecute(payload => { count++; throw new IntentionalTestException("Kaboom!"); }); }); var context = new TestConsumeContext <A>(new A()); Assert.That(async() => await pipe.Send(context), Throws.TypeOf <IntentionalTestException>()); count.ShouldBe(5); }
public void Should_retry_the_specified_times_and_fail() { int count = 0; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseRetry(Retry.Interval(4, TimeSpan.FromMilliseconds(2))); x.UseExecute(payload => { count++; throw new IntentionalTestException("Kaboom!"); }); }); var context = new TestConsumeContext<A>(new A()); var exception = Assert.Throws<IntentionalTestException>(async () => await pipe.Send(context)); count.ShouldBe(5); }
public void Should_support_overloading_downstream_either_way() { int count = 0; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseRetry(Retry.None); x.UseRetry(Retry.Interval(4, TimeSpan.FromMilliseconds(2))); x.UseExecute(payload => { count++; throw new IntentionalTestException("Kaboom!"); }); }); var context = new TestConsumeContext <A>(new A()); Assert.That(async() => await pipe.Send(context), Throws.TypeOf <IntentionalTestException>()); count.ShouldBe(5); }
public void Should_support_overloading_downstream() { int count = 0; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseRetry(Retry.Interval(4, TimeSpan.FromMilliseconds(2))); x.UseRetry(Retry.None); x.UseExecute(payload => { count++; throw new IntentionalTestException("Kaboom!"); }); }); var context = new TestConsumeContext<A>(new A()); var exception = Assert.Throws<IntentionalTestException>(async () => await pipe.Send(context)); count.ShouldBe(1); }
protected T Return <T>(byte[] serializedMessageData) where T : class { var message = new InMemoryTransportMessage(Guid.NewGuid(), serializedMessageData, Serializer.ContentType.MediaType, TypeMetadataCache <T> .ShortName); var receiveContext = new InMemoryReceiveContext(message, TestConsumeContext.GetContext()); var consumeContext = Deserializer.Deserialize(receiveContext); consumeContext.TryGetMessage(out ConsumeContext <T> messageContext); messageContext.ShouldNotBe(null); messageContext.SourceAddress.ShouldBe(_sourceAddress); messageContext.DestinationAddress.ShouldBe(_destinationAddress); messageContext.FaultAddress.ShouldBe(_faultAddress); messageContext.ResponseAddress.ShouldBe(_responseAddress); messageContext.RequestId.HasValue.ShouldBe(true); messageContext.RequestId.Value.ShouldBe(_requestId); return(messageContext.Message); }
public async Task Should_count_success_and_failure_as_same() { int count = 0; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseRateLimit(10, TimeSpan.FromSeconds(1)); x.UseExecute(payload => { var index = Interlocked.Increment(ref count); if (index % 2 == 0) { throw new IntentionalTestException(); } }); }); var context = new TestConsumeContext <A>(new A()); var timer = Stopwatch.StartNew(); Task[] tasks = Enumerable.Range(0, 101) .Select(index => Task.Run(async() => { try { await pipe.Send(context); } catch (Exception) { } })) .ToArray(); await Task.WhenAll(tasks); timer.Stop(); timer.ElapsedMilliseconds.ShouldBeGreaterThan(9500); }
public async Task Should_properly_succeed() { IPipe <ConsumeContext> pipe = Pipe.New <ConsumeContext>(x => { x.UseTransaction(); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(payload => Task.Run(() => { using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); scope.Complete(); } })); }); var context = new TestConsumeContext <PingMessage>(new PingMessage()); await pipe.Send(context); }
public async Task Should_allow_the_first_call() { int count = 0; IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x => { x.UseCircuitBreaker(v => v.ResetInterval(TimeSpan.FromSeconds(60))); x.UseExecute(payload => { Interlocked.Increment(ref count); throw new IntentionalTestException(); }); }); var context = new TestConsumeContext <A>(new A()); for (int i = 0; i < 100; i++) { Assert.Throws <IntentionalTestException>(async() => await pipe.Send(context)); } count.ShouldBe(6); }
public void Should_properly_fail() { IPipe <ConsumeContext> pipe = Pipe.New <ConsumeContext>(x => { x.UseTransaction(); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(payload => Task.Run(() => { using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); } })); }); var context = new TestConsumeContext <PingMessage>(new PingMessage()); Assert.That(async() => await pipe.Send(context), Throws.TypeOf <TransactionAbortedException>()); //Console.WriteLine(exception.Message); }
public async Task Should_keep_track_of_only_the_last_value() { ILatestFilter<ConsumeContext<A>> latestFilter = null; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseLatest(l => l.Created = filter => latestFilter = filter); x.UseExecute(payload => { }); }); latestFilter.ShouldNotBe(null); for (int i = 0; i <= 100; i++) { var context = new TestConsumeContext<A>(new A {Index = i}); await pipe.Send(context); } ConsumeContext<A> latest = await latestFilter.Latest; latest.Message.Index.ShouldBe(100); }
public void Should_properly_fail() { IPipe<ConsumeContext> pipe = Pipe.New<ConsumeContext>(x => { x.UseTransaction(); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(payload => Task.Run(() => { using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); } })); }); var context = new TestConsumeContext<PingMessage>(new PingMessage()); Assert.That(async () => await pipe.Send(context), Throws.TypeOf<TransactionAbortedException>()); //Console.WriteLine(exception.Message); }
public void Should_timeout() { IPipe<ConsumeContext> pipe = Pipe.New<ConsumeContext>(x => { x.UseTransaction(t => t.Timeout = TimeSpan.FromSeconds(1)); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(async payload => { await Task.Yield(); using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); Thread.Sleep(2000); scope.Complete(); } Console.WriteLine("Exited Scope"); }); x.UseExecute(payload => Console.WriteLine("After Transaction: {0}", Thread.CurrentThread.ManagedThreadId)); }); var context = new TestConsumeContext<PingMessage>(new PingMessage()); Assert.That(async () => await pipe.Send(context), Throws.TypeOf<TransactionAbortedException>()); //Console.WriteLine(exception.Message); }
public async Task Should_count_success_and_failure_as_same() { int count = 0; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseRateLimit(10, TimeSpan.FromSeconds(1)); x.UseExecute(payload => { var index = Interlocked.Increment(ref count); if (index % 2 == 0) throw new IntentionalTestException(); }); }); var context = new TestConsumeContext<A>(new A()); var timer = Stopwatch.StartNew(); Task[] tasks = Enumerable.Range(0, 101) .Select(index => Task.Run(async () => { try { await pipe.Send(context); } catch (Exception) { } })) .ToArray(); await Task.WhenAll(tasks); timer.Stop(); timer.ElapsedMilliseconds.ShouldBeGreaterThan(9500); }
public async Task Should_only_do_n_messages_per_interval() { int count = 0; IPipe<ConsumeContext<A>> pipe = Pipe.New<ConsumeContext<A>>(x => { x.UseRateLimit(10, TimeSpan.FromSeconds(1)); x.UseExecute(payload => { Interlocked.Increment(ref count); }); }); var context = new TestConsumeContext<A>(new A()); var timer = Stopwatch.StartNew(); Task[] tasks = Enumerable.Range(0, 101) .Select(index => Task.Run(async () => await pipe.Send(context))) .ToArray(); await Task.WhenAll(tasks); timer.Stop(); timer.ElapsedMilliseconds.ShouldBeGreaterThan(9500); }
public async Task Should_properly_succeed() { IPipe<ConsumeContext> pipe = Pipe.New<ConsumeContext>(x => { x.UseTransaction(); x.UseExecute(payload => Console.WriteLine("Execute: {0}", Thread.CurrentThread.ManagedThreadId)); x.UseExecuteAsync(payload => Task.Run(() => { using (TransactionScope scope = payload.CreateTransactionScope()) { Console.WriteLine("ExecuteAsync: {0}", Thread.CurrentThread.ManagedThreadId); Assert.IsNotNull(Transaction.Current); Console.WriteLine("Isolation Level: {0}", Transaction.Current.IsolationLevel); scope.Complete(); } })); }); var context = new TestConsumeContext<PingMessage>(new PingMessage()); await pipe.Send(context); }