public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
_stream.Start();
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(
new FakePublisher(), _readyHandler, false, CheckpointTag.FromPosition(0, -1), 250);
_checkpoint.Start();
}
public void Handler_DispatchesMessagesCorrectly()
{
var handler = new TestMessageHandler();
handler.Handle("Hello").Wait();
Assert.AreEqual("Hello", handler.LastString);
}
public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
_stream.EmitEvents(
new[] {new EmittedEvent("stream", Guid.NewGuid(), "type", "data")}, CheckpointTag.FromPosition(200, 150));
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestMessageHandler<ClientMessage.ReadEventsBackwards>();
_bus.Subscribe(_listEventsHandler);
_coreProjection = new CoreProjection(
"projection", Guid.NewGuid(), _bus, new FakeProjectionStateHandler(),
new ProjectionConfig(ProjectionMode.AdHoc, 5, 10, 1000, 250, true, true, true));
_coreProjection.Start();
}
public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler <ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
_stream.Start();
_stream.EmitEvents(
new[] { new EmittedEvent("stream", Guid.NewGuid(), "type", "data") }, CheckpointTag.FromPosition(100, 50));
_stream.EmitEvents(
new[] { new EmittedEvent("stream", Guid.NewGuid(), "type2", "data2") },
CheckpointTag.FromPosition(100, 50));
}
public WhenExecutingCommandBehaviorPipeline()
{
_logger = new TestLogger();
_behaviorOne = new CommandBehaviorOne(_logger);
_behaviorTwo = new CommandBehaviorTwo(_logger);
_handler = new TestMessageHandler(_logger);
var registeredBehaviors = new ICommandBehavior <ICommand>[] { _behaviorOne, _behaviorTwo };
_behaviors.Setup(b => b.GetEnumerator()).Returns(registeredBehaviors.ToList().GetEnumerator());
_sut = new CommandBehaviorPipeline <ICommand>(_behaviors.Object);
}
public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
_stream.Start();
_stream.EmitEvents(
new[] {new EmittedEvent("stream", Guid.NewGuid(), "type", "data")}, CheckpointTag.FromPosition(-1, -1));
var msg = _publisher.Messages.OfType<ClientMessage.WriteEvents>().First();
_stream.Handle(new ClientMessage.WriteEventsCompleted(msg.CorrelationId, msg.EventStreamId, 0));
_stream.Checkpoint();
}
public async Task CreatesBlobIfNotExist(HttpStatusCode createStatusCode)
{
var stage = 0;
var testMessageHandler = new TestMessageHandler(async message =>
{
// First PUT request
if (stage == 0)
{
Assert.Equal(HttpMethod.Put, message.Method);
Assert.Equal("https://host/container/blob/path?query=1&comp=appendblock", message.RequestUri.ToString());
Assert.Equal(new byte[] { 0, 2, 3 }, await message.Content.ReadAsByteArrayAsync());
Assert.Equal(3, message.Content.Headers.ContentLength);
AssertDefaultHeaders(message);
stage++;
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
// Create request
if (stage == 1)
{
Assert.Equal(HttpMethod.Put, message.Method);
Assert.Equal("https://host/container/blob/path?query=1", message.RequestUri.ToString());
Assert.Equal(0, message.Content.Headers.ContentLength);
Assert.Equal(new[] { "*" }, message.Headers.GetValues("If-None-Match"));
AssertDefaultHeaders(message);
stage++;
return(new HttpResponseMessage(createStatusCode));
}
// First PUT request
if (stage == 2)
{
Assert.Equal(HttpMethod.Put, message.Method);
Assert.Equal("https://host/container/blob/path?query=1&comp=appendblock", message.RequestUri.ToString());
Assert.Equal(new byte[] { 0, 2, 3 }, await message.Content.ReadAsByteArrayAsync());
Assert.Equal(3, message.Content.Headers.ContentLength);
AssertDefaultHeaders(message);
stage++;
return(new HttpResponseMessage(HttpStatusCode.Created));
}
throw new NotImplementedException();
});
var blob = new BlobAppendReferenceWrapper(_containerUrl, _blobName, new HttpClient(testMessageHandler));
await blob.AppendAsync(new ArraySegment <byte>(new byte[] { 0, 2, 3 }), CancellationToken.None);
Assert.Equal(3, stage);
}
public async Task ReturnsResponseHeader()
{
// setup
var testMessageHandler = new TestMessageHandler(HttpStatusCode.OK, "test content", "text/plain", Encoding.UTF8);
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler));
// execute
HttpResponseMessage response = await client.GetAsync("http://unittest");
// validate
response.Content.Headers.ContentType.MediaType.Should().Be("text/plain");
response.Content.Headers.ContentType.CharSet.Should().Be("utf-8");
}
public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler <ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
_stream.Start();
_stream.EmitEvents(
new[] { new EmittedEvent("stream", Guid.NewGuid(), "type", "data") }, CheckpointTag.FromPosition(-1, -1));
var msg = _publisher.Messages.OfType <ClientMessage.WriteEvents>().First();
_stream.Handle(new ClientMessage.WriteEventsCompleted(msg.CorrelationId, msg.EventStreamId, 0));
_stream.Checkpoint();
}
public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
try
{
_stream.Checkpoint();
}
catch (Exception ex)
{
_caughtException = ex;
}
}
public void setup()
{
_checkpointUnhandledBytesThreshold = 1000;
Given();
_bus = new FakePublisher();
_projectionCorrelationId = Guid.NewGuid();
_eventHandler = new TestMessageHandler<ProjectionMessage.Projections.CommittedEventReceived>();
_checkpointHandler = new TestMessageHandler<ProjectionMessage.Projections.CheckpointSuggested>();
_subscription = new ProjectionSubscription(
_projectionCorrelationId, CheckpointTag.FromPosition(0, -1), _eventHandler, _checkpointHandler,
CreateCheckpointStrategy(), _checkpointUnhandledBytesThreshold);
When();
}
public void Given_Valid_Arguments_When_I_Call_Consume_Then_It_Returns_Same_Instance_Of_Itself_Back()
{
//arrange
int numberOfMessages = 1;
var messageHandler = new TestMessageHandler();
//act
var result = _sut.Consume(numberOfMessages, messageHandler);
//assert
Assert.IsNotNull(result);
Assert.IsInstanceOf <IFluentSubscriptionApi>(result);
Assert.AreSame(_sut, result);
}
public void setup()
{
_publisher = new FakePublisher();
_readyHandler = new TestMessageHandler <ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test", _publisher, _readyHandler, false, 50);
try
{
_stream.Checkpoint();
}
catch (Exception ex)
{
_caughtException = ex;
}
}
public async Task Single_Handler_Can_Be_Invoked()
{
//ARRANGE
var result = 0;
var logger = new Mock <IGWLogger <BaseMessageHandler <TestMessage> > >();
var command = new TestMessage(Guid.NewGuid(), Guid.NewGuid());
var handler = new TestMessageHandler(() => result = 10, logger.Object, false);
var handlerInvoker = new HandlerInvoker();
//ACT
await handlerInvoker.InvokeHandlers(new[] { handler }, command, CancellationToken.None);
//ASSERT
Assert.That(result, Is.EqualTo(10));
}
public async Task CachesHeadAndGetRequestWithoutConflict()
{
var testMessageHandler = new TestMessageHandler();
var cache = new MemoryCache(new MemoryCacheOptions());
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler, null, null, cache));
// execute twice for different methods
await client.SendAsync(new HttpRequestMessage(HttpMethod.Head, "http://unittest"));
await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://unittest"));
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public async Task CachesTheResult()
{
// setup
var testMessageHandler = new TestMessageHandler();
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler));
// execute twice
await client.GetAsync("http://unittest");
await client.GetAsync("http://unittest");
// validate
testMessageHandler.NumberOfCalls.Should().Be(1);
}
public void Given_ForSubscription_Has_Not_Called_In_A_Previous_Step_When_I_Call_Now_Then_A_NullReferenceExceptionIs_Thrown()
{
//arrange
var projectId = "Project123";
int numberOfMessages = 1;
var messageHandler = new TestMessageHandler();
_sut.ForProject(projectId);
_sut.Consume(numberOfMessages, messageHandler);
//act && assert
var exception = Assert.Throws <NullReferenceException>(() => _sut.Now());
Assert.AreEqual("The 'ForSubscription' step needs to be called prior to this", exception.Message);
}
public void setup()
{
_checkpointUnhandledBytesThreshold = 1000;
Given();
_bus = new FakePublisher();
_projectionCorrelationId = Guid.NewGuid();
_eventHandler = new TestMessageHandler <ProjectionMessage.Projections.CommittedEventReceived>();
_checkpointHandler = new TestMessageHandler <ProjectionMessage.Projections.CheckpointSuggested>();
_subscription = new ProjectionSubscription(
_projectionCorrelationId, CheckpointTag.FromPosition(0, -1), _eventHandler, _checkpointHandler,
CreateCheckpointStrategy(), _checkpointUnhandledBytesThreshold);
When();
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(_bus, _readyHandler, false, CheckpointTag.FromPosition(100, 50), 250);
try
{
_checkpoint.EmitEvents(
new[] {new EmittedEvent("stream1", Guid.NewGuid(), "type", "data")},
CheckpointTag.FromPosition(40, 30));
}
catch (Exception ex)
{
_lastException = ex;
}
}
public async Task CachesPerUrl()
{
// setup
var testMessageHandler = new TestMessageHandler();
var cache = new MemoryCache(new MemoryCacheOptions());
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler, null, null, cache));
// execute for different URLs
await client.GetAsync("http://unittest1");
await client.GetAsync("http://unittest2");
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public void setup()
{
_readyHandler = new TestMessageHandler <ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(_bus, _readyHandler, false, CheckpointTag.FromPosition(100, 50), 250);
try
{
_checkpoint.EmitEvents(
new[] { new EmittedEvent("stream1", Guid.NewGuid(), "type", "data") },
CheckpointTag.FromPosition(40, 30));
}
catch (Exception ex)
{
_lastException = ex;
}
}
public async Task SendsDataAsStream()
{
var testMessageHandler = new TestMessageHandler(async message =>
{
Assert.Equal(HttpMethod.Put, message.Method);
Assert.Equal("https://host/container/blob/path?query=1&comp=appendblock", message.RequestUri.ToString());
Assert.Equal(new byte[] { 0, 2, 3 }, await message.Content.ReadAsByteArrayAsync());
AssertDefaultHeaders(message);
return(new HttpResponseMessage(HttpStatusCode.OK));
});
var blob = new BlobAppendReferenceWrapper(_containerUrl, _blobName, new HttpClient(testMessageHandler));
await blob.AppendAsync(new ArraySegment <byte>(new byte[] { 0, 2, 3 }), CancellationToken.None);
}
public async Task IsCaseSensitive()
{
// setup
var testMessageHandler = new TestMessageHandler();
var cache = new MemoryCache(new MemoryCacheOptions());
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler, null, null, cache));
// execute for different URLs, only different by casing
await client.GetAsync("http://unittest/foo.html");
await client.GetAsync("http://unittest/FOO.html");
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public async Task AlwaysCallsTheHttpHandler()
{
// setup
var testMessageHandler = new TestMessageHandler();
var cache = new MemoryCache(new MemoryCacheOptions());
var client = new System.Net.Http.HttpClient(new InMemoryCacheFallbackHandler(testMessageHandler, TimeSpan.FromDays(1), TimeSpan.FromDays(1), null, cache));
// execute twice
await client.GetAsync(this.url);
cache.Get(InMemoryCacheFallbackHandler.CacheFallbackKeyPrefix + HttpMethod.Get + this.url).Should().NotBeNull(); // ensure it's cached before the 2nd call
await client.GetAsync(this.url);
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public void setup()
{
_readyHandler = new TestMessageHandler <ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(_bus, _readyHandler, false, CheckpointTag.FromPosition(100, 50), 250);
_checkpoint.EmitEvents(
new[]
{
new EmittedEvent("stream2", Guid.NewGuid(), "type", "data2"),
new EmittedEvent("stream3", Guid.NewGuid(), "type", "data3"),
new EmittedEvent("stream2", Guid.NewGuid(), "type", "data4"),
},
CheckpointTag.FromPosition(120, 110));
_checkpoint.EmitEvents(
new[] { new EmittedEvent("stream1", Guid.NewGuid(), "type", "data") },
CheckpointTag.FromPosition(140, 130));
}
public void If_Message_Is_Null_Then_An_Argument_Null_Exception_Will_Be_Thrown()
{
// Arrange
var testMessageHandler = new TestMessageHandler(
action: null,
logger: Mock.Of <IGWLogger <BaseMessageHandler <TestMessage> > >(),
throwException: false);
Task TestDelegate() => testMessageHandler.Handle(message: null, cancellationToken: CancellationToken.None);
// Act
// Assert
var exception = Assert.ThrowsAsync <ArgumentNullException>(TestDelegate, "null message should result in exception being thrown");
Assert.That(exception.ParamName, Is.EqualTo("message"));
}
public async Task GetsTheDataAgainAfterEntryIsGoneFromCache()
{
// setup
var testMessageHandler = new TestMessageHandler();
var cache = new MemoryCache(new MemoryCacheOptions());
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler, null, null, cache));
// execute twice
await client.GetAsync("http://unittest");
cache.Remove(HttpMethod.Get + new Uri("http://unittest").ToString());
await client.GetAsync("http://unittest");
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(_bus, _readyHandler, CheckpointTag.FromPosition(100, 50), 250);
_checkpoint.EmitEvents(
new[]
{
new EmittedEvent("stream2", Guid.NewGuid(), "type", "data2"),
new EmittedEvent("stream3", Guid.NewGuid(), "type", "data3"),
new EmittedEvent("stream2", Guid.NewGuid(), "type", "data4"),
},
CheckpointTag.FromPosition(120, 110));
_checkpoint.EmitEvents(
new[] {new EmittedEvent("stream1", Guid.NewGuid(), "type", "data")},
CheckpointTag.FromPosition(140, 130));
}
public void Given_ForProject_Has_Not_Called_In_A_Previous_Step_When_I_Call_Every_Then_A_NullReferenceExceptionIs_Thrown()
{
//arrange
var subscriptionId = "Subscription123";
int numberOfMessages = 1;
var messageHandler = new TestMessageHandler();
var intervalNumber = 1;
var intervalType = IntervalType.Hours;
_sut.ForSubscription(subscriptionId);
_sut.Consume(numberOfMessages, messageHandler);
//act && assert
var exception = Assert.Throws <NullReferenceException>(() => _sut.Every(intervalNumber, intervalType));
Assert.AreEqual("The 'ForProject' step needs to be called prior to this", exception.Message);
}
public async Task TriesToAccessCacheOnFailureButReturnsErrorIfNotInCache()
{
// setup
var testMessageHandler = new TestMessageHandler(HttpStatusCode.InternalServerError);
var cache = new Mock <IMemoryCache>(MockBehavior.Strict);
var cacheTime = TimeSpan.FromSeconds(123);
object expectedValue;
cache.Setup(c => c.TryGetValue(this.url, out expectedValue)).Returns(false);
var client = new System.Net.Http.HttpClient(new InMemoryCacheFallbackHandler(testMessageHandler, TimeSpan.FromDays(1), cacheTime, null, cache.Object));
// execute
var result = await client.GetAsync(this.url);
// validate
result.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestMessageHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
_coreProjection = new CoreProjection(
"projection", Guid.NewGuid(), _bus, new FakeProjectionStateHandler(),
new ProjectionConfig(ProjectionMode.AdHoc, 5, 10, 1000, 250, true, true, true), _readDispatcher, _writeDispatcher);
_coreProjection.Start();
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestMessageHandler <ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
_coreProjection = new CoreProjection(
"projection", Guid.NewGuid(), _bus, new FakeProjectionStateHandler(),
new ProjectionConfig(ProjectionMode.AdHoc, 5, 10, 1000, 250, true, true, true), _readDispatcher, _writeDispatcher);
_coreProjection.Start();
}
/// <summary>
/// Creates a test client that communicates with the specified server.
/// </summary>
/// <param name="server">The server.</param>
/// <returns>A newly-created <see cref="TestHttpClient"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="server"/> is <see langword="null"/>.</exception>
/// <seealso cref="Create(string)"/>
/// <seealso cref="Create(Uri)"/>
public static TestHttpClient Create(ITestWebServer server)
{
Validate.NotNull(nameof(server), server);
#pragma warning disable CA2000 // Dispose handler before it goes out of scope - Ownership of handler is transferred to the TestHttpClient instance.
var handler = new TestMessageHandler(server);
#pragma warning restore CA2000
try
{
return(new TestHttpClient(handler, server.BaseUrl));
}
catch
{
handler.Dispose();
throw;
}
}
public async Task InvalidatesCacheCorrectly()
{
// setup
var testMessageHandler = new TestMessageHandler();
var handler = new InMemoryCacheHandler(testMessageHandler);
var client = new System.Net.Http.HttpClient(handler);
// execute twice, with cache invalidation in between
var uri = new Uri("http://unittest");
await client.GetAsync(uri);
handler.InvalidateCache(uri);
await client.GetAsync(uri);
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public void setup1()
{
_ticksAreHandledImmediately = false;
_writesQueue = new Queue <ClientMessage.WriteEvents>();
_consumer = new WatchingConsumer();
_bus.Subscribe(_consumer);
_listEventsHandler = new TestMessageHandler <ClientMessage.ReadEventsBackwards>();
_bus.Subscribe(_listEventsHandler);
_bus.Subscribe <ClientMessage.WriteEvents>(this);
_bus.Subscribe <ClientMessage.ReadEventsBackwards>(this);
_bus.Subscribe <ProjectionMessage.CoreService.Tick>(this);
_lastMessageReplies.Clear();
Given();
_lastPosition =
_lastMessageReplies.Values.Max(v => v == null ? (long?)0 : v.Max(u => (long?)u.LogPosition))
?? 0 + 100;
}
public async Task WithMessageRouting_WithMessageHandlerMessageBodySerializer_GoesThroughRegisteredMessageHandlers()
{
// Arrange
var services = new ServiceCollection();
var collection = new MessageHandlerCollection(services);
var spyHandler = new StubTestMessageHandler <TestMessage, TestMessageContext>();
var ignoredSameTypeHandler = new StubTestMessageHandler <TestMessage, TestMessageContext>();
var ignoredWrongDeserializedTypeHandler = new StubTestMessageHandler <Order, TestMessageContext>();
var ignoredDefaultHandler = new DefaultTestMessageHandler();
var ignoredHandler = new TestMessageHandler();
var expectedMessage = new TestMessage {
TestProperty = "Some value"
};
string expectedBody = JsonConvert.SerializeObject(expectedMessage);
var serializer = new TestMessageBodySerializer(expectedBody, expectedMessage);
collection.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(serviceProvider => ignoredDefaultHandler)
.WithMessageHandler <StubTestMessageHandler <Order, TestMessageContext>, Order, TestMessageContext>(
messageBodySerializer: new TestMessageBodySerializer(expectedBody, new Customer()),
implementationFactory: serviceProvider => ignoredWrongDeserializedTypeHandler)
.WithMessageHandler <StubTestMessageHandler <TestMessage, TestMessageContext>, TestMessage, TestMessageContext>(
messageContextFilter: ctx => false, implementationFactory: serviceProvider => ignoredSameTypeHandler)
.WithMessageHandler <StubTestMessageHandler <TestMessage, TestMessageContext>, TestMessage, TestMessageContext>(
messageBodySerializer: serializer,
implementationFactory: serviceProvider => spyHandler)
.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(serviceProvider => ignoredHandler);
// Act
services.AddMessageRouting();
// Assert
IServiceProvider provider = services.BuildServiceProvider();
var router = provider.GetRequiredService <IMessageRouter>();
var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id");
var context = TestMessageContext.Generate();
await router.RouteMessageAsync(expectedBody, context, correlationInfo, CancellationToken.None);
Assert.True(spyHandler.IsProcessed);
Assert.False(ignoredSameTypeHandler.IsProcessed);
Assert.False(ignoredDefaultHandler.IsProcessed);
Assert.False(ignoredWrongDeserializedTypeHandler.IsProcessed);
Assert.False(ignoredHandler.IsProcessed);
}
public async Task NeverUpdatesTheCacheOnFailure()
{
// setup
var testMessageHandler = new TestMessageHandler(HttpStatusCode.InternalServerError);
var cache = new Mock <IMemoryCache>(MockBehavior.Strict);
var cacheTime = TimeSpan.FromSeconds(123);
object expectedValue;
cache.Setup(c => c.CreateEntry(It.IsAny <string>()));
cache.Setup(c => c.TryGetValue(this.url, out expectedValue)).Returns(false);
var client = new System.Net.Http.HttpClient(new InMemoryCacheFallbackHandler(testMessageHandler, TimeSpan.FromDays(1), cacheTime, null, cache.Object));
// execute
await client.GetAsync(this.url);
// validate
cache.Verify(c => c.CreateEntry(It.IsAny <string>()), Times.Never);
}
public async Task DisableCachePerStatusCode()
{
// setup
var cacheExpirationPerStatusCode = new Dictionary <HttpStatusCode, TimeSpan>();
cacheExpirationPerStatusCode.Add((HttpStatusCode)200, TimeSpan.FromSeconds(0));
var testMessageHandler = new TestMessageHandler();
var client = new System.Net.Http.HttpClient(new InMemoryCacheHandler(testMessageHandler, cacheExpirationPerStatusCode));
// execute twice
await client.GetAsync("http://unittest");
await client.GetAsync("http://unittest");
// validate
testMessageHandler.NumberOfCalls.Should().Be(2);
}
public void Given_Previous_Steps_Are_Setup_And_I_Supply_Throttle_When_I_Call_StartConsuming_With_IMessageHandler_Then_It_Calls_The_Correct_Service_Method(bool throttle)
{
//arrange
var messageHandler = new TestMessageHandler();
_subscriberServiceMock.Setup(s => s.StartConsuming(It.IsAny <string>(), It.IsAny <string>(),
It.IsAny <IMessageHandler>(), It.IsAny <bool>()));
_sut.WithProject(_projectId);
_sut.WithSubscription(_subscriptionId);
//act
_sut.StartConsuming(messageHandler, throttle);
//assert
_subscriberServiceMock.Verify(v => v.StartConsuming(_projectId, _subscriptionId, messageHandler, throttle));
}
public void setup()
{
_subscribeProjectionHandler = new TestMessageHandler<ProjectionMessage.Projections.SubscribeProjection>();
_writeEventHandler = new TestMessageHandler<ClientMessage.WriteEvents>();
_bus.Subscribe(_subscribeProjectionHandler);
_bus.Subscribe(_writeEventHandler);
_stateHandler = _stateHandler
?? new FakeProjectionStateHandler(configureBuilder: _configureBuilderByQuerySource);
_firstWriteCorrelationId = Guid.NewGuid();
_projectionCorrelationId = Guid.NewGuid();
_coreProjection = new CoreProjection(
"projection", _projectionCorrelationId, _bus, _stateHandler,
new ProjectionConfig(
_projectionMode, _checkpointHandledThreshold, _checkpointUnhandledBytesThreshold, 1000, 250, true, true,
true), _readDispatcher, _writeDispatcher);
_coreProjection.Start();
When();
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(_bus, _readyHandler, CheckpointTag.FromPosition(100, 50), 250);
_checkpoint.Start();
_checkpoint.EmitEvents(
new[]
{
new EmittedEvent("stream2", Guid.NewGuid(), "type", "data2"),
new EmittedEvent("stream2", Guid.NewGuid(), "type", "data4"),
},
CheckpointTag.FromPosition(120, 110));
_checkpoint.EmitEvents(
new[] {new EmittedEvent("stream1", Guid.NewGuid(), "type", "data")},
CheckpointTag.FromPosition(140, 130));
var writes = _consumer.HandledMessages.OfType<ClientMessage.WriteEvents>().ToArray();
writes[0].Envelope.ReplyWith(
new ClientMessage.WriteEventsCompleted(writes[0].CorrelationId, writes[0].EventStreamId, 0));
writes[1].Envelope.ReplyWith(
new ClientMessage.WriteEventsCompleted(writes[1].CorrelationId, writes[1].EventStreamId, 0));
_checkpoint.Prepare(CheckpointTag.FromPosition(200, 150));
//TODO: test whether checkpoint does not allow positions before last emitted event caused by position
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_stream = new EmittedStream("test_stream", _bus, _readyHandler, recoveryMode: true, maxWriteBatchLength: 50);
_stream.Start();
}
public async Task SyncBasicTests()
{
var mockTracer = new Mock<ITracer>();
mockTracer
.Setup(m => m.Trace(It.IsAny<string>(), It.IsAny<IDictionary<string, string>>()));
var repository = Mock.Of<IRepository>();
var fileSystem = new Mock<IFileSystem>();
var fileBase = new Mock<FileBase>();
var fileInfoFactory = new Mock<IFileInfoFactory>();
var fileInfo = new Mock<FileInfoBase>();
var dirBase = new Mock<DirectoryBase>();
var dirInfoFactory = new Mock<IDirectoryInfoFactory>(); // mock dirInfo to make FileSystemHelpers.DeleteDirectorySafe not throw exception
var dirInfoBase = new Mock<DirectoryInfoBase>();
fileSystem.Setup(f => f.File).Returns(fileBase.Object);
fileSystem.Setup(f => f.FileInfo).Returns(fileInfoFactory.Object);
fileInfoFactory.Setup(f => f.FromFileName(It.IsAny<string>()))
.Returns(() => fileInfo.Object);
fileSystem.Setup(f => f.Directory).Returns(dirBase.Object);
fileSystem.Setup(f => f.DirectoryInfo).Returns(dirInfoFactory.Object);
dirInfoFactory.Setup(d => d.FromDirectoryName(It.IsAny<string>())).Returns(dirInfoBase.Object);
fileBase.Setup(fb => fb.Exists(It.IsAny<string>())).Returns((string path) =>
{
return (path != null && (path.EndsWith("f-delete") || path.EndsWith("bar.txt")));
});
fileBase.Setup(fb => fb.SetLastWriteTimeUtc(It.IsAny<string>(), It.IsAny<DateTime>()));
dirBase.Setup(d => d.Exists(It.IsAny<string>())).Returns((string path) =>
{
return (path != null && (path.EndsWith("f-delete-dir") || path.EndsWith("f2")));
});
FileSystemHelpers.Instance = fileSystem.Object;
// prepare change from OneDrive
OneDriveModel.OneDriveChange change = new OneDriveModel.OneDriveChange();
change.IsDeleted = false;
// prepare OneDriveInfo
var info = new OneDriveInfo();
info.AccessToken = "fake-token";
info.RepositoryUrl = "https://api.onedrive.com/v1.0/drive/special/approot:/fake-folder";
info.TargetChangeset = new ChangeSet("id", "authorName", "authorEmail", "message", DateTime.UtcNow);
// prepare http handler
var handler = new TestMessageHandler((HttpRequestMessage message) =>
{
StringContent content = null;
if (message != null && message.RequestUri != null)
{
if (message.RequestUri.AbsoluteUri.Equals(info.RepositoryUrl))
{
content = new StringContent(@"{ 'id': 'fake-id'}", Encoding.UTF8, "application/json");
return new HttpResponseMessage { Content = content };
}
else if (message.RequestUri.AbsoluteUri.Equals("https://api.onedrive.com/v1.0/drive/items/fake-id/view.changes"))
{
content = new StringContent(ViewChangePayload, Encoding.UTF8, "application/json");
return new HttpResponseMessage { Content = content };
}
else if (message.RequestUri.AbsoluteUri.EndsWith("items/A6034FFBC93398FD!331")
|| message.RequestUri.AbsoluteUri.EndsWith("items/A6034FFBC93398FD!330"))
{
content = new StringContent(@"{ '@content.downloadUrl': 'http://site-does-not-exist.microsoft.com'}", Encoding.UTF8, "application/json");
return new HttpResponseMessage { Content = content };
}
}
content = new StringContent("test file content", Encoding.UTF8, "application/json");
return new HttpResponseMessage { Content = content };
});
// perform action
OneDriveHelper helper = CreateMockOneDriveHelper(handler: handler, tracer: mockTracer.Object);
await helper.Sync(info, repository);
// verification
/*
Sycing f2 to wwwroot:
There are 6 changes
2 deletion
f2\f-delete (existed as file)
f2\f-delete-dir (existed as folder)
2 file changes
f2\foo.txt (not existed)
f2\f22\bar.txt (existed)
2 folder chagnes
f2 (existed)
f2\f22 (not existed)
*/
// deletion
mockTracer.Verify(t => t.Trace(@"Deleted file D:\home\site\wwwroot\f-delete", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
mockTracer.Verify(t => t.Trace(@"Deleted directory D:\home\site\wwwroot\f-delete-dir", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
// file changes
mockTracer.Verify(t => t.Trace(@"Creating file D:\home\site\wwwroot\foo.txt ...", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
mockTracer.Verify(t => t.Trace(@"Updating file D:\home\site\wwwroot\f22\bar.txt ...", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
mockTracer.Verify(t => t.Trace(@"Deleted file D:\home\site\wwwroot\f-delete", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
mockTracer.Verify(t => t.Trace(@"Deleted directory D:\home\site\wwwroot\f-delete-dir", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
// directory changes
mockTracer.Verify(t => t.Trace(@"Ignore folder f2", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
mockTracer.Verify(t => t.Trace(@"Creating directory D:\home\site\wwwroot\f22 ...", It.Is<IDictionary<string, string>>(d => d.Count == 0)));
}
private static OneDriveHelper CreateMockOneDriveHelper(TestMessageHandler handler, ITracer tracer, IDeploymentSettingsManager settings = null, IEnvironment env = null)
{
var envMock = new Mock<IEnvironment>();
envMock.Setup(e => e.WebRootPath).Returns(DefaultWebRoot);
var helper = new Mock<OneDriveHelper>(tracer, Mock.Of<IDeploymentStatusManager>(), settings ?? Mock.Of<IDeploymentSettingsManager>(), env ?? envMock.Object);
helper.CallBase = true;
helper.Object.Logger = Mock.Of<ILogger>();
helper.Setup(h => h.CreateHttpClient(It.IsAny<string>()))
.Returns(() =>
{
handler.Disposed = false;
return new HttpClient(handler) { BaseAddress = new Uri("http://site-does-not-exist.microsoft.com") };
});
helper.Setup(h => h.WriteToFile(It.IsAny<Stream>(), It.IsAny<string>())).Returns(() =>
{
return Task.Delay(TimeSpan.FromMilliseconds(5));
});
return helper.Object;
}
public void setup()
{
_readyHandler = new TestMessageHandler<ProjectionMessage.Projections.ReadyForCheckpoint>();
_checkpoint = new ProjectionCheckpoint(_bus, _readyHandler, false, CheckpointTag.FromPosition(100, 50), 250);
}
public void Handler_ShouldThrowExceptionUponUnexpectedMessage()
{
var handler = new TestMessageHandler();
Assert.Throws<AggregateException>(() => handler.Handle(new Symbol()).Wait());
}
public void Handler_CanIgnoreMessages()
{
var handler = new TestMessageHandler();
handler.Handle(new object()).Wait();
}
public async Task SendAndRecieveMessage()
{
var queueName = "testqueueB";
var message = new RabbitMessage() { RoutingKey = queueName, Body = new byte[]{0,1,2,3,4}};
var messageHandler = new TestMessageHandler();
var connectionFactory = new ConnectionFactory
{
HostName = "mqBalancer",
UserName = "******",
Password = "******",
RequestedHeartbeat = 5,
};
using (var connection = new RabbitMqConnection(connectionFactory))
{
using (var model = new RabbitMqModel(connection))
{
model.QueueDeclare(queueName, false, true, false, new Dictionary<string, object>());
var consumer = model.HandleMessagesAsync(queueName);
var publisher = new ConfirmingPublisher(model);
await Task.Delay(TimeSpan.FromSeconds(1));
publisher.Publish(string.Empty, new[] { message });
await consumer.ConsumeMessages(messageHandler, CancellationToken.None);
}
}
var result = messageHandler.LastMessage;
Assert.That(result.Body, Is.EquivalentTo(message.Body));
}
